← 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/K2.cxx

  • Committer: Package Import Robot
  • Author(s): Kamal Mostafa
  • Date: 2014-10-25 11:17:10 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20141025111710-n32skgya3l9u1brw
Tags: 1.3.17-1
http://bugs.debian.org/761839
* New upstream release (Closes: #761839)
* Debian Standards-Version: 3.9.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0001-License-Declaration.patch/src/rigs/K2.cxx
1
 
/*
2
 
 * K2 drivers
3
 
 * 
4
 
 * a part of flrig
5
 
 * 
6
 
 * Copyright 2009, Dave Freese, W1HKJ
7
 
 *
8
 
 * Additions by Kent Haase, VE4KEH
9
 
 * Ref Elecraft KIO2 Programmer's Reference (Rev E, 3 Feb, 2004)
10
 
 * K2 MCU firmware rev 2.04
11
 
 * 
12
 
*/
13
 
 
14
 
#include "K2.h"
15
 
#include "support.h"
16
 
#include "status.h"
17
 
 
18
 
const char K2name_[] = "K2";
19
 
 
20
 
const char *K2modes_[] = {
21
 
                "LSB", "USB", "CW", "FM", "AM", "RTTY-L", "CW-R", "USER-L", "RTTY-U", NULL};
22
 
 
23
 
static const char K2_mode_type[] =
24
 
        {'L', 'U', 'U', 'U', 'U', 'L', 'L', 'L', 'U', 'U'};
25
 
 
26
 
const char *K2_widths[] = {"FL1", "FL2", "FL3", "FL4", NULL};
27
 
 
28
 
static GUI k2_widgets[]= {
29
 
        { (Fl_Widget *)sldrPOWER, 266, 105, 156 },
30
 
        { (Fl_Widget *)NULL, 0, 0, 0 }
31
 
};
32
 
 
33
 
RIG_K2::RIG_K2() {
34
 
// base class values    
35
 
        name_ = K2name_;
36
 
        modes_ = K2modes_;
37
 
        bandwidths_ = K2_widths;
38
 
 
39
 
        widgets = k2_widgets;
40
 
 
41
 
        comm_baudrate = BR4800;
42
 
        stopbits = 2;
43
 
        comm_retries = 3;
44
 
        comm_wait = 50;
45
 
        comm_timeout = 200;
46
 
        comm_rtscts = false;
47
 
        comm_rtsplus = false;
48
 
        comm_dtrplus = false;
49
 
        comm_catptt = true;
50
 
        comm_rtsptt = false;
51
 
        comm_dtrptt = false;
52
 
        modeB = modeA = 1;
53
 
        bwB = bwA = 0;
54
 
        freqB = freqA = 14070000;
55
 
 
56
 
        has_split_AB =
57
 
        has_get_info =
58
 
        has_attenuator_control =
59
 
        has_preamp_control =
60
 
        has_power_control =
61
 
        has_mode_control =
62
 
        has_bandwidth_control =
63
 
        has_ptt_control =
64
 
        has_split =
65
 
        has_smeter =
66
 
        has_power_out =
67
 
        has_tune_control = true;
68
 
 
69
 
        K2split =
70
 
        has_micgain_control =
71
 
        has_notch_control =
72
 
        has_ifshift_control =
73
 
        has_volume_control =
74
 
        has_swr_control = false;
75
 
 
76
 
        hipower = false;
77
 
 
78
 
        precision = 10;
79
 
        ndigits = 7;
80
 
 
81
 
}
82
 
 
83
 
int  RIG_K2::adjust_bandwidth(int m)
84
 
{
85
 
        return 0;
86
 
}
87
 
 
88
 
void RIG_K2::initialize()
89
 
{
90
 
        k2_widgets[0].W = sldrPOWER;
91
 
 
92
 
//enable extended command mode
93
 
        sendCommand("K22;", 0);
94
 
//disable auto reporting of info
95
 
        sendCommand("AI0;", 0);
96
 
//ensure K2 is in VFO A
97
 
    get_power_control();
98
 
}
99
 
 
100
 
/*
101
 
 * IF (Transceiver Information; GET only)
102
 
 * 
103
 
 * RSP format: IF[f]*****+yyyyrx*00tmvspb01*; where the fields are defined as follows:
104
 
 * 
105
 
 * 0         1         2         3
106
 
 * 0123456789012345678901234567890123456789
107
 
 * IFfffffffffff*****+yyyyrx*00tmvspb01*;
108
 
 *   0..1   IF 
109
 
 *   2..12  [f] operating frequency, excluding any RIT/XIT offset (11 digits; see FA command)
110
 
 *   13..17 * represents a space (BLANK, or ASCII 0x20)
111
 
 *   18     + either "+" or "-" (sign of RIT/XIT offset)
112
 
 *   19..22 yyyy RIT/XIT offset in Hz (range is -9990 to +9990 Hz when computer-controlled)
113
 
 *   23     r 1 if RIT is on, 0 if off
114
 
 *   24     x 1 if XIT is on, 0 if off
115
 
 *   25..27 fill
116
 
 *   28     t 1 if the K2 is in transmit mode, 0 if receive
117
 
 *   29     m operating mode (see MD command)
118
 
 *   30     v receive-mode VFO selection, 0 for VFO A, 1 for VFO B
119
 
 *   31     s 1 if scan is in progress, 0 otherwise
120
 
 *   32     p 1 if the transeiver is in split mode, 0 otherwise
121
 
 *   33     b basic RSP format: always 0
122
 
 *            extended RSP format: 
123
 
 *                1 if the present IF response is due to a K2 band change and 
124
 
 *                0 otherwise
125
 
 *   34..35 fill
126
 
 *   37     ; terminator
127
 
 * The fixed-value fields (space, 0, and 1) are provided for syntactic compatibility with existing software.
128
 
*/
129
 
// set replystr to teststr to test for various control bytes
130
 
//const char *teststr = "IFfffffffffff*****+yyyyrx*000m0s1b01*;";
131
 
 
132
 
static void do_selectA(void *)
133
 
{
134
 
        cb_selectA();
135
 
}
136
 
 
137
 
static void do_selectB(void *)
138
 
{
139
 
        cb_selectB();
140
 
}
141
 
 
142
 
bool RIG_K2::get_info()
143
 
{
144
 
        rsp = cmd = "IF";
145
 
        cmd += ';';
146
 
        int ret = waitN(38, 100, "get info", ASC);
147
 
        if (ret < 38) return false;
148
 
        size_t p = replystr.find(rsp);
149
 
        if (PTT && (replystr[p+28]=='0')) Fl::awake(setPTT, (void*)0);
150
 
        if (!PTT && (replystr[p+28]=='1')) Fl::awake(setPTT, (void*)1);
151
 
        if (useB && (replystr[p+30]=='0')) Fl::awake(do_selectA, (void*)0);
152
 
        else if(!useB && (replystr[p+30]=='1')) Fl::awake(do_selectB, (void*)0);
153
 
        K2split = replystr[p+32]-'0';
154
 
        return true;
155
 
}
156
 
 
157
 
void RIG_K2::selectA()
158
 
{
159
 
        cmd = "FR0;FT0";
160
 
        sendCommand(cmd);
161
 
        K2split = false;
162
 
        showresp(WARN, ASC, "select A", cmd, replystr);
163
 
}
164
 
 
165
 
void RIG_K2::selectB()
166
 
{
167
 
        cmd = "FR1;FT1";
168
 
        sendCommand(cmd);
169
 
        K2split = false;
170
 
        showresp(WARN, ASC, "select B", cmd, replystr);
171
 
}
172
 
 
173
 
bool RIG_K2::can_split()
174
 
{
175
 
        return true;
176
 
}
177
 
 
178
 
void RIG_K2::set_split(bool val)
179
 
{
180
 
        if (val) {
181
 
                if (useB)
182
 
                        cmd = "FR1;FT0;";
183
 
                else
184
 
                        cmd = "FR0;FT1;";
185
 
                sendCommand(cmd);
186
 
                showresp(WARN, ASC, "set split ON", cmd, replystr);
187
 
        } else {
188
 
                if (useB)
189
 
                        cmd = "FR1;FT1;";
190
 
                else
191
 
                        cmd = "FR0;FT0;";
192
 
                sendCommand(cmd);
193
 
                showresp(WARN, ASC, "set split OFF", cmd, replystr);
194
 
        }
195
 
}
196
 
 
197
 
int RIG_K2::get_split()
198
 
{
199
 
        return K2split;
200
 
}
201
 
 
202
 
long RIG_K2::get_vfoA ()
203
 
{
204
 
        rsp = cmd = "FA";
205
 
        cmd += ';';
206
 
        int ret = waitN(14, 100, "get vfo A", ASC);
207
 
        if (ret < 14) return freqA;
208
 
        size_t p = replystr.rfind(rsp);
209
 
        if (p == string::npos) return freqA;
210
 
        long f = 0;
211
 
        for (size_t n = 2; n < 13; n++)
212
 
                f = f*10 + replystr[p + n] - '0';
213
 
        freqA = f;
214
 
        return freqA;
215
 
}
216
 
 
217
 
void RIG_K2::set_vfoA (long freq)
218
 
{
219
 
        freqA = freq;
220
 
        cmd = "FA00000000000;";
221
 
        for (int i = 12; i > 1; i--) {
222
 
                cmd[i] += freq % 10;
223
 
                freq /= 10;
224
 
        }
225
 
        sendCommand(cmd);
226
 
        showresp(WARN, ASC, "SET vfo A", cmd, replystr);
227
 
}
228
 
 
229
 
long RIG_K2::get_vfoB()
230
 
{
231
 
        rsp = cmd = "FB";
232
 
        cmd += ';';
233
 
        int ret = waitN(14, 100, "get vfo B", ASC);
234
 
        if (ret < 14) return freqB;
235
 
        size_t p = replystr.rfind(rsp);
236
 
        if (p == string::npos) return freqB;
237
 
        long f = 0;
238
 
        for (size_t n = 2; n < 13; n++)
239
 
                f = f*10 + replystr[p + n] - '0';
240
 
        freqB = f;
241
 
        return freqB;
242
 
}
243
 
 
244
 
void RIG_K2::set_vfoB(long freq)
245
 
{
246
 
        freqB = freq;
247
 
        cmd = "FB00000000000;";
248
 
        for (int i = 12; i > 1; i--) {
249
 
                cmd[i] += freq % 10;
250
 
                freq /= 10;
251
 
        }
252
 
        sendCommand(cmd);
253
 
        showresp(WARN, ASC, "SET vfo B", cmd, replystr);
254
 
}
255
 
 
256
 
void RIG_K2::set_modeA(int val)
257
 
{
258
 
        modeA = val;
259
 
        val++;
260
 
        cmd = "MD0;";
261
 
        cmd[2] += val;
262
 
        sendCommand(cmd);
263
 
        showresp(WARN, ASC, "SET mode A", cmd, replystr);
264
 
}
265
 
 
266
 
int RIG_K2::get_modeA()
267
 
{
268
 
        rsp = cmd = "MD";
269
 
        cmd += ';';
270
 
        int ret = waitN(4, 100, "get mode A", ASC);
271
 
        if (ret < 4) return 0;
272
 
        size_t p = replystr.rfind(rsp);
273
 
        if (p == string::npos) return 0;
274
 
        modeA = replystr[p + 2] - '1';
275
 
        return modeA;
276
 
}
277
 
 
278
 
void RIG_K2::set_modeB(int val)
279
 
{
280
 
        modeB = val;
281
 
        val++;
282
 
        cmd = "MD0;";
283
 
        cmd[2] += val;
284
 
        sendCommand(cmd);
285
 
        showresp(WARN, ASC, "SET mode B", cmd, replystr);
286
 
}
287
 
 
288
 
int  RIG_K2::get_modeB()
289
 
{
290
 
        rsp = cmd = "MD";
291
 
        cmd += ';';
292
 
        int ret = waitN(4, 100, "get mode B", ASC);
293
 
        if (ret < 4) return 0;
294
 
        size_t p = replystr.rfind(rsp);
295
 
        if (p == string::npos) return 0;
296
 
        modeB = replystr[p + 2] - '1';
297
 
        return modeB;
298
 
}
299
 
 
300
 
int RIG_K2::get_modetype(int n)
301
 
{
302
 
        return K2_mode_type[n];
303
 
}
304
 
 
305
 
void RIG_K2::set_bwA(int val)
306
 
{
307
 
        bwA = val;
308
 
        switch (val) {
309
 
                case 0 : cmd = "FW00001;"; break;
310
 
                case 1 : cmd = "FW00002;"; break;
311
 
                case 2 : cmd = "FW00003;"; break;
312
 
                case 3 : cmd = "FW00004;"; break;
313
 
                default: cmd = "FW00001;";
314
 
        }
315
 
        sendCommand(cmd);
316
 
        showresp(WARN, ASC, "set bwA", cmd, replystr);
317
 
}
318
 
 
319
 
int RIG_K2::get_bwA()
320
 
{
321
 
        rsp = cmd = "FW";
322
 
        cmd += ';';
323
 
        int ret = waitN(9, 100, "get bw A", ASC);
324
 
        if (ret < 9) return 0;
325
 
        size_t p = replystr.rfind(rsp);
326
 
        if (p == string::npos) return 0;
327
 
        bwA = replystr[p + 6] - '1';
328
 
        return bwA;
329
 
}
330
 
 
331
 
void RIG_K2::set_bwB(int val)
332
 
{
333
 
        bwB = val;
334
 
        switch (val) {
335
 
                case 0 : cmd = "FW00001;"; break;
336
 
                case 1 : cmd = "FW00002;"; break;
337
 
                case 2 : cmd = "FW00003;"; break;
338
 
                case 3 : cmd = "FW00004;"; break;
339
 
                default: cmd = "FW00001;";
340
 
        }
341
 
        sendCommand(cmd);
342
 
        showresp(WARN, ASC, "set bwA", cmd, replystr);
343
 
}
344
 
 
345
 
int  RIG_K2::get_bwB()
346
 
{
347
 
        rsp = cmd = "FW";
348
 
        cmd += ';';
349
 
        int ret = waitN(9, 100, "get bw B", ASC);
350
 
        if (ret < 9) return 0;
351
 
        size_t p = replystr.rfind(rsp);
352
 
        if (p == string::npos) return 0;
353
 
        bwB = replystr[p + 6] - '1';
354
 
        return bwB;
355
 
}
356
 
 
357
 
void RIG_K2::tune_rig()
358
 
{
359
 
        cmd = "SW20;";
360
 
        sendCommand(cmd);
361
 
        showresp(WARN, ASC, "tune", cmd, replystr);
362
 
}
363
 
 
364
 
int RIG_K2::get_smeter()
365
 
{
366
 
        rsp = cmd = "BG";
367
 
        cmd += ';';
368
 
        int ret = waitN(5, 100, "get smeter", ASC);
369
 
        if (ret < 5) return 0;
370
 
        size_t p = replystr.rfind(rsp);
371
 
        if (p == string::npos) return 0;
372
 
        int mtr = 10 * (replystr[p + 2] - '0') 
373
 
                        + replystr[p + 3] - '0';   //assemble two chars into 2 digit int
374
 
        if (mtr > 10) {                    //if int greater than 10 (bar mode)
375
 
            mtr -= 12;                     //shift down to 0 thru 10
376
 
        }
377
 
        mtr *= 10;                         //normalize to 0 thru 100
378
 
        return mtr;
379
 
}
380
 
 
381
 
int RIG_K2::get_power_out()
382
 
{
383
 
        rsp = cmd = "BG";
384
 
        cmd += ';';
385
 
        int ret = waitN(5, 100, "get power", ASC);
386
 
        if (ret < 5) return 0;
387
 
        size_t p = replystr.rfind(rsp);
388
 
        if (p == string::npos) return 0;
389
 
        int mtr = 10 * (replystr[p + 2] - '0') 
390
 
                        + replystr[p + 3] - '0';   //assemble two chars into 2 digit int
391
 
        if (mtr > 10) {                           //if int greater than 10 (bar mode)
392
 
            mtr -= 12;                            //shift down to 0 thru 10
393
 
        }
394
 
        mtr *= 10;                                //normalize to 0 thru 100
395
 
        return mtr;
396
 
}
397
 
 
398
 
int RIG_K2::get_power_control()
399
 
{
400
 
        rsp = cmd = "PC;";  // extended mode for get power
401
 
        cmd += ';';
402
 
        int ret = waitN(7, 100, "get pwr cont", ASC);
403
 
        if (ret < 7) return progStatus.power_level;
404
 
        size_t p = replystr.rfind(rsp);
405
 
        if (p == string::npos) return 0;
406
 
        hipower = (replystr[p+5] == '1');
407
 
        int mtr = fm_decimal(&replystr[p+4], 3);
408
 
        if (!hipower) mtr /= 10;
409
 
        return mtr;
410
 
}
411
 
 
412
 
void RIG_K2::set_power_control(double val)
413
 
{
414
 
    int ival = (int)val;
415
 
        cmd = "PC";                    //init the cmd string
416
 
        if (val > 15) {
417
 
                hipower = true;
418
 
                cmd[5] = '1';
419
 
                cmd.append(to_decimal(ival,3)).append("1;");
420
 
        } else {
421
 
                hipower = false;
422
 
                cmd.append(to_decimal((int)(val*10),3)).append("0;");
423
 
        }
424
 
        sendCommand(cmd);
425
 
        showresp(WARN, ASC, "SET pwr", cmd, replystr);
426
 
}
427
 
 
428
 
void RIG_K2::get_pc_min_max_step(double &min, double &max, double &step)
429
 
{
430
 
        if (hipower) {
431
 
                min = 1.0; max_power = max = 110.0; step = 1.0;
432
 
        } else {
433
 
                min = 0.1; max_power = max = 20; step = 0.1;
434
 
        }
435
 
}
436
 
 
437
 
void RIG_K2::set_PTT_control(int val)
438
 
{
439
 
        if (val) cmd = "TX;";
440
 
        else     cmd = "RX;";
441
 
        sendCommand(cmd);
442
 
        showresp(WARN, ASC, "SET ptt", cmd, replystr);
443
 
}
444
 
 
445
 
void RIG_K2::set_attenuator(int val)
446
 
{
447
 
        if (val) cmd = "RA01;";
448
 
        else     cmd = "RA00;";
449
 
        sendCommand(cmd);
450
 
        showresp(WARN, ASC, "SET att", cmd, replystr);
451
 
}
452
 
 
453
 
int RIG_K2::get_attenuator()
454
 
{
455
 
        rsp = cmd = "RA";
456
 
        cmd += ';';
457
 
        int ret = waitN(5, 100, "get att", ASC);
458
 
        if (ret < 5) return 0;
459
 
        size_t p = replystr.rfind(rsp);
460
 
        if (p == string::npos) return 0;
461
 
        return (replystr[p + 3] == '1' ? 1 : 0);
462
 
}
463
 
 
464
 
void RIG_K2::set_preamp(int val)
465
 
{
466
 
        if (val) cmd = "PA1;";
467
 
        else     cmd = "PA0;";
468
 
        sendCommand(cmd);
469
 
        showresp(WARN, ASC, "SET pre", cmd, replystr);
470
 
}
471
 
 
472
 
int RIG_K2::get_preamp()
473
 
{
474
 
        rsp = cmd = "PA";
475
 
        cmd += ';';
476
 
        int ret = waitN(4, 100, "get pre", ASC);
477
 
        if (ret < 4) return 0;
478
 
        size_t p = replystr.rfind(rsp);
479
 
        if (p == string::npos) return 0;
480
 
        return (replystr[p + 2] == '1' ? 1 : 0);
481
 
}
482