← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rigs/TT550.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/TT550.cxx
 
1
/*
 
2
 * Pegasus TT-550 drivers
 
3
 * 
 
4
 * a part of flrig
 
5
 * 
 
6
 * Copyright 2009, Dave Freese, W1HKJ
 
7
 * 
 
8
 */
 
9
 
 
10
// TenTec Pegasus computer controlled transceiver
 
11
 
 
12
#include <math.h>
 
13
#include <vector>
 
14
#include <queue>
 
15
 
 
16
#include "TT550.h"
 
17
#include "support.h"
 
18
#include "util.h"
 
19
#include "debug.h"
 
20
 
 
21
static const char TT550name_[] = "TT-550";
 
22
 
 
23
enum TT550_MODES { 
 
24
TT550_AM_MODE, TT550_USB_MODE, TT550_LSB_MODE, TT550_CW_MODE, TT550_DIGI_MODE, TT550_FM_MODE };
 
25
 
 
26
static const char *TT550modes_[] = {
 
27
                "AM", "USB", "LSB", "CW", "DIGI", "FM", NULL};
 
28
 
 
29
static const int TT550_def_bw[] = { 32, 20, 20, 10, 20, 32 };
 
30
 
 
31
static const char TT550mode_chr[] =  { '0', '1', '2', '3', '1', '4' };
 
32
static const char TT550mode_type[] = { 'U', 'U', 'L', 'L', 'U', 'U' };
 
33
 
 
34
static const char *TT550_widths[] = {
 
35
"300",  "330",  "375",  "450",  "525",   "600",  "675",  "750",  "900", "1050", 
 
36
"1200", "1350", "1500", "1650", "1800", "1950", "2100", "2250", "2400", "2550", 
 
37
"2700", "2850", "3000", "3300", "3600", "3900", "4200", "4500", "4800", "5100", 
 
38
"5400", "5700", "6000", "8000", NULL};
 
39
 
 
40
static const int TT550_filter_nbr[] = {
 
41
32, 31, 30, 29, 28, 27, 26, 25, 24, 23,
 
42
22, 21, 20, 19, 18, 17, 16, 15, 14, 13,
 
43
12, 11, 10,  9,  8,  7,  6,  5,  4,  3,
 
44
 2,  1,  0, 33 };
 
45
 
 
46
static const int TT550_filter_width[] = {
 
47
 300,  330,  375,  450,  525,  600,  675,  750,  900, 1050, 
 
48
1200, 1350, 1500, 1650, 1800, 1950, 2100, 2250, 2400, 2550, 
 
49
2700, 2850, 3000, 3300, 3600, 3900, 4200, 4500, 4800, 5100, 
 
50
5400, 5700, 6000, 8000 };
 
51
 
 
52
const char *TT550_xmt_widths[] = {
 
53
"900", "1050",  "1200", "1350", "1500", "1650", "1800", "1950", "2100", "2250",
 
54
"2400", "2550", "2700", "2850", "3000", "3300", "3600", "3900", NULL};
 
55
 
 
56
static const int TT550_xmt_filter_nbr[] = {
 
57
24, 23, 22, 21, 20, 19, 18, 17, 16,
 
58
15, 14, 13, 12, 11, 10,  9,  8,  7};
 
59
 
 
60
static const int TT550_xmt_filter_width[] = {
 
61
 900, 1050, 1200, 1350, 1500, 1650, 1800, 1950, 2100,
 
62
2250, 2400, 2550, 2700, 2850, 3000, 3300, 3600, 3900 };
 
63
 
 
64
static const int TT550_steps[] = { 1, 10, 100, 1000, 10000 };
 
65
 
 
66
static char TT550restart[]              = "XX\r";
 
67
static char TT550init[]                 = "P1\r";
 
68
//static char TT550isRADIO[]    = " RADIO START";
 
69
//static char TT550isDSP[]              = " DSP START";
 
70
 
 
71
//static char TT550setFREQ[]            = "N123456\r";
 
72
 
 
73
static char TT550setMODE[]              = "Mnn\r";
 
74
static char TT550setRcvBW[]             = "Wx\r";
 
75
static char TT550setXmtBW[]             = "Cx\r";
 
76
static char TT550setVolume[]    = "Vn\r";
 
77
static char TT550setAGC[]               = "Gc\r";
 
78
static char TT550setRFGAIN[]    = "An\r";
 
79
static char TT550setATT[]               = "Bc\r";
 
80
static char TT550setCWWPM[]             = "Eabcdef\r";
 
81
static char TT550setMONVOL[]    = "Hn\r";
 
82
static char TT550setCWMONVOL[]  = "Jn\r";
 
83
static char TT550setNRNOTCH[]   = "Kna\r";
 
84
static char TT550setLINEOUT[]   = "Ln\r"; // 63 - min, 0 - max
 
85
static char TT550setMICLINE[]   = "O1cn\r"; // *******************************************
 
86
static char TT550setPOWER[]             = "Pn\r"; // ****************************************
 
87
static char TT550setXMT[]               = "Q1\r";
 
88
static char TT550setRCV[]               = "Q0\r";
 
89
static char TT550setSQUELCH[]   = "Sn\r";       // 0..19; 6db / unit
 
90
static char TT550setVOX[]               = "Uc\r";       // '0' = off; '1' = on
 
91
static char TT550setVOXGAIN[]   = "UGn\r";      // 0 <= n <= 255
 
92
static char TT550setANTIVOX[]   = "UAn\r";      // 0..255
 
93
static char TT550setVOXHANG[]   = "UHn\r";      // 0..255; n= delay*0.0214 sec
 
94
static char TT550setCWSPOTLVL[] = "Fn\r";       // 0..255; 0 = off
 
95
static char TT550setCWQSK[]             = "UQn\r";      // 0..255; 0 = none
 
96
static char TT550setAUXHANG[]   = "UTn\r";      // 0..255; 0 = none
 
97
static char TT550setBLANKER[]   = "Dn\r";       // 0..7; 0 = off
 
98
static char TT550setSPEECH[]    = "Yn\r";       // 0..127; 0 = off
 
99
 
 
100
static char TT550setDISABLE[]   = "#0\r";       // disable transmitter
 
101
static char TT550setENABLE[]    = "#1\r";       // enable transmitter
 
102
static char TT550setTLOOP_OFF[] = "#2\r";       // disable T loop
 
103
static char TT550setTLOOP_ON[]  = "#3\r";       // enable T loop
 
104
static char TT550setKEYER_OFF[] = "#6\r";       // enable keyer
 
105
static char TT550setKEYER_ON[]  = "#7\r";       // disable keyer
 
106
static char TT550setALIVE_OFF[] = "#8\r";       // disable keep alive
 
107
//static char TT550setALIVE_ON[]        = "#9\r";       // enable keep alive
 
108
 
 
109
//static char TT550getAGC[]             = "?Y\r";       // 0..255
 
110
//static char TT550getFWDPWR[]  = "?F\r";       // F<0..255>
 
111
//static char TT550getREFPWR[]  = "?R\r";       // R<0..255>
 
112
static char TT550getSIG_LEVEL[] = "?S\r";       // S<0..255><0..255>
 
113
static char TT550getFWDREF[]    = "?S\r";       // T<0..255><0..255>
 
114
 
 
115
static char TT550setAMCARRIER[] = "R \r";       // enables AM mode transmit
 
116
 
 
117
static string xcvrstream = "";
 
118
 
 
119
static GUI rig_widgets[]= {
 
120
        { (Fl_Widget *)btnVol,        2, 125,  50 },
 
121
        { (Fl_Widget *)sldrVOLUME,   54, 125, 156 },
 
122
        { (Fl_Widget *)sldrRFGAIN,   54, 145, 156 },
 
123
        { (Fl_Widget *)btnIFsh,     214, 125,  50 },
 
124
        { (Fl_Widget *)sldrIFSHIFT, 266, 125, 156 },
 
125
        { (Fl_Widget *)sldrMICGAIN, 266, 145, 156 },
 
126
        { (Fl_Widget *)sldrPOWER,    54, 165, 368 },
 
127
        { (Fl_Widget *)NULL,          0,   0,   0 }
 
128
};
 
129
 
 
130
RIG_TT550::RIG_TT550() {
 
131
// base class values    
 
132
        name_ = TT550name_;
 
133
        modes_ = TT550modes_;
 
134
        bandwidths_ = TT550_widths;
 
135
 
 
136
        widgets = rig_widgets;
 
137
 
 
138
        comm_baudrate = BR57600;
 
139
        stopbits = 1;
 
140
        comm_retries = 2;
 
141
        comm_wait = 5;
 
142
        comm_timeout = 50;
 
143
        comm_rtscts = true;
 
144
        comm_rtsplus = false;
 
145
        comm_dtrplus = true;
 
146
        comm_catptt = true;
 
147
        comm_rtsptt = false;
 
148
        comm_dtrptt = false;
 
149
        serloop_timing = 100;
 
150
 
 
151
        def_mode = modeA = modeB = 1;
 
152
        def_bw = bwA = bwB = 20;
 
153
        def_freq = freqA = freqB = 14070000;
 
154
        max_power = 100;
 
155
        can_change_alt_vfo = true;
 
156
 
 
157
        VfoAdj = 0;
 
158
        Bfo = 600;
 
159
 
 
160
        ATTlevel = 0;
 
161
        RFgain = 100;
 
162
 
 
163
        has_notch_control =
 
164
        has_preamp_control = false;
 
165
 
 
166
        has_extras =
 
167
        has_bfo =
 
168
        has_smeter =
 
169
        has_power_out =
 
170
        has_split =
 
171
        has_swr_control = 
 
172
        has_micgain_control =
 
173
        has_power_control =
 
174
        has_agc_level =
 
175
        has_cw_wpm =
 
176
        has_cw_vol =
 
177
        has_cw_spot =
 
178
        has_vox_onoff =
 
179
        has_vox_gain =
 
180
        has_vox_anti =
 
181
        has_vox_hang =
 
182
        has_compression =
 
183
        has_rit =
 
184
        has_xit =
 
185
        has_rf_control =
 
186
        has_attenuator_control =
 
187
        has_volume_control =
 
188
        has_ifshift_control =
 
189
        has_ptt_control =
 
190
        has_bandwidth_control =
 
191
        has_auto_notch = 
 
192
        has_tune_control =
 
193
        has_noise_control =
 
194
        has_mode_control = true;
 
195
 
 
196
        auto_notch = noise_reduction = false;
 
197
 
 
198
        precision = 1;
 
199
        ndigits = 8;
 
200
 
 
201
}
 
202
 
 
203
void RIG_TT550::showASCII(string s1, string s)
 
204
{
 
205
        while (s[0] == ' ' || s[0] == '\r' || s[0] == '\n') s.erase(0,1);
 
206
        for (size_t i = 0; i < s.length(); i++) {
 
207
                if (s[i] == '\r' || s[i] == '\n') s[i] = ' ';
 
208
        }
 
209
        LOG_WARN("%9s : %s", s1.c_str(), s.c_str());
 
210
}
 
211
 
 
212
void RIG_TT550::initialize()
 
213
{
 
214
        rig_widgets[0].W = btnVol;
 
215
        rig_widgets[1].W = sldrVOLUME;
 
216
        rig_widgets[2].W = sldrRFGAIN;
 
217
        rig_widgets[3].W = btnIFsh;
 
218
        rig_widgets[4].W = sldrIFSHIFT;
 
219
        rig_widgets[5].W = sldrMICGAIN;
 
220
        rig_widgets[6].W = sldrPOWER;
 
221
 
 
222
        sendCommand(TT550restart);
 
223
 
 
224
        if (replystr.find("RADIO") == string::npos) {
 
225
                showASCII("Power up", "DSP START");
 
226
                sendCommand(TT550init); // put into radio mode
 
227
        }
 
228
        showASCII("Init", replystr);
 
229
 
 
230
        sendCommand("?V\r");
 
231
        showASCII("Version", replystr);
 
232
 
 
233
        sendCommand(TT550setALIVE_OFF);
 
234
 
 
235
        set_volume_control(0);
 
236
 
 
237
        set_auto_notch(auto_notch);
 
238
        set_compression();
 
239
 
 
240
        set_vox_hang();
 
241
        set_vox_anti();
 
242
        set_vox_gain();
 
243
        set_vox_onoff();
 
244
 
 
245
        set_cw_spot();
 
246
        set_cw_vol();
 
247
        set_cw_wpm();
 
248
        set_cw_qsk();
 
249
        enable_keyer();
 
250
 
 
251
        set_agc_level();
 
252
        set_line_out();
 
253
//      use_line_in = progStatus.use_line_in;
 
254
        set_mic_gain(progStatus.mic_gain);
 
255
        set_mic_line(0);
 
256
        set_rf_gain(RFgain);
 
257
        
 
258
        XitFreq = progStatus.xit_freq;
 
259
        RitFreq = progStatus.rit_freq;
 
260
        Bfo = progStatus.bfo_freq;
 
261
        set_vfoA(freqA);
 
262
 
 
263
        VfoAdj = progStatus.vfo_adj;
 
264
 
 
265
        setXit(XitFreq);
 
266
        setRit(RitFreq);
 
267
        setBfo(Bfo);
 
268
 
 
269
        set_attenuator(0);
 
270
        set_mon_vol();
 
271
        set_squelch_level();
 
272
        set_if_shift(pbt);
 
273
        set_aux_hang();
 
274
 
 
275
        set_volume_control(progStatus.volume);
 
276
 
 
277
        cmd = TT550setAMCARRIER;
 
278
        cmd[1] = 0x0F;
 
279
        sendCommand(cmd, 0); 
 
280
 
 
281
        enable_tloop();
 
282
        enable_xmtr();
 
283
 
 
284
        xcvrstream.clear();
 
285
        keypad_timeout = 0;
 
286
 
 
287
        onA = true;
 
288
 
 
289
        encoder_count = 0;
 
290
}
 
291
 
 
292
void RIG_TT550::enable_xmtr()
 
293
{
 
294
        if (progStatus.tt550_enable_xmtr)
 
295
                cmd = TT550setENABLE;
 
296
        else
 
297
                cmd = TT550setDISABLE;
 
298
        sendCommand(cmd, 0);
 
299
}
 
300
 
 
301
void RIG_TT550::enable_tloop()
 
302
{
 
303
        if (progStatus.tt550_enable_tloop)
 
304
                cmd = TT550setTLOOP_ON;
 
305
        else
 
306
                cmd = TT550setTLOOP_OFF;
 
307
        sendCommand(cmd, 0);
 
308
}
 
309
 
 
310
void RIG_TT550::shutdown()
 
311
{
 
312
        cmd = "Vx\r";
 
313
        cmd[1] = 0;
 
314
        sendCommand(cmd, 0); // volume = zero
 
315
        cmd = "Lx\r";
 
316
        cmd[1] = 0x3F;
 
317
        sendCommand(cmd, 0); // line out = minimum
 
318
}
 
319
 
 
320
int DigiAdj = 0;
 
321
 
 
322
void RIG_TT550::set_vfoRX(long freq)
 
323
{
 
324
        int NVal = 0, FVal = 0; // N value / finetune value
 
325
    int TBfo = 0;                       // temporary BFO (Hz)
 
326
        int IBfo = 0;                   // Intermediate BFO Freq (Hz)
 
327
 
 
328
        int PbtAdj = PbtActive ? pbt : 0;//PbtFreq : 0; // passband adj (Hz)
 
329
        int     RitAdj = RitActive ? RitFreq : 0;       // RIT adj (Hz)
 
330
 
 
331
        int FiltAdj = (TT550_filter_width[def_bw])/2;           // filter bw (Hz)
 
332
 
 
333
        long lFreq = freq * (1 + VfoAdj * 1e-6) + RitAdj;
 
334
 
 
335
LOG_INFO("rx freq = %ld", freq);
 
336
 
 
337
        if(def_mode == TT550_DIGI_MODE) {
 
338
                DigiAdj = 1500 - FiltAdj - 200;
 
339
                DigiAdj = DigiAdj < 0 ? 0 : DigiAdj;
 
340
                IBfo = FiltAdj + 200;
 
341
                lFreq += (IBfo + PbtAdj + DigiAdj);
 
342
                IBfo = IBfo + PbtAdj + DigiAdj;
 
343
        }
 
344
 
 
345
        if(def_mode == TT550_USB_MODE) {
 
346
                IBfo = FiltAdj + 200;
 
347
                lFreq += (IBfo + PbtAdj);
 
348
                IBfo = IBfo + PbtAdj;
 
349
        }
 
350
 
 
351
        if(def_mode == TT550_LSB_MODE) {
 
352
                IBfo = FiltAdj + 200;
 
353
                lFreq -= (IBfo + PbtAdj);
 
354
                IBfo = IBfo + PbtAdj;
 
355
        }
 
356
 
 
357
        if(def_mode == TT550_CW_MODE) {
 
358
// CW Mode uses LSB Mode
 
359
                if (( FiltAdj + 300) <= Bfo) {
 
360
                        IBfo = PbtAdj + Bfo;
 
361
                } else {
 
362
                        IBfo = FiltAdj + 300;
 
363
                        lFreq += (Bfo - IBfo);
 
364
                        IBfo = IBfo + PbtAdj;
 
365
                }
 
366
        }
 
367
        
 
368
        if(def_mode == TT550_FM_MODE) {
 
369
                lFreq += Bfo;
 
370
                IBfo = 0;
 
371
        }
 
372
 
 
373
        lFreq -= 1250;
 
374
 
 
375
        NVal = lFreq / 2500 + 18000;
 
376
        FVal = (int)((lFreq % 2500) * 5.46);
 
377
 
 
378
        cmd = "N";
 
379
        cmd += (NVal >> 8) & 0xff;
 
380
        cmd += NVal & 0xff;
 
381
        cmd += (FVal >> 8) & 0xff;
 
382
        cmd += FVal & 0xff;
 
383
 
 
384
        TBfo = (int)((IBfo + 8000)*2.73);
 
385
        cmd += (TBfo >> 8) & 0xff;
 
386
        cmd += TBfo & 0xff;
 
387
        cmd += '\r';
 
388
        sendCommand(cmd, 0);
 
389
}
 
390
 
 
391
void RIG_TT550::set_vfoTX(long freq)
 
392
{
 
393
        int NVal = 0, FVal = 0; // N value / finetune value
 
394
    int TBfo = 0;                       // temporary BFO
 
395
        int IBfo = 1500;                // Intermediate BFO Freq
 
396
        int bwBFO = 0;                  // BFO based on selected bandwidth
 
397
        int FilterBw = 0;               // Filter Bandwidth determined from table
 
398
 
 
399
        int XitAdj;
 
400
        long lFreq = freq * (1 + VfoAdj * 1e-6);
 
401
 
 
402
LOG_INFO("tx freq = %ld", freq);
 
403
 
 
404
        lFreq += XitAdj = XitActive ? XitFreq : 0;
 
405
 
 
406
        if (progStatus.tt550_use_xmt_bw)
 
407
                FilterBw = TT550_xmt_filter_width[progStatus.tt550_xmt_bw];
 
408
        else
 
409
                FilterBw = TT550_filter_width[def_bw];
 
410
        if (FilterBw < 900) FilterBw = 900;
 
411
        if (FilterBw > 3900) FilterBw = 3900;
 
412
//      if (def_mode == TT550_DIGI_MODE) FilterBw = 3000;
 
413
 
 
414
        bwBFO = (FilterBw/2) + 200;
 
415
        IBfo = (bwBFO > IBfo) ?  bwBFO : IBfo ;
 
416
 
 
417
        if (def_mode == TT550_USB_MODE || def_mode == TT550_DIGI_MODE) {
 
418
                lFreq += IBfo;
 
419
                TBfo = (int)(IBfo * 2.73);
 
420
        }
 
421
 
 
422
        if (def_mode == TT550_LSB_MODE) {
 
423
                lFreq -= IBfo;
 
424
                TBfo = (int)(IBfo * 2.73);
 
425
        }
 
426
 
 
427
// CW Mode uses LSB Mode
 
428
        if(def_mode == TT550_CW_MODE) {
 
429
                IBfo = 1500; // fixed for CW
 
430
                lFreq += Bfo - IBfo;
 
431
                TBfo = (int)(Bfo * 2.73);
 
432
        }
 
433
 
 
434
        if(def_mode == TT550_FM_MODE) {
 
435
                IBfo = 0;
 
436
                lFreq -= IBfo;
 
437
                TBfo = 0;
 
438
        }
 
439
 
 
440
        lFreq -= 1250;
 
441
        NVal = lFreq / 2500 + 18000;
 
442
        FVal = (int)((lFreq % 2500) * 5.46);
 
443
 
 
444
        cmd = "T";
 
445
        cmd += (NVal >> 8) & 0xff;
 
446
        cmd += NVal & 0xff;
 
447
        cmd += (FVal >> 8) & 0xff;
 
448
        cmd += FVal & 0xff;
 
449
        cmd += (TBfo >> 8) & 0xff;
 
450
        cmd += TBfo & 0xff;
 
451
        cmd += '\r';
 
452
        sendCommand(cmd, 0);
 
453
}
 
454
 
 
455
void RIG_TT550::set_split(bool val)
 
456
{
 
457
        split = val;
 
458
        selectA();
 
459
        if (split)
 
460
                set_vfoTX(freqB);
 
461
}
 
462
 
 
463
void RIG_TT550::set_vfo(long freq)
 
464
{
 
465
//LOG_WARN("set vfo %ld", freq);
 
466
        set_vfoRX(freq);
 
467
        if (!split)
 
468
                set_vfoTX(freq);
 
469
        xcvrstream.clear();
 
470
}
 
471
 
 
472
void RIG_TT550::set_vfoA (long freq)
 
473
{
 
474
LOG_WARN("set vfo A %ld", freq);
 
475
        freqA = freq;
 
476
        if (onA)
 
477
                set_vfo(freq);
 
478
}
 
479
 
 
480
long RIG_TT550::get_vfoA ()
 
481
{
 
482
        return freqA;
 
483
}
 
484
 
 
485
void RIG_TT550::set_vfoB (long freq)
 
486
{
 
487
LOG_WARN("set vfo B %ld", freq);
 
488
        freqB = freq;
 
489
        if (!onA)
 
490
                set_vfo(freqB);
 
491
}
 
492
 
 
493
long RIG_TT550::get_vfoB ()
 
494
{
 
495
        return freqB;
 
496
}
 
497
 
 
498
// Tranceiver PTT on/off
 
499
void RIG_TT550::set_PTT_control(int val)
 
500
{
 
501
        if (val) cmd = TT550setXMT;
 
502
        else     cmd = TT550setRCV;
 
503
        sendCommand(cmd, 0);
 
504
LOG_WARN("%s", str2hex(cmd.c_str(), cmd.length()));
 
505
}
 
506
 
 
507
void RIG_TT550::set_mode(int val)
 
508
{
 
509
        def_mode = val;
 
510
        if (val == TT550_AM_MODE) {
 
511
 
 
512
                cmd = TT550setMODE;
 
513
                cmd[1] = cmd[2] = TT550mode_chr[val];
 
514
                sendCommand(cmd, 0);
 
515
 
 
516
                cmd =  TT550setPOWER;
 
517
                cmd[1] = 0xFF;
 
518
                sendCommand(cmd, 0);
 
519
 
 
520
                set_power_control(progStatus.tt550_AM_level);
 
521
 
 
522
        } else {
 
523
 
 
524
                cmd = TT550setMODE;
 
525
                cmd[1] = cmd[2] = TT550mode_chr[val];
 
526
                sendCommand(cmd, 0);
 
527
                set_power_control(progStatus.power_level);
 
528
        }
 
529
        set_bw(def_bw);
 
530
}
 
531
 
 
532
void RIG_TT550::set_modeA(int val)
 
533
{
 
534
LOG_WARN("mode A = %d", val);
 
535
        modeA = val;
 
536
        set_mode(val);
 
537
}
 
538
 
 
539
void RIG_TT550::set_modeB(int val)
 
540
{
 
541
LOG_WARN("mode B = %d", val);
 
542
        modeB = val;
 
543
        if (!onA)
 
544
                set_mode(val);
 
545
}
 
546
 
 
547
int  RIG_TT550::get_modeB()
 
548
{
 
549
        return modeB;
 
550
}
 
551
 
 
552
static int ret_mode = TT550_CW_MODE;
 
553
static void tt550_tune_off(void *)
 
554
{
 
555
        pthread_mutex_lock(&mutex_serial);
 
556
                selrig->set_power_control(0);
 
557
                selrig->set_PTT_control(0);
 
558
                sendCommand("$0\r", 0);
 
559
LOG_INFO("%s", str2hex("$0\r", 3));
 
560
                selrig->set_modeA(ret_mode);
 
561
        pthread_mutex_unlock(&mutex_serial);
 
562
}
 
563
 
 
564
void RIG_TT550::tune_rig()
 
565
{
 
566
        ret_mode = modeA;
 
567
        set_modeA(TT550_CW_MODE);
 
568
        set_power_control(5);
 
569
        sendCommand("$1\r", 0);
 
570
LOG_INFO("%s", str2hex("$1\r", 3));
 
571
        set_PTT_control(1);
 
572
        Fl::add_timeout(5.0, tt550_tune_off);
 
573
}
 
574
 
 
575
int RIG_TT550::get_modeA()
 
576
{
 
577
        return modeA;
 
578
}
 
579
 
 
580
int RIG_TT550::get_modetype(int n)
 
581
{
 
582
        return TT550mode_type[n];
 
583
}
 
584
 
 
585
void RIG_TT550::set_bw(int val)
 
586
{
 
587
LOG_WARN("bw = %d", val);
 
588
        def_bw = val;
 
589
        int rxbw = TT550_filter_nbr[val];
 
590
        int txbw = rxbw;
 
591
        if (progStatus.tt550_use_xmt_bw)
 
592
                txbw = TT550_xmt_filter_nbr[progStatus.tt550_xmt_bw];
 
593
        if (txbw < 7) txbw = 7;
 
594
        if (txbw > 24) txbw = 24;
 
595
        cmd = TT550setRcvBW;
 
596
        cmd[1] = rxbw;
 
597
        sendCommand(cmd, 0);
 
598
        cmd = TT550setXmtBW;
 
599
        cmd[1] = txbw;
 
600
        sendCommand(cmd, 0);
 
601
        set_vfo(onA ? freqA : freqB);
 
602
}
 
603
 
 
604
void RIG_TT550::set_bwA(int val)
 
605
{
 
606
LOG_WARN("bw A = %d", val);
 
607
        bwA = val;
 
608
        set_bw(bwA);
 
609
}
 
610
 
 
611
int RIG_TT550::get_bwA()
 
612
{
 
613
        return bwA;
 
614
}
 
615
 
 
616
void RIG_TT550::set_bwB(int val)
 
617
{
 
618
LOG_WARN("bw B = %d", val);
 
619
        bwB = val;
 
620
        if (!onA)
 
621
                set_bw(val);
 
622
}
 
623
 
 
624
int  RIG_TT550::get_bwB()
 
625
{
 
626
        return bwB;
 
627
}
 
628
 
 
629
int RIG_TT550::adjust_bandwidth(int md)
 
630
{
 
631
        return bwA;
 
632
}
 
633
 
 
634
int RIG_TT550::def_bandwidth(int m)
 
635
{
 
636
        if (m < 0) m = 0;
 
637
        if (m > 4) m = 4;
 
638
        return TT550_def_bw[m];
 
639
}
 
640
 
 
641
void RIG_TT550::set_if_shift(int val)
 
642
{
 
643
//      PbtFreq = val;
 
644
//      if (PbtFreq) PbtActive = true;
 
645
        pbt = val;
 
646
        if (pbt) PbtActive = true;
 
647
        set_vfoRX(onA ? freqA : freqB);
 
648
}
 
649
 
 
650
bool RIG_TT550::get_if_shift(int &val)
 
651
{
 
652
        val = pbt;//PbtFreq;
 
653
        if (!val) return false;
 
654
        return true;
 
655
}
 
656
 
 
657
void RIG_TT550::get_if_min_max_step(int &min, int &max, int &step)
 
658
{
 
659
        min = -500;
 
660
        max = 500;
 
661
        step = 50;
 
662
}
 
663
 
 
664
void RIG_TT550::set_attenuator(int val)
 
665
{
 
666
        cmd = TT550setATT;
 
667
        if (val) cmd[1] = '1';
 
668
        else     cmd[1] = '0';
 
669
        sendCommand(cmd, 0);
 
670
LOG_WARN("%s", str2hex(cmd.c_str(), cmd.length()));
 
671
}
 
672
 
 
673
void RIG_TT550::set_volume_control(int val)
 
674
{
 
675
        cmd = TT550setVolume;
 
676
        cmd[1] = 0xFF & ((val * 255) / 100);
 
677
        sendCommand(cmd, 0);
 
678
LOG_WARN("%s", str2hex(cmd.c_str(), cmd.length()));
 
679
}
 
680
 
 
681
int RIG_TT550::get_volume_control()
 
682
{
 
683
        return progStatus.volume;
 
684
}
 
685
 
 
686
static void show_encA(void *)
 
687
{
 
688
        txt_encA->show();
 
689
}
 
690
static void hide_encA(void *)
 
691
{
 
692
        txt_encA->hide();
 
693
}
 
694
static void update_encA(void *d)
 
695
{
 
696
        char *str = (char *)d;
 
697
        txt_encA->value(str);
 
698
}
 
699
 
 
700
void RIG_TT550::selectA()
 
701
{
 
702
LOG_WARN("%s", "select A");
 
703
        onA = true;
 
704
        Fl::awake(hide_encA, NULL);
 
705
        xcvrstream.clear();
 
706
}
 
707
 
 
708
void RIG_TT550::selectB()
 
709
{
 
710
LOG_WARN("%s", "select B");
 
711
        onA = false;
 
712
        Fl::awake(hide_encA, NULL);
 
713
        xcvrstream.clear();
 
714
}
 
715
 
 
716
void RIG_TT550::process_freq_entry(char c)
 
717
{
 
718
        static bool have_decimal = false;
 
719
        float ffreq = 0.0;
 
720
        long freq = 0;
 
721
        if (xcvrstream.empty()) have_decimal = false;
 
722
        if (c != '\r') {
 
723
                if ((c >= '0' && c <= '9') || c == '.') {
 
724
                        xcvrstream += c;
 
725
                        if (!have_decimal && c == '.') have_decimal = true;
 
726
                        else if (have_decimal && c == '.') {
 
727
                                xcvrstream.clear();
 
728
                                have_decimal = false;
 
729
                                keypad_timeout = 0;
 
730
                                Fl::awake(hide_encA, NULL);
 
731
                                return;
 
732
                        }
 
733
                        ffreq = 0;
 
734
                        sscanf(xcvrstream.c_str(), "%f", &ffreq);
 
735
                        if (have_decimal) ffreq *= 1000;
 
736
                        freq = (long) ffreq;
 
737
                        if (!txt_encA->visible())
 
738
                                Fl::awake(show_encA, NULL);
 
739
                        Fl::awake(update_encA, (void*)xcvrstream.c_str());
 
740
//                      LOG_WARN("%s => %ld", str2hex(xcvrstream.c_str(), xcvrstream.length()), freq);
 
741
                        keypad_timeout = progStatus.tt550_keypad_timeout / progStatus.serloop_timing;
 
742
                }
 
743
        } else {
 
744
                keypad_timeout = 0;
 
745
                if (xcvrstream.empty()) return;
 
746
                ffreq = 0;
 
747
                sscanf(xcvrstream.c_str(), "%f", &ffreq);
 
748
                if (have_decimal) ffreq *= 1000;
 
749
                freq = (long) ffreq;
 
750
                if (freq < 50000) freq *= 1000;
 
751
                Fl::awake(hide_encA, NULL);
 
752
                if (onA) {
 
753
                        freqA = freq;
 
754
                        set_vfoA(freqA);
 
755
                        Fl::awake(setFreqDispA, (void *)freqA);
 
756
                } else {
 
757
                        freqB = freq;
 
758
                        set_vfoB(freqB);
 
759
                        Fl::awake(setFreqDispB, (void *)freqB);
 
760
                }
 
761
                xcvrstream.clear();
 
762
                have_decimal = false;
 
763
        }
 
764
}
 
765
 
 
766
//static const char *tt550_fkey_strings[] = {"None","Clear","CW++","CW--","Band++","Band--","Step++","Step--"};
 
767
 
 
768
void RIG_TT550::fkey_clear()
 
769
{
 
770
//      LOG_WARN("%s", tt550_fkey_strings[1]);
 
771
        xcvrstream.clear();
 
772
        keypad_timeout = 0;
 
773
        Fl::awake(hide_encA, NULL);
 
774
}
 
775
 
 
776
void RIG_TT550::fkey_cw_plus()
 
777
{
 
778
//      LOG_WARN("%s", tt550_fkey_strings[2]);
 
779
        if (progStatus.tt550_cw_wpm >= 80) return;
 
780
        progStatus.tt550_cw_wpm++;
 
781
        cnt_tt550_cw_wpm->value(progStatus.tt550_cw_wpm);
 
782
        cnt_tt550_cw_wpm->redraw();
 
783
        selrig->set_cw_wpm();
 
784
}
 
785
 
 
786
void RIG_TT550::fkey_cw_minus()
 
787
{
 
788
//      LOG_WARN("%s", tt550_fkey_strings[3]);set_bw
 
789
        if (progStatus.tt550_cw_wpm <= 5) return;
 
790
        progStatus.tt550_cw_wpm--;
 
791
        cnt_tt550_cw_wpm->value(progStatus.tt550_cw_wpm);
 
792
        cnt_tt550_cw_wpm->redraw();
 
793
        selrig->set_cw_wpm();
 
794
}
 
795
 
 
796
struct BANDS { int lo; int hi; int digi; };
 
797
 
 
798
static BANDS ibands[] = {
 
799
{ 0, 1800000, 28120000 },
 
800
{ 1800000, 2000000, 1807000 },
 
801
{ 3500000, 4000000, 3580000 },
 
802
{ 7000000, 7300000, 7035000 },
 
803
{ 10100000, 10150000, 10140000 },
 
804
{ 14000000, 14350000, 14070000 },
 
805
{ 18068000, 18168000, 18100000 },
 
806
{ 21000000, 21450000, 21070000 },
 
807
{ 24890000, 24990000, 24920000 },
 
808
{ 28000000, 29700000, 28120000 },
 
809
{ 29700000, 0, 1807000 }
 
810
};
 
811
 
 
812
extern queue<FREQMODE> queA;
 
813
extern queue<FREQMODE> queB;
 
814
extern bool useB;
 
815
 
 
816
void RIG_TT550::fkey_band_plus()
 
817
{
 
818
        FREQMODE vfoplus = vfo;
 
819
        for (size_t i = 1; i < sizeof(ibands) / sizeof(BANDS); i++) {
 
820
                if (vfo.freq < ibands[i].lo) {
 
821
                        vfoplus.freq = ibands[i].digi;
 
822
                        break;
 
823
                }
 
824
        }
 
825
        vfo.src = UI;
 
826
        if (!useB)
 
827
                queA.push(vfoplus);
 
828
        else
 
829
                queB.push(vfoplus);
 
830
}
 
831
 
 
832
void RIG_TT550::fkey_band_minus()
 
833
{
 
834
        FREQMODE vfoplus = vfo;
 
835
        for (size_t i = sizeof(ibands) / sizeof(BANDS) - 2; i >= 0; i--) {
 
836
                if (vfo.freq > ibands[i].hi) {
 
837
                        vfoplus.freq = ibands[i].digi;
 
838
                        break;
 
839
                }
 
840
        }
 
841
        vfo.src = UI;
 
842
        if (!useB)
 
843
                queA.push(vfoplus);
 
844
        else
 
845
                queB.push(vfoplus);
 
846
}
 
847
 
 
848
void RIG_TT550::fkey_step_plus()
 
849
{
 
850
        progStatus.tt550_encoder_step++;
 
851
        if (progStatus.tt550_encoder_step > 4) progStatus.tt550_encoder_step = 0;
 
852
        sel_tt550_encoder_step->value(progStatus.tt550_encoder_step);
 
853
        sel_tt550_encoder_step->redraw();
 
854
}
 
855
 
 
856
void RIG_TT550::fkey_step_minus()
 
857
{
 
858
        progStatus.tt550_encoder_step--;
 
859
        if (progStatus.tt550_encoder_step < 0) progStatus.tt550_encoder_step = 4;
 
860
        sel_tt550_encoder_step->value(progStatus.tt550_encoder_step);
 
861
        sel_tt550_encoder_step->redraw();
 
862
}
 
863
 
 
864
void RIG_TT550::process_fkey(char c)
 
865
{
 
866
        if (c == 0x11) 
 
867
                switch (progStatus.tt550_F1_func) {
 
868
                        case 1 : fkey_clear(); break;
 
869
                        case 2 : fkey_cw_plus(); break;
 
870
                        case 3 : fkey_cw_minus(); break;
 
871
                        case 4 : fkey_band_plus(); break;
 
872
                        case 5 : fkey_band_minus(); break;
 
873
                        case 6 : fkey_step_plus(); break;
 
874
                        case 7 : fkey_step_minus(); break;
 
875
                        default: ;
 
876
                }
 
877
        if (c == 0x12)
 
878
                switch (progStatus.tt550_F2_func) {
 
879
                        case 1 : fkey_clear(); break;
 
880
                        case 2 : fkey_cw_plus(); break;
 
881
                        case 3 : fkey_cw_minus(); break;
 
882
                        case 4 : fkey_band_plus(); break;
 
883
                        case 5 : fkey_band_minus(); break;
 
884
                        case 6 : fkey_step_plus(); break;
 
885
                        case 7 : fkey_step_minus(); break;
 
886
                        default: ;
 
887
                }
 
888
        if (c == 0x13)
 
889
                switch (progStatus.tt550_F3_func) {
 
890
                        case 1 : fkey_clear(); break;
 
891
                        case 2 : fkey_cw_plus(); break;
 
892
                        case 3 : fkey_cw_minus(); break;
 
893
                        case 4 : fkey_band_plus(); break;
 
894
                        case 5 : fkey_band_minus(); break;
 
895
                        case 6 : fkey_step_plus(); break;
 
896
                        case 7 : fkey_step_minus(); break;
 
897
                        default: ;
 
898
                }
 
899
}
 
900
 
 
901
void RIG_TT550::process_keypad(char c)
 
902
{
 
903
        if (c < 0 || c > 0x7f) return;
 
904
        if (c == 0x11 || c == 0x12 || c == 0x13)
 
905
                process_fkey(c);
 
906
        else
 
907
                process_freq_entry(c);
 
908
}
 
909
 
 
910
void RIG_TT550::process_encoder(string s)
 
911
{
 
912
        size_t p = 0;
 
913
        int encval = 0, encoder = 0;
 
914
        size_t len = s.length();
 
915
        while (p < len) {
 
916
                encval = ((unsigned char)s[p+1] << 8) | (unsigned char)s[p+2];
 
917
                if (encval > 16383) encval -= 65536;
 
918
                encoder += encval;
 
919
                p += 5;
 
920
        }
 
921
 
 
922
        encoder_count += encoder;
 
923
        encoder = 0;
 
924
 
 
925
        encoder = encoder_count / progStatus.tt550_encoder_sensitivity;
 
926
        encoder_count -= encoder * progStatus.tt550_encoder_sensitivity;
 
927
 
 
928
        if (encoder != 0) {
 
929
                FREQMODE vfoplus = vfo;
 
930
                vfoplus.src = UI;
 
931
                vfoplus.freq += encoder*TT550_steps[progStatus.tt550_encoder_step];
 
932
                if (!useB)
 
933
                        queA.push(vfoplus);
 
934
                else
 
935
                        queB.push(vfoplus);
 
936
        }
 
937
}
 
938
 
 
939
int RIG_TT550::get_smeter()
 
940
{
 
941
        int sval = 0;
 
942
        float fval;
 
943
 
 
944
        cmd = TT550getSIG_LEVEL;
 
945
        sendCommand(cmd);
 
946
 
 
947
        string meter = "";
 
948
        string keys = "";
 
949
        string encoder = "";
 
950
 
 
951
        size_t p = 0;
 
952
        size_t len = replystr.length();
 
953
        char c;
 
954
        while (p < len) {
 
955
                c = replystr[p];
 
956
                if (c == 'S' || c == 'U' || c == '!') break;
 
957
                p++;
 
958
        }
 
959
        while (p < len) {
 
960
                if (replystr[p] == 'S') {
 
961
                        meter += replystr[p++];
 
962
                        if (p < len) meter += replystr[p++];
 
963
                        if (p < len) meter += replystr[p++];
 
964
                        if (p < len) meter += replystr[p++];
 
965
                        if (p < len) meter += replystr[p++];
 
966
                        if (p < len) meter += replystr[p++];
 
967
                } else if (replystr[p] == 'U') {
 
968
                        keys += replystr[p++];
 
969
                        if (p < len) keys += replystr[p++];
 
970
                        if (p < len) keys += replystr[p++];
 
971
                } else if (replystr[p] == '!') {
 
972
                        encoder += replystr[p++];
 
973
                        if (p < len) encoder += replystr[p++];
 
974
                        if (p < len) encoder += replystr[p++];
 
975
                        if (p < len) encoder += replystr[p++];
 
976
                        if (p < len) encoder += replystr[p++];
 
977
                } else
 
978
                        break;
 
979
        }
 
980
 
 
981
        if (keypad_timeout) {
 
982
                keypad_timeout--;
 
983
                if (keypad_timeout == 0) {
 
984
                        xcvrstream.clear();
 
985
                        Fl::awake(hide_encA, NULL);
 
986
                }
 
987
        }
 
988
// process all smeter returns, retain last
 
989
        p = 0;
 
990
        len = meter.length();
 
991
        if (len) {
 
992
                while (p < len) {
 
993
                        sscanf(&replystr[p+1], "%4x", &sval);
 
994
                        fval = sval/256.0;
 
995
                        sval = (int)(fval * 100.0 / 18.0);
 
996
                        if (sval > 100) sval = 100;
 
997
//printf("%s %6.2f %d\n", str2hex(&replystr[p+1],4), fval, sval);
 
998
                        p += 6;
 
999
                }
 
1000
        }
 
1001
 
 
1002
// process all keypad entries
 
1003
        p = 0;
 
1004
        len = keys.length();
 
1005
        if (len) {
 
1006
                while (p < len) {
 
1007
                        process_keypad(keys[p+1]);
 
1008
                        p += 3;
 
1009
                }
 
1010
        }
 
1011
 
 
1012
// process all encoder changes
 
1013
        if (!encoder.empty()) {
 
1014
                process_encoder(encoder);
 
1015
        }
 
1016
 
 
1017
        return sval;
 
1018
}
 
1019
 
 
1020
int RIG_TT550::get_swr()
 
1021
{
 
1022
        double swr, nu;
 
1023
        if (fwdpwr == 0) return 0;
 
1024
        if (fwdpwr == refpwr) return 100;
 
1025
        nu = sqrt(refpwr / fwdpwr);
 
1026
        swr = (1 + nu) / (1 - nu) - 1.0;
 
1027
        swr *= 16.67;
 
1028
        if (swr < 0) swr = 0;
 
1029
        if (swr > 100) swr = 100;
 
1030
        return (int)swr;
 
1031
}
 
1032
 
 
1033
int RIG_TT550::get_power_out()
 
1034
{
 
1035
        cmd = TT550getFWDREF;
 
1036
        int ret = sendCommand(cmd);
 
1037
        if (ret < 4) return fwdpwr;
 
1038
        size_t p = replystr.rfind("T");
 
1039
        if (p == string::npos) return fwdpwr;
 
1040
 
 
1041
        fwdpwr = 0.8*fwdpwr + 0.2*(unsigned char)replystr[p+1];
 
1042
        refpwr = 0.8*refpwr + 0.2*(unsigned char)replystr[p+2];
 
1043
//LOG_INFO("%s // %4.1f : %4.1f", str2hex(replystr.c_str(), replystr.length()), fwdpwr, refpwr);
 
1044
        return fwdpwr;
 
1045
}
 
1046
 
 
1047
void RIG_TT550::setBfo(int val)
 
1048
{
 
1049
        progStatus.bfo_freq = Bfo = val;
 
1050
        if (!onA) {
 
1051
                set_vfoRX(freqB);
 
1052
                set_vfoTX(freqB);
 
1053
        } else if (split) {
 
1054
                set_vfoRX(freqA);
 
1055
                set_vfoTX(freqB);
 
1056
        } else {
 
1057
                set_vfoRX(freqA);
 
1058
                set_vfoTX(freqA);
 
1059
        }
 
1060
}
 
1061
 
 
1062
int RIG_TT550::getBfo()
 
1063
{
 
1064
        return Bfo;
 
1065
}
 
1066
 
 
1067
void RIG_TT550::setVfoAdj(double v)
 
1068
{
 
1069
        VfoAdj = v;
 
1070
        set_vfoRX(onA ? freqA : freqB);
 
1071
}
 
1072
 
 
1073
void RIG_TT550::setRit(int val)
 
1074
{
 
1075
        progStatus.rit_freq = RitFreq = val;
 
1076
        if (RitFreq) RitActive = true;
 
1077
        if (!onA) {
 
1078
                set_vfoRX(freqB);
 
1079
                set_vfoTX(freqB);
 
1080
        } else if (split) {
 
1081
                set_vfoRX(freqA);
 
1082
                set_vfoTX(freqB);
 
1083
        } else {
 
1084
                set_vfoRX(freqA);
 
1085
                set_vfoTX(freqA);
 
1086
        }
 
1087
}
 
1088
 
 
1089
int RIG_TT550::getRit()
 
1090
{
 
1091
        return RitFreq;
 
1092
}
 
1093
 
 
1094
void RIG_TT550::setXit(int val)
 
1095
{
 
1096
        progStatus.xit_freq = XitFreq = val;
 
1097
        if (XitFreq) XitActive = true;
 
1098
        if (!onA) {
 
1099
                set_vfoRX(freqB);
 
1100
                set_vfoTX(freqB);
 
1101
        } else if (split) {
 
1102
                set_vfoRX(freqA);
 
1103
                set_vfoTX(freqB);
 
1104
        } else {
 
1105
                set_vfoRX(freqA);
 
1106
                set_vfoTX(freqA);
 
1107
        }
 
1108
}
 
1109
 
 
1110
int RIG_TT550::getXit()
 
1111
{
 
1112
        return XitFreq;
 
1113
}
 
1114
 
 
1115
void RIG_TT550::set_rf_gain(int val)
 
1116
{
 
1117
        cmd = TT550setRFGAIN;
 
1118
        cmd[1] = (unsigned char)(255 - val * 2.55);
 
1119
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1120
        RFgain = val;
 
1121
        sendCommand(cmd, 0);
 
1122
}
 
1123
 
 
1124
int  RIG_TT550::get_rf_gain()
 
1125
{
 
1126
        return RFgain;
 
1127
}
 
1128
 
 
1129
void RIG_TT550::get_rf_min_max_step(int &min, int &max, int &step)
 
1130
{
 
1131
        min = 0;
 
1132
        max = 100;
 
1133
        step = 1;
 
1134
}
 
1135
 
 
1136
void RIG_TT550::set_line_out()
 
1137
{
 
1138
        cmd = TT550setLINEOUT;
 
1139
        cmd[1] = (0x3F) & (((100 - progStatus.tt550_line_out) * 63) / 100);
 
1140
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1141
        sendCommand(cmd, 0);
 
1142
}
 
1143
 
 
1144
void RIG_TT550::set_agc_level()
 
1145
{
 
1146
        cmd = TT550setAGC;
 
1147
        switch (progStatus.tt550_agc_level) {
 
1148
                case 0 : cmd[1] = '1'; break;
 
1149
                case 1 : cmd[1] = '2'; break;
 
1150
                case 2 : cmd[1] = '3'; break;
 
1151
        }
 
1152
        sendCommand(cmd, 0);
 
1153
}
 
1154
 
 
1155
void RIG_TT550::set_cw_wpm()
 
1156
{
 
1157
        cmd = TT550setCWWPM;
 
1158
        int duration = 7200 / progStatus.tt550_cw_wpm;
 
1159
        int ditfactor = duration * progStatus.tt550_cw_weight;
 
1160
        int spcfactor = duration * (2.0 - progStatus.tt550_cw_weight);
 
1161
        int dahfactor = duration * 3;
 
1162
        cmd[1] = 0xFF & (ditfactor >> 8);
 
1163
        cmd[2] = 0xFF & ditfactor;
 
1164
        cmd[3] = 0xFF & (dahfactor >> 8);
 
1165
        cmd[4] = 0xFF & dahfactor;
 
1166
        cmd[5] = 0xFF & (spcfactor >> 8);
 
1167
        cmd[6] = 0xFF & spcfactor;
 
1168
        sendCommand(cmd, 0);
 
1169
}
 
1170
 
 
1171
void RIG_TT550::set_cw_vol()
 
1172
{
 
1173
        int val = progStatus.tt550_cw_vol;
 
1174
        cmd = TT550setCWMONVOL;
 
1175
        cmd[1] = 0xFF & (val * 255) / 100;
 
1176
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1177
        sendCommand(cmd, 0);
 
1178
}
 
1179
 
 
1180
bool RIG_TT550::set_cw_spot()
 
1181
{
 
1182
        int val = progStatus.tt550_cw_spot;
 
1183
        cmd = TT550setCWSPOTLVL;
 
1184
        cmd[1] = 0xFF & ((val * 255 ) / 100);
 
1185
        if (!progStatus.tt550_spot_onoff) cmd[1] = 0;
 
1186
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1187
        sendCommand(cmd, 0);
 
1188
        return true;
 
1189
}
 
1190
 
 
1191
void RIG_TT550::set_spot_onoff()
 
1192
{
 
1193
        set_cw_spot();
 
1194
}
 
1195
 
 
1196
// front panel Preamp control is hijacked for a spot control !
 
1197
 
 
1198
void RIG_TT550::set_preamp(int val)
 
1199
{
 
1200
        progStatus.tt550_spot_onoff = val;
 
1201
        set_cw_spot();
 
1202
}
 
1203
 
 
1204
void RIG_TT550::set_cw_weight()
 
1205
{
 
1206
        set_cw_wpm();
 
1207
}
 
1208
 
 
1209
void RIG_TT550::set_cw_qsk()
 
1210
{
 
1211
        cmd = TT550setCWQSK;
 
1212
        cmd[2] = (0xFF) & (int)(progStatus.tt550_cw_qsk * 2);
 
1213
        if (cmd[2] == 0x0D) cmd[2] = 0x0E;
 
1214
        sendCommand(cmd, 0);
 
1215
}
 
1216
 
 
1217
 
 
1218
void RIG_TT550::enable_keyer()
 
1219
{
 
1220
        if (progStatus.tt550_enable_keyer)
 
1221
                cmd = TT550setKEYER_ON;
 
1222
        else
 
1223
                cmd = TT550setKEYER_OFF;
 
1224
        sendCommand(cmd, 0);
 
1225
}
 
1226
 
 
1227
 
 
1228
void RIG_TT550::set_vox_onoff()
 
1229
{
 
1230
        cmd = TT550setVOX;
 
1231
        cmd[1] = progStatus.vox_onoff ? '1' : '0';
 
1232
        sendCommand(cmd, 0);
 
1233
}
 
1234
 
 
1235
void RIG_TT550::set_vox_gain()
 
1236
{
 
1237
        cmd = TT550setVOXGAIN;
 
1238
        cmd[2] = (0xFF) & (int)(progStatus.tt550_vox_gain * 2.55);
 
1239
        if (cmd[2] == 0x0D) cmd[2] = 0x0E;
 
1240
        sendCommand(cmd, 0);
 
1241
}
 
1242
 
 
1243
void RIG_TT550::set_vox_anti()
 
1244
{
 
1245
        cmd = TT550setANTIVOX;
 
1246
        cmd[2] = (0xFF) & (int)(progStatus.tt550_vox_anti * 2.55);
 
1247
        if (cmd[2] == 0x0D) cmd[2] = 0x0E;
 
1248
        sendCommand(cmd, 0);
 
1249
}
 
1250
 
 
1251
void RIG_TT550::set_vox_hang()
 
1252
{
 
1253
        cmd = TT550setVOXHANG;
 
1254
        cmd[2] = (0xFF) & (int)(progStatus.tt550_vox_hang * 2.55);
 
1255
        if (cmd[2] == 0x0D) cmd[2] = 0x0E;
 
1256
        sendCommand(cmd, 0);
 
1257
}
 
1258
 
 
1259
void RIG_TT550::set_aux_hang()
 
1260
{
 
1261
        cmd = TT550setAUXHANG;
 
1262
        cmd[2] = 0;
 
1263
        sendCommand(cmd, 0);
 
1264
}
 
1265
 
 
1266
void RIG_TT550::set_compression()
 
1267
{
 
1268
        cmd = TT550setSPEECH;
 
1269
        cmd[1] = (0x7F) & (int)(progStatus.tt550_compression * 1.27);
 
1270
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1271
        sendCommand(cmd, 0);
 
1272
}
 
1273
 
 
1274
void RIG_TT550::set_auto_notch(int v)
 
1275
{
 
1276
        auto_notch = v;
 
1277
        cmd = TT550setNRNOTCH;
 
1278
                cmd[1] = '0';
 
1279
                cmd[1] = noise_reduction ? '1' : '0';
 
1280
        if (v)
 
1281
                cmd[2] = '1';
 
1282
        else
 
1283
                cmd[2] = '0';
 
1284
        sendCommand(cmd, 0);
 
1285
}
 
1286
 
 
1287
void RIG_TT550::set_noise_reduction(int b)
 
1288
{
 
1289
        noise_reduction = b;
 
1290
        cmd = TT550setNRNOTCH;
 
1291
        if (b)
 
1292
                cmd[1] = '1'; 
 
1293
        else
 
1294
                cmd[1] = '0';
 
1295
        cmd[2] = auto_notch ? '1' : '0';
 
1296
        sendCommand(cmd, 0);
 
1297
}
 
1298
 
 
1299
void RIG_TT550::set_mic_gain(int v)
 
1300
{
 
1301
        progStatus.mic_gain = v;
 
1302
        if (!progStatus.tt550_use_line_in) {
 
1303
                cmd = TT550setMICLINE;
 
1304
                cmd[2] = 0;
 
1305
                cmd[3] = (unsigned char) v;
 
1306
                sendCommand(cmd, 0);
 
1307
        }
 
1308
}
 
1309
 
 
1310
void RIG_TT550::set_mic_line(int v)
 
1311
{
 
1312
        if (progStatus.tt550_use_line_in) {
 
1313
                cmd = TT550setMICLINE;
 
1314
                cmd[2] = 1;
 
1315
                cmd[3] = 0;//(unsigned char) v;
 
1316
                sendCommand(cmd, 0);
 
1317
        }
 
1318
}
 
1319
 
 
1320
void RIG_TT550::get_mic_min_max_step(int &min, int &max, int &step)
 
1321
{
 
1322
        min = 0;
 
1323
        max = 15;
 
1324
        step = 1;
 
1325
}
 
1326
 
 
1327
void RIG_TT550::set_power_control(double val)
 
1328
{
 
1329
        if (def_mode == TT550_AM_MODE) {
 
1330
                progStatus.tt550_AM_level = (int)val;
 
1331
                cmd = TT550setAMCARRIER;
 
1332
                cmd[1] = (unsigned char)(val * .64);
 
1333
        } else {
 
1334
                progStatus.power_level = (int) val;
 
1335
                cmd =  TT550setPOWER;
 
1336
                cmd[1] = (unsigned char)(val * 2.55);
 
1337
        }
 
1338
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1339
        sendCommand(cmd, 0);
 
1340
}
 
1341
 
 
1342
void RIG_TT550::set_mon_vol()
 
1343
{
 
1344
        cmd = TT550setMONVOL;
 
1345
        cmd[1] = 0xFF & ((progStatus.tt550_mon_vol * 255) / 100);
 
1346
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1347
        sendCommand(cmd, 0);
 
1348
}
 
1349
 
 
1350
void RIG_TT550::set_squelch_level()
 
1351
{
 
1352
        cmd = TT550setSQUELCH;
 
1353
        cmd[1] = 0xFF & ((progStatus.tt550_squelch_level * 255) / 100);
 
1354
        if (cmd[1] == 0x0D) cmd[1] = 0x0E;
 
1355
        sendCommand(cmd, 0);
 
1356
}
 
1357
 
 
1358
void RIG_TT550::set_nb_level()
 
1359
{
 
1360
        cmd = TT550setBLANKER;
 
1361
        cmd[1] = progStatus.tt550_nb_level;
 
1362
        sendCommand(cmd, 0);
 
1363
}
 
1364
 
 
1365
void RIG_TT550::set_noise(bool b)
 
1366
{
 
1367
        progStatus.noise = b;
 
1368
        set_noise_reduction(b);
 
1369
}
 
1370
 
 
1371
void RIG_TT550::tuner_bypass()
 
1372
{
 
1373
}
 
1374
 
 
1375
// callbacks for tt550 transceiver
 
1376
void cb_tt550_line_out()
 
1377
{
 
1378
        pthread_mutex_lock(&mutex_serial);
 
1379
        selrig->set_line_out();
 
1380
        pthread_mutex_unlock(&mutex_serial);
 
1381
}
 
1382
 
 
1383
void cb_tt550_agc_level()
 
1384
{
 
1385
        pthread_mutex_lock(&mutex_serial);
 
1386
        selrig->set_agc_level();
 
1387
        pthread_mutex_unlock(&mutex_serial);
 
1388
}
 
1389
 
 
1390
void cb_tt550_cw_wpm()
 
1391
{
 
1392
        pthread_mutex_lock(&mutex_serial);
 
1393
        selrig->set_cw_wpm();
 
1394
        pthread_mutex_unlock(&mutex_serial);
 
1395
}
 
1396
 
 
1397
void cb_tt550_cw_vol()
 
1398
{
 
1399
        pthread_mutex_lock(&mutex_serial);
 
1400
        selrig->set_cw_vol();
 
1401
        pthread_mutex_unlock(&mutex_serial);
 
1402
}
 
1403
 
 
1404
void cb_tt550_cw_spot()
 
1405
{
 
1406
        pthread_mutex_lock(&mutex_serial);
 
1407
        selrig->set_cw_spot();
 
1408
        pthread_mutex_unlock(&mutex_serial);
 
1409
}
 
1410
 
 
1411
void cb_tt550_cw_weight()
 
1412
{
 
1413
        pthread_mutex_lock(&mutex_serial);
 
1414
        selrig->set_cw_weight();
 
1415
        pthread_mutex_unlock(&mutex_serial);
 
1416
}
 
1417
 
 
1418
void cb_tt550_enable_keyer()
 
1419
{
 
1420
        pthread_mutex_lock(&mutex_serial);
 
1421
        selrig->enable_keyer();
 
1422
        pthread_mutex_unlock(&mutex_serial);
 
1423
}
 
1424
 
 
1425
void cb_tt550_spot_onoff()
 
1426
{
 
1427
        pthread_mutex_lock(&mutex_serial);
 
1428
        selrig->set_spot_onoff();
 
1429
        pthread_mutex_unlock(&mutex_serial);
 
1430
}
 
1431
 
 
1432
void cb_tt550_vox_gain()
 
1433
{
 
1434
        pthread_mutex_lock(&mutex_serial);
 
1435
        selrig->set_vox_gain();
 
1436
        pthread_mutex_unlock(&mutex_serial);
 
1437
}
 
1438
 
 
1439
void cb_tt550_vox_anti()
 
1440
{
 
1441
        pthread_mutex_lock(&mutex_serial);
 
1442
        selrig->set_vox_anti();
 
1443
        pthread_mutex_unlock(&mutex_serial);
 
1444
}
 
1445
 
 
1446
void cb_tt550_vox_hang()
 
1447
{
 
1448
        pthread_mutex_lock(&mutex_serial);
 
1449
        selrig->set_vox_hang();
 
1450
        pthread_mutex_unlock(&mutex_serial);
 
1451
}
 
1452
 
 
1453
void cb_tt550_vox_onoff()
 
1454
{
 
1455
        pthread_mutex_lock(&mutex_serial);
 
1456
        selrig->set_vox_onoff();
 
1457
        pthread_mutex_unlock(&mutex_serial);
 
1458
}
 
1459
 
 
1460
void cb_tt550_compression()
 
1461
{
 
1462
        pthread_mutex_lock(&mutex_serial);
 
1463
        selrig->set_compression();
 
1464
        pthread_mutex_unlock(&mutex_serial);
 
1465
}
 
1466
 
 
1467
void cb_tt550_mon_vol()
 
1468
{
 
1469
        pthread_mutex_lock(&mutex_serial);
 
1470
        selrig->set_mon_vol();
 
1471
        pthread_mutex_unlock(&mutex_serial);
 
1472
}
 
1473
 
 
1474
void cb_tt550_tuner_bypass()
 
1475
{
 
1476
        pthread_mutex_lock(&mutex_serial);
 
1477
        selrig->tuner_bypass();
 
1478
        pthread_mutex_unlock(&mutex_serial);
 
1479
}
 
1480
 
 
1481
void cb_tt550_enable_xmtr()
 
1482
{
 
1483
        pthread_mutex_lock(&mutex_serial);
 
1484
        selrig->enable_xmtr();
 
1485
        pthread_mutex_unlock(&mutex_serial);
 
1486
}
 
1487
 
 
1488
void cb_tt550_enable_tloop()
 
1489
{
 
1490
        pthread_mutex_lock(&mutex_serial);
 
1491
        selrig->enable_tloop();
 
1492
        pthread_mutex_unlock(&mutex_serial);
 
1493
}
 
1494
 
 
1495
void cb_tt550_nb_level()
 
1496
{
 
1497
        pthread_mutex_lock(&mutex_serial);
 
1498
        progStatus.tt550_nb_level = cbo_tt550_nb_level->index();
 
1499
        selrig->set_nb_level();
 
1500
        pthread_mutex_unlock(&mutex_serial);
 
1501
}
 
1502
 
 
1503
void cb_tt550_use_line_in()
 
1504
{
 
1505
        pthread_mutex_lock(&mutex_serial);
 
1506
        if (progStatus.tt550_use_line_in)
 
1507
                selrig->set_mic_line(0);
 
1508
        else
 
1509
                selrig->set_mic_gain(progStatus.mic_gain);
 
1510
        pthread_mutex_unlock(&mutex_serial);
 
1511
}
 
1512
 
 
1513
void cb_tt550_setXmtBW()
 
1514
{
 
1515
        pthread_mutex_lock(&mutex_serial);
 
1516
        selrig->set_bwA(selrig->bwA);
 
1517
        pthread_mutex_unlock(&mutex_serial);
 
1518
}
 
1519
 
 
1520
void cb_tt550_cw_qsk()
 
1521
{
 
1522
        pthread_mutex_lock(&mutex_serial);
 
1523
        selrig->set_cw_qsk();
 
1524
        pthread_mutex_unlock(&mutex_serial);
 
1525
}
 
1526
 
 
1527
//======================================================================
 
1528
// data strings captured from TenTec Windows control program for Pegasus
 
1529
//======================================================================
 
1530
 
 
1531
/*
 
1532
       Pegasus Control Program Startup, Query and Close Sequences
 
1533
       ==========================================================
 
1534
 
 
1535
========================= start program ======================================
 
1536
WRITE Length 3: 
 
1537
58 58 0D                                  "XX"
 
1538
 
 
1539
READ  Length 2: 
 
1540
0D 0D 
 
1541
READ  Length 14:
 
1542
20 20 52 41 44 49 4F 20 53 54 41 52 54 0D "  RADIO START"
 
1543
 
 
1544
WRITE Length 3: 
 
1545
3F 56 0D                                  "?V"  version?
 
1546
READ  Length 13:
 
1547
56 45 52 20 31 32 39 31 2D 35 33 38 0D    "VER 1291.538"
 
1548
 
 
1549
WRITE Length 7: 
 
1550
4D 31 31 0D                               "M11" mode - USB / USB
 
1551
50 2B 0D                                  "P+"  power = 16.8 watts
 
1552
 
 
1553
WRITE Length 28: 
 
1554
47 31 0D                                  "G1" agc - slow
 
1555
4E 51 5C 0A A9 67 70 0D                   "N...." Receive tuning factor
 
1556
54 51 5C 0A A9 12 20 0D                   "T...." Transmit tuning factor
 
1557
57 0A 0D                                  "W." Width 3000
 
1558
56 3E 0D                                  "V." Volume 24
 
1559
4C 00 0D                                  "L0" Line out - 0, full output
 
1560
 
 
1561
WRITE Length 3: 
 
1562
50 2B 0D                                  "P+" power = 16.8 watts
 
1563
 
 
1564
WRITE Length 3: 
 
1565
4A 29 0D                                  "J." sidetone volume = 16
 
1566
 
 
1567
WRITE Length 13:
 
1568
4F 31 01 00 0D                            "O1." select line in, gain factor = 1
 
1569
55 47 0F 0D                               "UG." Vox gain = 15
 
1570
55 48 0F 0D                               "UH." Vox hang = 15
 
1571
 
 
1572
WRITE Length 16: 
 
1573
55 41 5D 0D                               "UA." Antivox = 36
 
1574
55 30 0D                                  "U0" Vox OFF
 
1575
48 00 0D                                  "H." Audio monitor volume = 0
 
1576
23 32 0D                                  "#2" Disable 'T' loop
 
1577
23 31 0D                                  "#1" Enable transmitter
 
1578
 
 
1579
WRITE Length 26: 
 
1580
43 0A 0D                                  "C." Transmit filter width = 3000
 
1581
23 36 0D                                  "#6" Enable keyer
 
1582
53 00 0D                                  "S." Squelch = 0, OFF
 
1583
52 0F 0D                                  "R." UNKNOWN
 
1584
45 01 1F 03 5D 01 1F 0D                   "E...." Keyer timing 
 
1585
44 00 0D                                  "D." Noise blanker = 0, OFF
 
1586
59 00 0D                                  "Y." Speech processor = 0, OFF
 
1587
 
 
1588
WRITE Length 8: 
 
1589
55 51 00 0D                               "UQ." set CW QSK = 0..255
 
1590
55 54 00 0D                               "UT." set AUX TX HANG = 0..255 (aux T/R delay)
 
1591
 
 
1592
============================ smeter query ======================================
 
1593
WRITE Length 3: 
 
1594
3F 53 0D                                  "?S" read smeter
 
1595
READ    Length 6: 
 
1596
53 30 39 31 42 0D                         "S...." smeter value
 
1597
 
 
1598
============================== close program ====================================
 
1599
 
 
1600
WRITE Length 3: 
 
1601
56 00 0D                                  "V0" volume = ZERO
 
1602
 
 
1603
WRITE Length 3: 
 
1604
4C 3F 0D                                  "L." Line out = 63, MINIMUM
 
1605
 
 
1606
 
 
1607
unsigned char datastream[] = {
 
1608
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1609
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1610
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1611
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1612
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1613
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1614
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1615
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1616
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1617
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1618
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1619
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1620
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1621
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1622
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1623
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1624
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1625
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1626
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1627
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1628
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1629
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1630
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1631
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1632
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1633
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1634
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1635
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1636
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1637
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1638
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1639
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1640
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1641
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1642
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1643
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1644
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1645
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1646
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1647
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1648
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1649
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1650
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1651
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1652
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1653
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1654
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1655
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1656
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1657
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1658
 
 
1659
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1660
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1661
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1662
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1663
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1664
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1665
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1666
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1667
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1668
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1669
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1670
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1671
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1672
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1673
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1674
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1675
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1676
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1677
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1678
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1679
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1680
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1681
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1682
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1683
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1684
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1685
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1686
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1687
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1688
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1689
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1690
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1691
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1692
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1693
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1694
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1695
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1696
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1697
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1698
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1699
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1700
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1701
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1702
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1703
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1704
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1705
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1706
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1707
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1708
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1709
 
 
1710
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1711
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1712
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1713
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1714
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1715
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1716
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1717
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1718
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1719
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1720
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1721
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1722
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1723
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1724
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1725
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1726
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1727
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1728
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1729
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1730
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1731
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1732
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1733
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1734
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1735
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1736
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1737
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1738
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1739
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1740
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1741
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1742
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1743
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1744
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1745
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1746
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1747
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1748
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1749
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1750
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1751
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1752
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1753
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1754
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1755
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1756
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1757
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1758
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1759
0x21, 0xFF, 0xFF, 0x00, 0x0D,
 
1760
 
 
1761
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1762
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1763
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1764
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1765
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1766
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1767
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1768
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1769
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1770
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1771
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1772
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1773
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1774
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1775
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1776
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1777
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1778
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1779
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1780
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1781
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1782
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1783
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1784
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1785
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1786
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1787
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1788
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1789
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1790
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1791
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1792
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1793
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1794
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1795
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1796
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1797
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1798
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1799
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1800
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1801
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1802
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1803
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1804
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1805
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1806
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1807
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1808
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1809
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1810
0x21, 0x00, 0x01, 0x00, 0x0D,
 
1811
 
 
1812
0x80 };
 
1813
 
 
1814
*/