← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/0001-License-Declaration.patch/src/rigs/TS570.cxx

  • Committer: Package Import Robot
  • Author(s): Kamal Mostafa
  • Date: 2014-06-07 11:28:52 UTC
  • Revision ID: package-import@ubuntu.com-20140607112852-pj9xhtlvwpgqjy5x
Tags: 1.3.15-1
http://bugs.debian.org/750861
* Initial release (Closes: #750861)
  flrig version 1.3.15 plus the following upstream commits:
  - 0001-License-Declaration.patch
  - 0002-FL_APPS-folder.patch
  - 0003-rig-home-dir.patch
  - 0004-RTS-DTR-restore.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0001-License-Declaration.patch/src/rigs/TS570.cxx
 
1
/*
 
2
 * Kenwood TS570 driver
 
3
 * originally based on Kenwood TS2000 driver
 
4
 *
 
5
 * a part of flrig
 
6
 *
 
7
 * Copyright 2009, Dave Freese, W1HKJ
 
8
 *
 
9
 */
 
10
 
 
11
 
 
12
#include "TS570.h"
 
13
#include "support.h"
 
14
 
 
15
static const char TS570name_[] = "TS-570";
 
16
 
 
17
static const char *TS570modes_[] = {
 
18
                "LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "FSK-R", NULL};
 
19
static const char TS570_mode_chr[] =  { '1', '2', '3', '4', '5', '6', '7', '9' };
 
20
static const char TS570_mode_type[] = { 'L', 'U', 'U', 'U', 'U', 'L', 'L', 'U' };
 
21
 
 
22
static const char *TS570_SSBwidths[] = { // same for AM and FM
 
23
"NARR", "WIDE", NULL};
 
24
 
 
25
static const char *TS570_SSBbw[] = {
 
26
"FW0000;", "FW0001;", NULL};
 
27
 
 
28
static const char *TS570_CWwidths[] = {
 
29
"50", "100", "200", "300", "400", "600", "1000", "2000", NULL};
 
30
 
 
31
static const char *TS570_CWbw[] = {
 
32
"FW0050;", "FW0100;", "FW0200;", "FW0300;",
 
33
"FW0400;", "FW0600;", "FW1000;", "FW2000;", NULL};
 
34
 
 
35
static const char *TS570_FSKwidths[] = {
 
36
"250", "500", "1000", "1500", NULL};
 
37
 
 
38
static const char *TS570_FSKbw[] = {
 
39
  "FW0250;", "FW0500;", "FW1000;", "FW1500;", NULL};
 
40
 
 
41
static GUI rig_widgets[]= {
 
42
        { (Fl_Widget *)btnVol, 2, 125,  50 },
 
43
        { (Fl_Widget *)sldrVOLUME, 54, 125, 156 },
 
44
        { (Fl_Widget *)sldrRFGAIN, 266, 145, 156 },
 
45
        { (Fl_Widget *)sldrPOWER, 54, 165, 368 },
 
46
        { (Fl_Widget *)btnIFsh, 214, 105,  50 },
 
47
        { (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
 
48
        { (Fl_Widget *)sldrSQUELCH, 266, 125, 156 },
 
49
        { (Fl_Widget *)sldrMICGAIN, 54, 145, 156 },
 
50
        { (Fl_Widget *)NULL,          0,   0,   0 }
 
51
};
 
52
 
 
53
void RIG_TS570::initialize()
 
54
{
 
55
        rig_widgets[0].W = btnVol;
 
56
        rig_widgets[1].W = sldrVOLUME;
 
57
        rig_widgets[2].W = sldrRFGAIN;
 
58
        rig_widgets[3].W = sldrPOWER;
 
59
        rig_widgets[4].W = btnIFsh;
 
60
        rig_widgets[5].W = sldrIFSHIFT;
 
61
        rig_widgets[6].W = sldrSQUELCH;
 
62
        rig_widgets[7].W = sldrMICGAIN;
 
63
 
 
64
        cmd = "FR0;"; sendCommand(cmd);
 
65
        showresp(WARN, ASC, "Rx on A", cmd, replystr);
 
66
        cmd = "AC001;"; sendCommand(cmd);
 
67
        showresp(WARN, ASC, "Thru - tune ON", cmd, replystr);
 
68
        get_preamp();
 
69
        get_attenuator();
 
70
        is_TS570S = get_ts570id();
 
71
}
 
72
 
 
73
RIG_TS570::RIG_TS570() {
 
74
// base class values
 
75
        name_ = TS570name_;
 
76
        modes_ = TS570modes_;
 
77
        bandwidths_ = TS570_SSBwidths;
 
78
 
 
79
        widgets = rig_widgets;
 
80
 
 
81
        comm_baudrate = BR4800;
 
82
        stopbits = 2;
 
83
        comm_retries = 2;
 
84
        comm_wait = 5;
 
85
        comm_timeout = 50;
 
86
        comm_rtscts = true;
 
87
        comm_rtsplus = false;
 
88
        comm_dtrplus = false;
 
89
        comm_catptt = true;
 
90
        comm_rtsptt = false;
 
91
        comm_dtrptt = false;
 
92
 
 
93
        A.freq = 14070000;
 
94
        A.imode = 1;
 
95
        A.iBW = 1;
 
96
        B.freq = 7035000;
 
97
        B.imode = 1;
 
98
        B.iBW = 1;
 
99
        can_change_alt_vfo = true;
 
100
 
 
101
        has_notch_control = false;
 
102
 
 
103
        has_smeter =
 
104
        has_power_out =
 
105
        has_split = has_split_AB =
 
106
        has_swr_control =
 
107
        has_ifshift_control =
 
108
        has_noise_control =
 
109
        has_micgain_control =
 
110
        has_volume_control =
 
111
        has_power_control =
 
112
        has_tune_control =
 
113
        has_attenuator_control =
 
114
        has_preamp_control =
 
115
        has_mode_control =
 
116
        has_bandwidth_control =
 
117
        has_rf_control = 
 
118
        has_sql_control =
 
119
        has_ptt_control = true;
 
120
 
 
121
        precision = 1;
 
122
        ndigits = 8;
 
123
 
 
124
}
 
125
 
 
126
bool RIG_TS570::get_ts570id()
 
127
{
 
128
        cmd = "ID;";
 
129
        int ret = sendCommand(cmd);
 
130
        showresp(WARN, ASC, "Id", cmd, replystr);
 
131
        if (ret < 6) return false;
 
132
        size_t p = replystr.rfind("ID");
 
133
        if (p == string::npos) return false;
 
134
        if (replystr[p + 3] == '1' && 
 
135
                replystr[p + 4] == '8')  return true;
 
136
        return false;
 
137
}
 
138
 
 
139
void RIG_TS570::selectA()
 
140
{
 
141
        cmd = "FR0;";
 
142
        sendCommand(cmd);
 
143
        showresp(WARN, ASC, "select A", cmd, replystr);
 
144
}
 
145
 
 
146
void RIG_TS570::selectB()
 
147
{
 
148
        cmd = "FR1;";
 
149
        sendCommand(cmd);
 
150
        showresp(WARN, ASC, "select B", cmd, replystr);
 
151
}
 
152
 
 
153
void RIG_TS570::set_split(bool val) 
 
154
{
 
155
        split = val;
 
156
        if (useB) {
 
157
                if (val) {
 
158
                        cmd = "FR1;FT0;";
 
159
                        sendCommand(cmd);
 
160
                        showresp(WARN, ASC, "Rx on B, Tx on A", cmd, replystr);
 
161
                } else {
 
162
                        cmd = "FR1;FT1;";
 
163
                        sendCommand(cmd);
 
164
                        showresp(WARN, ASC, "Rx on B, Tx on B", cmd, replystr);
 
165
                }
 
166
        } else {
 
167
                if (val) {
 
168
                        cmd = "FR0;FT1;";
 
169
                        sendCommand(cmd);
 
170
                        showresp(WARN, ASC, "Rx on A, Tx on B", cmd, replystr);
 
171
                } else {
 
172
                        cmd = "FR0;FT0;";
 
173
                        sendCommand(cmd);
 
174
                        showresp(WARN, ASC, "Rx on A, Tx on A", cmd, replystr);
 
175
                }
 
176
        }
 
177
        Fl::awake(highlight_vfo, (void *)0);
 
178
}
 
179
 
 
180
int RIG_TS570::get_split()
 
181
{
 
182
        cmd = "IF;";
 
183
        int ret = sendCommand(cmd);
 
184
        showresp(INFO, ASC, "get info", cmd, replystr);
 
185
        if (ret < 38) return split;
 
186
        size_t p = replystr.rfind("IF");
 
187
        if (p == string::npos) return split;
 
188
        split = replystr[p+32] ? true : false;
 
189
        return split;
 
190
}
 
191
 
 
192
long RIG_TS570::get_vfoA ()
 
193
{
 
194
        cmd = "FA;";
 
195
        int ret = sendCommand(cmd);
 
196
        showresp(WARN, ASC, "get vfoA", cmd, replystr);
 
197
        if (ret < 14) return A.freq;
 
198
        size_t p = replystr.rfind("FA");
 
199
        if (p == string::npos) return A.freq;
 
200
        
 
201
        int f = 0;
 
202
        for (size_t n = 2; n < 13; n++)
 
203
                f = f*10 + replystr[p + n] - '0';
 
204
        A.freq = f;
 
205
        return A.freq;
 
206
}
 
207
 
 
208
void RIG_TS570::set_vfoA (long freq)
 
209
{
 
210
        A.freq = freq;
 
211
        cmd = "FA00000000000;";
 
212
        for (int i = 12; i > 1; i--) {
 
213
                cmd[i] += freq % 10;
 
214
                freq /= 10;
 
215
        }
 
216
        sendCommand(cmd);
 
217
        showresp(WARN, ASC, "set vfoA", cmd, replystr);
 
218
}
 
219
 
 
220
long RIG_TS570::get_vfoB ()
 
221
{
 
222
        cmd = "FB;";
 
223
        int ret = sendCommand(cmd);
 
224
        showresp(WARN, ASC, "get vfoB", cmd, replystr);
 
225
        if (ret < 14) return freqB;
 
226
        size_t p = replystr.rfind("FB");
 
227
        if (p == string::npos) return freqB;
 
228
        
 
229
        int f = 0;
 
230
        for (size_t n = 2; n < 13; n++)
 
231
                f = f*10 + replystr[p + n] - '0';
 
232
        freqB = f;
 
233
        return freqB;
 
234
}
 
235
 
 
236
void RIG_TS570::set_vfoB (long freq)
 
237
{
 
238
        freqB = freq;
 
239
        cmd = "FB00000000000;";
 
240
        for (int i = 12; i > 1; i--) {
 
241
                cmd[i] += freq % 10;
 
242
                freq /= 10;
 
243
        }
 
244
        sendCommand(cmd);
 
245
        showresp(WARN, ASC, "set vfoB", cmd, replystr);
 
246
}
 
247
 
 
248
// SM cmd 0 ... 100 (rig values 0 ... 15)
 
249
int RIG_TS570::get_smeter()
 
250
{
 
251
        cmd = "SM;";
 
252
        int ret = sendCommand(cmd);
 
253
        showresp(WARN, ASC, "S meter", cmd, replystr);
 
254
        if (ret < 7) return 0;
 
255
        size_t p = replystr.rfind("SM");
 
256
        if (p == string::npos) return -1;
 
257
 
 
258
        replystr[p + 6] = 0;
 
259
        int mtr = atoi(&replystr[p + 2]);
 
260
        mtr = (mtr * 100) / 15;
 
261
        return mtr;
 
262
}
 
263
 
 
264
// RM cmd 0 ... 100 (rig values 0 ... 8)
 
265
int RIG_TS570::get_swr()
 
266
{
 
267
        cmd = "RM1;RM;"; // select measurement '1' (swr) and read meter
 
268
        int ret = sendCommand(cmd);
 
269
        showresp(WARN, ASC, "SWR", cmd, replystr);
 
270
        if (ret < 8) return 0;
 
271
        size_t p = replystr.rfind("RM1");
 
272
        if (p == string::npos) return 0;
 
273
        
 
274
        replystr[p + 7] = 0;
 
275
        int mtr = atoi(&replystr[p + 3]);
 
276
        mtr = (mtr * 100) / 15;
 
277
        return mtr;
 
278
}
 
279
 
 
280
// power output measurement 0 ... 15
 
281
int RIG_TS570::get_power_out()
 
282
{
 
283
        cmd = "SM;";
 
284
        int ret = sendCommand(cmd);
 
285
        showresp(WARN, ASC, "P out", cmd, replystr);
 
286
        if (ret < 7) return 0;
 
287
        size_t p = replystr.rfind("SM");
 
288
        if (p == string::npos) return 0;
 
289
        
 
290
        replystr[p + 6] = 0;
 
291
        int mtr = atoi(&replystr[p + 2]);
 
292
        mtr = (int)(0.34 + (((0.035*mtr - 0.407)*mtr + 5.074)*mtr));
 
293
        if (mtr < 1) mtr = 0;
 
294
        if (mtr > 100) mtr = 100;
 
295
        return mtr;
 
296
}
 
297
 
 
298
// (xcvr power level is in 5W increments)
 
299
void RIG_TS570::set_power_control(double val)
 
300
{
 
301
        int ival = (int)val;
 
302
        cmd = "PC000;";
 
303
        for (int i = 4; i > 1; i--) {
 
304
                cmd[i] += ival % 10;
 
305
                ival /= 10;
 
306
        }
 
307
        sendCommand(cmd);
 
308
        showresp(WARN, ASC, "set pwr", cmd, replystr);
 
309
}
 
310
 
 
311
int RIG_TS570::get_power_control()
 
312
{
 
313
        cmd = "PC;";
 
314
        int ret = sendCommand(cmd);
 
315
        showresp(WARN, ASC, "get pwr", cmd, replystr);
 
316
        if (ret < 6) return 0;
 
317
        size_t p = replystr.rfind("PC");
 
318
        if (p == string::npos) return 0;
 
319
        
 
320
        replystr[p + 5] = 0;
 
321
        int mtr = atoi(&replystr[p + 2]);
 
322
        return mtr;
 
323
}
 
324
 
 
325
// Volume control return 0 ... 100  (rig values 0 ... 255)
 
326
int RIG_TS570::get_volume_control()
 
327
{
 
328
        cmd = "AG;";
 
329
        int ret = sendCommand(cmd);
 
330
        showresp(WARN, ASC, "get vol", cmd, replystr);
 
331
 
 
332
        if (ret < 6) return 0;
 
333
        size_t p = replystr.rfind("AG");
 
334
        if (p == string::npos) return 0;
 
335
        
 
336
        replystr[p + 5] = 0;
 
337
        int val = atoi(&replystr[p + 2]);
 
338
        return (int)(val / 2.55);
 
339
}
 
340
 
 
341
void RIG_TS570::set_volume_control(int val)
 
342
{
 
343
        int ivol = (int)(val * 2.55);
 
344
        showresp(WARN, ASC, "set vol", cmd, replystr);
 
345
        cmd = "AG000;";
 
346
        for (int i = 4; i > 1; i--) {
 
347
                cmd[i] += ivol % 10;
 
348
                ivol /= 10;
 
349
        }
 
350
        sendCommand(cmd);
 
351
}
 
352
 
 
353
// Tranceiver PTT on/off
 
354
void RIG_TS570::set_PTT_control(int val)
 
355
{
 
356
        if (val) cmd = "TX;";
 
357
        else     cmd = "RX;";
 
358
        sendCommand(cmd);
 
359
        showresp(WARN, ASC, "PTT", cmd, replystr);
 
360
}
 
361
 
 
362
void RIG_TS570::tune_rig()
 
363
{
 
364
        cmd = "AC 11;";
 
365
        sendCommand(cmd);
 
366
        showresp(WARN, ASC, "TUNE", cmd, replystr);
 
367
}
 
368
 
 
369
void RIG_TS570::set_attenuator(int val)
 
370
{
 
371
        att_on = val;
 
372
        if (val) cmd = "RA01;";
 
373
        else     cmd = "RA00;";
 
374
        sendCommand(cmd);
 
375
        showresp(WARN, ASC, "set Att", cmd, replystr);
 
376
}
 
377
 
 
378
int RIG_TS570::get_attenuator()
 
379
{
 
380
        cmd = "RA;";
 
381
        int ret = sendCommand(cmd);
 
382
        showresp(WARN, ASC, "get Att", cmd, replystr);
 
383
        if (ret < 5) return att_on;
 
384
        size_t p = replystr.rfind("RA");
 
385
        if (p == string::npos) return att_on;
 
386
 
 
387
        if (replystr[p + 2] == '0' && 
 
388
                replystr[p + 3] == '0')
 
389
                att_on = 0;
 
390
        else
 
391
                att_on = 1;
 
392
        return att_on;
 
393
}
 
394
 
 
395
void RIG_TS570::set_preamp(int val)
 
396
{
 
397
        preamp_on = val;
 
398
        if (val) cmd = "PA1;";
 
399
        else     cmd = "PA0;";
 
400
        sendCommand(cmd);
 
401
        showresp(WARN, ASC, "set pre", cmd, replystr);
 
402
}
 
403
 
 
404
int RIG_TS570::get_preamp()
 
405
{
 
406
        cmd = "PA;";
 
407
        int ret = sendCommand(cmd);
 
408
        showresp(WARN, ASC, "get pre", cmd, replystr);
 
409
        if (ret < 4 ) return preamp_on;
 
410
        size_t p = replystr.rfind("PA");
 
411
        if (p == string::npos) return preamp_on;
 
412
 
 
413
        if (replystr[p + 2] == '1')
 
414
                preamp_on = 1;
 
415
        else
 
416
                preamp_on = 0;
 
417
        return preamp_on;
 
418
}
 
419
 
 
420
void RIG_TS570::set_widths()
 
421
{
 
422
        switch (A.imode) {
 
423
        case 0:
 
424
        case 1:
 
425
        case 3:
 
426
        case 4:
 
427
        bandwidths_ = TS570_SSBwidths;
 
428
        A.iBW = 1;
 
429
        break;
 
430
        case 2:
 
431
        case 6:
 
432
        bandwidths_ = TS570_CWwidths;
 
433
        A.iBW = 5;
 
434
        break;
 
435
        case 5:
 
436
        case 7:
 
437
        bandwidths_ = TS570_FSKwidths;
 
438
        A.iBW = 2;
 
439
        break;
 
440
        default:
 
441
        break;
 
442
        }
 
443
}
 
444
 
 
445
const char **RIG_TS570::bwtable(int m)
 
446
{
 
447
        switch (m) {
 
448
                case 0:
 
449
                case 1:
 
450
                case 3:
 
451
                case 4:
 
452
                        return TS570_SSBwidths;
 
453
                        break;
 
454
                case 2:
 
455
                case 6:
 
456
                        return TS570_CWwidths;
 
457
                        break;
 
458
                case 5:
 
459
                case 7:
 
460
                        return TS570_FSKwidths;
 
461
                        break;
 
462
        }
 
463
        return TS570_SSBwidths;
 
464
}
 
465
 
 
466
void RIG_TS570::set_modeA(int val)
 
467
{
 
468
        A.imode = val;
 
469
        cmd = "MD";
 
470
        cmd += TS570_mode_chr[val];
 
471
        cmd += ';';
 
472
        sendCommand(cmd);
 
473
        showresp(WARN, ASC, "set modeA", cmd, replystr);
 
474
        set_widths();
 
475
}
 
476
 
 
477
int RIG_TS570::get_modeA()
 
478
{
 
479
        cmd = "MD;";
 
480
        int ret = sendCommand(cmd);
 
481
        showresp(WARN, ASC, "get modeA", cmd, replystr);
 
482
        if (ret < 4) return A.imode;
 
483
        size_t p = replystr.rfind("MD");
 
484
        if (p == string::npos) return A.imode;
 
485
 
 
486
        int md = replystr[p + 2];
 
487
        md = md - '1';
 
488
        if (md == 8) md = 7;
 
489
        A.imode = md;
 
490
        set_widths();
 
491
        return A.imode;
 
492
}
 
493
 
 
494
void RIG_TS570::set_modeB(int val)
 
495
{
 
496
        B.imode = val;
 
497
        cmd = "MD";
 
498
        cmd += TS570_mode_chr[val];
 
499
        cmd += ';';
 
500
        sendCommand(cmd);
 
501
        showresp(WARN, ASC, "set modeB", cmd, replystr);
 
502
        set_widths();
 
503
}
 
504
 
 
505
int RIG_TS570::get_modeB()
 
506
{
 
507
        cmd = "MD;";
 
508
        int ret = sendCommand(cmd);
 
509
        showresp(WARN, ASC, "get modeB", cmd, replystr);
 
510
        if (ret < 4) return B.imode;
 
511
        size_t p = replystr.rfind("MD");
 
512
        if (p == string::npos) return B.imode;
 
513
 
 
514
        int md = replystr[p + 2];
 
515
        md = md - '1';
 
516
        if (md == 8) md = 7;
 
517
        B.imode = md;
 
518
        set_widths();
 
519
        return B.imode;
 
520
}
 
521
 
 
522
int RIG_TS570::adjust_bandwidth(int val)
 
523
{
 
524
        switch (val) {
 
525
        case 0:
 
526
        case 1:
 
527
        case 3:
 
528
        case 4:
 
529
                bandwidths_ = TS570_SSBwidths;
 
530
                return 1;
 
531
        case 2:
 
532
        case 6:
 
533
                bandwidths_ = TS570_CWwidths;
 
534
                return 5;
 
535
        case 5:
 
536
        case 7:
 
537
                bandwidths_ = TS570_FSKwidths;
 
538
                return 2;
 
539
        }
 
540
        return 1;
 
541
}
 
542
 
 
543
int RIG_TS570::def_bandwidth(int val)
 
544
{
 
545
        switch (val) {
 
546
        case 0:
 
547
        case 1:
 
548
        case 3:
 
549
        case 4:
 
550
                return 1;
 
551
        case 2:
 
552
        case 6:
 
553
                return 5;
 
554
        case 5:
 
555
        case 7:
 
556
                return 2;
 
557
        }
 
558
        return 2;
 
559
}
 
560
 
 
561
void RIG_TS570::set_bwA(int val)
 
562
{
 
563
        A.iBW = val;
 
564
 
 
565
        switch (A.imode) {
 
566
        case 0:
 
567
        case 1:
 
568
        case 3:
 
569
        case 4:
 
570
                cmd = TS570_SSBbw[A.iBW];
 
571
                sendCommand(cmd, 0);
 
572
                break;
 
573
        case 2:
 
574
        case 6:
 
575
                cmd = TS570_CWbw[A.iBW];
 
576
                sendCommand(cmd, 0);
 
577
                break;
 
578
        case 5:
 
579
        case 7:
 
580
                cmd = TS570_FSKbw[A.iBW];
 
581
                sendCommand(cmd, 0);
 
582
                break;
 
583
        default:
 
584
                break;
 
585
        }
 
586
        showresp(WARN, ASC, "set bwA", cmd, replystr);
 
587
}
 
588
 
 
589
int RIG_TS570::get_bwA()
 
590
{
 
591
        int i;
 
592
 
 
593
        cmd = "FW;";
 
594
        int ret = sendCommand(cmd);
 
595
        showresp(WARN, ASC, "get bwA", cmd, replystr);
 
596
        if (ret < 7) return A.iBW;
 
597
        size_t p = replystr.rfind("FW");
 
598
        if (p == string::npos) return A.iBW;
 
599
 
 
600
        string test = replystr.substr(p, 7);
 
601
 
 
602
        switch (A.imode) {
 
603
        case 0:
 
604
        case 1:
 
605
        case 3:
 
606
        case 4:
 
607
                for (i = 0; TS570_SSBbw[i] != NULL; i++)
 
608
                        if (test == TS570_SSBbw[i])  break;
 
609
                if (TS570_SSBbw[i] != NULL) A.iBW = i;
 
610
                else A.iBW = 1;
 
611
                break;
 
612
        case 2:
 
613
        case 6:
 
614
                for (i = 0; TS570_CWbw[i] != NULL; i++)
 
615
                        if (test == TS570_CWbw[i])  break;
 
616
                if (TS570_CWbw[i] != NULL) A.iBW = i;
 
617
                else A.iBW = 1;
 
618
                break;
 
619
        case 5:
 
620
        case 7:
 
621
                for (i = 0; TS570_FSKbw[i] != NULL; i++)
 
622
                        if (test == TS570_FSKbw[i])  break;
 
623
                if (TS570_FSKbw[i] != NULL) A.iBW = i;
 
624
                else A.iBW = 1;
 
625
                break;
 
626
        default:
 
627
        break;
 
628
        }
 
629
 
 
630
        return A.iBW;
 
631
}
 
632
 
 
633
void RIG_TS570::set_bwB(int val)
 
634
{
 
635
        B.iBW = val;
 
636
 
 
637
        switch (B.imode) {
 
638
        case 0:
 
639
        case 1:
 
640
        case 3:
 
641
        case 4:
 
642
                cmd = TS570_SSBbw[B.iBW];
 
643
                sendCommand(cmd, 0);
 
644
                break;
 
645
        case 2:
 
646
        case 6:
 
647
                cmd = TS570_CWbw[B.iBW];
 
648
                sendCommand(cmd, 0);
 
649
                break;
 
650
        case 5:
 
651
        case 7:
 
652
                cmd = TS570_FSKbw[B.iBW];
 
653
                sendCommand(cmd, 0);
 
654
                break;
 
655
        default:
 
656
                break;
 
657
        }
 
658
        showresp(WARN, ASC, "set bwB", cmd, replystr);
 
659
}
 
660
 
 
661
int RIG_TS570::get_bwB()
 
662
{
 
663
        int i;
 
664
 
 
665
        cmd = "FW;";
 
666
        int ret = sendCommand(cmd);
 
667
        showresp(WARN, ASC, "get bwB", cmd, replystr);
 
668
        if (ret < 7) return B.iBW;
 
669
        size_t p = replystr.rfind("FW");
 
670
        if (p == string::npos) return B.iBW;
 
671
 
 
672
        string test = replystr.substr(p,7);
 
673
 
 
674
        switch (B.imode) {
 
675
        case 0:
 
676
        case 1:
 
677
        case 3:
 
678
        case 4:
 
679
                for (i = 0; TS570_SSBbw[i] != NULL; i++)
 
680
                        if (test == TS570_SSBbw[i])  break;
 
681
                if (TS570_SSBbw[i] != NULL) B.iBW = i;
 
682
                else B.iBW = 1;
 
683
                break;
 
684
        case 2:
 
685
        case 6:
 
686
                for (i = 0; TS570_CWbw[i] != NULL; i++)
 
687
                        if (test == TS570_CWbw[i])  break;
 
688
                if (TS570_CWbw[i] != NULL) B.iBW = i;
 
689
                else B.iBW = 1;
 
690
                break;
 
691
        case 5:
 
692
        case 7:
 
693
                for (i = 0; TS570_FSKbw[i] != NULL; i++)
 
694
                        if (test == TS570_FSKbw[i])  break;
 
695
                if (TS570_FSKbw[i] != NULL) B.iBW = i;
 
696
                else B.iBW = 1;
 
697
                break;
 
698
        default:
 
699
        break;
 
700
        }
 
701
 
 
702
        return B.iBW;
 
703
}
 
704
 
 
705
int RIG_TS570::get_modetype(int n)
 
706
{
 
707
        return TS570_mode_type[n];
 
708
}
 
709
 
 
710
// val 0 .. 100
 
711
void RIG_TS570::set_mic_gain(int val)
 
712
{
 
713
        cmd = "MG000;";
 
714
        for (int i = 4; i > 1; i--) {
 
715
                cmd[i] += val % 10;
 
716
                val /= 10;
 
717
        }
 
718
        sendCommand(cmd);
 
719
        showresp(WARN, ASC, "set mic", cmd, replystr);
 
720
}
 
721
 
 
722
int RIG_TS570::get_mic_gain()
 
723
{
 
724
        cmd = "MG;";
 
725
        int ret = sendCommand(cmd);
 
726
        showresp(WARN, ASC, "get mic", cmd, replystr);
 
727
        if (ret < 6) return 0;
 
728
        size_t p = replystr.rfind("MG");
 
729
        if (p == string::npos) return 0;
 
730
 
 
731
        replystr[p + 5] = 0;
 
732
        int val = atoi(&replystr[p + 2]);
 
733
        return val;
 
734
}
 
735
 
 
736
void RIG_TS570::get_mic_min_max_step(int &min, int &max, int &step)
 
737
{
 
738
        min = 0;
 
739
        max = 100;
 
740
        step = 1;
 
741
}
 
742
 
 
743
void RIG_TS570::set_noise(bool b)
 
744
{
 
745
        if (b)
 
746
                cmd = "NB1;";
 
747
        else
 
748
                cmd = "NB0;";
 
749
        sendCommand(cmd);
 
750
        showresp(WARN, ASC, "set NB", cmd, replystr);
 
751
}
 
752
 
 
753
int  RIG_TS570::get_noise()
 
754
{
 
755
        cmd = "NB;";
 
756
        int ret = sendCommand(cmd);
 
757
        showresp(WARN, ASC, "get NB", cmd, replystr);
 
758
        if (ret < 4) return 0;
 
759
        size_t p = replystr.rfind("NB");
 
760
        if (p == string::npos) return 0;
 
761
 
 
762
        return (replystr[p + 2] == '1');
 
763
}
 
764
 
 
765
//======================================================================
 
766
// IF shift command
 
767
// step size is 100 Hz
 
768
//======================================================================
 
769
void RIG_TS570::set_if_shift(int val)
 
770
{
 
771
        cmd = "IS+0000;";
 
772
        if (val < 0) cmd[2] = '-';
 
773
        val = abs(val);
 
774
        for (int i = 6; i > 2; i--) {
 
775
                cmd[i] += val % 10;
 
776
                val /= 10;
 
777
        }
 
778
        sendCommand(cmd, 0);
 
779
        showresp(WARN, ASC, "set IF shift", cmd, replystr);
 
780
}
 
781
 
 
782
bool RIG_TS570::get_if_shift(int &val)
 
783
{
 
784
        size_t p = 0;
 
785
        cmd = "IS;";
 
786
        int ret = sendCommand(cmd);
 
787
        showresp(WARN, ASC, "get IF shift", cmd, replystr);
 
788
 
 
789
        if (ret >= 8) {
 
790
                p = replystr.rfind("IS");
 
791
                if (p == string::npos) return false;
 
792
                replystr[p + 7] = 0;
 
793
                val = atoi(&replystr[p + 3]);
 
794
                if (replystr[p+2] == '-') val = -val;
 
795
                return true;
 
796
        }
 
797
        val = 0;
 
798
        return false;
 
799
}
 
800
 
 
801
void RIG_TS570::get_if_min_max_step(int &min, int &max, int &step)
 
802
{
 
803
        min = -1000;
 
804
        max = 1000;
 
805
        step = 100;
 
806
}
 
807
 
 
808
void RIG_TS570::set_rf_gain(int val)    
 
809
{
 
810
        cmd = "RG";
 
811
        cmd.append(to_decimal(val,3)).append(";");
 
812
        sendCommand(cmd,0);
 
813
        showresp(WARN, ASC, "set rf gain", cmd, replystr);
 
814
}
 
815
 
 
816
int  RIG_TS570::get_rf_gain()
 
817
{
 
818
        int val = progStatus.rfgain;
 
819
        cmd = "RG;";
 
820
        int ret = waitN(6, 100, "get rf gain", ASC);
 
821
        if (ret < 6) return val;
 
822
        size_t p = replystr.rfind("RG");
 
823
        if (p != string::npos)
 
824
                val = fm_decimal(&replystr[p+2], 3);
 
825
        return val;
 
826
}
 
827
 
 
828
void RIG_TS570::get_rf_min_max_step(int &min, int &max, int &step)
 
829
{
 
830
        min = 0; max = 255; step = 1;
 
831
}
 
832
 
 
833
void RIG_TS570::set_squelch(int val)
 
834
{
 
835
        cmd = "SQ";
 
836
        cmd.append(to_decimal(abs(val),3)).append(";");
 
837
        sendCommand(cmd,0);
 
838
        showresp(WARN, ASC, "set squelch", cmd, replystr);
 
839
}
 
840
 
 
841
int  RIG_TS570::get_squelch()
 
842
{
 
843
        cmd = "SQ;";
 
844
        if (waitN(6, 100, "get squelch", ASC) < 6) return 0;
 
845
 
 
846
        size_t p = replystr.rfind("SQ");
 
847
 
 
848
        if (p == string::npos) return 0;
 
849
 
 
850
        replystr[p + 5] = 0;
 
851
        return atoi(&replystr[p + 2]);
 
852
}
 
853
 
 
854
void RIG_TS570::get_squelch_min_max_step(int &min, int &max, int &step)
 
855
{
 
856
        min = 0; max = 255; step = 1;
 
857
}
 
858
 
 
859