← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rigs/TT599.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/TT599.cxx
 
1
/*
 
2
 * TenTec 599 (Eagle) driver
 
3
 *
 
4
 * a part of flrig
 
5
 * 
 
6
 * Copyright 2011, Dave Freese, W1HKJ
 
7
 * 
 
8
 */
 
9
 
 
10
#include "TT599.h"
 
11
 
 
12
//=============================================================================
 
13
// TT-599
 
14
 
 
15
const char RIG_TT599name_[] = "Eagle";
 
16
 
 
17
const char *RIG_TT599modes_[] = {
 
18
                "USB", "LSB", "CWU", "CWL", "AM", "FM", NULL};
 
19
static const int  RIG_TT599_def_bw[] = { 19, 19, 7, 7, 24, 19 };
 
20
static const char RIG_TT599_mode_type[] = {'U', 'L', 'U', 'L', 'U', 'U'};
 
21
 
 
22
const char *RIG_TT599widths[] = { 
 
23
"100",  "200",  "300",  "400",  "500",
 
24
"600",  "700",  "800",  "900",  "1000",
 
25
"1200", "1400", "1600", "1800", "2000",
 
26
"2200", "2400", "2600", "2800", "3000",
 
27
"3200", "3400", "3600", "3800", "4000",
 
28
NULL};
 
29
 
 
30
static GUI rig_widgets[]= {
 
31
        { (Fl_Widget *)sldrPOWER,   266, 105, 156 },
 
32
        { (Fl_Widget *)NULL,          0,   0,   0 }
 
33
};
 
34
 
 
35
RIG_TT599::RIG_TT599() {
 
36
        name_ = RIG_TT599name_;
 
37
        modes_ = RIG_TT599modes_;
 
38
        bandwidths_ = RIG_TT599widths;
 
39
 
 
40
        widgets = rig_widgets;
 
41
 
 
42
        comm_baudrate = BR57600;
 
43
        stopbits = 1;
 
44
        comm_retries = 2;
 
45
        comm_wait = 10;
 
46
        comm_timeout = 50;
 
47
        comm_echo = false;
 
48
        comm_rtscts = true;
 
49
        comm_rtsplus = false;
 
50
        comm_dtrplus = true;
 
51
        comm_catptt = true;
 
52
        comm_rtsptt = false;
 
53
        comm_dtrptt = false;
 
54
        modeA = 1;
 
55
        bwA = 16;
 
56
        can_change_alt_vfo = true;
 
57
 
 
58
        max_power = 100;
 
59
 
 
60
        has_smeter =
 
61
        has_power_out =
 
62
        has_split =
 
63
        has_split_AB =
 
64
        has_swr_control =
 
65
        has_mode_control =
 
66
        has_bandwidth_control =
 
67
        has_ptt_control =
 
68
        has_preamp_control =
 
69
        has_auto_notch =
 
70
        has_attenuator_control =
 
71
        has_power_control = true;
 
72
//      has_agc_level = true;
 
73
 
 
74
        precision = 1;
 
75
        ndigits = 8;
 
76
 
 
77
};
 
78
 
 
79
void RIG_TT599::initialize()
 
80
{
 
81
        rig_widgets[0].W = sldrPOWER;
 
82
 
 
83
        cmd = "X\r";
 
84
        sendCommand(cmd, 0);
 
85
        MilliSleep(200);
 
86
        readResponse();
 
87
        showresp(WARN, ASC, "init", cmd, replystr);
 
88
 
 
89
        split = false;
 
90
        cmd = "*KVAAA\r";
 
91
        sendCommand(cmd, 0);
 
92
        MilliSleep(200);
 
93
        readResponse();
 
94
        showresp(WARN, ASC, "normal", cmd, replystr);
 
95
}
 
96
 
 
97
void RIG_TT599::shutdown()
 
98
{
 
99
        cmd = "*RMF0\r";
 
100
        sendCommand(cmd, 0);
 
101
        readResponse();
 
102
        showresp(WARN, ASC, "Enable BW control", cmd, replystr);
 
103
}
 
104
 
 
105
long RIG_TT599::get_vfoA ()
 
106
{
 
107
        size_t p;
 
108
        cmd = "?AF\r";
 
109
        sendCommand(cmd);
 
110
        showresp(WARN, ASC, "get vfoA", cmd, replystr);
 
111
        if ((p = replystr.rfind("@AF")) != string::npos) {
 
112
                freqA = fm_decimal(&replystr[p+3], 8);
 
113
        }
 
114
        return freqA;
 
115
}
 
116
 
 
117
void RIG_TT599::set_vfoA (long freq)
 
118
{
 
119
        freqA = freq;
 
120
        cmd = "*AF";
 
121
        cmd.append( to_decimal( freq, 8 ) );
 
122
        cmd += '\r';
 
123
        sendCommand(cmd);
 
124
        showresp(WARN, ASC, "set vfoA", cmd, replystr);
 
125
}
 
126
 
 
127
long RIG_TT599::get_vfoB ()
 
128
{
 
129
        size_t p;
 
130
        cmd = "?BF\r";
 
131
        sendCommand(cmd);
 
132
        showresp(WARN, ASC, "get vfoB", cmd, replystr);
 
133
        if ((p = replystr.rfind("@BF")) != string::npos) {
 
134
                freqB = fm_decimal(&replystr[p+3], 8);
 
135
        }
 
136
        return freqB;
 
137
}
 
138
 
 
139
void RIG_TT599::set_vfoB (long freq)
 
140
{
 
141
        freqB = freq;
 
142
        cmd = "*BF";
 
143
        cmd.append( to_decimal( freq, 8 ) );
 
144
        cmd += '\r';
 
145
        LOG_WARN("set B : %s", cmd.c_str());
 
146
        sendCommand(cmd);
 
147
        showresp(WARN, ASC, "set vfoB", cmd, replystr);
 
148
}
 
149
 
 
150
void RIG_TT599::set_PTT_control(int val)
 
151
{
 
152
        cmd = val ? "*TK\r" : "*TU\r";
 
153
        sendCommand(cmd);
 
154
        showresp(WARN, ASC, "set PTT", cmd, replystr);
 
155
}
 
156
 
 
157
void RIG_TT599::set_modeA(int md)
 
158
{
 
159
        modeA = md;
 
160
        cmd = "*RMM";
 
161
        cmd += '0' + md;
 
162
        cmd += '\r';
 
163
        sendCommand(cmd);
 
164
        showresp(WARN, ASC, "set modeA", cmd, replystr);
 
165
}
 
166
 
 
167
int RIG_TT599::get_modeA()
 
168
{
 
169
        size_t p;
 
170
        cmd = "?RMM\r";
 
171
        sendCommand(cmd);
 
172
        showresp(WARN, ASC, "get modeA", cmd, replystr);
 
173
        if ((p = replystr.rfind("@RMM")) != string::npos) {
 
174
                modeA = replystr[p+4] - '0';
 
175
        }
 
176
        return modeA;
 
177
}
 
178
 
 
179
void RIG_TT599::set_modeB(int md)
 
180
{
 
181
        modeB = md;
 
182
        cmd = "*RMM";
 
183
        cmd += '0' + md;
 
184
        cmd += '\r';
 
185
        sendCommand(cmd);
 
186
        showresp(WARN, ASC, "set modeB", cmd, replystr);
 
187
}
 
188
 
 
189
int RIG_TT599::get_modeB()
 
190
{
 
191
        size_t p;
 
192
        cmd = "?RMM\r";
 
193
        sendCommand(cmd);
 
194
        showresp(WARN, ASC, "get modeB", cmd, replystr);
 
195
        if ((p = replystr.rfind("@RMM")) != string::npos) {
 
196
                modeB = replystr[p+4] - '0';
 
197
        }
 
198
        return modeB;
 
199
}
 
200
 
 
201
void RIG_TT599::set_bwA(int bw)
 
202
{
 
203
        cmd = "*RMF";
 
204
        cmd.append(RIG_TT599widths[bw]);
 
205
        cmd += '\r';
 
206
        sendCommand(cmd);
 
207
        showresp(WARN, ASC, "set bwA", cmd, replystr);
 
208
        bwA = bw;
 
209
}
 
210
 
 
211
int RIG_TT599::get_bwA()
 
212
{
 
213
        size_t p;
 
214
        cmd = "?RMF\r";
 
215
        sendCommand(cmd);
 
216
        showresp(WARN, ASC, "get bwA", cmd, replystr);
 
217
 
 
218
        if ((p = replystr.rfind("@RMF")) != string::npos) {
 
219
                string bwstr = replystr.substr(p+4);
 
220
                p = bwstr.find("\r");
 
221
                if ( p != string::npos)
 
222
                        bwstr.erase(p, string::npos);
 
223
                if (bwstr.empty()) return bwA;
 
224
                int i = 0;
 
225
                while( RIG_TT599widths[i] != NULL) {
 
226
                        if (bwstr == RIG_TT599widths[i]) {
 
227
                                bwA = i;
 
228
                                break;
 
229
                        }
 
230
                        i++;
 
231
                }
 
232
        }
 
233
        return bwA;
 
234
}
 
235
 
 
236
void RIG_TT599::set_bwB(int bw)
 
237
{
 
238
        cmd = "*RMF";
 
239
        cmd.append(RIG_TT599widths[bw]);
 
240
        cmd += '\r';
 
241
        sendCommand(cmd);
 
242
        showresp(WARN, ASC, "set bwB", cmd, replystr);
 
243
        bwB = bw;
 
244
}
 
245
 
 
246
int RIG_TT599::get_bwB()
 
247
{
 
248
        size_t p;
 
249
        cmd = "?RMF\r";
 
250
        sendCommand(cmd);
 
251
        showresp(WARN, ASC, "get bwB", cmd, replystr);
 
252
 
 
253
        if ((p = replystr.rfind("@RMF")) != string::npos) {
 
254
                string bwstr = replystr.substr(p+4);
 
255
                p = bwstr.find("\r");
 
256
                if ( p != string::npos)
 
257
                        bwstr.erase(p, string::npos);
 
258
                if (bwstr.empty()) return bwB;
 
259
                int i = 0;
 
260
                while( RIG_TT599widths[i] != NULL) {
 
261
                        if (bwstr == RIG_TT599widths[i]) {
 
262
                                bwA = i;
 
263
                                break;
 
264
                        }
 
265
                        i++;
 
266
                }
 
267
        }
 
268
        return bwB;
 
269
}
 
270
 
 
271
int  RIG_TT599::adjust_bandwidth(int m)
 
272
{
 
273
        return RIG_TT599_def_bw[m];
 
274
}
 
275
 
 
276
int  RIG_TT599::def_bandwidth(int m)
 
277
{
 
278
        return RIG_TT599_def_bw[m];
 
279
}
 
280
 
 
281
int RIG_TT599::get_modetype(int n)
 
282
{
 
283
        return RIG_TT599_mode_type[n];
 
284
}
 
285
 
 
286
void RIG_TT599::set_preamp(int val)
 
287
{
 
288
        cmd = val ? "*RME1\r" : "*RME0\r";
 
289
        sendCommand(cmd);
 
290
        showresp(WARN, ASC, "set preamp", cmd, replystr);
 
291
}
 
292
 
 
293
int RIG_TT599::get_preamp()
 
294
{
 
295
        size_t p;
 
296
        cmd = "?RME\r";
 
297
        sendCommand(cmd);
 
298
        showresp(WARN, ASC, "get preamp", cmd, replystr);
 
299
 
 
300
        if ((p = replystr.rfind("@RME")) != string::npos)
 
301
                return replystr[p+4] - '0';
 
302
        return 0;
 
303
}
 
304
 
 
305
//void RIG_TT599::set_agc_level()
 
306
//{
 
307
// *RMAF - fast *RMAM - medium *RMAS - slow
 
308
//}
 
309
 
 
310
int  RIG_TT599::get_power_control(void)
 
311
{
 
312
        size_t p;
 
313
        cmd = "?TP\r";
 
314
        sendCommand(cmd);
 
315
        showresp(WARN, ASC, "get pc", cmd, replystr);
 
316
 
 
317
        if ((p = replystr.rfind("@TP")) != string::npos) {
 
318
                int pwr = 0;
 
319
                sscanf(&replystr[p+3], "%d", &pwr);
 
320
                return pwr;
 
321
        }
 
322
        return progStatus.power_level;//0;
 
323
}
 
324
 
 
325
void RIG_TT599::set_power_control(double val) 
 
326
{
 
327
        char szCmd[12];
 
328
        snprintf(szCmd, sizeof(szCmd), "*TP%d\r", (int)val);
 
329
        sendCommand(szCmd);
 
330
        showresp(WARN, ASC, "set pc", cmd, replystr);
 
331
}
 
332
 
 
333
void RIG_TT599::set_auto_notch(int v)
 
334
{
 
335
        cmd = v ? "*RMNA1\r" : "*RMNA0\r";
 
336
        sendCommand(cmd);
 
337
        showresp(WARN, ASC, "set AN", cmd, replystr);
 
338
}
 
339
 
 
340
int  RIG_TT599::get_auto_notch()
 
341
{
 
342
        cmd = "?RMNA\r";
 
343
        sendCommand(cmd);
 
344
        showresp(WARN, ASC, "get AN", cmd, replystr);
 
345
 
 
346
        if (replystr.rfind("@RMNA1") == string::npos)
 
347
                return 0;
 
348
        return 1;
 
349
}
 
350
 
 
351
void RIG_TT599::set_attenuator(int val)
 
352
{
 
353
        cmd = val ? "*RMT1\r" : "*RMT0\r";
 
354
        sendCommand(cmd);
 
355
        showresp(WARN, ASC, "set ATT", cmd, replystr);
 
356
}
 
357
 
 
358
int  RIG_TT599::get_attenuator()
 
359
{
 
360
        size_t p;
 
361
        cmd = "?RMT\r";
 
362
        sendCommand(cmd);
 
363
        showresp(WARN, ASC, "get ATT", cmd, replystr);
 
364
 
 
365
        if ((p = replystr.rfind("@RMT1")) != string::npos)
 
366
                return 1;
 
367
        return 0;
 
368
}
 
369
 
 
370
int smeter_count = 10;
 
371
int  RIG_TT599::get_smeter()
 
372
{
 
373
        size_t p;
 
374
        int dbm = 0;
 
375
        cmd = "?S\r";
 
376
        sendCommand(cmd);
 
377
        showresp(WARN, ASC, "get Smeter", cmd, replystr);
 
378
 
 
379
        if ((p = replystr.rfind("@SRM")) != string::npos)
 
380
                sscanf(&replystr[p+4], "%d", &dbm);
 
381
        return 5 * dbm / 6;
 
382
}
 
383
 
 
384
int  RIG_TT599::get_swr()
 
385
{
 
386
        float swr = (sqrtf(fwdpwr) + sqrtf(refpwr))/(sqrt(fwdpwr) - sqrt(refpwr) + .0001);
 
387
        swr -= 1.0;
 
388
        swr *= 25.0;
 
389
        if (swr < 0) swr = 0;
 
390
        if (swr > 100) swr = 100;
 
391
        return (int)swr;
 
392
 
 
393
}
 
394
 
 
395
int  RIG_TT599::get_power_out()
 
396
{
 
397
        size_t p;
 
398
        fwdpwr = 0; refpwr = 0;
 
399
        cmd = "?S\r";
 
400
        sendCommand(cmd);
 
401
        showresp(WARN, ASC, "get pout", cmd, replystr);
 
402
 
 
403
        if ((p = replystr.rfind ("@STF")) != string::npos) {
 
404
                sscanf(&replystr[p+4], "%d", &fwdpwr);
 
405
                p = replystr.find("R", p+4);
 
406
                if (p != string::npos) {
 
407
                        sscanf(&replystr[p+1], "%d", &refpwr);
 
408
                        refpwr /= 10;
 
409
                }
 
410
        }
 
411
        return fwdpwr;
 
412
}
 
413
 
 
414
void  RIG_TT599:: set_split(bool val)
 
415
{
 
416
        split = val;
 
417
        cmd = val ? "*KVAAB\r" : "*KVAAA\r";
 
418
        sendCommand(cmd);
 
419
        showresp(WARN, ASC, "set split", cmd, replystr);
 
420
}
 
421
 
 
422
int RIG_TT599::get_split()
 
423
{
 
424
        cmd = "?KV\r";
 
425
        sendCommand(cmd);
 
426
        showresp(WARN, ASC, "get split", cmd, replystr);
 
427
        size_t p = replystr.find("@KVAA");
 
428
        if ((p != string::npos) && (replystr[p+5] == 'B')) split = 1;
 
429
        else split = 0;
 
430
        return split;
 
431
}
 
432
 
 
433