← 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/TS450S.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/TS450S.cxx
 
1
/*
 
2
 * Kenwood TS450S 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 "TS450S.h"
 
13
#include "support.h"
 
14
 
 
15
static const char TS450Sname_[] = "TS-450S";
 
16
 
 
17
static const char *TS450Smodes_[] = {
 
18
                "LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "FSK-R", NULL};
 
19
static const char TS450S_mode_chr[] =  { '1', '2', '3', '4', '5', '6', '7', '9' };
 
20
static const char TS450S_mode_type[] = { 'L', 'U', 'U', 'U', 'U', 'L', 'L', 'U' };
 
21
 
 
22
static const char *TS450S_widths[] = {
 
23
"NONE", "FM-W", "FM-N", "AM", "SSB", "CW", NULL};
 
24
static const char *TS450S_filters[] = {
 
25
"000", "002", "003", "005", "007", "009", NULL};
 
26
 
 
27
RIG_TS450S::RIG_TS450S() {
 
28
// base class values
 
29
        name_ = TS450Sname_;
 
30
        modes_ = TS450Smodes_;
 
31
        _mode_type = TS450S_mode_type;
 
32
        bandwidths_ = TS450S_widths;
 
33
        comm_baudrate = BR4800;
 
34
        stopbits = 2;
 
35
        comm_retries = 2;
 
36
        comm_wait = 5;
 
37
        comm_timeout = 50;
 
38
        comm_rtscts = true;
 
39
        comm_rtsplus = false;
 
40
        comm_dtrplus = false;
 
41
        comm_catptt = true;
 
42
        comm_rtsptt = false;
 
43
        comm_dtrptt = false;
 
44
        modeB = modeA = def_mode = 1;
 
45
        bwB = bwA = def_bw = 1;
 
46
        freqB = freqA = def_freq = 14070000;
 
47
        can_change_alt_vfo = true;
 
48
 
 
49
        has_noise_control =
 
50
        has_micgain_control =
 
51
        has_volume_control =
 
52
        has_power_control =
 
53
        has_tune_control =
 
54
        has_attenuator_control =
 
55
        has_preamp_control =
 
56
        has_notch_control =
 
57
        has_ifshift_control =
 
58
        has_swr_control = false;
 
59
 
 
60
        has_smeter =
 
61
        has_swr_control =
 
62
        has_mode_control =
 
63
        has_bandwidth_control =
 
64
        has_ptt_control = true;
 
65
 
 
66
        precision = 10;
 
67
        ndigits = 7;
 
68
 
 
69
}
 
70
 
 
71
void RIG_TS450S::initialize()
 
72
{
 
73
        cmd = "RM1;"; // select measurement '1' (swr)
 
74
        sendCommand(cmd, 0);
 
75
}
 
76
 
 
77
long RIG_TS450S::get_vfoA ()
 
78
{
 
79
        cmd = "FA;";
 
80
        int ret = sendCommand(cmd);
 
81
        showresp(WARN, ASC, "get vfo A", cmd, replystr);
 
82
        if (ret < 14) return freqA;
 
83
 
 
84
        size_t p = replystr.rfind("FA");
 
85
        if (p == string::npos) return freqA;
 
86
 
 
87
        int f = 0;
 
88
        for (size_t n = 2; n < 13; n++)
 
89
                f = f*10 + replystr[p + n] - '0';
 
90
        freqA = f;
 
91
        return freqA;
 
92
}
 
93
 
 
94
void RIG_TS450S::set_vfoA (long freq)
 
95
{
 
96
        freqA = freq;
 
97
        cmd = "FA00000000000;";
 
98
        for (int i = 12; i > 1; i--) {
 
99
                cmd[i] += freq % 10;
 
100
                freq /= 10;
 
101
        }
 
102
        sendCommand(cmd, 0);
 
103
        showresp(WARN, ASC, "set vfo A", cmd, replystr);
 
104
}
 
105
 
 
106
long RIG_TS450S::get_vfoB ()
 
107
{
 
108
        cmd = "FB;";
 
109
        int ret = sendCommand(cmd);
 
110
        showresp(WARN, ASC, "get vfo B", cmd, replystr);
 
111
        if (ret < 14) return freqB;
 
112
        size_t p = replystr.rfind("FB");
 
113
        if (p == string::npos) return freqB;
 
114
        
 
115
        int f = 0;
 
116
        for (size_t n = 2; n < 13; n++)
 
117
                f = f*10 + replystr[p + n] - '0';
 
118
        freqB = f;
 
119
        return freqB;
 
120
}
 
121
 
 
122
void RIG_TS450S::set_vfoB (long freq)
 
123
{
 
124
        freqB = freq;
 
125
        cmd = "FB00000000000;";
 
126
        for (int i = 12; i > 1; i--) {
 
127
                cmd[i] += freq % 10;
 
128
                freq /= 10;
 
129
        }
 
130
        sendCommand(cmd);
 
131
        showresp(WARN, ASC, "set vfoB", cmd, replystr);
 
132
}
 
133
 
 
134
// SM cmd 0 ... 100 (rig values 0 ... 15)
 
135
int RIG_TS450S::get_smeter()
 
136
{
 
137
        cmd = "SM;";
 
138
        int ret = sendCommand(cmd);
 
139
        showresp(WARN, ASC, "get smeter", cmd, replystr);
 
140
        if (ret < 7) return 0;
 
141
 
 
142
        size_t p = replystr.rfind("SM");
 
143
        if (p == string::npos) return 0;
 
144
 
 
145
        replystr[p + 6] = 0;
 
146
        int mtr = atoi(&replystr[p + 2]);
 
147
        mtr = (mtr * 100) / 30;
 
148
        return mtr;
 
149
}
 
150
 
 
151
// RM cmd 0 ... 100 (rig values 0 ... 8)
 
152
int RIG_TS450S::get_swr()
 
153
{
 
154
        cmd = "RM;";
 
155
        int ret = sendCommand(cmd);
 
156
        showresp(WARN, ASC, "get swr", cmd, replystr);
 
157
        if (ret < 8) return 0;
 
158
 
 
159
        size_t p = replystr.rfind("RM");
 
160
        if (p == string::npos) return 0;
 
161
        
 
162
        replystr[p + 7] = 0;
 
163
        int mtr = atoi(&replystr[p + 3]);
 
164
        mtr = (mtr * 50) / 30;
 
165
        return mtr;
 
166
}
 
167
 
 
168
 
 
169
// Tranceiver PTT on/off
 
170
void RIG_TS450S::set_PTT_control(int val)
 
171
{
 
172
        if (val) cmd = "TX;";
 
173
        else     cmd = "RX;";
 
174
        sendCommand(cmd, 0);
 
175
}
 
176
 
 
177
void RIG_TS450S::set_modeA(int val)
 
178
{
 
179
        modeA = val;
 
180
        cmd = "MD";
 
181
        cmd += TS450S_mode_chr[val];
 
182
        cmd += ';';
 
183
        sendCommand(cmd);
 
184
        showresp(WARN, ASC, "set mode A", cmd, replystr);
 
185
}
 
186
 
 
187
int RIG_TS450S::get_modeA()
 
188
{
 
189
        cmd = "IF;";
 
190
        int ret = sendCommand(cmd);
 
191
        showresp(WARN, ASC, "info mode A", cmd, replystr);
 
192
        if (ret < 38) return split;
 
193
        size_t p = replystr.rfind("IF");
 
194
        if (p == string::npos) return modeA;
 
195
        modeA = replystr[p+29] - '1'; // 0 - 6, 8
 
196
        if (modeA == 8) modeA = 7;
 
197
        return modeA;
 
198
}
 
199
 
 
200
void RIG_TS450S::set_modeB(int val)
 
201
{
 
202
        modeB = val;
 
203
        cmd = "MD";
 
204
        cmd += TS450S_mode_chr[val];
 
205
        cmd += ';';
 
206
        sendCommand(cmd);
 
207
        showresp(WARN, ASC, "set mode B", cmd, replystr);
 
208
}
 
209
 
 
210
int RIG_TS450S::get_modeB()
 
211
{
 
212
        cmd = "IF;";
 
213
        int ret = sendCommand(cmd);
 
214
        showresp(WARN, ASC, "info mode B", cmd, replystr);
 
215
        if (ret < 38) return split;
 
216
        size_t p = replystr.rfind("IF");
 
217
        if (p == string::npos) return modeA;
 
218
        modeB = replystr[p+29] - '1'; // 0 - 6, 8
 
219
        if (modeB == 8) modeB = 7;
 
220
        return modeB;
 
221
}
 
222
 
 
223
int RIG_TS450S::get_modetype(int n)
 
224
{
 
225
        return _mode_type[n];
 
226
}
 
227
 
 
228
void RIG_TS450S::set_bwA(int val)
 
229
{
 
230
        bwA = val;
 
231
        cmd = "FL";
 
232
        cmd.append(TS450S_filters[val]).append(TS450S_filters[val]);
 
233
        cmd += ';';
 
234
        sendCommand(cmd, 0);
 
235
        showresp(WARN, ASC, "set bw A", cmd, replystr);
 
236
}
 
237
 
 
238
int RIG_TS450S::get_bwA()
 
239
{
 
240
        cmd = "FL;";
 
241
        int ret = sendCommand(cmd);
 
242
        showresp(WARN, ASC, "get bw A", cmd, replystr);
 
243
        if (ret < 9) return bwA;
 
244
        size_t p = replystr.rfind("FL");
 
245
        if (p == string::npos) return bwA;
 
246
        
 
247
        replystr[p + 8] = 0;
 
248
        int bw = 0;
 
249
        while (TS450S_filters[bw]) {
 
250
                if (strcmp(&replystr[p + 5], TS450S_filters[bw]) == 0)
 
251
                        return bwA = bw;
 
252
                bw++;
 
253
        }
 
254
        return bwA;
 
255
}
 
256
 
 
257
void RIG_TS450S::set_bwB(int val)
 
258
{
 
259
        bwB = val;
 
260
        cmd = "FL";
 
261
        cmd.append(TS450S_filters[val]).append(TS450S_filters[val]);
 
262
        cmd += ';';
 
263
        sendCommand(cmd, 0);
 
264
        showresp(WARN, ASC, "set bw b", cmd, replystr);
 
265
}
 
266
 
 
267
int RIG_TS450S::get_bwB()
 
268
{
 
269
        cmd = "FL;";
 
270
        int ret = sendCommand(cmd);
 
271
        showresp(WARN, ASC, "get bw B", cmd, replystr);
 
272
        if (ret < 9) return bwB;
 
273
        size_t p = replystr.rfind("FL");
 
274
        if (p == string::npos) return bwB;
 
275
        
 
276
        replystr[p + 8] = 0;
 
277
        int bw = 0;
 
278
        while (TS450S_filters[bw]) {
 
279
                if (strcmp(&replystr[p + 5], TS450S_filters[bw]) == 0)
 
280
                        return bwB = bw;
 
281
                bw++;
 
282
        }
 
283
        return bwB;
 
284
}
 
285
 
 
286
int RIG_TS450S::def_bandwidth(int val)
 
287
{
 
288
        if (val == 0 || val == 1)
 
289
                return 4;
 
290
        else if (val == 2 || val == 6)
 
291
                return 5;
 
292
        else if (val == 3)
 
293
                return 1;
 
294
        else if (val == 4)
 
295
                return 3;
 
296
        else if (val == 5 || val == 7)
 
297
                return 2;
 
298
        return 4;
 
299
}
 
300
 
 
301
void RIG_TS450S::selectA()
 
302
{
 
303
        showresp(WARN, ASC, "select A", "", "");
 
304
        cmd = "FR0;";
 
305
        sendCommand(cmd);
 
306
        showresp(WARN, ASC, "rx on A", cmd, replystr);
 
307
        cmd = "FT0;";
 
308
        sendCommand(cmd);
 
309
        showresp(WARN, ASC, "tx on A", cmd, replystr);
 
310
}
 
311
 
 
312
void RIG_TS450S::selectB()
 
313
{
 
314
        showresp(WARN, ASC, "select B", "", "");
 
315
        cmd = "FR1;";
 
316
        sendCommand(cmd);
 
317
        showresp(WARN, ASC, "rx on B", cmd, replystr);
 
318
        cmd = "FT1;";
 
319
        sendCommand(cmd);
 
320
        showresp(WARN, ASC, "tx on B", cmd, replystr);
 
321
}
 
322
 
 
323
bool RIG_TS450S::can_split()
 
324
{
 
325
        return true;
 
326
}
 
327
 
 
328
void RIG_TS450S::set_split(bool val)
 
329
{
 
330
        if (val) {
 
331
                cmd = "FR0;";
 
332
                sendCommand(cmd);
 
333
                showresp(WARN, ASC, "rx on A", cmd, replystr);
 
334
                cmd = "FT1;";
 
335
                sendCommand(cmd);
 
336
                showresp(WARN, ASC, "tx on B", cmd, replystr);
 
337
        } else {
 
338
                cmd = "FR0;";
 
339
                sendCommand(cmd);
 
340
                showresp(WARN, ASC, "rx on A", cmd, replystr);
 
341
                cmd = "FT0;";
 
342
                sendCommand(cmd);
 
343
                showresp(WARN, ASC, "tx on A", cmd, replystr);
 
344
        }
 
345
}
 
346
 
 
347
int RIG_TS450S::get_split()
 
348
{
 
349
        cmd = "IF;";
 
350
        int ret = sendCommand(cmd);
 
351
        showresp(WARN, ASC, "info split", cmd, replystr);
 
352
        if (ret < 38) return split;
 
353
        size_t p = replystr.rfind("IF");
 
354
        if (p == string::npos) return split;
 
355
        split = replystr[p+32] ? true : false;
 
356
        return split;
 
357
}
 
358