/* * 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 #include #include #ifdef HAVE_CONFIG_H #include "config.h" #undef VERSION /* avoid conflict below */ #endif #ifdef HAVE_SYS_SOUNDCARD_H #include #else # ifdef HAVE_SYS_AUDIOIO_H # include # else # include # endif #endif #include "ntp_stdlib.h" /* for strlcat(), strlcpy() */ #include #include #include #include #include #include #include #include #include #include #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) || (CountOfSecondsSent60 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 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; } }