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

typedef struct _timeregs {
    u_int counts;
    u_int secs;
    u_int set;
    u_int adj_value;
    u_int cmd;

    EdtDev *dev_p;

    /* used to be SS_TimeAdjust */
    int check_interval; /* seconds */
    int adjust_sample;
    int adjustment_scalar;    /* 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;

    double err;
    int sign;
    int loop;
    double converge;
    double drift;
    double adjust_drift;
    int iter;

    int ticks;

} EdtTimeController;

#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(EdtTimeController *tm, char *bitfile);

EDTAPI void edt_sstm_strobe(EdtTimeController *tm, unsigned int bits);

/*
 * Latches the current time into registers
 */

EDTAPI void edt_sstm_latch_time(EdtTimeController *tm);

/*
 * returns the value of seconds
 */

EDTAPI u_int edt_sstm_get_seconds(EdtTimeController *tm);

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

EDTAPI u_int edt_sstm_get_counts(EdtTimeController *tm);

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

EDTAPI u_int edt_sstm_get_usecs(EdtTimeController *tm);

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

EDTAPI void edt_sstm_get_time_parts(EdtTimeController *tm, u_int *seconds, u_int *usecs);

/*
 * Returns time as double
 *
 */

EDTAPI double edt_sstm_timestamp(EdtTimeController *tm);

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

EDTAPI int edt_sstm_get_adjust_enabled(EdtTimeController *tm);

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

EDTAPI int edt_sstm_get_adjust_sign(EdtTimeController *tm);

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

EDTAPI u_int edt_sstm_get_adjust_ticks(EdtTimeController *tm);


/*
 * 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(EdtTimeController *tm, 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(EdtTimeController *tm, 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(EdtTimeController *tm);

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

EDTAPI void edt_sstm_set_to_sys_error(EdtTimeController *tm, int error);

/* 
Turn off rate adjustment
*/

EDTAPI void edt_sstm_disable_adjust(EdtTimeController *tm);

/*
Turn on rate adjustment
*/

EDTAPI void edt_sstm_enable_adjust(EdtTimeController *tm);

/* 
Set the sign bit for rate adjustment 
*/

EDTAPI void edt_sstm_set_adj_sign(EdtTimeController *tm, 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(EdtTimeController *tm, int ticks, int positive);

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


EDTAPI double edt_sstm_sys_error(EdtTimeController *tm);

/*
 *
 * 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(EdtTimeController *tm);

/* 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(EdtTimeController *tm, 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(EdtTimeController *tm);

/*
 * 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(EdtTimeController *tm);
/*
 * Calculate and execute auto adjust
 *
 */

EDTAPI void edt_sstm_iterate_adjust(EdtTimeController *tm);

EDTAPI void
edt_sstm_print_loop(EdtTimeController *tm, int interval, int total_time);

/*
 * 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
 * adjustment_scalar - how many times to do the auto adjust if error exceeds
 *              max_usec_error.
 * 
*/

 
EDTAPI EdtTimeController *
edt_sstm_launch_adjuster(EdtTimeController * tm);


EDTAPI void
edt_sstm_adjuster_stop(EdtTimeController * tm);


EDTAPI void
edt_sstm_adjuster_start(EdtTimeController * tm);

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

EDTAPI void edt_init_time_controller(EdtTimeController *tm,
                                     EdtDev *edt_p,
                                     u_int address_base);


#ifndef WIN32

#define edt_sys_timestamp edt_timestamp

#else

EDTAPI double edt_sys_timestamp();

#endif



#ifdef __cplusplus
}
#endif



#endif

---