/*
* 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;
}
}