]> git.rkrishnan.org Git - dttsp.git/blob - jDttSP/keyer.c
added on/off switching for aux input port mix
[dttsp.git] / jDttSP / keyer.c
1 /* keyer.c */
2 /*
3 This file is part of a program that implements a Software-Defined Radio.
4
5 The code in this file is derived from routines originally written by
6 Pierre-Philippe Coupard for his CWirc X-chat program. That program
7 is issued under the GPL and is
8 Copyright (C) Pierre-Philippe Coupard - 18/06/2003
9
10 This derived version is
11 Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26
27 The authors can be reached by email at
28
29 ab2kt@arrl.net
30 or
31 rwmcgwier@comcast.net
32
33 or by paper mail at
34
35 The DTTS Microwave Society
36 6 Kathleen Place
37 Bridgewater, NJ 08807
38 */  
39
40 // see below for places where serial port is read
41 // and needs replacement for parallel port hookup
42
43 #include <keyer.h>
44
45 //========================================================================
46 // nothing affected by physical port connection here
47
48 BOOLEAN
49 klogic(KeyerLogic kl,
50        BOOLEAN dit,
51        BOOLEAN dah,
52        double wpm,
53        int iambicmode,
54        BOOLEAN midelementmodeB,
55        BOOLEAN ditmemory,
56        BOOLEAN dahmemory,
57        BOOLEAN autocharspacing,
58        BOOLEAN autowordspacing,
59        int weight,
60        double ticklen) {
61
62   double ditlen = 1200 / wpm;
63   int set_element_timeouts = NO_TIMEOUTS_SCHED;
64
65   /* Do we need to initialize the keyer? */
66   if (!kl->flag.init) {
67     kl->flag.prev.dit = dit;
68     kl->flag.prev.dah = dah;
69     kl->element.last = kl->element.curr = NO_ELEMENT;
70     kl->element.iamb = NO_PADDLE_SQUEEZE;
71     kl->element.psqam = 0;
72     kl->element.invtd = 0;
73     kl->timeout.midl = kl->timeout.beep = kl->timeout.elem = 0;
74     kl->timeout.dlay = 0;
75     kl->dlay_type = NO_DELAY;
76     kl->flag.init = 1;
77   }
78
79   /* Decrement the timeouts */
80   kl->timeout.dlay -= kl->timeout.dlay > 0 ? ticklen : 0;
81   if (kl->timeout.dlay <= 0) {
82     /* If nothing is scheduled to play, and we just did a character
83        spacing delay, and we do auto word spacing, wait for a word
84        spacing delay, otherwise resume the normal element timeout
85        countdowns */
86     if (kl->timeout.elem <= 0 &&
87         kl->dlay_type == CHAR_SPACING_DELAY &&
88         autowordspacing) {
89       kl->timeout.dlay = ditlen * 4;
90       kl->dlay_type = WORD_SPACING_DELAY;
91     } else {
92       kl->dlay_type = NO_DELAY;
93       kl->timeout.midl -= kl->timeout.midl > 0 ? ticklen : 0;
94       kl->timeout.beep -= kl->timeout.beep > 0 ? ticklen : 0;
95       kl->timeout.elem -= kl->timeout.elem > 0 ? ticklen : 0;
96     }
97   }
98
99   /* Are both paddles squeezed? */
100   if (dit && dah) {
101     kl->element.iamb = PADDLES_SQUEEZED;
102
103     /* Are the paddles squeezed past the middle of the element? */
104     if (kl->timeout.midl <= 0)
105       kl->element.psqam = 1;
106   } else
107     /* Are both paddles released and we had gotten a squeeze in this element? */
108   if (!dit && !dah && kl->element.iamb == PADDLES_SQUEEZED)
109     kl->element.iamb = PADDLES_RELEASED;
110
111   /* Is the current element finished? */
112   if (kl->timeout.elem <= 0 && kl->element.curr != NO_ELEMENT) {
113     kl->element.last = kl->element.curr;
114
115     /* Should we insert an inverted element? */
116     if (((dit && dah) ||
117          (kl->element.invtd &&
118           kl->element.iamb != PADDLES_RELEASED) ||
119          (kl->element.iamb == PADDLES_RELEASED &&
120           iambicmode == MODE_B &&
121           (!midelementmodeB || kl->element.psqam)))) {
122       if (kl->element.last == DAH)
123         set_element_timeouts = kl->element.curr = DIT;
124       else
125         set_element_timeouts = kl->element.curr = DAH;
126     } else {
127       /* No more element */
128       kl->element.curr = NO_ELEMENT;
129
130       /* Do we do automatic character spacing? */
131       if (autocharspacing && !dit && !dah) {
132         kl->timeout.dlay = ditlen * 2;
133         kl->dlay_type = CHAR_SPACING_DELAY;
134       }
135     }
136
137     kl->element.invtd = 0;
138     kl->element.iamb = NO_PADDLE_SQUEEZE;
139     kl->element.psqam = 0;
140   }
141
142   /* Is an element currently being played? */
143   if (kl->element.curr == NO_ELEMENT) {
144     if (dah)                    /* Dah paddle down ? */
145       set_element_timeouts = kl->element.curr = DAH;
146     else if (dit)               /* Dit paddle down ? */
147       set_element_timeouts = kl->element.curr = DIT;
148   }
149
150   /* Do the dah memory */
151   if (kl->element.curr == DIT &&
152       !kl->flag.prev.dah &&
153       dah &&
154       dahmemory)
155     kl->element.invtd = 1;
156
157   /* Do the dit memory */
158   if (kl->element.curr == DAH &&
159       !kl->flag.prev.dit &&
160       dit &&
161       ditmemory)
162     kl->element.invtd = 1;
163
164   /* If we had a dit (or dah) scheduled to be played after a delay,
165      and the operator lifted both paddles before the end of the delay,
166      and we have no dit (or dah) memory, forget it */
167
168   if (kl->timeout.dlay > 0 &&
169       !dit &&
170       !dah &&
171       ((kl->element.curr == DIT &&
172         !ditmemory) ||
173        (kl->element.curr == DAH
174         && !dahmemory)))
175     set_element_timeouts = kl->element.curr = NO_ELEMENT;
176
177   /* Do we need to set the playing timeouts of an element? */
178   switch (set_element_timeouts) {
179   case NO_ELEMENT:              /* Cancel any dit or dah */
180     kl->timeout.beep = 0;
181     kl->timeout.midl = 0;
182     kl->timeout.elem = 0;
183     break;
184
185   case DIT:                     /* Schedule a dit? */
186     kl->timeout.beep = (ditlen * (double) weight) / 50;
187     kl->timeout.midl = kl->timeout.beep / 2;
188     kl->timeout.elem = ditlen * 2;
189     break;
190
191   case DAH:                     /* Schedule a dah? */
192     kl->timeout.beep = (ditlen * (double) weight) / 50 + ditlen * 2;
193     kl->timeout.midl = kl->timeout.beep / 2;
194     kl->timeout.elem = ditlen * 4;
195     break;
196   }
197
198   kl->flag.prev.dit = dit;
199   kl->flag.prev.dah = dah;
200
201   return kl->timeout.beep > 0 && kl->timeout.dlay <= 0;
202 }
203
204 //========================================================================
205
206 /* Read a straight key connected to a serial port, do debouncing, then
207    return the key state */
208
209 BOOLEAN
210 read_straight_key_serial(KeyerState ks, int fd) {
211   int i, j, serstatus;
212   static BOOLEAN keystate = 0;
213   static int debounce_buf_i = 0,
214              debounce_buf[DEBOUNCE_BUF_MAX_SIZE];
215
216   //***************************************************
217   // replace this with parallel port logic if necessary
218   //***************************************************
219   //
220   /* Read the key state */
221   if (ioctl(fd, TIOCMGET, &serstatus) != -1) {
222     debounce_buf[debounce_buf_i] =
223       (serstatus & (TIOCM_DSR | TIOCM_CTS)) ?
224       DSR_LINE_CLOSED_KEY : !DSR_LINE_CLOSED_KEY;
225
226     debounce_buf_i++;
227   }
228   //
229   //***************************************************
230   // back to business as usual
231   //***************************************************
232
233   /* If the debounce buffer is full, determine the state of the key */
234   if (debounce_buf_i >= ks->debounce) {
235     debounce_buf_i = 0;
236
237     j = 0;
238     for (i = 0; i < ks->debounce; i++)
239       if (debounce_buf[i])
240         j++;
241     keystate = (j > ks->debounce / 2) ? 1 : 0;
242   }
243
244   return keystate;
245 }
246
247 //------------------------------------------------------------------------
248
249 /* Read an iambic key connected to a serial port, do debouncing, emulate a
250    straight key, then return the emulated key state */
251
252 BOOLEAN
253 read_iambic_key_serial(KeyerState ks, int fd, KeyerLogic kl, double ticklen) {
254   int i, j, serstatus;
255   static BOOLEAN dah_debounce_buf[DEBOUNCE_BUF_MAX_SIZE],
256                  dit_debounce_buf[DEBOUNCE_BUF_MAX_SIZE];
257   static int dah = 0, debounce_buf_i = 0, dit = 0;
258
259   //***************************************************
260   // replace this with parallel port logic if necessary
261   //***************************************************
262   //
263   /* Read the key states */
264   if (ioctl(fd, TIOCMGET, &serstatus) != -1) {
265     if (ks->flag.revpdl) {
266       dah_debounce_buf[debounce_buf_i] =
267         (serstatus & TIOCM_DSR) ? DSR_LINE_CLOSED_KEY : !DSR_LINE_CLOSED_KEY;
268       dit_debounce_buf[debounce_buf_i] =
269         (serstatus & TIOCM_CTS) ? CTS_LINE_CLOSED_KEY : !CTS_LINE_CLOSED_KEY;
270     } else {
271       dit_debounce_buf[debounce_buf_i] =
272         (serstatus & TIOCM_DSR) ? DSR_LINE_CLOSED_KEY : !DSR_LINE_CLOSED_KEY;
273       dah_debounce_buf[debounce_buf_i] =
274         (serstatus & TIOCM_CTS) ? CTS_LINE_CLOSED_KEY : !CTS_LINE_CLOSED_KEY;
275     }
276
277     debounce_buf_i++;
278   }
279   //
280   //***************************************************
281   // back to business as usual
282   //***************************************************
283
284   /* If the debounce buffer is full, determine the state of the keys */
285   if (debounce_buf_i >= ks->debounce) {
286     debounce_buf_i = 0;
287
288     j = 0;
289     for (i = 0; i < ks->debounce; i++)
290       if (dah_debounce_buf[i]) j++;
291     dah = (j > ks->debounce / 2) ? 1 : 0;
292
293     j = 0;
294     for (i = 0; i < ks->debounce; i++)
295       if (dit_debounce_buf[i]) j++;
296     dit = (j > ks->debounce / 2) ? 1 : 0;
297   }
298
299   return klogic(kl,
300                 dit,
301                 dah,
302                 ks->wpm,
303                 ks->mode,
304                 ks->flag.mdlmdB,
305                 ks->flag.memory.dit,
306                 ks->flag.memory.dah,
307                 ks->flag.autospace.khar,
308                 ks->flag.autospace.word,
309                 ks->weight,
310                 ticklen);
311 }
312
313 //========================================================================
314
315 KeyerState
316 newKeyerState(void) {
317   return (KeyerState) safealloc(1, sizeof(KeyerStateInfo), "newKeyerState");
318 }
319
320 void
321 delKeyerState(KeyerState ks) {
322   safefree((char *) ks);
323 }
324
325 KeyerLogic
326 newKeyerLogic(void) {
327   return (KeyerLogic) safealloc(1, sizeof(KeyerLogicInfo), "newKeyerLogic");
328 }
329
330 void
331 delKeyerLogic(KeyerLogic kl) {
332   safefree((char *) kl);
333 }
334
335 //========================================================================