← 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/rigbase.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/rigbase.cxx
1
 
#include "rigbase.h"
2
 
#include "util.h"
3
 
#include "debug.h"
4
 
#include "rig_io.h"
5
 
#include "support.h"
6
 
 
7
 
 
8
 
const char *szNORIG = "NONE";
9
 
const char *szNOMODES[] = {"LSB", "USB", NULL};
10
 
const char *szNOBWS[] = {"NONE", NULL};
11
 
const char *szDSPLO[] = {"NONE", NULL};
12
 
const char *szDSPHI[] = {"NONE", NULL};
13
 
const char *szdsptooltip = "dsp tooltip";
14
 
const char *szbtnlabel = " ";
15
 
const int  ibw_val = -1;
16
 
 
17
 
static GUI basewidgets[] = { {NULL, 0, 0} };
18
 
 
19
 
rigbase::rigbase()
20
 
{
21
 
        name_ = szNORIG;
22
 
        modes_ = szNOMODES;
23
 
        bandwidths_ = szNOBWS;
24
 
        dsp_lo = szDSPLO;
25
 
        lo_tooltip = szdsptooltip;
26
 
        lo_label = szbtnlabel;
27
 
        dsp_hi = szDSPHI;
28
 
        hi_tooltip = szdsptooltip;
29
 
        hi_label = szbtnlabel;
30
 
        bw_vals_ = &ibw_val;
31
 
 
32
 
        widgets = basewidgets;
33
 
 
34
 
        serloop_timing = 200; // msec, 5x / second
35
 
 
36
 
        stopbits = 2;
37
 
 
38
 
        CIV = 0;
39
 
        defaultCIV = 0;
40
 
        USBaudio = false;
41
 
 
42
 
        has_xcvr_auto_on_off =
43
 
        comm_echo =
44
 
        has_vfo_adj =
45
 
        has_rit =
46
 
        has_xit =
47
 
        has_bfo =
48
 
        has_power_control =
49
 
        has_volume_control =
50
 
        has_mode_control =
51
 
        has_bandwidth_control =
52
 
        has_dsp_controls =
53
 
        has_micgain_control =
54
 
        has_mic_line_control =
55
 
        has_auto_notch = 
56
 
        has_notch_control =
57
 
        has_noise_control =
58
 
        has_noise_reduction_control =
59
 
        has_noise_reduction =
60
 
        has_attenuator_control =
61
 
        has_preamp_control =
62
 
        has_ifshift_control =
63
 
        has_ptt_control =
64
 
        has_tune_control =
65
 
        has_swr_control =
66
 
        has_alc_control =
67
 
        has_rf_control =
68
 
        has_sql_control = 
69
 
        has_data_port =
70
 
        restore_mbw =
71
 
 
72
 
        has_extras = 
73
 
        has_nb_level =
74
 
        has_agc_level =
75
 
        has_cw_wpm =
76
 
        has_cw_vol =
77
 
        has_cw_spot =
78
 
        has_cw_spot_tone =
79
 
        has_cw_qsk =
80
 
        has_cw_weight =
81
 
        has_cw_keyer =
82
 
        has_vox_onoff =
83
 
        has_vox_gain =
84
 
        has_vox_anti =
85
 
        has_vox_hang =
86
 
        has_vox_on_dataport =
87
 
        has_compression =
88
 
        has_compON =
89
 
        use_line_in =
90
 
        has_bpf_center =
91
 
        has_special =  
92
 
        has_smeter =
93
 
        has_power_out =
94
 
        has_split =
95
 
        has_split_AB =
96
 
        has_a2b =
97
 
        has_band_selection =
98
 
        has_get_info = false;
99
 
 
100
 
        A.freq = 14070000L;
101
 
        A.imode = 1;
102
 
        A.iBW = 0;
103
 
        B.freq = 14070000L;
104
 
        B.imode = 1;
105
 
        B.iBW = 0;
106
 
        inuse = onA;
107
 
        precision = 1;
108
 
        ndigits = 9;
109
 
        can_change_alt_vfo = false;
110
 
 
111
 
        freqA = 14070000L;
112
 
        modeA = 1;
113
 
        bwA = 0;
114
 
        freqB = 14070000L;
115
 
        modeB = 1;
116
 
        bwB = 0;
117
 
 
118
 
        def_freq = 14070000L;
119
 
        def_mode = 1;
120
 
        def_bw = 0;
121
 
        bpf_center = 0;
122
 
        pbt = 0;
123
 
 
124
 
        max_power = 100;
125
 
 
126
 
        active_mode = 0; // wbx
127
 
 
128
 
        if_shift_min = -1500;
129
 
        if_shift_max = 1500;
130
 
        if_shift_step = 10;
131
 
        if_shift_mid = 0;
132
 
}
133
 
 
134
 
string rigbase::to_bcd_be(long freq, int len)
135
 
{
136
 
        unsigned char a;
137
 
        int numchars = len / 2;
138
 
        string bcd = "";
139
 
        if (len & 1) numchars ++;
140
 
        for (int i = 0; i < numchars; i++) {
141
 
                a = 0;
142
 
                a |= freq % 10;
143
 
                freq /= 10;
144
 
                a |= (freq % 10)<<4;
145
 
                freq /= 10;
146
 
                bcd += a;
147
 
        }
148
 
        return bcd;
149
 
}
150
 
 
151
 
string rigbase::to_bcd(long freq, int len)
152
 
{
153
 
        string bcd_be = to_bcd_be(freq, len);
154
 
        string bcd = "";
155
 
        int bcdlen = bcd_be.size();
156
 
        for (int i = bcdlen - 1; i >= 0; i--)
157
 
                bcd += bcd_be[i];
158
 
        return bcd;
159
 
}
160
 
 
161
 
long rigbase::fm_bcd (char *bcd, int len)
162
 
{
163
 
        int i;
164
 
        long f = 0;
165
 
        int numchars = len/2;
166
 
        if (len & 1) numchars ++;
167
 
        for (i = 0; i < numchars; i++) {
168
 
                f *=10;
169
 
                f += (bcd[i] >> 4) & 0x0F;
170
 
                f *= 10;
171
 
                f += bcd[i] & 0x0F;
172
 
        }
173
 
        return f;
174
 
}
175
 
 
176
 
 
177
 
long rigbase::fm_bcd_be(char *bcd, int len)
178
 
{
179
 
        char temp;
180
 
        int numchars = len/2;
181
 
        if (len & 1) numchars++;
182
 
        for (int i = 0; i < numchars / 2; i++) {
183
 
                temp = bcd[i];
184
 
                bcd[i] = bcd[numchars -1 - i];
185
 
                bcd[numchars -1 - i] = temp;
186
 
        }
187
 
        return fm_bcd(bcd, len);
188
 
}
189
 
 
190
 
string rigbase::to_binary_be(long freq, int len)
191
 
{
192
 
        static string bin = "";
193
 
        for (int i = 0; i < len; i++) {
194
 
                bin += freq & 0xFF;
195
 
                freq >>= 8;
196
 
        }
197
 
        return bin;
198
 
}
199
 
 
200
 
string rigbase::to_binary(long freq, int len)
201
 
{
202
 
        static string bin = "";
203
 
        string bin_be = to_binary_be(freq, len);
204
 
        int binlen = bin_be.size();
205
 
        for (int i = binlen - 1; i >= 0; i--)
206
 
                bin += bin_be[i];
207
 
        return bin;
208
 
}
209
 
 
210
 
long rigbase::fm_binary(char *binary, int len)
211
 
{
212
 
        int i;
213
 
        long f = 0;
214
 
        for (i = 0; i < len; i++) {
215
 
                f *= 256;
216
 
                f += (unsigned char)binary[i];
217
 
        }
218
 
        return f;
219
 
}
220
 
 
221
 
long rigbase::fm_binary_be(char *binary_be, int len)
222
 
{
223
 
        unsigned char temp;
224
 
        int numchars = len/2;
225
 
        if (len & 1) numchars++;
226
 
        for (int i = 0; i < numchars / 2; i++) {
227
 
                temp = binary_be[i];
228
 
                binary_be[i] = binary_be[numchars -1 - i];
229
 
                binary_be[numchars -1 - i] = temp;
230
 
        }
231
 
        return fm_binary(binary_be, len);
232
 
}
233
 
 
234
 
string rigbase::to_decimal_be(long d, int len)
235
 
{
236
 
        static string sdec_be;
237
 
        sdec_be.clear();
238
 
        for (int i = 0; i < len; i++) {
239
 
                sdec_be += (char)((d % 10) + '0');
240
 
                d /= 10;
241
 
        }
242
 
        return sdec_be;
243
 
}
244
 
 
245
 
string rigbase::to_decimal(long d, int len)
246
 
{
247
 
        static string sdec;
248
 
        sdec.clear();
249
 
        string sdec_be = to_decimal_be(d, len);
250
 
        int bcdlen = sdec_be.size();
251
 
        for (int i = bcdlen - 1; i >= 0; i--)
252
 
                sdec += sdec_be[i];
253
 
        return sdec;
254
 
}
255
 
 
256
 
long rigbase::fm_decimal(char *decimal, int len)
257
 
{
258
 
        long d = 0;
259
 
        for (int i = 0; i < len; i++) {
260
 
                d *= 10;
261
 
                d += decimal[i] - '0';
262
 
        }
263
 
        return d;
264
 
}
265
 
 
266
 
long rigbase::fm_decimal_be(char *decimal_be, int len)
267
 
{
268
 
        unsigned char temp;
269
 
        int numchars = len/2;
270
 
        if (len & 1) numchars++;
271
 
        for (int i = 0; i < numchars / 2; i++) {
272
 
                temp = decimal_be[i];
273
 
                decimal_be[i] = decimal_be[numchars -1 - i];
274
 
                decimal_be[numchars -1 - i] = temp;
275
 
        }
276
 
        return fm_decimal(decimal_be, len);
277
 
}
278
 
 
279
 
void rigbase::showresp(int level, int how, string s, string tx, string rx) 
280
 
{
281
 
        time_t now;
282
 
        time(&now);
283
 
        struct tm *local = localtime(&now);
284
 
        char sztm[20];
285
 
        strftime(sztm, sizeof(sztm), "%H:%M:%S", local);
286
 
 
287
 
        string s1 = how == HEX ? str2hex(tx.c_str(), tx.length()) : tx;
288
 
        string s2 = how == HEX ? str2hex(rx.c_str(), rx.length()) : rx;
289
 
        if (how == ASC) {
290
 
                size_t p;
291
 
                while((p = s1.find('\r')) != string::npos)
292
 
                        s1.replace(p, 1, "<cr>");
293
 
                while((p = s1.find('\n')) != string::npos)
294
 
                        s1.replace(p, 1, "<lf>");
295
 
                while((p = s2.find('\r')) != string::npos)
296
 
                        s2.replace(p, 1, "<cr>");
297
 
                while((p = s2.find('\n')) != string::npos)
298
 
                        s2.replace(p, 1, "<lf>");
299
 
        }
300
 
 
301
 
        switch (level) {
302
 
        case ERR:
303
 
                SLOG_ERROR("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
304
 
                break;
305
 
        case WARN:
306
 
                SLOG_WARN("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
307
 
                break;
308
 
        case INFO:
309
 
                SLOG_INFO("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
310
 
                break;
311
 
        default:
312
 
                SLOG_DEBUG("%s: %10s\ncmd %s\nans %s", sztm, s.c_str(), s1.c_str(), s2.c_str());
313
 
        }
314
 
}
315
 
 
316
 
int rigbase::waitN(size_t n, int timeout, const char *sz, int pr)
317
 
{
318
 
        char sztemp[50];
319
 
        string returned = "";
320
 
        string tosend = cmd;
321
 
        int cnt = 0, repeat = 0;
322
 
        int waited = 0;
323
 
        size_t num = n + cmd.length();
324
 
        int delay =  num * 11000.0 / RigSerial.Baud();
325
 
 
326
 
        replystr.clear();
327
 
 
328
 
        if (!RigSerial.IsOpen()) {
329
 
                snprintf(sztemp, sizeof(sztemp), "TEST %s", sz);
330
 
                showresp(WARN, pr, sztemp, tosend, replystr);
331
 
                return 0;
332
 
        }
333
 
 
334
 
        sendCommand(tosend, 0);
335
 
        MilliSleep(delay);
336
 
        returned = "";
337
 
        for ( cnt = 0; cnt < timeout / 10; cnt++) {
338
 
                readResponse();
339
 
                returned.append(replystr);
340
 
                if (returned.length() >= n) {
341
 
                        replystr = returned;
342
 
                        waited = cnt * 10 * repeat + delay;
343
 
                        snprintf(sztemp, sizeof(sztemp), "%s OK %d ms", sz, waited);
344
 
                        showresp(WARN, pr, sztemp, cmd, returned);
345
 
                        return replystr.length();
346
 
                }
347
 
                MilliSleep(10);
348
 
                Fl::awake();
349
 
        }
350
 
 
351
 
        replystr = returned;
352
 
        waited = cnt * 10 * repeat + delay;
353
 
        snprintf(sztemp, sizeof(sztemp), "%s failed %d ms", sz, waited);
354
 
        showresp(WARN, pr, sztemp, cmd, returned);
355
 
        return 0;
356
 
}
357
 
 
358