ss_time_lib.h

#ifndef SS_TIME_LIB_H
#define SS_TIME_LIB_H

#ifdef __cplusplus
extern "C" {
#endif

#define EDT_SSTM_COUNTS 0x04010080
#define EDT_SSTM_SECS    0x04010084
#define EDT_SSTM_SET     0x04010088
#define EDT_SSTM_ADJ_VALUE  0x0301008C
#define EDT_SSTM_CMD     0x0101008F

#define EDT_SSTM_COPY       0x01
#define EDT_SSTM_LATCH      0x02
#define EDT_SSTM_COPY_ADJ         0x04

#define EDT_SSTM_ADJ_EN   0x10
#define EDT_SSTM_ADJ_PLUS   0x20
#define EDT_SSTM_CMD_LOCK   0x80

#define EDT_SSTM_ZERO_OFFSET_MAX 100

#define EDT_SSTM_MAX_ADJ  0xffffff

#define USECS_FACTOR  (1000000.0 / (double) (1 << 20))


EDTAPI void edt_sstm_setup(EdtDev *edt_p, char *bitfile);

EDTAPI void edt_sstm_strobe(EdtDev *edt_p, unsigned int bits);

/*
 * Latches the current time into registers
 */

EDTAPI void edt_sstm_latch_time(EdtDev *edt_p);

/*
 * returns the value of seconds
 */

EDTAPI u_int edt_sstm_get_seconds(EdtDev *edt_p);

/*
 * returns # of ticks ( = (1<<20)/1000000 microseconds
 */

EDTAPI u_int edt_sstm_get_counts(EdtDev *edt_p);

/*
 * returns # of usecs by multiplying by 
 * (1<<20)/1000000)
 *
 */

EDTAPI u_int edt_sstm_get_usecs(EdtDev *edt_p);

/*
 * gets both parts (secs/usecs) of time values 
 */

EDTAPI void edt_sstm_get_time_parts(EdtDev *edt_p, u_int *seconds, u_int *usecs);

/*
 * Returns time as double
 *
 */

EDTAPI double edt_sstm_timestamp(EdtDev *edt_p);

/*
 * returns 0 or 1 depending on 
 * EDT_SSTM_ADJ_enabled bit.
 */

EDTAPI int edt_sstm_get_adjust_enabled(EdtDev *edt_p);

/*
 * returns -1 or 1 depending on 
 * EDT_SSTM_ADJ_PLUS bit.
 */

EDTAPI int edt_sstm_get_adjust_sign(EdtDev *edt_p);

/*
 * returns the signed value of the adjustment
 */

EDTAPI u_int edt_sstm_get_adjust_ticks(EdtDev *edt_p);


/*
 * Set the current seconds value, clears usecs
 * Not in synch with system time - to do so use
 * edt_sstm_set instead, which waits for system
 * zero crossing.
 */
 
EDTAPI void edt_sstm_set_secs(EdtDev *edt_p, unsigned int second);

/*
 * Set the current seconds value to second + 1, clears usecs
 * Calls edt_wait_for_zero before strobing value
 */
 
EDTAPI void edt_sstm_set(EdtDev *edt_p, unsigned int second);


/*
 * Sets the time to the current system time, by waiting 
 * for zero crossing, then half a second, then calling 
 * edt_sstm_set
 */

EDTAPI void edt_sstm_set_to_sys(EdtDev *edt_p);

/*
 * Sets the time to the current system time, adding error ms
 */

EDTAPI void edt_sstm_set_to_sys_error(EdtDev *edt_p, int error);

/* 
Turn off rate adjustment
*/

EDTAPI void edt_sstm_disable_adjust(EdtDev *edt_p);

/*
Turn on rate adjustment
*/

EDTAPI void edt_sstm_enable_adjust(EdtDev *edt_p);

/* 
Set the sign bit for rate adjustment 
*/

EDTAPI void edt_sstm_set_adj_sign(EdtDev *edt_p, int positive);


/* 
 * sets the time adjustment to ticks
 * between delta. Sign of ticks determines whether to add 1
 * or not add 1
 *
 */

EDTAPI void edt_sstm_set_adj_ticks(EdtDev *edt_p, int ticks, int positive);

/*
 * Return mean error between SS time and sys time
 * as a double (in seconds)
 */


EDTAPI double edt_sstm_sys_error(EdtDev *edt_p);

/*
 *
 * Calculate basic error rate between SS clock and sys clock
 * Take mean of <samples> over sample_seconds 
 * Returns drift as ppm
 *
 */ 

EDTAPI double edt_sstm_measure_drift(EdtDev *edt_p);

/* compute adjustment ticks from drift value in ppm */

EDTAPI int edt_sstm_ticks_from_drift(double drift);

/* Take a drift value in ppm and set adjustment ticks
    accordingly */

EDTAPI void edt_sstm_set_adj_from_drift(EdtDev *edt_p, double drift);

EDTAPI void edt_sstm_set_drift_sampling(int seconds, int samples);

EDTAPI int edt_sstm_get_adj_sample_secs();

EDTAPI int edt_sstm_get_adj_samples();

/*
 * Calculate auto adjust values - sample for sample_seconds
 * to calculate basic error rate, then find total error and compute
 * adjustment to get to zero in revert_secs.
 * adjust_to returns the correction for basic error rate.
 *
 */

EDTAPI double edt_sstm_calc_convergence(EdtDev *edt_p, 
                             int revert_secs,
                             double drift_ticks);

/*
 * Given two drift values, one to converge to zero error and 
 * a constant drift, block until finished
 * stop value will be checked at 200 ms intervals to 
 * see whether to stop 
 */

EDTAPI double edt_sstm_adjust(EdtDev *edt_p,
                              double converge, 
                              double drift,
                              int *active);
/*
 * Calculate and execute auto adjust
 *
 */

EDTAPI void edt_sstm_iterate_adjust(EdtDev *edt_p, 
                             int revert_secs,
                             int maxiterations,
                             int tolerance,
                             int *active);

EDTAPI void
edt_sstm_print_loop(EdtDev *edt_p, int interval, int total_time);


/* 
 * Structure used by edt_sstm_launch_adjuster to
 * have a thread running in the background 
 * which periodically checks the clock error and does
 * correction. Set active to 0 to stop the thread.
 */


typedef struct {
    EdtDev *edt_p;
    int check_interval; /* seconds */
    int revert_seconds;
    int iterations;    /* how many times to auto adjust */
    int max_error;
    int tolerance; /* desired closeness to zero error */
    int active;
    int done;
    int loops;
    thread_t thread;
} EdtSSTimeAdjuster;

/*
 * Start a thread to check and correct time against 
 * system time.
 * check - interval between checks
 * revert - how long a period for converging to 0 error
 * iterations - how many times to do the auto adjust if error exceeds
 *              max_usec_error.
 * 
*/

 
EDTAPI EdtSSTimeAdjuster *
edt_sstm_launch_adjuster(EdtDev *edt_p, 
                            int check, 
                            int revert, 
                            int iterations, 
                            int max_usec_error,
                            int tolerance,
                            int loops);


EDTAPI void
edt_sstm_adjuster_stop(EdtSSTimeAdjuster *adj_p);


EDTAPI void
edt_sstm_adjuster_start(EdtSSTimeAdjuster *adj_p);

EDTAPI char * edt_printable_time(double sys_t, char *buf);

#ifndef WIN32

#define edt_sys_timestamp edt_timestamp

#else

EDTAPI double edt_sys_timestamp();

#endif



#ifdef __cplusplus
}
#endif



#endif

---