]> git.rkrishnan.org Git - dttsp.git/blob - jDttSP/keyd.c
slight changes to type-in keyer, autoconnect to playback for type-in and iambic keyers
[dttsp.git] / jDttSP / keyd.c
1 /* keyd.c */
2 /*
3 This file is part of a program that implements a Software-Defined Radio.
4
5 Copyright (C) 2004 by Frank Brickle, AB2KT and Bob McGwier, N4HY
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
21 The authors can be reached by email at
22
23 ab2kt@arrl.net
24 or
25 rwmcgwier@comcast.net
26
27 or by paper mail at
28
29 The DTTS Microwave Society
30 6 Kathleen Place
31 Bridgewater, NJ 08807
32 */  
33
34 #include <linux/rtc.h>
35 #include <fromsys.h>
36 #include <banal.h>
37 #include <splitfields.h>
38 #include <datatypes.h>
39 #include <bufvec.h>
40 #include <cxops.h>
41 #include <ringb.h>
42 #include <chan.h>
43 #include <oscillator.h>
44 #include <cwtones.h>
45 #include <keyer.h>
46
47 #define SAMP_RATE (48000)
48
49 // # times key is sampled per sec
50 // > 64 requires root on Linux
51 //#define RTC_RATE (128)
52 #define RTC_RATE (64)
53
54 // # samples generated during 1 clock tick at RTC_RATE
55 #define TONE_SIZE (SAMP_RATE / RTC_RATE)
56
57 // ring buffer size; > 1 sec at this sr
58 #define RING_SIZE (01 << 020)
59
60 KeyerState ks;
61 KeyerLogic kl;
62
63 pthread_t play, key;
64 sem_t clock_fired, keyer_started;
65
66 int fdser, fdrtc;
67
68 jack_client_t *client;
69 jack_port_t *lport, *rport;
70 jack_ringbuffer_t *lring, *rring;
71 jack_nframes_t size;
72
73 CWToneGen gen;
74 BOOLEAN playing = FALSE, iambic = FALSE;
75 double wpm = 18.0, freq = 750.0;
76
77 //------------------------------------------------------------
78
79 void
80 jack_ringbuffer_clear(jack_ringbuffer_t *ring, int nbytes) {
81   int i;
82   char zero = 0;
83   for (i = 0; i < nbytes; i++)
84     jack_ringbuffer_write(ring, &zero, 1);
85 }
86
87 void
88 jack_ringbuffer_restart(jack_ringbuffer_t *ring, int nbytes) {
89   jack_ringbuffer_reset(ring);
90   jack_ringbuffer_clear(ring, nbytes);
91 }
92
93 //------------------------------------------------------------
94
95 // generated tone -> output ringbuffer
96 void
97 send_tone(void) {
98   if (jack_ringbuffer_write_space(lring) < TONE_SIZE * sizeof(float)) {
99     write(2, "overrun tone\n", 13);
100     jack_ringbuffer_restart(lring, TONE_SIZE * sizeof(float));
101     jack_ringbuffer_restart(rring, TONE_SIZE * sizeof(float));
102   } else {
103     int i;
104     for (i = 0; i < gen->size; i++) {
105       float l = CXBreal(gen->buf, i),
106             r = CXBimag(gen->buf, i);
107       jack_ringbuffer_write(lring, (char *) &l, sizeof(float));
108       jack_ringbuffer_write(rring, (char *) &r, sizeof(float));
109     }
110   }
111 }
112
113 // silence -> output ringbuffer
114 void
115 send_silence(void) {
116   if (jack_ringbuffer_write_space(lring) < TONE_SIZE * sizeof(float)) {
117     write(2, "overrun zero\n", 13);
118     jack_ringbuffer_restart(lring, TONE_SIZE * sizeof(float));
119     jack_ringbuffer_restart(rring, TONE_SIZE * sizeof(float));
120   } else {
121     int i;
122     for (i = 0; i < gen->size; i++) {
123       float zero = 0.0;
124       jack_ringbuffer_write(lring, (char *) &zero, sizeof(float));
125       jack_ringbuffer_write(rring, (char *) &zero, sizeof(float));
126     }
127   }
128 }
129
130 // sound/silence generation
131 // tone turned on/off asynchronously
132 void
133 sound_thread(void) {
134   for (;;) {
135     sem_wait(&clock_fired);
136
137     if (playing) {
138       // CWTone keeps playing for awhile after it's turned off,
139       // in order to allow for a decay envelope;
140       // returns FALSE when it's actually done.
141       playing = CWTone(gen);
142       send_tone();
143     } else
144       send_silence();
145   }
146
147   pthread_exit(0);
148 }
149
150 // basic heartbeat
151 // returns actual dur in msec since last tick;
152 // uses Linux rtc interrupts.
153 // other strategies will work too, so long as they
154 // provide a measurable delay in msec.
155 double
156 timed_delay(void) {
157   double del, std = 1000 / (double) RTC_RATE;
158   static int cnt = 0;
159   unsigned long data;
160   
161   if (read(fdrtc, &data, sizeof(unsigned long)) == -1) {
162     perror("read");
163     exit(1);
164   }
165   // indicate whether an interrupt was missed
166   // not really important except for performance tweaks
167   if ((del = (data >> 010) * 1000 / (double) RTC_RATE) != std)
168     fprintf(stderr, "%d %g ms\n", ++cnt, del);
169   return del;
170 }
171
172 // key down? (real or via keyer logic)
173 BOOLEAN
174 read_key(double del) {
175   if (iambic)
176     return read_iambic_key_serial(ks, fdser, kl, del);
177   else
178     return read_straight_key_serial(ks, fdser);
179 }
180
181 // main keyer loop
182 // 
183 void
184 key_thread(void) {
185
186   sem_wait(&keyer_started);
187
188   for (;;) {
189     // wait for next tick, get actual dur since last one
190     double del = timed_delay();
191     // read key; tell keyer elapsed time since last call
192     BOOLEAN keydown = read_key(del);
193
194     if (!playing && keydown)
195       CWToneOn(gen), playing = TRUE;
196     else if (playing && !keydown)
197       CWToneOff(gen);
198
199     sem_post(&clock_fired);
200   }
201
202   pthread_exit(0);
203 }
204
205 PRIVATE void
206 jack_xrun(void *arg) {
207   char *str = "xrun";
208   write(2, str, strlen(str));
209 }
210
211 PRIVATE void
212 jack_shutdown(void *arg) {}
213
214 PRIVATE void
215 jack_callback(jack_nframes_t nframes, void *arg) {
216   float *lp, *rp;
217   int nbytes = nframes * sizeof(float);
218   if (nframes == size) {
219     // output: copy from ring to port
220     lp = (float *) jack_port_get_buffer(lport, nframes);
221     rp = (float *) jack_port_get_buffer(rport, nframes);
222     if (jack_ringbuffer_read_space(lring) >= nbytes) {
223       jack_ringbuffer_read(lring, (char *) lp, nbytes);
224       jack_ringbuffer_read(rring, (char *) rp, nbytes);
225     } else { // rb pathology
226       memset((char *) lp, 0, nbytes);
227       memset((char *) rp, 0, nbytes);
228       jack_ringbuffer_reset(lring);
229       jack_ringbuffer_reset(rring);
230       jack_ringbuffer_clear(lring, nbytes);
231       jack_ringbuffer_clear(rring, nbytes);
232       //write(2, "underrun\n", 9); 
233     }
234   }
235 }
236
237 int
238 main(int argc, char **argv) {
239   int i;
240   char *serialdev = "/dev/ttyS0",
241        *clockdev = "/dev/rtc";
242   int serstatus;
243
244   for (i = 1; i < argc; i++)
245     if (argv[i][0] == '-')
246       switch (argv[i][1]) {
247       case 'f':
248         freq = atof(argv[++i]);
249         break;
250       case 'i':
251         iambic = TRUE;
252         break;
253       case 'w':
254         wpm = atof(argv[++i]);
255         break;
256       default:
257         fprintf(stderr, "keyd [-i] [-w wpm]\n");
258         exit(1);
259       }
260     else break;
261
262   //------------------------------------------------------------
263
264   gen = newCWToneGen(-3.0, freq, 5.0, 5.0, TONE_SIZE, 48000.0);
265
266   //------------------------------------------------------------
267
268   kl = newKeyerLogic();
269   ks = newKeyerState();
270   ks->flag.iambic = TRUE;
271   ks->flag.revpdl = TRUE; // depends on port wiring
272   ks->flag.autospace.khar = ks->flag.autospace.word = FALSE;
273   ks->debounce = 1; // could be more if sampled faster
274   ks->mode = MODE_B;
275   ks->weight = 50;
276   ks->wpm = wpm;
277
278   //------------------------------------------------------------
279
280   if (!(client = jack_client_new("keyd")))
281     fprintf(stderr, "can't make client -- jack not running?\n"), exit(1);
282   jack_set_process_callback(client, (void *) jack_callback, 0);
283   jack_on_shutdown(client, (void *) jack_shutdown, 0);
284   jack_set_xrun_callback(client, (void *) jack_xrun, 0);
285   size = jack_get_buffer_size(client);
286   lport = jack_port_register(client,
287                              "ol",
288                              JACK_DEFAULT_AUDIO_TYPE,
289                              JackPortIsOutput,
290                              0);
291   rport = jack_port_register(client,
292                              "or",
293                              JACK_DEFAULT_AUDIO_TYPE,
294                              JackPortIsOutput,
295                              0);
296   lring = jack_ringbuffer_create(RING_SIZE);
297   rring = jack_ringbuffer_create(RING_SIZE);
298   jack_ringbuffer_clear(lring, size * sizeof(float));
299   jack_ringbuffer_clear(rring, size * sizeof(float));
300   
301   //------------------------------------------------------------
302
303   // key
304   if ((fdser = open(serialdev, O_WRONLY)) == -1) {
305     fprintf(stderr, "cannot open serial device %s", serialdev);
306     exit(1);
307   }
308   if (ioctl(fdser, TIOCMGET, &serstatus) == -1) {
309     close(fdser);
310     fprintf(stderr, "cannot get serial device status");
311     exit(1);
312   }
313   serstatus |= TIOCM_DTR;
314   if (ioctl(fdser, TIOCMSET, &serstatus) == -1) {
315     close(fdser);
316     fprintf(stderr, "cannot set serial device status");
317     exit(1);
318   }
319
320   // rtc
321   if ((fdrtc = open(clockdev, O_RDONLY)) == -1) {
322     perror(clockdev);
323     exit(1);
324   }
325   if (ioctl(fdrtc, RTC_IRQP_SET, RTC_RATE) == -1) {
326     perror("ioctl irqp");
327     exit(1);
328   }
329   if (ioctl(fdrtc, RTC_PIE_ON, 0) == -1) {
330     perror("ioctl pie on");
331     exit(1);
332   }
333
334   //------------------------------------------------------------
335
336   sem_init(&clock_fired, 0, 0);
337   sem_init(&keyer_started, 0, 0);
338   pthread_create(&play, 0, (void *) sound_thread, 0);
339   pthread_create(&key, 0, (void *) key_thread, 0);
340
341   //------------------------------------------------------------
342
343   jack_activate(client);
344   {
345     const char **ports;
346     if (!(ports = jack_get_ports(client, 0, 0, JackPortIsPhysical | JackPortIsInput))) {
347       fprintf(stderr, "can't find any physical playback ports\n");
348       exit(1);
349     }
350     if (jack_connect(client, jack_port_name(lport), ports[0])) {
351       fprintf(stderr, "can't connect left output\n");
352       exit(1);
353     }
354     if (jack_connect(client, jack_port_name(rport), ports[1])) {
355       fprintf(stderr, "can't connect left output\n");
356       exit(1);
357     }
358     free(ports);
359   }
360   sem_post(&keyer_started);
361
362   pthread_join(play, 0);
363   pthread_join(key, 0);
364   jack_client_close(client);
365
366   //------------------------------------------------------------
367
368   if (ioctl(fdrtc, RTC_PIE_OFF, 0) == -1) {
369     perror("ioctl pie off");
370     exit(1);
371   }
372   close(fdrtc);
373   close(fdser);
374
375   jack_ringbuffer_free(lring);
376   jack_ringbuffer_free(rring);
377
378   sem_destroy(&clock_fired);
379   sem_destroy(&keyer_started);
380
381   delCWToneGen(gen);
382   delKeyerState(ks);
383   delKeyerLogic(kl);
384
385   //------------------------------------------------------------
386
387   exit(0);
388 }