← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rigs/RAY152.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/RAY152.cxx
 
1
/*
 
2
 * Global Marine, Raytheon 152 transceiver driver
 
3
 *
 
4
 * a part of flrig
 
5
 *
 
6
 * Copyright 2011, Dave Freese, W1HKJ
 
7
 *
 
8
 */
 
9
 
 
10
#include <stdlib.h>
 
11
#include <stdio.h>
 
12
#include <string.h>
 
13
#include <math.h>
 
14
 
 
15
#include "RAY152.h"
 
16
 
 
17
//=============================================================================
 
18
 
 
19
const char RIG_RAY152name_[] = "RAY 152";
 
20
 
 
21
const char *RIG_RAY152modes_[] = { "USB", "LSB", "H3E", "A1A", "F1B", NULL};
 
22
static const char RIG_RAY152_mode_type[] = {'U', 'L', 'U', 'L', 'U'};
 
23
 
 
24
static GUI rig_widgets[]= {
 
25
        { (Fl_Widget *)btnVol, 2, 145,  50 },
 
26
        { (Fl_Widget *)sldrVOLUME, 54, 145, 368 },
 
27
        { (Fl_Widget *)sldrRFGAIN, 54, 125, 156 },
 
28
        { (Fl_Widget *)sldrSQUELCH, 266, 125, 156 },
 
29
        { (Fl_Widget *)NULL, 0, 0, 0 }
 
30
};
 
31
 
 
32
RIG_RAY152::RIG_RAY152() {
 
33
        name_ = RIG_RAY152name_;
 
34
        modes_ = RIG_RAY152modes_;
 
35
 
 
36
        widgets = rig_widgets;
 
37
 
 
38
        comm_baudrate = BR1200;
 
39
        stopbits = 1;
 
40
        comm_retries = 2;
 
41
        comm_wait = 10;
 
42
        comm_timeout = 50;
 
43
        comm_echo = true;
 
44
        comm_rtscts = false;
 
45
        comm_rtsplus = false;
 
46
        comm_dtrplus = true;
 
47
        comm_catptt = true;
 
48
        comm_rtsptt = false;
 
49
        comm_dtrptt = false;
 
50
 
 
51
        A.freq = 14070000;
 
52
        A.imode = 0;
 
53
        A.iBW = 0;
 
54
 
 
55
        B.freq = 3580000;
 
56
        B.imode = 0;
 
57
        B.iBW = 0;
 
58
 
 
59
        precision = 100;
 
60
        ndigits = 6;
 
61
 
 
62
        has_mode_control = true;
 
63
        has_ptt_control = true;
 
64
        has_rf_control = true;
 
65
        has_volume_control = true;
 
66
        has_rit = true;
 
67
        has_sql_control = true;
 
68
        has_noise_control = true;
 
69
        has_auto_notch = true;
 
70
};
 
71
 
 
72
 
 
73
static void nocr( string & s)
 
74
{
 
75
        for (size_t i = 0; i < s.length(); i++)
 
76
                if (s[i] == '\r') s[i] = ' ';
 
77
}
 
78
 
 
79
/*
 
80
Data string returned by the 'O' command
 
81
                3       A*\r         AGC ON/OFF
 
82
                5       C***\r       Memory channel #
 
83
                5       D+/-**\r     Clarifier frequency
 
84
                9       FT******\r  Transmit frequemcy
 
85
                9       FR******\r  Receive frequency
 
86
                6       I****\r      ITU channel #
 
87
                3       M*\r         Mode
 
88
                3       N*\r         Noise blanker status
 
89
                3       P*\r         Power reduction status
 
90
                5       Q***\r       Squelch setting 
 
91
                5       R***\r       RF gain setting
 
92
                5       V***\r       Volume setting
 
93
                3       Z*\r         Meter function
 
94
total  64
 
95
*/
 
96
void RIG_RAY152::get_data()
 
97
{
 
98
        int ret = sendCommand("O\r");
 
99
        if (ret < 66) return;
 
100
// test string
 
101
//replystr = "A1\rC000\rD-05\rFT1407000\rFR1407000\rI0000\rM1\rN1\rP0\rQ000\rR100\rV128\rZ1\r";
 
102
 
 
103
        if (dumpdata)
 
104
                LOG_WARN("\n%s", replystr.c_str());
 
105
        dumpdata = false;
 
106
 
 
107
        size_t pos;
 
108
 
 
109
        pos = replystr.find("FR"); // receive frequency
 
110
        if (pos != string::npos) {
 
111
                int freq;
 
112
                sscanf(&replystr[pos + 2], "%d", &freq);
 
113
                A.freq = 100 * freq;
 
114
        }
 
115
 
 
116
        pos = replystr.find("M"); // mode
 
117
        if (pos != string::npos)
 
118
                A.imode = replystr[pos + 1] - '1';
 
119
 
 
120
        pos = replystr.find("D");
 
121
        if (pos != string::npos) {
 
122
                sscanf(&replystr[pos + 1], "%d", &RitFreq);
 
123
                RitFreq *= 10;
 
124
        }
 
125
 
 
126
        pos = replystr.find("\rR");
 
127
        if (pos != string::npos)
 
128
                sscanf(&replystr[pos + 2], "%d", &rfg);
 
129
 
 
130
        pos = replystr.find("V");
 
131
        if (pos != string::npos) {
 
132
                sscanf(&replystr[pos + 1], "%d", &vol);
 
133
                vol *= 100;
 
134
                vol /= 255;
 
135
        }
 
136
 
 
137
        pos = replystr.find("Q");
 
138
        if (pos != string::npos) {
 
139
                sscanf(&replystr[pos + 1], "%d", &squelch);
 
140
        }
 
141
 
 
142
        pos = replystr.find("N");
 
143
        if (pos != string::npos) {
 
144
                if (replystr[pos + 1] > '0') {
 
145
                        nb_set = replystr[pos+1];
 
146
                        nb = 1;
 
147
                }
 
148
                else {
 
149
                        nb = 0;
 
150
                        nb_set = '2';
 
151
                }
 
152
        }
 
153
 
 
154
// RAY152 usurps the autonotch button for AGC control
 
155
        pos = replystr.find("A");
 
156
        if (pos != string::npos)
 
157
                agc = replystr[1] == '1' ? 1 : 0;
 
158
 
 
159
}
 
160
 
 
161
void RIG_RAY152::initialize()
 
162
{
 
163
        rig_widgets[0].W = btnVol;
 
164
        rig_widgets[1].W = sldrVOLUME;
 
165
        rig_widgets[2].W = sldrRFGAIN;
 
166
        rig_widgets[3].W = sldrSQUELCH;
 
167
 
 
168
        sendCommand("E1\r", 0);
 
169
        sendCommand("Z1\r", 0);
 
170
        dumpdata = true;
 
171
        get_data();
 
172
        set_auto_notch(agc);
 
173
}
 
174
 
 
175
void RIG_RAY152::shutdown()
 
176
{
 
177
        sendCommand("E0\r", 0);
 
178
LOG_INFO("%s", cmd.c_str());
 
179
}
 
180
 
 
181
long RIG_RAY152::get_vfoA ()
 
182
{
 
183
        return A.freq;
 
184
}
 
185
 
 
186
void RIG_RAY152::set_vfoA (long freq)
 
187
{
 
188
        A.freq = freq;
 
189
        cmd = "FT000000\r";
 
190
        freq /= 100;
 
191
        cmd[7] += freq % 10; freq /= 10;
 
192
        cmd[6] += freq % 10; freq /= 10;
 
193
        cmd[5] += freq % 10; freq /= 10;
 
194
        cmd[4] += freq % 10; freq /= 10;
 
195
        cmd[3] += freq % 10; freq /=10;
 
196
        cmd[2] += freq;
 
197
        sendCommand(cmd, 0);
 
198
LOG_INFO("%s", cmd.c_str());
 
199
        cmd[1] = 'R';
 
200
        sendCommand(cmd, 0);
 
201
LOG_INFO("%s", cmd.c_str());
 
202
}
 
203
 
 
204
long RIG_RAY152::get_vfoB ()
 
205
{
 
206
        return B.freq;
 
207
}
 
208
 
 
209
void RIG_RAY152::set_vfoB (long freq)
 
210
{
 
211
        B.freq = freq;
 
212
        cmd = "FT000000\r";
 
213
        freq /= 100;
 
214
        cmd[7] += freq % 10; freq /= 10;
 
215
        cmd[6] += freq % 10; freq /= 10;
 
216
        cmd[5] += freq % 10; freq /= 10;
 
217
        cmd[4] += freq % 10; freq /= 10;
 
218
        cmd[3] += freq % 10; freq /=10;
 
219
        cmd[2] += freq;
 
220
        sendCommand(cmd, 0);
 
221
LOG_INFO("%s", cmd.c_str());
 
222
        cmd[1] = 'R';
 
223
        sendCommand(cmd, 0);
 
224
LOG_INFO("%s", cmd.c_str());
 
225
}
 
226
 
 
227
void RIG_RAY152::set_PTT_control(int val)
 
228
{
 
229
        cmd = val ? "X1\r" : "X0\r";
 
230
        sendCommand(cmd,0);
 
231
LOG_INFO("%s", cmd.c_str());
 
232
}
 
233
 
 
234
void RIG_RAY152::set_modeA(int md)
 
235
{
 
236
        A.imode = md;
 
237
        cmd = "M";
 
238
        cmd += (md  + '1');
 
239
        cmd += '\r';
 
240
        sendCommand(cmd, 0);
 
241
LOG_INFO("%s", cmd.c_str());
 
242
}
 
243
 
 
244
int RIG_RAY152::get_modeA()
 
245
{
 
246
        return A.imode;
 
247
}
 
248
 
 
249
void RIG_RAY152::set_modeB(int md)
 
250
{
 
251
        B.imode = md;
 
252
        cmd = "M";
 
253
        cmd += (md  + '1');
 
254
        cmd += '\r';
 
255
        sendCommand(cmd, 0);
 
256
LOG_INFO("%s", cmd.c_str());
 
257
}
 
258
 
 
259
int RIG_RAY152::get_modeB()
 
260
{
 
261
        return B.imode;
 
262
}
 
263
 
 
264
int RIG_RAY152::get_modetype(int n)
 
265
{
 
266
        return RIG_RAY152_mode_type[n];
 
267
}
 
268
 
 
269
void RIG_RAY152::set_volume_control(int val)
 
270
{
 
271
        vol = val;
 
272
        string cmd = "V000\r";
 
273
        val *= 255;
 
274
        val /= 100;
 
275
        cmd[3] += val % 10; val /= 10;
 
276
        cmd[2] += val % 10; val /= 10;
 
277
        cmd[1] += val;
 
278
        sendCommand(cmd, 0);
 
279
LOG_INFO("%s", cmd.c_str());
 
280
}
 
281
 
 
282
void RIG_RAY152::set_rf_gain(int val)
 
283
{
 
284
        rfg = val;
 
285
        cmd = "R000\r";
 
286
        cmd[3] += val % 10; val /= 10;
 
287
        cmd[2] += val % 10; val /= 10;
 
288
        cmd[1] += val;
 
289
        sendCommand(cmd, 0);
 
290
LOG_INFO("%s", cmd.c_str());
 
291
}
 
292
 
 
293
int RIG_RAY152::get_smeter(void)
 
294
{
 
295
        cmd = "U\r";
 
296
        int ret = sendCommand(cmd);
 
297
        string s = replystr;
 
298
        nocr(s);
 
299
LOG_WARN("%s", s.c_str());
 
300
        if (ret < 5) return 0;
 
301
        if (replystr[ret - 5] == 'U') {
 
302
                int val;
 
303
                sscanf(&replystr[ret - 5 + 1], "%d", &val);
 
304
                val = (int)(60.0 * (256.0 / (val + 16.0) - 1.0));
 
305
                if (val > 100) val = 100;
 
306
                if (val < 0) val = 0;
 
307
                return val;
 
308
        }
 
309
        return 0;
 
310
}
 
311
 
 
312
int RIG_RAY152::get_power_out(void)
 
313
{
 
314
        int ret = sendCommand("U\r");
 
315
        if (ret < 5) return 0;
 
316
        if (replystr[ret - 5] == 'U') {
 
317
                int val;
 
318
                sscanf(&replystr[ret - 5 + 1], "%d", &val);
 
319
                val /= 128;
 
320
                val *= 100;
 
321
                return val;
 
322
        }
 
323
        return -1;
 
324
}
 
325
 
 
326
 
 
327
void RIG_RAY152::setRit(int v)
 
328
{
 
329
        RitFreq = v;
 
330
        cmd = "D+00\r";
 
331
        if (v < 0) cmd[1] = '-';
 
332
        v /= 10;
 
333
        v = abs(v);
 
334
        cmd[3] += v % 10; v /= 10;
 
335
        cmd[2] += v % 10;
 
336
        sendCommand(cmd, 0);
 
337
LOG_INFO("%s", cmd.c_str());
 
338
}
 
339
 
 
340
int  RIG_RAY152::getRit()
 
341
{
 
342
        return RitFreq;
 
343
}
 
344
 
 
345
void RIG_RAY152::set_squelch(int val)
 
346
{
 
347
        squelch = val;
 
348
        cmd = "Q000\r";
 
349
        cmd[3] += val % 10; val /= 10;
 
350
        cmd[2] += val % 10; val /= 10;
 
351
        cmd[1] += val;
 
352
        sendCommand(cmd, 0);
 
353
LOG_INFO("%s", cmd.c_str());
 
354
}
 
355
 
 
356
int RIG_RAY152::get_squelch()
 
357
{
 
358
        return squelch;
 
359
}
 
360
 
 
361
void RIG_RAY152::set_noise(bool on) 
 
362
{
 
363
        cmd = "Nx\r";
 
364
        cmd[1] = on ? nb_set : '0';
 
365
        sendCommand(cmd, 0);
 
366
LOG_INFO("%s", cmd.c_str());
 
367
}
 
368
 
 
369
int RIG_RAY152::get_noise()
 
370
{
 
371
        return nb;
 
372
}
 
373
 
 
374
void RIG_RAY152::set_auto_notch(int v)
 
375
{
 
376
        cmd = "Ax\r";
 
377
        cmd[1] = v ? '1' : '0';
 
378
        sendCommand(cmd, 0);
 
379
LOG_INFO("%s", cmd.c_str());
 
380
}
 
381
 
 
382
int RIG_RAY152::get_auto_notch()
 
383
{
 
384
        return agc;
 
385
}
 
386