2507 lines
73 KiB
C
2507 lines
73 KiB
C
/*
|
|
* tg.c generate WWV or IRIG signals for test
|
|
*/
|
|
/*
|
|
* This program can generate audio signals that simulate the WWV/H
|
|
* broadcast timecode. Alternatively, it can generate the IRIG-B
|
|
* timecode commonly used to synchronize laboratory equipment. It is
|
|
* intended to test the WWV/H driver (refclock_wwv.c) and the IRIG
|
|
* driver (refclock_irig.c) in the NTP driver collection.
|
|
*
|
|
* Besides testing the drivers themselves, this program can be used to
|
|
* synchronize remote machines over audio transmission lines or program
|
|
* feeds. The program reads the time on the local machine and sets the
|
|
* initial epoch of the signal generator within one millisecond.
|
|
* Alernatively, the initial epoch can be set to an arbitrary time. This
|
|
* is useful when searching for bugs and testing for correct response to
|
|
* a leap second in UTC. Note however, the ultimate accuracy is limited
|
|
* by the intrinsic frequency error of the codec sample clock, which can
|
|
# reach well over 100 PPM.
|
|
*
|
|
* The default is to route generated signals to the line output
|
|
* jack; the s option on the command line routes these signals to the
|
|
* internal speaker as well. The v option controls the speaker volume
|
|
* over the range 0-255. The signal generator by default uses WWV
|
|
* format; the h option switches to WWVH format and the i option
|
|
* switches to IRIG-B format.
|
|
*
|
|
* Once started the program runs continuously. The default initial epoch
|
|
* for the signal generator is read from the computer system clock when
|
|
* the program starts. The y option specifies an alternate epoch using a
|
|
* string yydddhhmmss, where yy is the year of century, ddd the day of
|
|
* year, hh the hour of day and mm the minute of hour. For instance,
|
|
* 1946Z on 1 January 2006 is 060011946. The l option lights the leap
|
|
* warning bit in the WWV/H timecode, so is handy to check for correct
|
|
* behavior at the next leap second epoch. The remaining options are
|
|
* specified below under the Parse Options heading. Most of these are
|
|
* for testing.
|
|
*
|
|
* During operation the program displays the WWV/H timecode (9 digits)
|
|
* or IRIG timecode (20 digits) as each new string is constructed. The
|
|
* display is followed by the BCD binary bits as transmitted. Note that
|
|
* the transmissionorder is low-order first as the frame is processed
|
|
* left to right. For WWV/H The leap warning L preceeds the first bit.
|
|
* For IRIG the on-time marker M preceeds the first (units) bit, so its
|
|
* code is delayed one bit and the next digit (tens) needs only three
|
|
* bits.
|
|
*
|
|
* The program has been tested with the Sun Blade 1500 running Solaris
|
|
* 10, but not yet with other machines. It uses no special features and
|
|
* should be readily portable to other hardware and operating systems.
|
|
*
|
|
* $Log: tg.c,v $
|
|
* Revision 1.28 2007/02/12 23:57:45 dmw
|
|
* v0.23 2007-02-12 dmw:
|
|
* - Changed statistics to include calculated error
|
|
* of frequency, based on number of added or removed
|
|
* cycles over time.
|
|
*
|
|
* Revision 1.27 2007/02/09 02:28:59 dmw
|
|
* v0.22 2007-02-08 dmw:
|
|
* - Changed default for rate correction to "enabled", "-j" switch now disables.
|
|
* - Adjusted help message accordingly.
|
|
* - Added "2007" to modifications note at end of help message.
|
|
*
|
|
* Revision 1.26 2007/02/08 03:36:17 dmw
|
|
* v0.21 2007-02-07 dmw:
|
|
* - adjusted strings for shorten and lengthen to make
|
|
* fit on smaller screen.
|
|
*
|
|
* Revision 1.25 2007/02/01 06:08:09 dmw
|
|
* v0.20 2007-02-01 dmw:
|
|
* - Added periodic display of running time along with legend on IRIG-B, allows tracking how
|
|
* close IRIG output is to actual clock time.
|
|
*
|
|
* Revision 1.24 2007/01/31 19:24:11 dmw
|
|
* v0.19 2007-01-31 dmw:
|
|
* - Added tracking of how many seconds have been adjusted,
|
|
* how many cycles added (actually in milliseconds), how
|
|
* many cycles removed, print periodically if verbose is
|
|
* active.
|
|
* - Corrected lack of lengthen or shorten of minute & hour
|
|
* pulses for WWV format.
|
|
*
|
|
* Revision 1.23 2007/01/13 07:09:12 dmw
|
|
* v0.18 2007-01-13 dmw:
|
|
* - added -k option, which allows force of long or short
|
|
* cycles, to test against IRIG-B decoder.
|
|
*
|
|
* Revision 1.22 2007/01/08 16:27:23 dmw
|
|
* v0.17 2007-01-08 dmw:
|
|
* - Changed -j option to **enable** rate correction, not disable.
|
|
*
|
|
* Revision 1.21 2007/01/08 06:22:36 dmw
|
|
* v0.17 2007-01-08 dmw:
|
|
* - Run stability check versus ongoing system clock (assume NTP correction)
|
|
* and adjust time code rate to try to correct, if gets too far out of sync.
|
|
* Disable this algorithm with -j option.
|
|
*
|
|
* Revision 1.20 2006/12/19 04:59:04 dmw
|
|
* v0.16 2006-12-18 dmw
|
|
* - Corrected print of setting of output frequency, always
|
|
* showed 8000 samples/sec, now as specified on command line.
|
|
* - Modified to reflect new employer Norscan.
|
|
*
|
|
* Revision 1.19 2006/12/19 03:45:38 dmw
|
|
* v0.15 2006-12-18 dmw:
|
|
* - Added count of number of seconds to output then exit,
|
|
* default zero for forever.
|
|
*
|
|
* Revision 1.18 2006/12/18 05:43:36 dmw
|
|
* v0.14 2006-12-17 dmw:
|
|
* - Corrected WWV(H) signal to leave "tick" sound off of 29th and 59th second of minute.
|
|
* - Adjusted verbose output format for WWV(H).
|
|
*
|
|
* Revision 1.17 2006/12/18 02:31:33 dmw
|
|
* v0.13 2006-12-17 dmw:
|
|
* - Put SPARC code back in, hopefully will work, but I don't have
|
|
* a SPARC to try it on...
|
|
* - Reworked Verbose mode, different flag to initiate (x not v)
|
|
* and actually implement turn off of verbosity when this flag used.
|
|
* - Re-claimed v flag for output level.
|
|
* - Note that you must define OSS_MODS to get OSS to compile,
|
|
* otherwise will expect to compile using old SPARC options, as
|
|
* it used to be.
|
|
*
|
|
* Revision 1.16 2006/10/26 19:08:43 dmw
|
|
* v0.12 2006-10-26 dmw:
|
|
* - Reversed output binary dump for IRIG, makes it easier to read the numbers.
|
|
*
|
|
* Revision 1.15 2006/10/24 15:57:09 dmw
|
|
* v0.11 2006-10-24 dmw:
|
|
* - another tweak.
|
|
*
|
|
* Revision 1.14 2006/10/24 15:55:53 dmw
|
|
* v0.11 2006-10-24 dmw:
|
|
* - Curses a fix to the fix to the fix of the usaeg.
|
|
*
|
|
* Revision 1.13 2006/10/24 15:53:25 dmw
|
|
* v0.11 (still) 2006-10-24 dmw:
|
|
* - Messed with usage message that's all.
|
|
*
|
|
* Revision 1.12 2006/10/24 15:50:05 dmw
|
|
* v0.11 2006-10-24 dmw:
|
|
* - oops, needed to note "hours" in usage of that offset.
|
|
*
|
|
* Revision 1.11 2006/10/24 15:49:09 dmw
|
|
* v0.11 2006-10-24 dmw:
|
|
* - Added ability to offset actual time sent, from the UTC time
|
|
* as per the computer.
|
|
*
|
|
* Revision 1.10 2006/10/24 03:25:55 dmw
|
|
* v0.10 2006-10-23 dmw:
|
|
* - Corrected polarity of correction of offset when going into or out of DST.
|
|
* - Ensure that zero offset is always positive (pet peeve).
|
|
*
|
|
* Revision 1.9 2006/10/24 00:00:35 dmw
|
|
* v0.9 2006-10-23 dmw:
|
|
* - Shift time offset when DST in or out.
|
|
*
|
|
* Revision 1.8 2006/10/23 23:49:28 dmw
|
|
* v0.8 2006-10-23 dmw:
|
|
* - made offset of zero default positive.
|
|
*
|
|
* Revision 1.7 2006/10/23 23:44:13 dmw
|
|
* v0.7 2006-10-23 dmw:
|
|
* - Added unmodulated and inverted unmodulated output.
|
|
*
|
|
* Revision 1.6 2006/10/23 18:10:37 dmw
|
|
* v0.6 2006-10-23 dmw:
|
|
* - Cleaned up usage message.
|
|
* - Require at least one option, or prints usage message and exits.
|
|
*
|
|
* Revision 1.5 2006/10/23 16:58:10 dmw
|
|
* v0.5 2006-10-23 dmw:
|
|
* - Finally added a usage message.
|
|
* - Added leap second pending and DST change pending into IEEE 1344.
|
|
* - Default code type is now IRIG-B with IEEE 1344.
|
|
*
|
|
* Revision 1.4 2006/10/23 03:27:25 dmw
|
|
* v0.4 2006-10-22 dmw:
|
|
* - Added leap second addition and deletion.
|
|
* - Added DST changing forward and backward.
|
|
* - Changed date specification to more conventional year, month, and day of month
|
|
* (rather than day of year).
|
|
*
|
|
* Revision 1.3 2006/10/22 21:04:12 dmw
|
|
* v0.2 2006-10-22 dmw:
|
|
* - Corrected format of legend line.
|
|
*
|
|
* Revision 1.2 2006/10/22 21:01:07 dmw
|
|
* v0.1 2006-10-22 dmw:
|
|
* - Added some more verbose output (as is my style)
|
|
* - Corrected frame format - there were markers in the
|
|
* middle of frames, now correctly as "zero" bits.
|
|
* - Added header line to show fields of output.
|
|
* - Added straight binary seconds, were not implemented
|
|
* before.
|
|
* - Added IEEE 1344 with parity.
|
|
*
|
|
*
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#undef VERSION /* avoid conflict below */
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_SOUNDCARD_H
|
|
#include <sys/soundcard.h>
|
|
#else
|
|
# ifdef HAVE_SYS_AUDIOIO_H
|
|
# include <sys/audioio.h>
|
|
# else
|
|
# include <sys/audio.h>
|
|
# endif
|
|
#endif
|
|
|
|
#include "ntp_stdlib.h" /* for strlcat(), strlcpy() */
|
|
|
|
#include <math.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
|
|
#define VERSION (0)
|
|
#define ISSUE (23)
|
|
#define ISSUE_DATE "2007-02-12"
|
|
|
|
#define SECOND (8000) /* one second of 125-us samples */
|
|
#define BUFLNG (400) /* buffer size */
|
|
#define DEVICE "/dev/audio" /* default audio device */
|
|
#define WWV (0) /* WWV encoder */
|
|
#define IRIG (1) /* IRIG-B encoder */
|
|
#define OFF (0) /* zero amplitude */
|
|
#define LOW (1) /* low amplitude */
|
|
#define HIGH (2) /* high amplitude */
|
|
#define DATA0 (200) /* WWV/H 0 pulse */
|
|
#define DATA1 (500) /* WWV/H 1 pulse */
|
|
#define PI (800) /* WWV/H PI pulse */
|
|
#define M2 (2) /* IRIG 0 pulse */
|
|
#define M5 (5) /* IRIG 1 pulse */
|
|
#define M8 (8) /* IRIG PI pulse */
|
|
|
|
#define NUL (0)
|
|
|
|
#define SECONDS_PER_MINUTE (60)
|
|
#define SECONDS_PER_HOUR (3600)
|
|
|
|
#define OUTPUT_DATA_STRING_LENGTH (200)
|
|
|
|
/* Attempt at unmodulated - "high" */
|
|
int u6000[] = {
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 0- 9 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 10-19 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 20-29 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 30-39 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 40-49 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 50-59 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247, /* 60-69 */
|
|
247, 247, 247, 247, 247, 247, 247, 247, 247, 247}; /* 70-79 */
|
|
|
|
/* Attempt at unmodulated - "low" */
|
|
int u3000[] = {
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 0- 9 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 10-19 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 20-29 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 30-39 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 40-49 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 50-59 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, /* 60-69 */
|
|
119, 119, 119, 119, 119, 119, 119, 119, 119, 119}; /* 70-79 */
|
|
|
|
/*
|
|
* Companded sine table amplitude 3000 units
|
|
*/
|
|
int c3000[] = {1, 48, 63, 70, 78, 82, 85, 89, 92, 94, /* 0-9 */
|
|
96, 98, 99, 100, 101, 101, 102, 103, 103, 103, /* 10-19 */
|
|
103, 103, 103, 103, 102, 101, 101, 100, 99, 98, /* 20-29 */
|
|
96, 94, 92, 89, 85, 82, 78, 70, 63, 48, /* 30-39 */
|
|
129, 176, 191, 198, 206, 210, 213, 217, 220, 222, /* 40-49 */
|
|
224, 226, 227, 228, 229, 229, 230, 231, 231, 231, /* 50-59 */
|
|
231, 231, 231, 231, 230, 229, 229, 228, 227, 226, /* 60-69 */
|
|
224, 222, 220, 217, 213, 210, 206, 198, 191, 176}; /* 70-79 */
|
|
/*
|
|
* Companded sine table amplitude 6000 units
|
|
*/
|
|
int c6000[] = {1, 63, 78, 86, 93, 98, 101, 104, 107, 110, /* 0-9 */
|
|
112, 113, 115, 116, 117, 117, 118, 118, 119, 119, /* 10-19 */
|
|
119, 119, 119, 118, 118, 117, 117, 116, 115, 113, /* 20-29 */
|
|
112, 110, 107, 104, 101, 98, 93, 86, 78, 63, /* 30-39 */
|
|
129, 191, 206, 214, 221, 226, 229, 232, 235, 238, /* 40-49 */
|
|
240, 241, 243, 244, 245, 245, 246, 246, 247, 247, /* 50-59 */
|
|
247, 247, 247, 246, 246, 245, 245, 244, 243, 241, /* 60-69 */
|
|
240, 238, 235, 232, 229, 226, 221, 214, 206, 191}; /* 70-79 */
|
|
|
|
/*
|
|
* Decoder operations at the end of each second are driven by a state
|
|
* machine. The transition matrix consists of a dispatch table indexed
|
|
* by second number. Each entry in the table contains a case switch
|
|
* number and argument.
|
|
*/
|
|
struct progx {
|
|
int sw; /* case switch number */
|
|
int arg; /* argument */
|
|
};
|
|
|
|
/*
|
|
* Case switch numbers
|
|
*/
|
|
#define DATA (0) /* send data (0, 1, PI) */
|
|
#define COEF (1) /* send BCD bit */
|
|
#define DEC (2) /* decrement to next digit and send PI */
|
|
#define MIN (3) /* minute pulse */
|
|
#define LEAP (4) /* leap warning */
|
|
#define DUT1 (5) /* DUT1 bits */
|
|
#define DST1 (6) /* DST1 bit */
|
|
#define DST2 (7) /* DST2 bit */
|
|
#define DECZ (8) /* decrement to next digit and send zero */
|
|
#define DECC (9) /* decrement to next digit and send bit */
|
|
#define NODEC (10) /* no decerement to next digit, send PI */
|
|
#define DECX (11) /* decrement to next digit, send PI, but no tick */
|
|
#define DATAX (12) /* send data (0, 1, PI), but no tick */
|
|
|
|
/*
|
|
* WWV/H format (100-Hz, 9 digits, 1 m frame)
|
|
*/
|
|
struct progx progx[] = {
|
|
{MIN, 800}, /* 0 minute sync pulse */
|
|
{DATA, DATA0}, /* 1 */
|
|
{DST2, 0}, /* 2 DST2 */
|
|
{LEAP, 0}, /* 3 leap warning */
|
|
{COEF, 1}, /* 4 1 year units */
|
|
{COEF, 2}, /* 5 2 */
|
|
{COEF, 4}, /* 6 4 */
|
|
{COEF, 8}, /* 7 8 */
|
|
{DEC, DATA0}, /* 8 */
|
|
{DATA, PI}, /* 9 p1 */
|
|
{COEF, 1}, /* 10 1 minute units */
|
|
{COEF, 2}, /* 11 2 */
|
|
{COEF, 4}, /* 12 4 */
|
|
{COEF, 8}, /* 13 8 */
|
|
{DEC, DATA0}, /* 14 */
|
|
{COEF, 1}, /* 15 10 minute tens */
|
|
{COEF, 2}, /* 16 20 */
|
|
{COEF, 4}, /* 17 40 */
|
|
{COEF, 8}, /* 18 80 (not used) */
|
|
{DEC, PI}, /* 19 p2 */
|
|
{COEF, 1}, /* 20 1 hour units */
|
|
{COEF, 2}, /* 21 2 */
|
|
{COEF, 4}, /* 22 4 */
|
|
{COEF, 8}, /* 23 8 */
|
|
{DEC, DATA0}, /* 24 */
|
|
{COEF, 1}, /* 25 10 hour tens */
|
|
{COEF, 2}, /* 26 20 */
|
|
{COEF, 4}, /* 27 40 (not used) */
|
|
{COEF, 8}, /* 28 80 (not used) */
|
|
{DECX, PI}, /* 29 p3 */
|
|
{COEF, 1}, /* 30 1 day units */
|
|
{COEF, 2}, /* 31 2 */
|
|
{COEF, 4}, /* 32 4 */
|
|
{COEF, 8}, /* 33 8 */
|
|
{DEC, DATA0}, /* 34 not used */
|
|
{COEF, 1}, /* 35 10 day tens */
|
|
{COEF, 2}, /* 36 20 */
|
|
{COEF, 4}, /* 37 40 */
|
|
{COEF, 8}, /* 38 80 */
|
|
{DEC, PI}, /* 39 p4 */
|
|
{COEF, 1}, /* 40 100 day hundreds */
|
|
{COEF, 2}, /* 41 200 */
|
|
{COEF, 4}, /* 42 400 (not used) */
|
|
{COEF, 8}, /* 43 800 (not used) */
|
|
{DEC, DATA0}, /* 44 */
|
|
{DATA, DATA0}, /* 45 */
|
|
{DATA, DATA0}, /* 46 */
|
|
{DATA, DATA0}, /* 47 */
|
|
{DATA, DATA0}, /* 48 */
|
|
{DATA, PI}, /* 49 p5 */
|
|
{DUT1, 8}, /* 50 DUT1 sign */
|
|
{COEF, 1}, /* 51 10 year tens */
|
|
{COEF, 2}, /* 52 20 */
|
|
{COEF, 4}, /* 53 40 */
|
|
{COEF, 8}, /* 54 80 */
|
|
{DST1, 0}, /* 55 DST1 */
|
|
{DUT1, 1}, /* 56 0.1 DUT1 fraction */
|
|
{DUT1, 2}, /* 57 0.2 */
|
|
{DUT1, 4}, /* 58 0.4 */
|
|
{DATAX, PI}, /* 59 p6 */
|
|
{DATA, DATA0}, /* 60 leap */
|
|
};
|
|
|
|
/*
|
|
* IRIG format frames (1000 Hz, 1 second for 10 frames of data)
|
|
*/
|
|
|
|
/*
|
|
* IRIG format frame 10 - MS straight binary seconds
|
|
*/
|
|
struct progx progu[] = {
|
|
{COEF, 2}, /* 0 0x0 0200 seconds */
|
|
{COEF, 4}, /* 1 0x0 0400 */
|
|
{COEF, 8}, /* 2 0x0 0800 */
|
|
{DECC, 1}, /* 3 0x0 1000 */
|
|
{COEF, 2}, /* 4 0x0 2000 */
|
|
{COEF, 4}, /* 6 0x0 4000 */
|
|
{COEF, 8}, /* 7 0x0 8000 */
|
|
{DECC, 1}, /* 8 0x1 0000 */
|
|
{COEF, 2}, /* 9 0x2 0000 - but only 86,401 / 0x1 5181 seconds in a day, so always zero */
|
|
{NODEC, M8}, /* 9 PI */
|
|
};
|
|
|
|
/*
|
|
* IRIG format frame 8 - MS control functions
|
|
*/
|
|
struct progx progv[] = {
|
|
{COEF, 2}, /* 0 CF # 19 */
|
|
{COEF, 4}, /* 1 CF # 20 */
|
|
{COEF, 8}, /* 2 CF # 21 */
|
|
{DECC, 1}, /* 3 CF # 22 */
|
|
{COEF, 2}, /* 4 CF # 23 */
|
|
{COEF, 4}, /* 6 CF # 24 */
|
|
{COEF, 8}, /* 7 CF # 25 */
|
|
{DECC, 1}, /* 8 CF # 26 */
|
|
{COEF, 2}, /* 9 CF # 27 */
|
|
{DEC, M8}, /* 10 PI */
|
|
};
|
|
|
|
/*
|
|
* IRIG format frames 7 & 9 - LS control functions & LS straight binary seconds
|
|
*/
|
|
struct progx progw[] = {
|
|
{COEF, 1}, /* 0 CF # 10, 0x0 0001 seconds */
|
|
{COEF, 2}, /* 1 CF # 11, 0x0 0002 */
|
|
{COEF, 4}, /* 2 CF # 12, 0x0 0004 */
|
|
{COEF, 8}, /* 3 CF # 13, 0x0 0008 */
|
|
{DECC, 1}, /* 4 CF # 14, 0x0 0010 */
|
|
{COEF, 2}, /* 6 CF # 15, 0x0 0020 */
|
|
{COEF, 4}, /* 7 CF # 16, 0x0 0040 */
|
|
{COEF, 8}, /* 8 CF # 17, 0x0 0080 */
|
|
{DECC, 1}, /* 9 CF # 18, 0x0 0100 */
|
|
{NODEC, M8}, /* 10 PI */
|
|
};
|
|
|
|
/*
|
|
* IRIG format frames 2 to 6 - minutes, hours, days, hundreds days, 2 digit years (also called control functions bits 1-9)
|
|
*/
|
|
struct progx progy[] = {
|
|
{COEF, 1}, /* 0 1 units, CF # 1 */
|
|
{COEF, 2}, /* 1 2 units, CF # 2 */
|
|
{COEF, 4}, /* 2 4 units, CF # 3 */
|
|
{COEF, 8}, /* 3 8 units, CF # 4 */
|
|
{DECZ, M2}, /* 4 zero bit, CF # 5 / unused, default zero in years */
|
|
{COEF, 1}, /* 5 10 tens, CF # 6 */
|
|
{COEF, 2}, /* 6 20 tens, CF # 7*/
|
|
{COEF, 4}, /* 7 40 tens, CF # 8*/
|
|
{COEF, 8}, /* 8 80 tens, CF # 9*/
|
|
{DEC, M8}, /* 9 PI */
|
|
};
|
|
|
|
/*
|
|
* IRIG format first frame, frame 1 - seconds
|
|
*/
|
|
struct progx progz[] = {
|
|
{MIN, M8}, /* 0 PI (on-time marker for the second at zero cross of 1st cycle) */
|
|
{COEF, 1}, /* 1 1 units */
|
|
{COEF, 2}, /* 2 2 */
|
|
{COEF, 4}, /* 3 4 */
|
|
{COEF, 8}, /* 4 8 */
|
|
{DECZ, M2}, /* 5 zero bit */
|
|
{COEF, 1}, /* 6 10 tens */
|
|
{COEF, 2}, /* 7 20 */
|
|
{COEF, 4}, /* 8 40 */
|
|
{DEC, M8}, /* 9 PI */
|
|
};
|
|
|
|
/* LeapState values. */
|
|
#define LEAPSTATE_NORMAL (0)
|
|
#define LEAPSTATE_DELETING (1)
|
|
#define LEAPSTATE_INSERTING (2)
|
|
#define LEAPSTATE_ZERO_AFTER_INSERT (3)
|
|
|
|
|
|
/*
|
|
* Forward declarations
|
|
*/
|
|
void WWV_Second(int, int); /* send second */
|
|
void WWV_SecondNoTick(int, int); /* send second with no tick */
|
|
void digit(int); /* encode digit */
|
|
void peep(int, int, int); /* send cycles */
|
|
void poop(int, int, int, int); /* Generate unmodulated from similar tables */
|
|
void delay(int); /* delay samples */
|
|
int ConvertMonthDayToDayOfYear (int, int, int); /* Calc day of year from year month & day */
|
|
void Help (void); /* Usage message */
|
|
void ReverseString(char *);
|
|
|
|
/*
|
|
* Extern declarations, don't know why not in headers
|
|
*/
|
|
//float round ( float );
|
|
|
|
/*
|
|
* Global variables
|
|
*/
|
|
char buffer[BUFLNG]; /* output buffer */
|
|
int bufcnt = 0; /* buffer counter */
|
|
int fd; /* audio codec file descriptor */
|
|
int tone = 1000; /* WWV sync frequency */
|
|
int HourTone = 1500; /* WWV hour on-time frequency */
|
|
int encode = IRIG; /* encoder select */
|
|
int leap = 0; /* leap indicator */
|
|
int DstFlag = 0; /* winter/summer time */
|
|
int dut1 = 0; /* DUT1 correction (sign, magnitude) */
|
|
int utc = 0; /* option epoch */
|
|
int IrigIncludeYear = FALSE; /* Whether to send year in first control functions area, between P5 and P6. */
|
|
int IrigIncludeIeee = FALSE; /* Whether to send IEEE 1344 control functions extensions between P6 and P8. */
|
|
int StraightBinarySeconds = 0;
|
|
int ControlFunctions = 0;
|
|
int Debug = FALSE;
|
|
int Verbose = TRUE;
|
|
char *CommandName;
|
|
|
|
#ifndef HAVE_SYS_SOUNDCARD_H
|
|
int level = AUDIO_MAX_GAIN / 8; /* output level */
|
|
int port = AUDIO_LINE_OUT; /* output port */
|
|
#endif
|
|
|
|
int TotalSecondsCorrected = 0;
|
|
int TotalCyclesAdded = 0;
|
|
int TotalCyclesRemoved = 0;
|
|
|
|
|
|
/*
|
|
* Main program
|
|
*/
|
|
int
|
|
main(
|
|
int argc, /* command line options */
|
|
char **argv /* poiniter to list of tokens */
|
|
)
|
|
{
|
|
#ifndef HAVE_SYS_SOUNDCARD_H
|
|
audio_info_t info; /* Sun audio structure */
|
|
int rval; /* For IOCTL calls */
|
|
#endif
|
|
|
|
struct timeval TimeValue; /* System clock at startup */
|
|
time_t SecondsPartOfTime; /* Sent to gmtime() for calculation of TimeStructure (can apply offset). */
|
|
time_t BaseRealTime; /* Base realtime so can determine seconds since starting. */
|
|
time_t NowRealTime; /* New realtime to can determine seconds as of now. */
|
|
unsigned SecondsRunningRealTime; /* Difference between NowRealTime and BaseRealTime. */
|
|
unsigned SecondsRunningSimulationTime; /* Time that the simulator has been running. */
|
|
int SecondsRunningDifference; /* Difference between what real time says we have been running */
|
|
/* and what simulator says we have been running - will slowly */
|
|
/* change because of clock drift. */
|
|
int ExpectedRunningDifference = 0; /* Stable value that we've obtained from check at initial start-up. */
|
|
unsigned StabilityCount; /* Used to check stability of difference while starting */
|
|
#define RUN_BEFORE_STABILITY_CHECK (30) // Must run this many seconds before even checking stability.
|
|
#define MINIMUM_STABILITY_COUNT (10) // Number of consecutive differences that need to be within initial stability band to say we are stable.
|
|
#define INITIAL_STABILITY_BAND ( 2) // Determining initial stability for consecutive differences within +/- this value.
|
|
#define RUNNING_STABILITY_BAND ( 5) // When running, stability is defined as difference within +/- this value.
|
|
|
|
struct tm *TimeStructure = NULL; /* Structure returned by gmtime */
|
|
char device[200]; /* audio device */
|
|
char code[200]; /* timecode */
|
|
int temp;
|
|
int arg = 0;
|
|
int sw = 0;
|
|
int ptr = 0;
|
|
|
|
int Year;
|
|
int Month;
|
|
int DayOfMonth;
|
|
int Hour;
|
|
int Minute;
|
|
int Second = 0;
|
|
int DayOfYear;
|
|
|
|
int BitNumber;
|
|
#ifdef HAVE_SYS_SOUNDCARD_H
|
|
int AudioFormat;
|
|
int MonoStereo; /* 0=mono, 1=stereo */
|
|
#define MONO (0)
|
|
#define STEREO (1)
|
|
int SampleRate;
|
|
int SampleRateDifference;
|
|
#endif
|
|
int SetSampleRate;
|
|
char FormatCharacter = '3'; /* Default is IRIG-B with IEEE 1344 extensions */
|
|
char AsciiValue;
|
|
int HexValue;
|
|
int OldPtr = 0;
|
|
int FrameNumber = 0;
|
|
|
|
/* Time offset for IEEE 1344 indication. */
|
|
float TimeOffset = 0.0;
|
|
int OffsetSignBit = 0;
|
|
int OffsetOnes = 0;
|
|
int OffsetHalf = 0;
|
|
|
|
int TimeQuality = 0; /* Time quality for IEEE 1344 indication. */
|
|
char ParityString[200]; /* Partial output string, to calculate parity on. */
|
|
int ParitySum = 0;
|
|
int ParityValue;
|
|
char *StringPointer;
|
|
|
|
/* Flags to indicate requested leap second addition or deletion by command line option. */
|
|
/* Should be mutually exclusive - generally ensured by code which interprets command line option. */
|
|
int InsertLeapSecond = FALSE;
|
|
int DeleteLeapSecond = FALSE;
|
|
|
|
/* Date and time of requested leap second addition or deletion. */
|
|
int LeapYear = 0;
|
|
int LeapMonth = 0;
|
|
int LeapDayOfMonth = 0;
|
|
int LeapHour = 0;
|
|
int LeapMinute = 0;
|
|
int LeapDayOfYear = 0;
|
|
|
|
/* State flag for the insertion and deletion of leap seconds, esp. deletion, */
|
|
/* where the logic gets a bit tricky. */
|
|
int LeapState = LEAPSTATE_NORMAL;
|
|
|
|
/* Flags for indication of leap second pending and leap secod polarity in IEEE 1344 */
|
|
int LeapSecondPending = FALSE;
|
|
int LeapSecondPolarity = FALSE;
|
|
|
|
/* Date and time of requested switch into or out of DST by command line option. */
|
|
int DstSwitchYear = 0;
|
|
int DstSwitchMonth = 0;
|
|
int DstSwitchDayOfMonth = 0;
|
|
int DstSwitchHour = 0;
|
|
int DstSwitchMinute = 0;
|
|
int DstSwitchDayOfYear = 0;
|
|
|
|
/* Indicate when we have been asked to switch into or out of DST by command line option. */
|
|
int DstSwitchFlag = FALSE;
|
|
|
|
/* To allow predict for DstPendingFlag in IEEE 1344 */
|
|
int DstSwitchPendingYear = 0; /* Default value isn't valid, but I don't care. */
|
|
int DstSwitchPendingDayOfYear = 0;
|
|
int DstSwitchPendingHour = 0;
|
|
int DstSwitchPendingMinute = 0;
|
|
|
|
/* /Flag for indication of a DST switch pending in IEEE 1344 */
|
|
int DstPendingFlag = FALSE;
|
|
|
|
/* Attempt at unmodulated */
|
|
int Unmodulated = FALSE;
|
|
int UnmodulatedInverted = FALSE;
|
|
|
|
/* Offset to actual time value sent. */
|
|
float UseOffsetHoursFloat;
|
|
int UseOffsetSecondsInt = 0;
|
|
float UseOffsetSecondsFloat;
|
|
|
|
/* String to allow us to put out reversed data - so can read the binary numbers. */
|
|
char OutputDataString[OUTPUT_DATA_STRING_LENGTH];
|
|
|
|
/* Number of seconds to send before exiting. Default = 0 = forever. */
|
|
int SecondsToSend = 0;
|
|
int CountOfSecondsSent = 0; /* Counter of seconds */
|
|
|
|
/* Flags to indicate whether to add or remove a cycle for time adjustment. */
|
|
int AddCycle = FALSE; // We are ahead, add cycle to slow down and get back in sync.
|
|
int RemoveCycle = FALSE; // We are behind, remove cycle to slow down and get back in sync.
|
|
int RateCorrection; // Aggregate flag for passing to subroutines.
|
|
int EnableRateCorrection = TRUE;
|
|
|
|
float RatioError;
|
|
|
|
|
|
CommandName = argv[0];
|
|
|
|
if (argc < 1)
|
|
{
|
|
Help ();
|
|
exit (-1);
|
|
}
|
|
|
|
/*
|
|
* Parse options
|
|
*/
|
|
strlcpy(device, DEVICE, sizeof(device));
|
|
Year = 0;
|
|
SetSampleRate = SECOND;
|
|
|
|
#if HAVE_SYS_SOUNDCARD_H
|
|
while ((temp = getopt(argc, argv, "a:b:c:df:g:hHi:jk:l:o:q:r:stu:xy:z?")) != -1) {
|
|
#else
|
|
while ((temp = getopt(argc, argv, "a:b:c:df:g:hHi:jk:l:o:q:r:stu:v:xy:z?")) != -1) {
|
|
#endif
|
|
switch (temp) {
|
|
|
|
case 'a': /* specify audio device (/dev/audio) */
|
|
strlcpy(device, optarg, sizeof(device));
|
|
break;
|
|
|
|
case 'b': /* Remove (delete) a leap second at the end of the specified minute. */
|
|
sscanf(optarg, "%2d%2d%2d%2d%2d", &LeapYear, &LeapMonth, &LeapDayOfMonth,
|
|
&LeapHour, &LeapMinute);
|
|
InsertLeapSecond = FALSE;
|
|
DeleteLeapSecond = TRUE;
|
|
break;
|
|
|
|
case 'c': /* specify number of seconds to send output for before exiting, 0 = forever */
|
|
sscanf(optarg, "%d", &SecondsToSend);
|
|
break;
|
|
|
|
case 'd': /* set DST for summer (WWV/H only) / start with DST active (IRIG) */
|
|
DstFlag++;
|
|
break;
|
|
|
|
case 'f': /* select format: i=IRIG-98 (default) 2=IRIG-2004 3-IRIG+IEEE-1344 w=WWV(H) */
|
|
sscanf(optarg, "%c", &FormatCharacter);
|
|
break;
|
|
|
|
case 'g': /* Date and time to switch back into / out of DST active. */
|
|
sscanf(optarg, "%2d%2d%2d%2d%2d", &DstSwitchYear, &DstSwitchMonth, &DstSwitchDayOfMonth,
|
|
&DstSwitchHour, &DstSwitchMinute);
|
|
DstSwitchFlag = TRUE;
|
|
break;
|
|
|
|
case 'h':
|
|
case 'H':
|
|
case '?':
|
|
Help ();
|
|
exit(-1);
|
|
break;
|
|
|
|
case 'i': /* Insert (add) a leap second at the end of the specified minute. */
|
|
sscanf(optarg, "%2d%2d%2d%2d%2d", &LeapYear, &LeapMonth, &LeapDayOfMonth,
|
|
&LeapHour, &LeapMinute);
|
|
InsertLeapSecond = TRUE;
|
|
DeleteLeapSecond = FALSE;
|
|
break;
|
|
|
|
case 'j':
|
|
EnableRateCorrection = FALSE;
|
|
break;
|
|
|
|
case 'k':
|
|
sscanf (optarg, "%d", &RateCorrection);
|
|
EnableRateCorrection = FALSE;
|
|
if (RateCorrection < 0)
|
|
{
|
|
RemoveCycle = TRUE;
|
|
AddCycle = FALSE;
|
|
|
|
if (Verbose)
|
|
printf ("\n> Forcing rate correction removal of cycle...\n");
|
|
}
|
|
else
|
|
{
|
|
if (RateCorrection > 0)
|
|
{
|
|
RemoveCycle = FALSE;
|
|
AddCycle = TRUE;
|
|
|
|
if (Verbose)
|
|
printf ("\n> Forcing rate correction addition of cycle...\n");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'l': /* use time offset from UTC */
|
|
sscanf(optarg, "%f", &UseOffsetHoursFloat);
|
|
UseOffsetSecondsFloat = UseOffsetHoursFloat * (float) SECONDS_PER_HOUR;
|
|
UseOffsetSecondsInt = (int) (UseOffsetSecondsFloat + 0.5);
|
|
break;
|
|
|
|
case 'o': /* Set IEEE 1344 time offset in hours - positive or negative, to the half hour */
|
|
sscanf(optarg, "%f", &TimeOffset);
|
|
if (TimeOffset >= -0.2)
|
|
{
|
|
OffsetSignBit = 0;
|
|
|
|
if (TimeOffset > 0)
|
|
{
|
|
OffsetOnes = TimeOffset;
|
|
|
|
if ( (TimeOffset - floor(TimeOffset)) >= 0.4)
|
|
OffsetHalf = 1;
|
|
else
|
|
OffsetHalf = 0;
|
|
}
|
|
else
|
|
{
|
|
OffsetOnes = 0;
|
|
OffsetHalf = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OffsetSignBit = 1;
|
|
OffsetOnes = -TimeOffset;
|
|
|
|
if ( (ceil(TimeOffset) - TimeOffset) >= 0.4)
|
|
OffsetHalf = 1;
|
|
else
|
|
OffsetHalf = 0;
|
|
}
|
|
|
|
/*printf ("\nGot TimeOffset = %3.1f, OffsetSignBit = %d, OffsetOnes = %d, OffsetHalf = %d...\n",
|
|
TimeOffset, OffsetSignBit, OffsetOnes, OffsetHalf);
|
|
*/
|
|
break;
|
|
|
|
case 'q': /* Hex quality code 0 to 0x0F - 0 = maximum, 0x0F = no lock */
|
|
sscanf(optarg, "%x", &TimeQuality);
|
|
TimeQuality &= 0x0F;
|
|
/*printf ("\nGot TimeQuality = 0x%1X...\n", TimeQuality);
|
|
*/
|
|
break;
|
|
|
|
case 'r': /* sample rate (nominally 8000, integer close to 8000 I hope) */
|
|
sscanf(optarg, "%d", &SetSampleRate);
|
|
break;
|
|
|
|
case 's': /* set leap warning bit (WWV/H only) */
|
|
leap++;
|
|
break;
|
|
|
|
case 't': /* select WWVH sync frequency */
|
|
tone = 1200;
|
|
break;
|
|
|
|
case 'u': /* set DUT1 offset (-7 to +7) */
|
|
sscanf(optarg, "%d", &dut1);
|
|
if (dut1 < 0)
|
|
dut1 = abs(dut1);
|
|
else
|
|
dut1 |= 0x8;
|
|
break;
|
|
|
|
#ifndef HAVE_SYS_SOUNDCARD_H
|
|
case 'v': /* set output level (0-255) */
|
|
sscanf(optarg, "%d", &level);
|
|
break;
|
|
#endif
|
|
|
|
case 'x': /* Turn off verbose output. */
|
|
Verbose = FALSE;
|
|
break;
|
|
|
|
case 'y': /* Set initial date and time */
|
|
sscanf(optarg, "%2d%2d%2d%2d%2d%2d", &Year, &Month, &DayOfMonth,
|
|
&Hour, &Minute, &Second);
|
|
utc++;
|
|
break;
|
|
|
|
case 'z': /* Turn on Debug output (also turns on Verbose below) */
|
|
Debug = TRUE;
|
|
break;
|
|
|
|
default:
|
|
printf("Invalid option \"%c\", aborting...\n", temp);
|
|
exit (-1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Debug)
|
|
Verbose = TRUE;
|
|
|
|
if (InsertLeapSecond || DeleteLeapSecond)
|
|
{
|
|
LeapDayOfYear = ConvertMonthDayToDayOfYear (LeapYear, LeapMonth, LeapDayOfMonth);
|
|
|
|
if (Debug)
|
|
{
|
|
printf ("\nHave request for leap second %s at year %4d day %3d at %2.2dh%2.2d....\n",\
|
|
DeleteLeapSecond ? "DELETION" : (InsertLeapSecond ? "ADDITION" : "( error ! )" ),
|
|
LeapYear, LeapDayOfYear, LeapHour, LeapMinute);
|
|
}
|
|
}
|
|
|
|
if (DstSwitchFlag)
|
|
{
|
|
DstSwitchDayOfYear = ConvertMonthDayToDayOfYear (DstSwitchYear, DstSwitchMonth, DstSwitchDayOfMonth);
|
|
|
|
/* Figure out time of minute previous to DST switch, so can put up warning flag in IEEE 1344 */
|
|
DstSwitchPendingYear = DstSwitchYear;
|
|
DstSwitchPendingDayOfYear = DstSwitchDayOfYear;
|
|
DstSwitchPendingHour = DstSwitchHour;
|
|
DstSwitchPendingMinute = DstSwitchMinute - 1;
|
|
if (DstSwitchPendingMinute < 0)
|
|
{
|
|
DstSwitchPendingMinute = 59;
|
|
DstSwitchPendingHour--;
|
|
if (DstSwitchPendingHour < 0)
|
|
{
|
|
DstSwitchPendingHour = 23;
|
|
DstSwitchPendingDayOfYear--;
|
|
if (DstSwitchPendingDayOfYear < 1)
|
|
{
|
|
DstSwitchPendingYear--;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Debug)
|
|
{
|
|
printf ("\nHave DST switch request for year %4d day %3d at %2.2dh%2.2d,",
|
|
DstSwitchYear, DstSwitchDayOfYear, DstSwitchHour, DstSwitchMinute);
|
|
printf ("\n so will have warning at year %4d day %3d at %2.2dh%2.2d.\n",
|
|
DstSwitchPendingYear, DstSwitchPendingDayOfYear, DstSwitchPendingHour, DstSwitchPendingMinute);
|
|
}
|
|
}
|
|
|
|
switch (tolower(FormatCharacter)) {
|
|
case 'i':
|
|
printf ("\nFormat is IRIG-1998 (no year coded)...\n\n");
|
|
encode = IRIG;
|
|
IrigIncludeYear = FALSE;
|
|
IrigIncludeIeee = FALSE;
|
|
break;
|
|
|
|
case '2':
|
|
printf ("\nFormat is IRIG-2004 (BCD year coded)...\n\n");
|
|
encode = IRIG;
|
|
IrigIncludeYear = TRUE;
|
|
IrigIncludeIeee = FALSE;
|
|
break;
|
|
|
|
case '3':
|
|
printf ("\nFormat is IRIG with IEEE-1344 (BCD year coded, and more control functions)...\n\n");
|
|
encode = IRIG;
|
|
IrigIncludeYear = TRUE;
|
|
IrigIncludeIeee = TRUE;
|
|
break;
|
|
|
|
case '4':
|
|
printf ("\nFormat is unmodulated IRIG with IEEE-1344 (BCD year coded, and more control functions)...\n\n");
|
|
encode = IRIG;
|
|
IrigIncludeYear = TRUE;
|
|
IrigIncludeIeee = TRUE;
|
|
|
|
Unmodulated = TRUE;
|
|
UnmodulatedInverted = FALSE;
|
|
break;
|
|
|
|
case '5':
|
|
printf ("\nFormat is inverted unmodulated IRIG with IEEE-1344 (BCD year coded, and more control functions)...\n\n");
|
|
encode = IRIG;
|
|
IrigIncludeYear = TRUE;
|
|
IrigIncludeIeee = TRUE;
|
|
|
|
Unmodulated = TRUE;
|
|
UnmodulatedInverted = TRUE;
|
|
break;
|
|
|
|
case 'w':
|
|
printf ("\nFormat is WWV(H)...\n\n");
|
|
encode = WWV;
|
|
break;
|
|
|
|
default:
|
|
printf ("\n\nUnexpected format value of \'%c\', cannot parse, aborting...\n\n", FormatCharacter);
|
|
exit (-1);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Open audio device and set options
|
|
*/
|
|
fd = open(device, O_WRONLY);
|
|
if (fd <= 0) {
|
|
printf("Unable to open audio device \"%s\", aborting: %s\n", device, strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
#ifdef HAVE_SYS_SOUNDCARD_H
|
|
/* First set coding type */
|
|
AudioFormat = AFMT_MU_LAW;
|
|
if (ioctl(fd, SNDCTL_DSP_SETFMT, &AudioFormat)==-1)
|
|
{ /* Fatal error */
|
|
printf ("\nUnable to set output format, aborting...\n\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (AudioFormat != AFMT_MU_LAW)
|
|
{
|
|
printf ("\nUnable to set output format for mu law, aborting...\n\n");
|
|
exit(-1);
|
|
}
|
|
|
|
/* Next set number of channels */
|
|
MonoStereo = MONO; /* Mono */
|
|
if (ioctl(fd, SNDCTL_DSP_STEREO, &MonoStereo)==-1)
|
|
{ /* Fatal error */
|
|
printf ("\nUnable to set mono/stereo, aborting...\n\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (MonoStereo != MONO)
|
|
{
|
|
printf ("\nUnable to set mono/stereo for mono, aborting...\n\n");
|
|
exit(-1);
|
|
}
|
|
|
|
/* Now set sample rate */
|
|
SampleRate = SetSampleRate;
|
|
if (ioctl(fd, SNDCTL_DSP_SPEED, &SampleRate)==-1)
|
|
{ /* Fatal error */
|
|
printf ("\nUnable to set sample rate to %d, returned %d, aborting...\n\n", SetSampleRate, SampleRate);
|
|
exit(-1);
|
|
}
|
|
|
|
SampleRateDifference = SampleRate - SetSampleRate;
|
|
|
|
if (SampleRateDifference < 0)
|
|
SampleRateDifference = - SampleRateDifference;
|
|
|
|
/* Fixed allowable sample rate error 0.1% */
|
|
if (SampleRateDifference > (SetSampleRate/1000))
|
|
{
|
|
printf ("\nUnable to set sample rate to %d, result was %d, more than 0.1 percent, aborting...\n\n", SetSampleRate, SampleRate);
|
|
exit(-1);
|
|
}
|
|
else
|
|
{
|
|
/* printf ("\nAttempt to set sample rate to %d, actual %d...\n\n", SetSampleRate, SampleRate); */
|
|
}
|
|
#else
|
|
rval = ioctl(fd, AUDIO_GETINFO, &info);
|
|
if (rval < 0) {
|
|
printf("\naudio control %s", strerror(errno));
|
|
exit(0);
|
|
}
|
|
info.play.port = port;
|
|
info.play.gain = level;
|
|
info.play.sample_rate = SetSampleRate;
|
|
info.play.channels = 1;
|
|
info.play.precision = 8;
|
|
info.play.encoding = AUDIO_ENCODING_ULAW;
|
|
printf("\nport %d gain %d rate %d chan %d prec %d encode %d\n",
|
|
info.play.port, info.play.gain, info.play.sample_rate,
|
|
info.play.channels, info.play.precision,
|
|
info.play.encoding);
|
|
ioctl(fd, AUDIO_SETINFO, &info);
|
|
#endif
|
|
|
|
/*
|
|
* Unless specified otherwise, read the system clock and
|
|
* initialize the time.
|
|
*/
|
|
gettimeofday(&TimeValue, NULL); // Now always read the system time to keep "real time" of operation.
|
|
NowRealTime = BaseRealTime = SecondsPartOfTime = TimeValue.tv_sec;
|
|
SecondsRunningSimulationTime = 0; // Just starting simulation, running zero seconds as of now.
|
|
StabilityCount = 0; // No stability yet.
|
|
|
|
if (utc)
|
|
{
|
|
DayOfYear = ConvertMonthDayToDayOfYear (Year, Month, DayOfMonth);
|
|
}
|
|
else
|
|
{
|
|
/* Apply offset to time. */
|
|
if (UseOffsetSecondsInt >= 0)
|
|
SecondsPartOfTime += (time_t) UseOffsetSecondsInt;
|
|
else
|
|
SecondsPartOfTime -= (time_t) (-UseOffsetSecondsInt);
|
|
|
|
TimeStructure = gmtime(&SecondsPartOfTime);
|
|
Minute = TimeStructure->tm_min;
|
|
Hour = TimeStructure->tm_hour;
|
|
DayOfYear = TimeStructure->tm_yday + 1;
|
|
Year = TimeStructure->tm_year % 100;
|
|
Second = TimeStructure->tm_sec;
|
|
|
|
/*
|
|
* Delay the first second so the generator is accurately
|
|
* aligned with the system clock within one sample (125
|
|
* microseconds ).
|
|
*/
|
|
delay(SECOND - TimeValue.tv_usec * 8 / 1000);
|
|
}
|
|
|
|
StraightBinarySeconds = Second + (Minute * SECONDS_PER_MINUTE) + (Hour * SECONDS_PER_HOUR);
|
|
|
|
memset(code, 0, sizeof(code));
|
|
switch (encode) {
|
|
|
|
/*
|
|
* For WWV/H and default time, carefully set the signal
|
|
* generator seconds number to agree with the current time.
|
|
*/
|
|
case WWV:
|
|
printf("WWV time signal, starting point:\n");
|
|
printf(" Year = %02d, Day of year = %03d, Time = %02d:%02d:%02d, Minute tone = %d Hz, Hour tone = %d Hz.\n",
|
|
Year, DayOfYear, Hour, Minute, Second, tone, HourTone);
|
|
snprintf(code, sizeof(code), "%01d%03d%02d%02d%01d",
|
|
Year / 10, DayOfYear, Hour, Minute, Year % 10);
|
|
if (Verbose)
|
|
{
|
|
printf("\n Year = %2.2d, Day of year = %3d, Time = %2.2d:%2.2d:%2.2d, Code = %s",
|
|
Year, DayOfYear, Hour, Minute, Second, code);
|
|
|
|
if ((EnableRateCorrection) || (RemoveCycle) || (AddCycle))
|
|
printf (", CountOfSecondsSent = %d, TotalCyclesAdded = %d, TotalCyclesRemoved = %d\n", CountOfSecondsSent, TotalCyclesAdded, TotalCyclesRemoved);
|
|
else
|
|
printf ("\n");
|
|
}
|
|
|
|
ptr = 8;
|
|
for (BitNumber = 0; BitNumber <= Second; BitNumber++) {
|
|
if (progx[BitNumber].sw == DEC)
|
|
ptr--;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* For IRIG the signal generator runs every second, so requires
|
|
* no additional alignment.
|
|
*/
|
|
case IRIG:
|
|
printf ("IRIG-B time signal, starting point:\n");
|
|
printf (" Year = %02d, Day of year = %03d, Time = %02d:%02d:%02d, Straight binary seconds (SBS) = %05d / 0x%04X.\n",
|
|
Year, DayOfYear, Hour, Minute, Second, StraightBinarySeconds, StraightBinarySeconds);
|
|
printf ("\n");
|
|
if (Verbose)
|
|
{
|
|
printf ("Codes: \".\" = marker/position indicator, \"-\" = zero dummy bit, \"0\" = zero bit, \"1\" = one bit.\n");
|
|
if ((EnableRateCorrection) || (AddCycle) || (RemoveCycle))
|
|
{
|
|
printf (" \"o\" = short zero, \"*\" = long zero, \"x\" = short one, \"+\" = long one.\n");
|
|
}
|
|
printf ("Numerical values are time order reversed in output to make it easier to read.\n");
|
|
/* 111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999 */
|
|
/* 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 */
|
|
printf ("\n");
|
|
printf ("Legend of output codes:\n");
|
|
//printf ("\n");
|
|
//printf ("| StraightBinSecs | IEEE_1344_Control | Year | Day_of_Year | Hours | Minutes |Seconds |\n");
|
|
//printf ("| --------------- | ----------------- | ---- | ----------- | ----- | ------- |------- |\n");
|
|
//printf ("| | | | | | | |\n");
|
|
}
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Run the signal generator to generate new timecode strings
|
|
* once per minute for WWV/H and once per second for IRIG.
|
|
*/
|
|
for (CountOfSecondsSent=0; ((SecondsToSend==0) || (CountOfSecondsSent<SecondsToSend)); CountOfSecondsSent++)
|
|
{
|
|
if ((encode == IRIG) && (((Second % 20) == 0) || (CountOfSecondsSent == 0)))
|
|
{
|
|
printf ("\n");
|
|
|
|
printf (" Year = %02d, Day of year = %03d, Time = %02d:%02d:%02d, Straight binary seconds (SBS) = %05d / 0x%04X.\n",
|
|
Year, DayOfYear, Hour, Minute, Second, StraightBinarySeconds, StraightBinarySeconds);
|
|
if ((EnableRateCorrection) || (RemoveCycle) || (AddCycle))
|
|
{
|
|
printf (" CountOfSecondsSent = %d, TotalCyclesAdded = %d, TotalCyclesRemoved = %d\n", CountOfSecondsSent, TotalCyclesAdded, TotalCyclesRemoved);
|
|
if ((CountOfSecondsSent != 0) && ((TotalCyclesAdded != 0) || (TotalCyclesRemoved != 0)))
|
|
{
|
|
RatioError = ((float) (TotalCyclesAdded - TotalCyclesRemoved)) / (1000.0 * (float) CountOfSecondsSent);
|
|
printf (" Adjusted by %2.1f%%, apparent send frequency is %4.2f Hz not %d Hz.\n\n",
|
|
RatioError*100.0, (1.0+RatioError)*((float) SetSampleRate), SetSampleRate);
|
|
}
|
|
}
|
|
else
|
|
printf ("\n");
|
|
|
|
/* printf ("|Seconds | Minutes | Hours | Day_of_Year | Year | IEEE_1344_Control | StraightBinSecs |\n");
|
|
printf ("|------- | ------- | ----- | ----------- | ---- | ----------------- |-------------------|\n");
|
|
printf ("| | | | | | | |\n");*/
|
|
printf ("| StraightBinSecs | IEEE_1344_Control | Year | Day_of_Year | Hours | Minutes |Seconds |\n");
|
|
printf ("| --------------- | ----------------- | ---- | ----------- | ----- | ------- |------- |\n");
|
|
printf ("| | | | | | | |\n");
|
|
}
|
|
|
|
if (RemoveCycle)
|
|
{
|
|
RateCorrection = -1;
|
|
TotalSecondsCorrected ++;
|
|
}
|
|
else
|
|
{
|
|
if (AddCycle)
|
|
{
|
|
TotalSecondsCorrected ++;
|
|
RateCorrection = +1;
|
|
}
|
|
else
|
|
RateCorrection = 0;
|
|
}
|
|
|
|
/*
|
|
* Crank the state machine to propagate carries to the
|
|
* year of century. Note that we delayed up to one
|
|
* second for alignment after reading the time, so this
|
|
* is the next second.
|
|
*/
|
|
|
|
if (LeapState == LEAPSTATE_NORMAL)
|
|
{
|
|
/* If on the second of a leap (second 59 in the specified minute), then add or delete a second */
|
|
if ((Year == LeapYear) && (DayOfYear == LeapDayOfYear) && (Hour == LeapHour) && (Minute == LeapMinute))
|
|
{
|
|
/* To delete a second, which means we go from 58->60 instead of 58->59->00. */
|
|
if ((DeleteLeapSecond) && (Second == 58))
|
|
{
|
|
LeapState = LEAPSTATE_DELETING;
|
|
|
|
if (Debug)
|
|
printf ("\n<--- Ready to delete a leap second...\n");
|
|
}
|
|
else
|
|
{ /* Delete takes precedence over insert. */
|
|
/* To add a second, which means we go from 59->60->00 instead of 59->00. */
|
|
if ((InsertLeapSecond) && (Second == 59))
|
|
{
|
|
LeapState = LEAPSTATE_INSERTING;
|
|
|
|
if (Debug)
|
|
printf ("\n<--- Ready to insert a leap second...\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (LeapState)
|
|
{
|
|
case LEAPSTATE_NORMAL:
|
|
Second = (Second + 1) % 60;
|
|
break;
|
|
|
|
case LEAPSTATE_DELETING:
|
|
Second = 0;
|
|
LeapState = LEAPSTATE_NORMAL;
|
|
|
|
if (Debug)
|
|
printf ("\n<--- Deleting a leap second...\n");
|
|
break;
|
|
|
|
case LEAPSTATE_INSERTING:
|
|
Second = 60;
|
|
LeapState = LEAPSTATE_ZERO_AFTER_INSERT;
|
|
|
|
if (Debug)
|
|
printf ("\n<--- Inserting a leap second...\n");
|
|
break;
|
|
|
|
case LEAPSTATE_ZERO_AFTER_INSERT:
|
|
Second = 0;
|
|
LeapState = LEAPSTATE_NORMAL;
|
|
|
|
if (Debug)
|
|
printf ("\n<--- Inserted a leap second, now back to zero...\n");
|
|
break;
|
|
|
|
default:
|
|
printf ("\n\nLeap second state invalid value of %d, aborting...", LeapState);
|
|
exit (-1);
|
|
break;
|
|
}
|
|
|
|
/* Check for second rollover, increment minutes and ripple upward if required. */
|
|
if (Second == 0) {
|
|
Minute++;
|
|
if (Minute >= 60) {
|
|
Minute = 0;
|
|
Hour++;
|
|
}
|
|
|
|
/* Check for activation of DST switch. */
|
|
/* If DST is active, this would mean that at the appointed time, we de-activate DST, */
|
|
/* which translates to going backward an hour (repeating the last hour). */
|
|
/* If DST is not active, this would mean that at the appointed time, we activate DST, */
|
|
/* which translates to going forward an hour (skipping the next hour). */
|
|
if (DstSwitchFlag)
|
|
{
|
|
/* The actual switch happens on the zero'th second of the actual minute specified. */
|
|
if ((Year == DstSwitchYear) && (DayOfYear == DstSwitchDayOfYear) && (Hour == DstSwitchHour) && (Minute == DstSwitchMinute))
|
|
{
|
|
if (DstFlag == 0)
|
|
{ /* DST flag is zero, not in DST, going to DST, "spring ahead", so increment hour by two instead of one. */
|
|
Hour++;
|
|
DstFlag = 1;
|
|
|
|
/* Must adjust offset to keep consistent with UTC. */
|
|
/* Here we have to increase offset by one hour. If it goes from negative to positive, then we fix that. */
|
|
if (OffsetSignBit == 0)
|
|
{ /* Offset is positive */
|
|
if (OffsetOnes == 0x0F)
|
|
{
|
|
OffsetSignBit = 1;
|
|
OffsetOnes = (OffsetHalf == 0) ? 8 : 7;
|
|
}
|
|
else
|
|
OffsetOnes++;
|
|
}
|
|
else
|
|
{ /* Offset is negative */
|
|
if (OffsetOnes == 0)
|
|
{
|
|
OffsetSignBit = 0;
|
|
OffsetOnes = (OffsetHalf == 0) ? 1 : 0;
|
|
}
|
|
else
|
|
OffsetOnes--;
|
|
}
|
|
|
|
if (Debug)
|
|
printf ("\n<--- DST activated, spring ahead an hour, new offset !...\n");
|
|
}
|
|
else
|
|
{ /* DST flag is non zero, in DST, going out of DST, "fall back", so no increment of hour. */
|
|
Hour--;
|
|
DstFlag = 0;
|
|
|
|
/* Must adjust offset to keep consistent with UTC. */
|
|
/* Here we have to reduce offset by one hour. If it goes negative, then we fix that. */
|
|
if (OffsetSignBit == 0)
|
|
{ /* Offset is positive */
|
|
if (OffsetOnes == 0)
|
|
{
|
|
OffsetSignBit = 1;
|
|
OffsetOnes = (OffsetHalf == 0) ? 1 : 0;
|
|
}
|
|
else
|
|
OffsetOnes--;
|
|
}
|
|
else
|
|
{ /* Offset is negative */
|
|
if (OffsetOnes == 0x0F)
|
|
{
|
|
OffsetSignBit = 0;
|
|
OffsetOnes = (OffsetHalf == 0) ? 8 : 7;
|
|
}
|
|
else
|
|
OffsetOnes++;
|
|
}
|
|
|
|
if (Debug)
|
|
printf ("\n<--- DST de-activated, fall back an hour!...\n");
|
|
}
|
|
|
|
DstSwitchFlag = FALSE; /* One time deal, not intended to run this program past two switches... */
|
|
}
|
|
}
|
|
|
|
if (Hour >= 24) {
|
|
/* Modified, just in case dumb case where activating DST advances 23h59:59 -> 01h00:00 */
|
|
Hour = Hour % 24;
|
|
DayOfYear++;
|
|
}
|
|
|
|
/*
|
|
* At year rollover check for leap second.
|
|
*/
|
|
if (DayOfYear >= (Year & 0x3 ? 366 : 367)) {
|
|
if (leap) {
|
|
WWV_Second(DATA0, RateCorrection);
|
|
if (Verbose)
|
|
printf("\nLeap!");
|
|
leap = 0;
|
|
}
|
|
DayOfYear = 1;
|
|
Year++;
|
|
}
|
|
if (encode == WWV) {
|
|
snprintf(code, sizeof(code),
|
|
"%01d%03d%02d%02d%01d", Year / 10,
|
|
DayOfYear, Hour, Minute, Year % 10);
|
|
if (Verbose)
|
|
printf("\n Year = %2.2d, Day of year = %3d, Time = %2.2d:%2.2d:%2.2d, Code = %s",
|
|
Year, DayOfYear, Hour, Minute, Second, code);
|
|
|
|
if ((EnableRateCorrection) || (RemoveCycle) || (AddCycle))
|
|
{
|
|
printf (", CountOfSecondsSent = %d, TotalCyclesAdded = %d, TotalCyclesRemoved = %d\n", CountOfSecondsSent, TotalCyclesAdded, TotalCyclesRemoved);
|
|
if ((CountOfSecondsSent != 0) && ((TotalCyclesAdded != 0) || (TotalCyclesRemoved != 0)))
|
|
{
|
|
RatioError = ((float) (TotalCyclesAdded - TotalCyclesRemoved)) / (1000.0 * (float) CountOfSecondsSent);
|
|
printf (" Adjusted by %2.1f%%, apparent send frequency is %4.2f Hz not %d Hz.\n\n",
|
|
RatioError*100.0, (1.0+RatioError)*((float) SetSampleRate), SetSampleRate);
|
|
}
|
|
}
|
|
else
|
|
printf ("\n");
|
|
|
|
ptr = 8;
|
|
}
|
|
} /* End of "if (Second == 0)" */
|
|
|
|
/* After all that, if we are in the minute just prior to a leap second, warn of leap second pending */
|
|
/* and of the polarity */
|
|
if ((Year == LeapYear) && (DayOfYear == LeapDayOfYear) && (Hour == LeapHour) && (Minute == LeapMinute))
|
|
{
|
|
LeapSecondPending = TRUE;
|
|
LeapSecondPolarity = DeleteLeapSecond;
|
|
}
|
|
else
|
|
{
|
|
LeapSecondPending = FALSE;
|
|
LeapSecondPolarity = FALSE;
|
|
}
|
|
|
|
/* Notification through IEEE 1344 happens during the whole minute previous to the minute specified. */
|
|
/* The time of that minute has been previously calculated. */
|
|
if ((Year == DstSwitchPendingYear) && (DayOfYear == DstSwitchPendingDayOfYear) &&
|
|
(Hour == DstSwitchPendingHour) && (Minute == DstSwitchPendingMinute))
|
|
{
|
|
DstPendingFlag = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DstPendingFlag = FALSE;
|
|
}
|
|
|
|
|
|
StraightBinarySeconds = Second + (Minute * SECONDS_PER_MINUTE) + (Hour * SECONDS_PER_HOUR);
|
|
|
|
if (encode == IRIG) {
|
|
if (IrigIncludeIeee)
|
|
{
|
|
if ((OffsetOnes == 0) && (OffsetHalf == 0))
|
|
OffsetSignBit = 0;
|
|
|
|
ControlFunctions = (LeapSecondPending == 0 ? 0x00000 : 0x00001) | (LeapSecondPolarity == 0 ? 0x00000 : 0x00002)
|
|
| (DstPendingFlag == 0 ? 0x00000 : 0x00004) | (DstFlag == 0 ? 0x00000 : 0x00008)
|
|
| (OffsetSignBit == 0 ? 0x00000 : 0x00010) | ((OffsetOnes & 0x0F) << 5) | (OffsetHalf == 0 ? 0x00000 : 0x00200)
|
|
| ((TimeQuality & 0x0F) << 10);
|
|
/* if (Verbose)
|
|
printf ("\nDstFlag = %d, OffsetSignBit = %d, OffsetOnes = %d, OffsetHalf = %d, TimeQuality = 0x%1.1X ==> ControlFunctions = 0x%5.5X...",
|
|
DstFlag, OffsetSignBit, OffsetOnes, OffsetHalf, TimeQuality, ControlFunctions);
|
|
*/
|
|
}
|
|
else
|
|
ControlFunctions = 0;
|
|
|
|
/*
|
|
YearDay HourMin Sec
|
|
snprintf(code, sizeof(code), "%04x%04d%06d%02d%02d%02d",
|
|
0, Year, DayOfYear, Hour, Minute, Second);
|
|
*/
|
|
if (IrigIncludeYear) {
|
|
snprintf(ParityString, sizeof(ParityString),
|
|
"%04X%02d%04d%02d%02d%02d",
|
|
ControlFunctions & 0x7FFF, Year,
|
|
DayOfYear, Hour, Minute, Second);
|
|
} else {
|
|
snprintf(ParityString, sizeof(ParityString),
|
|
"%04X%02d%04d%02d%02d%02d",
|
|
ControlFunctions & 0x7FFF,
|
|
0, DayOfYear, Hour, Minute, Second);
|
|
}
|
|
|
|
if (IrigIncludeIeee)
|
|
{
|
|
ParitySum = 0;
|
|
for (StringPointer=ParityString; *StringPointer!=NUL; StringPointer++)
|
|
{
|
|
switch (toupper(*StringPointer))
|
|
{
|
|
case '1':
|
|
case '2':
|
|
case '4':
|
|
case '8':
|
|
ParitySum += 1;
|
|
break;
|
|
|
|
case '3':
|
|
case '5':
|
|
case '6':
|
|
case '9':
|
|
case 'A':
|
|
case 'C':
|
|
ParitySum += 2;
|
|
break;
|
|
|
|
case '7':
|
|
case 'B':
|
|
case 'D':
|
|
case 'E':
|
|
ParitySum += 3;
|
|
break;
|
|
|
|
case 'F':
|
|
ParitySum += 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((ParitySum & 0x01) == 0x01)
|
|
ParityValue = 0x01;
|
|
else
|
|
ParityValue = 0;
|
|
}
|
|
else
|
|
ParityValue = 0;
|
|
|
|
ControlFunctions |= ((ParityValue & 0x01) << 14);
|
|
|
|
if (IrigIncludeYear) {
|
|
snprintf(code, sizeof(code),
|
|
/* YearDay HourMin Sec */
|
|
"%05X%05X%02d%04d%02d%02d%02d",
|
|
StraightBinarySeconds,
|
|
ControlFunctions, Year, DayOfYear,
|
|
Hour, Minute, Second);
|
|
} else {
|
|
snprintf(code, sizeof(code),
|
|
/* YearDay HourMin Sec */
|
|
"%05X%05X%02d%04d%02d%02d%02d",
|
|
StraightBinarySeconds,
|
|
ControlFunctions, 0, DayOfYear,
|
|
Hour, Minute, Second);
|
|
}
|
|
|
|
if (Debug)
|
|
printf("\nCode string: %s, ParityString = %s, ParitySum = 0x%2.2X, ParityValue = %d, DstFlag = %d...\n", code, ParityString, ParitySum, ParityValue, DstFlag);
|
|
|
|
ptr = strlen(code)-1;
|
|
OldPtr = 0;
|
|
}
|
|
|
|
/*
|
|
* Generate data for the second
|
|
*/
|
|
switch (encode) {
|
|
|
|
/*
|
|
* The IRIG second consists of 20 BCD digits of width-
|
|
* modulateod pulses at 2, 5 and 8 ms and modulated 50
|
|
* percent on the 1000-Hz carrier.
|
|
*/
|
|
case IRIG:
|
|
/* Initialize the output string */
|
|
OutputDataString[0] = '\0';
|
|
|
|
for (BitNumber = 0; BitNumber < 100; BitNumber++) {
|
|
FrameNumber = (BitNumber/10) + 1;
|
|
switch (FrameNumber)
|
|
{
|
|
case 1:
|
|
/* bits 0 to 9, first frame */
|
|
sw = progz[BitNumber % 10].sw;
|
|
arg = progz[BitNumber % 10].arg;
|
|
break;
|
|
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
/* bits 10 to 59, second to sixth frame */
|
|
sw = progy[BitNumber % 10].sw;
|
|
arg = progy[BitNumber % 10].arg;
|
|
break;
|
|
|
|
case 7:
|
|
/* bits 60 to 69, seventh frame */
|
|
sw = progw[BitNumber % 10].sw;
|
|
arg = progw[BitNumber % 10].arg;
|
|
break;
|
|
|
|
case 8:
|
|
/* bits 70 to 79, eighth frame */
|
|
sw = progv[BitNumber % 10].sw;
|
|
arg = progv[BitNumber % 10].arg;
|
|
break;
|
|
|
|
case 9:
|
|
/* bits 80 to 89, ninth frame */
|
|
sw = progw[BitNumber % 10].sw;
|
|
arg = progw[BitNumber % 10].arg;
|
|
break;
|
|
|
|
case 10:
|
|
/* bits 90 to 99, tenth frame */
|
|
sw = progu[BitNumber % 10].sw;
|
|
arg = progu[BitNumber % 10].arg;
|
|
break;
|
|
|
|
default:
|
|
/* , Unexpected values of FrameNumber */
|
|
printf ("\n\nUnexpected value of FrameNumber = %d, cannot parse, aborting...\n\n", FrameNumber);
|
|
exit (-1);
|
|
break;
|
|
}
|
|
|
|
switch(sw) {
|
|
|
|
case DECC: /* decrement pointer and send bit. */
|
|
ptr--;
|
|
case COEF: /* send BCD bit */
|
|
AsciiValue = toupper(code[ptr]);
|
|
HexValue = isdigit(AsciiValue) ? AsciiValue - '0' : (AsciiValue - 'A')+10;
|
|
/* if (Debug) {
|
|
if (ptr != OldPtr) {
|
|
if (Verbose)
|
|
printf("\n(%c->%X)", AsciiValue, HexValue);
|
|
OldPtr = ptr;
|
|
}
|
|
}
|
|
*/
|
|
// OK, adjust all unused bits in hundreds of days.
|
|
if ((FrameNumber == 5) && ((BitNumber % 10) > 1))
|
|
{
|
|
if (RateCorrection < 0)
|
|
{ // Need to remove cycles to catch up.
|
|
if ((HexValue & arg) != 0)
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M5, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M5-1, 1000, LOW, UnmodulatedInverted);
|
|
|
|
TotalCyclesRemoved += 1;
|
|
}
|
|
else
|
|
{
|
|
peep(M5, 1000, HIGH);
|
|
peep(M5-1, 1000, LOW);
|
|
|
|
TotalCyclesRemoved += 1;
|
|
}
|
|
strlcat(OutputDataString, "x", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
else
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M2, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M8-1, 1000, LOW, UnmodulatedInverted);
|
|
|
|
TotalCyclesRemoved += 1;
|
|
}
|
|
else
|
|
{
|
|
peep(M2, 1000, HIGH);
|
|
peep(M8-1, 1000, LOW);
|
|
|
|
TotalCyclesRemoved += 1;
|
|
}
|
|
strlcat(OutputDataString, "o", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
} // End of true clause for "if (RateCorrection < 0)"
|
|
else
|
|
{ // Else clause for "if (RateCorrection < 0)"
|
|
if (RateCorrection > 0)
|
|
{ // Need to add cycles to slow back down.
|
|
if ((HexValue & arg) != 0)
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M5, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M5+1, 1000, LOW, UnmodulatedInverted);
|
|
|
|
TotalCyclesAdded += 1;
|
|
}
|
|
else
|
|
{
|
|
peep(M5, 1000, HIGH);
|
|
peep(M5+1, 1000, LOW);
|
|
|
|
TotalCyclesAdded += 1;
|
|
}
|
|
strlcat(OutputDataString, "+", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
else
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M2, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M8+1, 1000, LOW, UnmodulatedInverted);
|
|
|
|
TotalCyclesAdded += 1;
|
|
}
|
|
else
|
|
{
|
|
peep(M2, 1000, HIGH);
|
|
peep(M8+1, 1000, LOW);
|
|
|
|
TotalCyclesAdded += 1;
|
|
}
|
|
strlcat(OutputDataString, "*", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
} // End of true clause for "if (RateCorrection > 0)"
|
|
else
|
|
{ // Else clause for "if (RateCorrection > 0)"
|
|
// Rate is OK, just do what you feel!
|
|
if ((HexValue & arg) != 0)
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M5, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M5, 1000, LOW, UnmodulatedInverted);
|
|
}
|
|
else
|
|
{
|
|
peep(M5, 1000, HIGH);
|
|
peep(M5, 1000, LOW);
|
|
}
|
|
strlcat(OutputDataString, "1", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
else
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M2, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M8, 1000, LOW, UnmodulatedInverted);
|
|
}
|
|
else
|
|
{
|
|
peep(M2, 1000, HIGH);
|
|
peep(M8, 1000, LOW);
|
|
}
|
|
strlcat(OutputDataString, "0", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
} // End of else clause for "if (RateCorrection > 0)"
|
|
} // End of else claues for "if (RateCorrection < 0)"
|
|
} // End of true clause for "if ((FrameNumber == 5) && (BitNumber == 8))"
|
|
else
|
|
{ // Else clause for "if ((FrameNumber == 5) && (BitNumber == 8))"
|
|
if ((HexValue & arg) != 0)
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M5, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M5, 1000, LOW, UnmodulatedInverted);
|
|
}
|
|
else
|
|
{
|
|
peep(M5, 1000, HIGH);
|
|
peep(M5, 1000, LOW);
|
|
}
|
|
strlcat(OutputDataString, "1", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
else
|
|
{
|
|
if (Unmodulated)
|
|
{
|
|
poop(M2, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M8, 1000, LOW, UnmodulatedInverted);
|
|
}
|
|
else
|
|
{
|
|
peep(M2, 1000, HIGH);
|
|
peep(M8, 1000, LOW);
|
|
}
|
|
strlcat(OutputDataString, "0", OUTPUT_DATA_STRING_LENGTH);
|
|
}
|
|
} // end of else clause for "if ((FrameNumber == 5) && (BitNumber == 8))"
|
|
break;
|
|
|
|
case DECZ: /* decrement pointer and send zero bit */
|
|
ptr--;
|
|
if (Unmodulated)
|
|
{
|
|
poop(M2, 1000, HIGH, UnmodulatedInverted);
|
|
poop(M8, 1000, LOW, UnmodulatedInverted);
|
|
}
|
|
else
|
|
{
|
|
peep(M2, 1000, HIGH);
|
|
peep(M8, 1000, LOW);
|
|
}
|
|
strlcat(OutputDataString, "-", OUTPUT_DATA_STRING_LENGTH);
|
|
break;
|
|
|
|
case DEC: /* send marker/position indicator IM/PI bit */
|
|
ptr--;
|
|
case NODEC: /* send marker/position indicator IM/PI bit but no decrement pointer */
|
|
case MIN: /* send "second start" marker/position indicator IM/PI bit */
|
|
if (Unmodulated)
|
|
{
|
|
poop(arg, 1000, HIGH, UnmodulatedInverted);
|
|
poop(10 - arg, 1000, LOW, UnmodulatedInverted);
|
|
}
|
|
else
|
|
{
|
|
peep(arg, 1000, HIGH);
|
|
peep(10 - arg, 1000, LOW);
|
|
}
|
|
strlcat(OutputDataString, ".", OUTPUT_DATA_STRING_LENGTH);
|
|
break;
|
|
|
|
default:
|
|
printf ("\n\nUnknown state machine value \"%d\", unable to continue, aborting...\n\n", sw);
|
|
exit (-1);
|
|
break;
|
|
}
|
|
if (ptr < 0)
|
|
break;
|
|
}
|
|
ReverseString ( OutputDataString );
|
|
if (Verbose)
|
|
{
|
|
printf("%s", OutputDataString);
|
|
if (RateCorrection > 0)
|
|
printf(" fast\n");
|
|
else
|
|
{
|
|
if (RateCorrection < 0)
|
|
printf (" slow\n");
|
|
else
|
|
printf ("\n");
|
|
}
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* The WWV/H second consists of 9 BCD digits of width-
|
|
* modulateod pulses 200, 500 and 800 ms at 100-Hz.
|
|
*/
|
|
case WWV:
|
|
sw = progx[Second].sw;
|
|
arg = progx[Second].arg;
|
|
switch(sw) {
|
|
|
|
case DATA: /* send data bit */
|
|
WWV_Second(arg, RateCorrection);
|
|
if (Verbose)
|
|
{
|
|
if (arg == DATA0)
|
|
printf ("0");
|
|
else
|
|
{
|
|
if (arg == DATA1)
|
|
printf ("1");
|
|
else
|
|
{
|
|
if (arg == PI)
|
|
printf ("P");
|
|
else
|
|
printf ("?");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DATAX: /* send data bit */
|
|
WWV_SecondNoTick(arg, RateCorrection);
|
|
if (Verbose)
|
|
{
|
|
if (arg == DATA0)
|
|
printf ("0");
|
|
else
|
|
{
|
|
if (arg == DATA1)
|
|
printf ("1");
|
|
else
|
|
{
|
|
if (arg == PI)
|
|
printf ("P");
|
|
else
|
|
printf ("?");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case COEF: /* send BCD bit */
|
|
if (code[ptr] & arg) {
|
|
WWV_Second(DATA1, RateCorrection);
|
|
if (Verbose)
|
|
printf("1");
|
|
} else {
|
|
WWV_Second(DATA0, RateCorrection);
|
|
if (Verbose)
|
|
printf("0");
|
|
}
|
|
break;
|
|
|
|
case LEAP: /* send leap bit */
|
|
if (leap) {
|
|
WWV_Second(DATA1, RateCorrection);
|
|
if (Verbose)
|
|
printf("L");
|
|
} else {
|
|
WWV_Second(DATA0, RateCorrection);
|
|
if (Verbose)
|
|
printf("0");
|
|
}
|
|
break;
|
|
|
|
case DEC: /* send data bit */
|
|
ptr--;
|
|
WWV_Second(arg, RateCorrection);
|
|
if (Verbose)
|
|
{
|
|
if (arg == DATA0)
|
|
printf ("0");
|
|
else
|
|
{
|
|
if (arg == DATA1)
|
|
printf ("1");
|
|
else
|
|
{
|
|
if (arg == PI)
|
|
printf ("P");
|
|
else
|
|
printf ("?");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DECX: /* send data bit with no tick */
|
|
ptr--;
|
|
WWV_SecondNoTick(arg, RateCorrection);
|
|
if (Verbose)
|
|
{
|
|
if (arg == DATA0)
|
|
printf ("0");
|
|
else
|
|
{
|
|
if (arg == DATA1)
|
|
printf ("1");
|
|
else
|
|
{
|
|
if (arg == PI)
|
|
printf ("P");
|
|
else
|
|
printf ("?");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MIN: /* send minute sync */
|
|
if (Minute == 0)
|
|
{
|
|
peep(arg, HourTone, HIGH);
|
|
|
|
if (RateCorrection < 0)
|
|
{
|
|
peep( 990 - arg, HourTone, OFF);
|
|
TotalCyclesRemoved += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Shorter Second: ");
|
|
}
|
|
else
|
|
{
|
|
if (RateCorrection > 0)
|
|
{
|
|
peep(1010 - arg, HourTone, OFF);
|
|
|
|
TotalCyclesAdded += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Longer Second: ");
|
|
}
|
|
else
|
|
{
|
|
peep(1000 - arg, HourTone, OFF);
|
|
}
|
|
}
|
|
|
|
if (Verbose)
|
|
printf("H");
|
|
}
|
|
else
|
|
{
|
|
peep(arg, tone, HIGH);
|
|
|
|
if (RateCorrection < 0)
|
|
{
|
|
peep( 990 - arg, tone, OFF);
|
|
TotalCyclesRemoved += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Shorter Second: ");
|
|
}
|
|
else
|
|
{
|
|
if (RateCorrection > 0)
|
|
{
|
|
peep(1010 - arg, tone, OFF);
|
|
|
|
TotalCyclesAdded += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Longer Second: ");
|
|
}
|
|
else
|
|
{
|
|
peep(1000 - arg, tone, OFF);
|
|
}
|
|
}
|
|
|
|
if (Verbose)
|
|
printf("M");
|
|
}
|
|
break;
|
|
|
|
case DUT1: /* send DUT1 bits */
|
|
if (dut1 & arg)
|
|
{
|
|
WWV_Second(DATA1, RateCorrection);
|
|
if (Verbose)
|
|
printf("1");
|
|
}
|
|
else
|
|
{
|
|
WWV_Second(DATA0, RateCorrection);
|
|
if (Verbose)
|
|
printf("0");
|
|
}
|
|
break;
|
|
|
|
case DST1: /* send DST1 bit */
|
|
ptr--;
|
|
if (DstFlag)
|
|
{
|
|
WWV_Second(DATA1, RateCorrection);
|
|
if (Verbose)
|
|
printf("1");
|
|
}
|
|
else
|
|
{
|
|
WWV_Second(DATA0, RateCorrection);
|
|
if (Verbose)
|
|
printf("0");
|
|
}
|
|
break;
|
|
|
|
case DST2: /* send DST2 bit */
|
|
if (DstFlag)
|
|
{
|
|
WWV_Second(DATA1, RateCorrection);
|
|
if (Verbose)
|
|
printf("1");
|
|
}
|
|
else
|
|
{
|
|
WWV_Second(DATA0, RateCorrection);
|
|
if (Verbose)
|
|
printf("0");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (EnableRateCorrection)
|
|
{
|
|
SecondsRunningSimulationTime++;
|
|
|
|
gettimeofday(&TimeValue, NULL);
|
|
NowRealTime = TimeValue.tv_sec;
|
|
|
|
if (NowRealTime >= BaseRealTime) // Just in case system time corrects backwards, do not blow up.
|
|
{
|
|
SecondsRunningRealTime = (unsigned) (NowRealTime - BaseRealTime);
|
|
SecondsRunningDifference = SecondsRunningSimulationTime - SecondsRunningRealTime;
|
|
|
|
if (Debug)
|
|
{
|
|
printf ("> NowRealTime = 0x%8.8X, BaseRealtime = 0x%8.8X, SecondsRunningRealTime = 0x%8.8X, SecondsRunningSimulationTime = 0x%8.8X.\n",
|
|
(unsigned) NowRealTime, (unsigned) BaseRealTime, SecondsRunningRealTime, SecondsRunningSimulationTime);
|
|
printf ("> SecondsRunningDifference = 0x%8.8X, ExpectedRunningDifference = 0x%8.8X.\n",
|
|
SecondsRunningDifference, ExpectedRunningDifference);
|
|
}
|
|
|
|
if (SecondsRunningSimulationTime > RUN_BEFORE_STABILITY_CHECK)
|
|
{
|
|
if (StabilityCount < MINIMUM_STABILITY_COUNT)
|
|
{
|
|
if (StabilityCount == 0)
|
|
{
|
|
ExpectedRunningDifference = SecondsRunningDifference;
|
|
StabilityCount++;
|
|
if (Debug)
|
|
printf ("> Starting stability check.\n");
|
|
}
|
|
else
|
|
{ // Else for "if (StabilityCount == 0)"
|
|
if ((ExpectedRunningDifference+INITIAL_STABILITY_BAND > SecondsRunningDifference)
|
|
&& (ExpectedRunningDifference-INITIAL_STABILITY_BAND < SecondsRunningDifference))
|
|
{ // So far, still within stability band, increment count.
|
|
StabilityCount++;
|
|
if (Debug)
|
|
printf ("> StabilityCount = %d.\n", StabilityCount);
|
|
}
|
|
else
|
|
{ // Outside of stability band, start over.
|
|
StabilityCount = 0;
|
|
if (Debug)
|
|
printf ("> Out of stability band, start over.\n");
|
|
}
|
|
} // End of else for "if (StabilityCount == 0)"
|
|
} // End of true clause for "if (StabilityCount < MINIMUM_STABILITY_COUNT))"
|
|
else
|
|
{ // Else clause for "if (StabilityCount < MINIMUM_STABILITY_COUNT))" - OK, so we are supposed to be stable.
|
|
if (AddCycle)
|
|
{
|
|
if (ExpectedRunningDifference >= SecondsRunningDifference)
|
|
{
|
|
if (Debug)
|
|
printf ("> Was adding cycles, ExpectedRunningDifference >= SecondsRunningDifference, can stop it now.\n");
|
|
|
|
AddCycle = FALSE;
|
|
RemoveCycle = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (Debug)
|
|
printf ("> Was adding cycles, not done yet.\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (RemoveCycle)
|
|
{
|
|
if (ExpectedRunningDifference <= SecondsRunningDifference)
|
|
{
|
|
if (Debug)
|
|
printf ("> Was removing cycles, ExpectedRunningDifference <= SecondsRunningDifference, can stop it now.\n");
|
|
|
|
AddCycle = FALSE;
|
|
RemoveCycle = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (Debug)
|
|
printf ("> Was removing cycles, not done yet.\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((ExpectedRunningDifference+RUNNING_STABILITY_BAND > SecondsRunningDifference)
|
|
&& (ExpectedRunningDifference-RUNNING_STABILITY_BAND < SecondsRunningDifference))
|
|
{ // All is well, within tolerances.
|
|
if (Debug)
|
|
printf ("> All is well, within tolerances.\n");
|
|
}
|
|
else
|
|
{ // Oops, outside tolerances. Else clause of "if ((ExpectedRunningDifference...SecondsRunningDifference)"
|
|
if (ExpectedRunningDifference > SecondsRunningDifference)
|
|
{
|
|
if (Debug)
|
|
printf ("> ExpectedRunningDifference > SecondsRunningDifference, running behind real time.\n");
|
|
|
|
// Behind real time, have to add a cycle to slow down and get back in sync.
|
|
AddCycle = FALSE;
|
|
RemoveCycle = TRUE;
|
|
}
|
|
else
|
|
{ // Else clause of "if (ExpectedRunningDifference < SecondsRunningDifference)"
|
|
if (ExpectedRunningDifference < SecondsRunningDifference)
|
|
{
|
|
if (Debug)
|
|
printf ("> ExpectedRunningDifference < SecondsRunningDifference, running ahead of real time.\n");
|
|
|
|
// Ahead of real time, have to remove a cycle to speed up and get back in sync.
|
|
AddCycle = TRUE;
|
|
RemoveCycle = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (Debug)
|
|
printf ("> Oops, outside tolerances, but doesn't fit the profiles, how can this be?\n");
|
|
}
|
|
} // End of else clause of "if (ExpectedRunningDifference > SecondsRunningDifference)"
|
|
} // End of else clause of "if ((ExpectedRunningDifference...SecondsRunningDifference)"
|
|
} // End of else clause of "if (RemoveCycle)".
|
|
} // End of else clause of "if (AddCycle)".
|
|
} // End of else clause for "if (StabilityCount < MINIMUM_STABILITY_COUNT))"
|
|
} // End of true clause for "if ((SecondsRunningSimulationTime > RUN_BEFORE_STABILITY_CHECK)"
|
|
} // End of true clause for "if (NowRealTime >= BaseRealTime)"
|
|
else
|
|
{
|
|
if (Debug)
|
|
printf ("> Hmm, time going backwards?\n");
|
|
}
|
|
} // End of true clause for "if (EnableRateCorrection)"
|
|
|
|
fflush (stdout);
|
|
}
|
|
|
|
|
|
printf ("\n\n>> Completed %d seconds, exiting...\n\n", SecondsToSend);
|
|
return (0);
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate WWV/H 0 or 1 data pulse.
|
|
*/
|
|
void WWV_Second(
|
|
int code, /* DATA0, DATA1, PI */
|
|
int Rate /* <0 -> do a short second, 0 -> normal second, >0 -> long second */
|
|
)
|
|
{
|
|
/*
|
|
* The WWV data pulse begins with 5 ms of 1000 Hz follwed by a
|
|
* guard time of 25 ms. The data pulse is 170, 570 or 770 ms at
|
|
* 100 Hz corresponding to 0, 1 or position indicator (PI),
|
|
* respectively. Note the 100-Hz data pulses are transmitted 6
|
|
* dB below the 1000-Hz sync pulses. Originally the data pulses
|
|
* were transmited 10 dB below the sync pulses, but the station
|
|
* engineers increased that to 6 dB because the Heath GC-1000
|
|
* WWV/H radio clock worked much better.
|
|
*/
|
|
peep(5, tone, HIGH); /* send seconds tick */
|
|
peep(25, tone, OFF);
|
|
peep(code - 30, 100, LOW); /* send data */
|
|
|
|
/* The quiet time is shortened or lengthened to get us back on time */
|
|
if (Rate < 0)
|
|
{
|
|
peep( 990 - code, 100, OFF);
|
|
|
|
TotalCyclesRemoved += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Shorter Second: ");
|
|
}
|
|
else
|
|
{
|
|
if (Rate > 0)
|
|
{
|
|
peep(1010 - code, 100, OFF);
|
|
|
|
TotalCyclesAdded += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Longer Second: ");
|
|
}
|
|
else
|
|
peep(1000 - code, 100, OFF);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Generate WWV/H 0 or 1 data pulse, with no tick, for 29th and 59th seconds
|
|
*/
|
|
void WWV_SecondNoTick(
|
|
int code, /* DATA0, DATA1, PI */
|
|
int Rate /* <0 -> do a short second, 0 -> normal second, >0 -> long second */
|
|
)
|
|
{
|
|
/*
|
|
* The WWV data pulse begins with 5 ms of 1000 Hz follwed by a
|
|
* guard time of 25 ms. The data pulse is 170, 570 or 770 ms at
|
|
* 100 Hz corresponding to 0, 1 or position indicator (PI),
|
|
* respectively. Note the 100-Hz data pulses are transmitted 6
|
|
* dB below the 1000-Hz sync pulses. Originally the data pulses
|
|
* were transmited 10 dB below the sync pulses, but the station
|
|
* engineers increased that to 6 dB because the Heath GC-1000
|
|
* WWV/H radio clock worked much better.
|
|
*/
|
|
peep(30, tone, OFF); /* send seconds non-tick */
|
|
peep(code - 30, 100, LOW); /* send data */
|
|
|
|
/* The quiet time is shortened or lengthened to get us back on time */
|
|
if (Rate < 0)
|
|
{
|
|
peep( 990 - code, 100, OFF);
|
|
|
|
TotalCyclesRemoved += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Shorter Second: ");
|
|
}
|
|
else
|
|
{
|
|
if (Rate > 0)
|
|
{
|
|
peep(1010 - code, 100, OFF);
|
|
|
|
TotalCyclesAdded += 10;
|
|
|
|
if (Debug)
|
|
printf ("\n* Longer Second: ");
|
|
}
|
|
else
|
|
peep(1000 - code, 100, OFF);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Generate cycles of 100 Hz or any multiple of 100 Hz.
|
|
*/
|
|
void peep(
|
|
int pulse, /* pulse length (ms) */
|
|
int freq, /* frequency (Hz) */
|
|
int amp /* amplitude */
|
|
)
|
|
{
|
|
int increm; /* phase increment */
|
|
int i, j;
|
|
|
|
if (amp == OFF || freq == 0)
|
|
increm = 10;
|
|
else
|
|
increm = freq / 100;
|
|
j = 0;
|
|
for (i = 0 ; i < pulse * 8; i++) {
|
|
switch (amp) {
|
|
|
|
case HIGH:
|
|
buffer[bufcnt++] = ~c6000[j];
|
|
break;
|
|
|
|
case LOW:
|
|
buffer[bufcnt++] = ~c3000[j];
|
|
break;
|
|
|
|
default:
|
|
buffer[bufcnt++] = ~0;
|
|
}
|
|
if (bufcnt >= BUFLNG) {
|
|
write(fd, buffer, BUFLNG);
|
|
bufcnt = 0;
|
|
}
|
|
j = (j + increm) % 80;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate unmodulated from similar tables.
|
|
*/
|
|
void poop(
|
|
int pulse, /* pulse length (ms) */
|
|
int freq, /* frequency (Hz) */
|
|
int amp, /* amplitude */
|
|
int inverted /* is upside down */
|
|
)
|
|
{
|
|
int increm; /* phase increment */
|
|
int i, j;
|
|
|
|
if (amp == OFF || freq == 0)
|
|
increm = 10;
|
|
else
|
|
increm = freq / 100;
|
|
j = 0;
|
|
for (i = 0 ; i < pulse * 8; i++) {
|
|
switch (amp) {
|
|
|
|
case HIGH:
|
|
if (inverted)
|
|
buffer[bufcnt++] = ~u3000[j];
|
|
else
|
|
buffer[bufcnt++] = ~u6000[j];
|
|
break;
|
|
|
|
case LOW:
|
|
if (inverted)
|
|
buffer[bufcnt++] = ~u6000[j];
|
|
else
|
|
buffer[bufcnt++] = ~u3000[j];
|
|
break;
|
|
|
|
default:
|
|
buffer[bufcnt++] = ~0;
|
|
}
|
|
if (bufcnt >= BUFLNG) {
|
|
write(fd, buffer, BUFLNG);
|
|
bufcnt = 0;
|
|
}
|
|
j = (j + increm) % 80;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Delay for initial phasing
|
|
*/
|
|
void delay (
|
|
int Delay /* delay in samples */
|
|
)
|
|
{
|
|
int samples; /* samples remaining */
|
|
|
|
samples = Delay;
|
|
memset(buffer, 0, BUFLNG);
|
|
while (samples >= BUFLNG) {
|
|
write(fd, buffer, BUFLNG);
|
|
samples -= BUFLNG;
|
|
}
|
|
write(fd, buffer, samples);
|
|
}
|
|
|
|
|
|
/* Calc day of year from year month & day */
|
|
/* Year - 0 means 2000, 100 means 2100. */
|
|
/* Month - 1 means January, 12 means December. */
|
|
/* DayOfMonth - 1 is first day of month */
|
|
int
|
|
ConvertMonthDayToDayOfYear (int YearValue, int MonthValue, int DayOfMonthValue)
|
|
{
|
|
int ReturnValue;
|
|
int LeapYear;
|
|
int MonthCounter;
|
|
|
|
/* Array of days in a month. Note that here January is zero. */
|
|
/* NB: have to add 1 to days in February in a leap year! */
|
|
int DaysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
|
|
|
|
|
LeapYear = FALSE;
|
|
if ((YearValue % 4) == 0)
|
|
{
|
|
if ((YearValue % 100) == 0)
|
|
{
|
|
if ((YearValue % 400) == 0)
|
|
{
|
|
LeapYear = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LeapYear = TRUE;
|
|
}
|
|
}
|
|
|
|
if (Debug)
|
|
printf ("\nConvertMonthDayToDayOfYear(): Year %d %s a leap year.\n", YearValue+2000, LeapYear ? "is" : "is not");
|
|
|
|
/* Day of month given us starts in this algorithm. */
|
|
ReturnValue = DayOfMonthValue;
|
|
|
|
/* Add in days in month for each month past January. */
|
|
for (MonthCounter=1; MonthCounter<MonthValue; MonthCounter++)
|
|
{
|
|
ReturnValue += DaysInMonth [ MonthCounter - 1 ];
|
|
}
|
|
|
|
/* Add a day for leap years where we are past February. */
|
|
if ((LeapYear) && (MonthValue > 2))
|
|
{
|
|
ReturnValue++;
|
|
}
|
|
|
|
if (Debug)
|
|
printf ("\nConvertMonthDayToDayOfYear(): %4.4d-%2.2d-%2.2d represents day %3d of year.\n",
|
|
YearValue+2000, MonthValue, DayOfMonthValue, ReturnValue);
|
|
|
|
return (ReturnValue);
|
|
}
|
|
|
|
|
|
void
|
|
Help ( void )
|
|
{
|
|
printf ("\n\nTime Code Generation - IRIG-B or WWV, v%d.%d, %s dmw", VERSION, ISSUE, ISSUE_DATE);
|
|
printf ("\n\nRCS Info:");
|
|
printf ( "\n $Header: /home/dmw/src/IRIG_generation/ntp-4.2.2p3/util/RCS/tg.c,v 1.28 2007/02/12 23:57:45 dmw Exp $");
|
|
printf ("\n\nUsage: %s [option]*", CommandName);
|
|
printf ("\n\nOptions: -a device_name Output audio device name (default /dev/audio)");
|
|
printf ( "\n -b yymmddhhmm Remove leap second at end of minute specified");
|
|
printf ( "\n -c seconds_to_send Number of seconds to send (default 0 = forever)");
|
|
printf ( "\n -d Start with IEEE 1344 DST active");
|
|
printf ( "\n -f format_type i = Modulated IRIG-B 1998 (no year coded)");
|
|
printf ( "\n 2 = Modulated IRIG-B 2002 (year coded)");
|
|
printf ( "\n 3 = Modulated IRIG-B w/IEEE 1344 (year & control funcs) (default)");
|
|
printf ( "\n 4 = Unmodulated IRIG-B w/IEEE 1344 (year & control funcs)");
|
|
printf ( "\n 5 = Inverted unmodulated IRIG-B w/IEEE 1344 (year & control funcs)");
|
|
printf ( "\n w = WWV(H)");
|
|
printf ( "\n -g yymmddhhmm Switch into/out of DST at beginning of minute specified");
|
|
printf ( "\n -i yymmddhhmm Insert leap second at end of minute specified");
|
|
printf ( "\n -j Disable time rate correction against system clock (default enabled)");
|
|
printf ( "\n -k nn Force rate correction for testing (+1 = add cycle, -1 = remove cycle)");
|
|
printf ( "\n -l time_offset Set offset of time sent to UTC as per computer, +/- float hours");
|
|
printf ( "\n -o time_offset Set IEEE 1344 time offset, +/-, to 0.5 hour (default 0)");
|
|
printf ( "\n -q quality_code_hex Set IEEE 1344 quality code (default 0)");
|
|
printf ( "\n -r sample_rate Audio sample rate (default 8000)");
|
|
printf ( "\n -s Set leap warning bit (WWV[H] only)");
|
|
printf ( "\n -t sync_frequency WWV(H) on-time pulse tone frequency (default 1200)");
|
|
printf ( "\n -u DUT1_offset Set WWV(H) DUT1 offset -7 to +7 (default 0)");
|
|
#ifndef HAVE_SYS_SOUNDCARD_H
|
|
printf ( "\n -v initial_output_level Set initial output level (default %d, must be 0 to 255)", AUDIO_MAX_GAIN/8);
|
|
#endif
|
|
printf ( "\n -x Turn off verbose output (default on)");
|
|
printf ( "\n -y yymmddhhmmss Set initial date and time as specified (default system time)");
|
|
printf ("\n\nThis software licenced under the GPL, modifications performed 2006 & 2007 by Dean Weiten");
|
|
printf ( "\nContact: Dean Weiten, Norscan Instruments Ltd., Winnipeg, MB, Canada, ph (204)-233-9138, E-mail dmw@norscan.com");
|
|
printf ("\n\n");
|
|
}
|
|
|
|
/* Reverse string order for nicer print. */
|
|
void
|
|
ReverseString(char *str)
|
|
{
|
|
int StringLength;
|
|
int IndexCounter;
|
|
int CentreOfString;
|
|
char TemporaryCharacter;
|
|
|
|
|
|
StringLength = strlen(str);
|
|
CentreOfString = (StringLength/2)+1;
|
|
for (IndexCounter = StringLength; IndexCounter >= CentreOfString; IndexCounter--)
|
|
{
|
|
TemporaryCharacter = str[IndexCounter-1];
|
|
str[IndexCounter-1] = str[StringLength-IndexCounter];
|
|
str[StringLength-IndexCounter] = TemporaryCharacter;
|
|
}
|
|
}
|
|
|