![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tg.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / util|
Return to tg.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / util |
1.1 misho 1: /*
2: * tg.c generate WWV or IRIG signals for test
3: */
4: /*
5: * This program can generate audio signals that simulate the WWV/H
6: * broadcast timecode. Alternatively, it can generate the IRIG-B
7: * timecode commonly used to synchronize laboratory equipment. It is
8: * intended to test the WWV/H driver (refclock_wwv.c) and the IRIG
9: * driver (refclock_irig.c) in the NTP driver collection.
10: *
11: * Besides testing the drivers themselves, this program can be used to
12: * synchronize remote machines over audio transmission lines or program
13: * feeds. The program reads the time on the local machine and sets the
14: * initial epoch of the signal generator within one millisecond.
15: * Alernatively, the initial epoch can be set to an arbitrary time. This
16: * is useful when searching for bugs and testing for correct response to
17: * a leap second in UTC. Note however, the ultimate accuracy is limited
18: * by the intrinsic frequency error of the codec sample clock, which can
19: # reach well over 100 PPM.
20: *
21: * The default is to route generated signals to the line output
22: * jack; the s option on the command line routes these signals to the
23: * internal speaker as well. The v option controls the speaker volume
24: * over the range 0-255. The signal generator by default uses WWV
25: * format; the h option switches to WWVH format and the i option
26: * switches to IRIG-B format.
27: *
28: * Once started the program runs continuously. The default initial epoch
29: * for the signal generator is read from the computer system clock when
30: * the program starts. The y option specifies an alternate epoch using a
31: * string yydddhhmmss, where yy is the year of century, ddd the day of
32: * year, hh the hour of day and mm the minute of hour. For instance,
33: * 1946Z on 1 January 2006 is 060011946. The l option lights the leap
34: * warning bit in the WWV/H timecode, so is handy to check for correct
35: * behavior at the next leap second epoch. The remaining options are
36: * specified below under the Parse Options heading. Most of these are
37: * for testing.
38: *
39: * During operation the program displays the WWV/H timecode (9 digits)
40: * or IRIG timecode (20 digits) as each new string is constructed. The
41: * display is followed by the BCD binary bits as transmitted. Note that
42: * the transmissionorder is low-order first as the frame is processed
43: * left to right. For WWV/H The leap warning L preceeds the first bit.
44: * For IRIG the on-time marker M preceeds the first (units) bit, so its
45: * code is delayed one bit and the next digit (tens) needs only three
46: * bits.
47: *
48: * The program has been tested with the Sun Blade 1500 running Solaris
49: * 10, but not yet with other machines. It uses no special features and
50: * should be readily portable to other hardware and operating systems.
51: */
52: #include <stdio.h>
53: #include <stdlib.h>
54: #include <time.h>
55: #include <sys/audio.h>
56: #include <math.h>
57: #include <errno.h>
58: #include <sys/types.h>
59: #include <sys/stat.h>
60: #include <fcntl.h>
61: #include <string.h>
62: #include <unistd.h>
63:
64: #define SECOND 8000 /* one second of 125-us samples */
65: #define BUFLNG 400 /* buffer size */
66: #define DEVICE "/dev/audio" /* default audio device */
67: #define WWV 0 /* WWV encoder */
68: #define IRIG 1 /* IRIG-B encoder */
69: #define OFF 0 /* zero amplitude */
70: #define LOW 1 /* low amplitude */
71: #define HIGH 2 /* high amplitude */
72: #define DATA0 200 /* WWV/H 0 pulse */
73: #define DATA1 500 /* WWV/H 1 pulse */
74: #define PI 800 /* WWV/H PI pulse */
75: #define M2 2 /* IRIG 0 pulse */
76: #define M5 5 /* IRIG 1 pulse */
77: #define M8 8 /* IRIG PI pulse */
78:
79: /*
80: * Companded sine table amplitude 3000 units
81: */
82: int c3000[] = {1, 48, 63, 70, 78, 82, 85, 89, 92, 94, /* 0-9 */
83: 96, 98, 99, 100, 101, 101, 102, 103, 103, 103, /* 10-19 */
84: 103, 103, 103, 103, 102, 101, 101, 100, 99, 98, /* 20-29 */
85: 96, 94, 92, 89, 85, 82, 78, 70, 63, 48, /* 30-39 */
86: 129, 176, 191, 198, 206, 210, 213, 217, 220, 222, /* 40-49 */
87: 224, 226, 227, 228, 229, 229, 230, 231, 231, 231, /* 50-59 */
88: 231, 231, 231, 231, 230, 229, 229, 228, 227, 226, /* 60-69 */
89: 224, 222, 220, 217, 213, 210, 206, 198, 191, 176}; /* 70-79 */
90: /*
91: * Companded sine table amplitude 6000 units
92: */
93: int c6000[] = {1, 63, 78, 86, 93, 98, 101, 104, 107, 110, /* 0-9 */
94: 112, 113, 115, 116, 117, 117, 118, 118, 119, 119, /* 10-19 */
95: 119, 119, 119, 118, 118, 117, 117, 116, 115, 113, /* 20-29 */
96: 112, 110, 107, 104, 101, 98, 93, 86, 78, 63, /* 30-39 */
97: 129, 191, 206, 214, 221, 226, 229, 232, 235, 238, /* 40-49 */
98: 240, 241, 243, 244, 245, 245, 246, 246, 247, 247, /* 50-59 */
99: 247, 247, 247, 246, 246, 245, 245, 244, 243, 241, /* 60-69 */
100: 240, 238, 235, 232, 229, 226, 221, 214, 206, 191}; /* 70-79 */
101:
102: /*
103: * Decoder operations at the end of each second are driven by a state
104: * machine. The transition matrix consists of a dispatch table indexed
105: * by second number. Each entry in the table contains a case switch
106: * number and argument.
107: */
108: struct progx {
109: int sw; /* case switch number */
110: int arg; /* argument */
111: };
112:
113: /*
114: * Case switch numbers
115: */
116: #define DATA 0 /* send data (0, 1, PI) */
117: #define COEF 1 /* send BCD bit */
118: #define DEC 2 /* decrement to next digit */
119: #define MIN 3 /* minute pulse */
120: #define LEAP 4 /* leap warning */
121: #define DUT1 5 /* DUT1 bits */
122: #define DST1 6 /* DST1 bit */
123: #define DST2 7 /* DST2 bit */
124:
125: /*
126: * WWV/H format (100-Hz, 9 digits, 1 m frame)
127: */
128: struct progx progx[] = {
129: {MIN, 800}, /* 0 minute sync pulse */
130: {DATA, DATA0}, /* 1 */
131: {DST2, 0}, /* 2 DST2 */
132: {LEAP, 0}, /* 3 leap warning */
133: {COEF, 1}, /* 4 1 year units */
134: {COEF, 2}, /* 5 2 */
135: {COEF, 4}, /* 6 4 */
136: {COEF, 8}, /* 7 8 */
137: {DEC, DATA0}, /* 8 */
138: {DATA, PI}, /* 9 p1 */
139: {COEF, 1}, /* 10 1 minute units */
140: {COEF, 2}, /* 11 2 */
141: {COEF, 4}, /* 12 4 */
142: {COEF, 8}, /* 13 8 */
143: {DEC, DATA0}, /* 14 */
144: {COEF, 1}, /* 15 10 minute tens */
145: {COEF, 2}, /* 16 20 */
146: {COEF, 4}, /* 17 40 */
147: {COEF, 8}, /* 18 80 (not used) */
148: {DEC, PI}, /* 19 p2 */
149: {COEF, 1}, /* 20 1 hour units */
150: {COEF, 2}, /* 21 2 */
151: {COEF, 4}, /* 22 4 */
152: {COEF, 8}, /* 23 8 */
153: {DEC, DATA0}, /* 24 */
154: {COEF, 1}, /* 25 10 hour tens */
155: {COEF, 2}, /* 26 20 */
156: {COEF, 4}, /* 27 40 (not used) */
157: {COEF, 8}, /* 28 80 (not used) */
158: {DEC, PI}, /* 29 p3 */
159: {COEF, 1}, /* 30 1 day units */
160: {COEF, 2}, /* 31 2 */
161: {COEF, 4}, /* 32 4 */
162: {COEF, 8}, /* 33 8 */
163: {DEC, DATA0}, /* 34 not used */
164: {COEF, 1}, /* 35 10 day tens */
165: {COEF, 2}, /* 36 20 */
166: {COEF, 4}, /* 37 40 */
167: {COEF, 8}, /* 38 80 */
168: {DEC, PI}, /* 39 p4 */
169: {COEF, 1}, /* 40 100 day hundreds */
170: {COEF, 2}, /* 41 200 */
171: {COEF, 4}, /* 42 400 (not used) */
172: {COEF, 8}, /* 43 800 (not used) */
173: {DEC, DATA0}, /* 44 */
174: {DATA, DATA0}, /* 45 */
175: {DATA, DATA0}, /* 46 */
176: {DATA, DATA0}, /* 47 */
177: {DATA, DATA0}, /* 48 */
178: {DATA, PI}, /* 49 p5 */
179: {DUT1, 8}, /* 50 DUT1 sign */
180: {COEF, 1}, /* 51 10 year tens */
181: {COEF, 2}, /* 52 20 */
182: {COEF, 4}, /* 53 40 */
183: {COEF, 8}, /* 54 80 */
184: {DST1, 0}, /* 55 DST1 */
185: {DUT1, 1}, /* 56 0.1 DUT1 fraction */
186: {DUT1, 2}, /* 57 0.2 */
187: {DUT1, 4}, /* 58 0.4 */
188: {DATA, PI}, /* 59 p6 */
189: {DATA, DATA0}, /* 60 leap */
190: };
191:
192: /*
193: * IRIG format except first frame (1000 Hz, 20 digits, 1 s frame)
194: */
195: struct progx progy[] = {
196: {COEF, 1}, /* 0 1 units */
197: {COEF, 2}, /* 1 2 */
198: {COEF, 4}, /* 2 4 */
199: {COEF, 8}, /* 3 8 */
200: {DEC, M2}, /* 4 im */
201: {COEF, 1}, /* 5 10 tens */
202: {COEF, 2}, /* 6 20 */
203: {COEF, 4}, /* 7 40 */
204: {COEF, 8}, /* 8 80 */
205: {DEC, M8}, /* 9 pi */
206: };
207:
208: /*
209: * IRIG format first frame (1000 Hz, 20 digits, 1 s frame)
210: */
211: struct progx progz[] = {
212: {MIN, M8}, /* 0 pi (second) */
213: {COEF, 1}, /* 1 1 units */
214: {COEF, 2}, /* 2 2 */
215: {COEF, 4}, /* 3 4 */
216: {COEF, 8}, /* 4 8 */
217: {DEC, M2}, /* 5 im */
218: {COEF, 1}, /* 6 10 tens */
219: {COEF, 2}, /* 7 20 */
220: {COEF, 4}, /* 8 40 */
221: {DEC, M8}, /* 9 pi */
222: };
223:
224: /*
225: * Forward declarations
226: */
227: void sec(int); /* send second */
228: void digit(int); /* encode digit */
229: void peep(int, int, int); /* send cycles */
230: void delay(int); /* delay samples */
231:
232: /*
233: * Global variables
234: */
235: char buffer[BUFLNG]; /* output buffer */
236: int bufcnt = 0; /* buffer counter */
237: int second = 0; /* seconds counter */
238: int fd; /* audio codec file descriptor */
239: int tone = 1000; /* WWV sync frequency */
240: int level = AUDIO_MAX_GAIN / 8; /* output level */
241: int port = AUDIO_LINE_OUT; /* output port */
242: int encode = WWV; /* encoder select */
243: int leap = 0; /* leap indicator */
244: int dst = 0; /* winter/summer time */
245: int dut1 = 0; /* DUT1 correction (sign, magnitude) */
246: int utc = 0; /* option epoch */
247:
248: /*
249: * Main program
250: */
251: int
252: main(
253: int argc, /* command line options */
254: char **argv /* poiniter to list of tokens */
255: )
256: {
257: struct timeval tv; /* system clock at startup */
258: audio_info_t info; /* Sun audio structure */
259: struct tm *tm = NULL; /* structure returned by gmtime */
260: char device[50]; /* audio device */
261: char code[100]; /* timecode */
262: int rval, temp, arg, sw, ptr;
263: int minute, hour, day, year;
264: int i;
265:
266: /*
267: * Parse options
268: */
269: strcpy(device, DEVICE);
270: year = 0;
271: while ((temp = getopt(argc, argv, "a:dhilsu:v:y:")) != -1) {
272: switch (temp) {
273:
274: case 'a': /* specify audio device (/dev/audio) */
275: strcpy(device, optarg);
276: break;
277:
278: case 'd': /* set DST for summer (WWV/H only) */
279: dst++;
280: break;
281:
282: case 'h': /* select WWVH sync frequency */
283: tone = 1200;
284: break;
285:
286: case 'i': /* select irig format */
287: encode = IRIG;
288: break;
289:
290: case 'l': /* set leap warning bit (WWV/H only) */
291: leap++;
292: break;
293:
294: case 's': /* enable speaker */
295: port |= AUDIO_SPEAKER;
296: break;
297:
298: case 'u': /* set DUT1 offset (-7 to +7) */
299: sscanf(optarg, "%d", &dut1);
300: if (dut1 < 0)
301: dut1 = abs(dut1);
302: else
303: dut1 |= 0x8;
304: break;
305:
306: case 'v': /* set output level (0-255) */
307: sscanf(optarg, "%d", &level);
308: break;
309:
310: case 'y': /* set initial date and time */
311: sscanf(optarg, "%2d%3d%2d%2d", &year, &day,
312: &hour, &minute);
313: utc++;
314: break;
315:
316: defult:
317: printf("invalid option %c\n", temp);
318: break;
319: }
320: }
321:
322: /*
323: * Open audio device and set options
324: */
325: fd = open("/dev/audio", O_WRONLY);
326: if (fd <= 0) {
327: printf("audio open %s\n", strerror(errno));
328: exit(1);
329: }
330: rval = ioctl(fd, AUDIO_GETINFO, &info);
331: if (rval < 0) {
332: printf("audio control %s\n", strerror(errno));
333: exit(0);
334: }
335: info.play.port = port;
336: info.play.gain = level;
337: info.play.sample_rate = SECOND;
338: info.play.channels = 1;
339: info.play.precision = 8;
340: info.play.encoding = AUDIO_ENCODING_ULAW;
341: printf("port %d gain %d rate %d chan %d prec %d encode %d\n",
342: info.play.port, info.play.gain, info.play.sample_rate,
343: info.play.channels, info.play.precision,
344: info.play.encoding);
345: ioctl(fd, AUDIO_SETINFO, &info);
346:
347: /*
348: * Unless specified otherwise, read the system clock and
349: * initialize the time.
350: */
351: if (!utc) {
352: gettimeofday(&tv, NULL);
353: tm = gmtime(&tv.tv_sec);
354: minute = tm->tm_min;
355: hour = tm->tm_hour;
356: day = tm->tm_yday + 1;
357: year = tm->tm_year % 100;
358: second = tm->tm_sec;
359:
360: /*
361: * Delay the first second so the generator is accurately
362: * aligned with the system clock within one sample (125
363: * microseconds ).
364: */
365: delay(SECOND - tv.tv_usec * 8 / 1000);
366: }
367: memset(code, 0, sizeof(code));
368: switch (encode) {
369:
370: /*
371: * For WWV/H and default time, carefully set the signal
372: * generator seconds number to agree with the current time.
373: */
374: case WWV:
375: printf("year %d day %d time %02d:%02d:%02d tone %d\n",
376: year, day, hour, minute, second, tone);
377: sprintf(code, "%01d%03d%02d%02d%01d", year / 10, day,
378: hour, minute, year % 10);
379: printf("%s\n", code);
380: ptr = 8;
381: for (i = 0; i <= second; i++) {
382: if (progx[i].sw == DEC)
383: ptr--;
384: }
385: break;
386:
387: /*
388: * For IRIG the signal generator runs every second, so requires
389: * no additional alignment.
390: */
391: case IRIG:
392: printf("sbs %x year %d day %d time %02d:%02d:%02d\n",
393: 0, year, day, hour, minute, second);
394: break;
395: }
396:
397: /*
398: * Run the signal generator to generate new timecode strings
399: * once per minute for WWV/H and once per second for IRIG.
400: */
401: while(1) {
402:
403: /*
404: * Crank the state machine to propagate carries to the
405: * year of century. Note that we delayed up to one
406: * second for alignment after reading the time, so this
407: * is the next second.
408: */
409: second = (second + 1) % 60;
410: if (second == 0) {
411: minute++;
412: if (minute >= 60) {
413: minute = 0;
414: hour++;
415: }
416: if (hour >= 24) {
417: hour = 0;
418: day++;
419: }
420:
421: /*
422: * At year rollover check for leap second.
423: */
424: if (day >= (year & 0x3 ? 366 : 367)) {
425: if (leap) {
426: sec(DATA0);
427: printf("\nleap!");
428: leap = 0;
429: }
430: day = 1;
431: year++;
432: }
433: if (encode == WWV) {
434: sprintf(code, "%01d%03d%02d%02d%01d",
435: year / 10, day, hour, minute, year %
436: 10);
437: printf("\n%s\n", code);
438: ptr = 8;
439: }
440: }
441: if (encode == IRIG) {
442: sprintf(code, "%04x%04d%06d%02d%02d%02d", 0,
443: year, day, hour, minute, second);
444: printf("%s\n", code);
445: ptr = 19;
446: }
447:
448: /*
449: * Generate data for the second
450: */
451: switch(encode) {
452:
453: /*
454: * The IRIG second consists of 20 BCD digits of width-
455: * modulateod pulses at 2, 5 and 8 ms and modulated 50
456: * percent on the 1000-Hz carrier.
457: */
458: case IRIG:
459: for (i = 0; i < 100; i++) {
460: if (i < 10) {
461: sw = progz[i].sw;
462: arg = progz[i].arg;
463: } else {
464: sw = progy[i % 10].sw;
465: arg = progy[i % 10].arg;
466: }
467: switch(sw) {
468:
469: case COEF: /* send BCD bit */
470: if (code[ptr] & arg) {
471: peep(M5, 1000, HIGH);
472: peep(M5, 1000, LOW);
473: printf("1");
474: } else {
475: peep(M2, 1000, HIGH);
476: peep(M8, 1000, LOW);
477: printf("0");
478: }
479: break;
480:
481: case DEC: /* send IM/PI bit */
482: ptr--;
483: printf(" ");
484: peep(arg, 1000, HIGH);
485: peep(10 - arg, 1000, LOW);
486: break;
487:
488: case MIN: /* send data bit */
489: peep(arg, 1000, HIGH);
490: peep(10 - arg, 1000, LOW);
491: printf("M ");
492: break;
493: }
494: if (ptr < 0)
495: break;
496: }
497: printf("\n");
498: break;
499:
500: /*
501: * The WWV/H second consists of 9 BCD digits of width-
502: * modulateod pulses 200, 500 and 800 ms at 100-Hz.
503: */
504: case WWV:
505: sw = progx[second].sw;
506: arg = progx[second].arg;
507: switch(sw) {
508:
509: case DATA: /* send data bit */
510: sec(arg);
511: break;
512:
513: case COEF: /* send BCD bit */
514: if (code[ptr] & arg) {
515: sec(DATA1);
516: printf("1");
517: } else {
518: sec(DATA0);
519: printf("0");
520: }
521: break;
522:
523: case LEAP: /* send leap bit */
524: if (leap) {
525: sec(DATA1);
526: printf("L ");
527: } else {
528: sec(DATA0);
529: printf(" ");
530: }
531: break;
532:
533: case DEC: /* send data bit */
534: ptr--;
535: sec(arg);
536: printf(" ");
537: break;
538:
539: case MIN: /* send minute sync */
540: peep(arg, tone, HIGH);
541: peep(1000 - arg, tone, OFF);
542: break;
543:
544: case DUT1: /* send DUT1 bits */
545: if (dut1 & arg)
546: sec(DATA1);
547: else
548: sec(DATA0);
549: break;
550:
551: case DST1: /* send DST1 bit */
552: ptr--;
553: if (dst)
554: sec(DATA1);
555: else
556: sec(DATA0);
557: printf(" ");
558: break;
559:
560: case DST2: /* send DST2 bit */
561: if (dst)
562: sec(DATA1);
563: else
564: sec(DATA0);
565: break;
566: }
567: }
568: }
569: }
570:
571:
572: /*
573: * Generate WWV/H 0 or 1 data pulse.
574: */
575: void sec(
576: int code /* DATA0, DATA1, PI */
577: )
578: {
579: /*
580: * The WWV data pulse begins with 5 ms of 1000 Hz follwed by a
581: * guard time of 25 ms. The data pulse is 170, 570 or 770 ms at
582: * 100 Hz corresponding to 0, 1 or position indicator (PI),
583: * respectively. Note the 100-Hz data pulses are transmitted 6
584: * dB below the 1000-Hz sync pulses. Originally the data pulses
585: * were transmited 10 dB below the sync pulses, but the station
586: * engineers increased that to 6 dB because the Heath GC-1000
587: * WWV/H radio clock worked much better.
588: */
589: peep(5, tone, HIGH); /* send seconds tick */
590: peep(25, tone, OFF);
591: peep(code - 30, 100, LOW); /* send data */
592: peep(1000 - code, 100, OFF);
593: }
594:
595:
596: /*
597: * Generate cycles of 100 Hz or any multiple of 100 Hz.
598: */
599: void peep(
600: int pulse, /* pulse length (ms) */
601: int freq, /* frequency (Hz) */
602: int amp /* amplitude */
603: )
604: {
605: int increm; /* phase increment */
606: int i, j;
607:
608: if (amp == OFF || freq == 0)
609: increm = 10;
610: else
611: increm = freq / 100;
612: j = 0;
613: for (i = 0 ; i < pulse * 8; i++) {
614: switch (amp) {
615:
616: case HIGH:
617: buffer[bufcnt++] = ~c6000[j];
618: break;
619:
620: case LOW:
621: buffer[bufcnt++] = ~c3000[j];
622: break;
623:
624: default:
625: buffer[bufcnt++] = ~0;
626: }
627: if (bufcnt >= BUFLNG) {
628: write(fd, buffer, BUFLNG);
629: bufcnt = 0;
630: }
631: j = (j + increm) % 80;
632: }
633: }
634:
635:
636: /*
637: * Delay for initial phasing
638: */
639: void delay (
640: int delay /* delay in samples */
641: )
642: {
643: int samples; /* samples remaining */
644:
645: samples = delay;
646: memset(buffer, 0, BUFLNG);
647: while (samples >= BUFLNG) {
648: write(fd, buffer, BUFLNG);
649: samples -= BUFLNG;
650: }
651: write(fd, buffer, samples);
652: }