pps-client.h

Go to the documentation of this file.

#ifndef PPS_CLIENT_OLD_PPS_CLIENT_H_
#define PPS_CLIENT_OLD_PPS_CLIENT_H_

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/timex.h>
#include <math.h>
#include <sys/types.h>
#include <errno.h>
#include <poll.h>
#include <sys/mman.h>

#define PTHREAD_STACK_REQUIRED 16384        
#define USECS_PER_SEC 1000000
#define SECS_PER_MINUTE 60
#define SECS_PER_5_MIN 300
#define SECS_PER_10_MIN 600
#define SECS_PER_HOUR 3600
#define SECS_PER_DAY 86400
#define NUM_5_MIN_INTERVALS 288         
#define FIVE_MINUTES 5
#define PER_MINUTE (1.0 / (double)SECS_PER_MINUTE)  
#define SETTLE_TIME (2 * SECS_PER_10_MIN)   
#define INV_GAIN_1 1                        
#define INV_GAIN_0 4                        
#define INTEGRAL_GAIN 0.63212           
#define SHOW_INTRPT_DATA_INTVL 6            
#define INV_DELAY_SAMPLES_PER_MIN (1.0 / (double)SECS_PER_MINUTE) 
#define FREQDIFF_INTRVL 5               

#define OFFSETFIFO_LEN 80               
#define NUM_INTEGRALS 10                    
#define PER_NUM_INTEGRALS (1.0 / (double)NUM_INTEGRALS) 

#define ADJTIMEX_SCALE 65536.0          

#define INTERRUPT_LATENCY 6             

#define RAW_ERROR_ZERO  20              
#define MIN_PEAK_RATIO 0.05             
#define MAX_VALLEY_RATIO 0.99           
#define RAW_ERROR_DECAY 0.98851         

#define INTERRUPT_LOST 15               

#define MAX_SERVERS 4                   
#define CHECK_TIME 1024                 
#define BLOCK_FOR_10 10                 
#define BLOCK_FOR_3 3                   
#define CHECK_TIME_SERIAL 600           

#define MAX_SPIKES 30                   

#define NOISE_FACTOR 0.354              
#define NOISE_LEVEL_MIN 4               
#define SLEW_LEN 10                     
#define SLEW_MAX 65                     

#define MAX_LINE_LEN 50
#define STRBUF_SZ 500
#define LOGBUF_SZ 500
#define MSGBUF_SZ 500
#define SNTP_MSG_SZ 200
#define CONFIG_FILE_SZ 10000

#define NUM_PARAMS 5
#define ERROR_DISTRIB_LEN 121
#define JITTER_DISTRIB_LEN 121
#define INTRPT_DISTRIB_LEN 121

#define HARD_LIMIT_NONE 32768
#define HARD_LIMIT_1024 1024
#define HARD_LIMIT_4 4
#define HARD_LIMIT_1 1
#define HARD_LIMIT_05 0.5

#define HIGH 1
#define LOW 0

#define MAX_CONFIGS 32

#define ERROR_DISTRIB 1             // Configuration file Keys
#define ALERT_PPS_LOST 2
#define JITTER_DISTRIB 4
#define CALIBRATE 8
#define INTERRUPT_DISTRIB 16
#define SYSDELAY_DISTRIB 32
#define EXIT_LOST_PPS 64
#define PPS_GPIO 128
#define OUTPUT_GPIO 256
#define INTRPT_GPIO 512
#define SNTP 1024
#define SERIAL 2048
#define SERIAL_PORT 4096

/*
 * Struct for passing arguments to and from threads
 * querying time servers.
 */
struct timeCheckParams {
    pthread_t *tid;                                 
    pthread_attr_t attr;                                
    int serverIndex;                                    
    int *serverTimeDiff;                                
    char **ntp_server;                              
    char *serialPort;                               
    char *buf;                                      
    bool doReadSerial;                              
    char *strbuf;                                   
    char *logbuf;                                   
    bool *threadIsBusy;                             
    int rv;                                         
};                                                  

/*
 * Struct for program-wide global variables.
 */
struct G {
    int ppsGPIO;                                        
    int outputGPIO;                                 
    int intrptGPIO;                                 

    bool isVerbose;                                 

    bool configWasRead;                             

    unsigned int seq_num;                           

    bool isControlling;                             
    unsigned int activeCount;                       

    bool interruptReceived;                         
    bool interruptLost;                             
    int interruptLossCount;                         

    struct timeval t;                               
    int interruptTime;                              

    int tm[6];                                      

    int t_now;                                      
    int t_count;                                        
    double t_mono_now;                              
    double t_mono_last;                             
    double zeroAccum;                               

    int intrptDelay;                                    
    int intrptError;                                    
    unsigned int intrptCount;                       
    double delayMedian;                             
    int sysDelay;                                   

    int rawError;                                   

    int delayShift;                                 
    int sysDelayShift;                              
    int delayPeakLen;                               
    bool disableDelayShift;                         

    int disableDelayCount;                          

    double rawErrorDistrib[ERROR_DISTRIB_LEN];      
    int delayMinIdx;                                    
    unsigned int ppsCount;                          

    int nIntrptDelaySpikes;

    int noiseLevel;                                 
    int nDelaySpikes;                               
    bool isDelaySpike;                              

    double slewAccum;                               
    int slewAccum_cnt;                              
    double avgSlew;                                 
    bool slewIsLow;                                 

    int zeroError;                                  
    int hardLimit;                                  
    int invProportionalGain;                            
    int timeCorrection;                             
    struct timex t3;                                    

    double avgCorrection;                           
    int correctionFifo[OFFSETFIFO_LEN];             
    int correctionFifoCount;                            
    int correctionAccum;                                

    double integral[NUM_INTEGRALS];                 
    double avgIntegral;                             
    int integralCount;                              

    int correctionFifo_idx;                         

    double integralGain;                                
    double integralTimeCorrection;                  
    double freqOffset;                              

    int consensusTimeError;                         

    char linuxVersion[20];                          

    char logbuf[LOGBUF_SZ];
    char msgbuf[MSGBUF_SZ];
    char savebuf[MSGBUF_SZ];
    char strbuf[STRBUF_SZ];
    char *configVals[MAX_CONFIGS];

    bool exit_requested;
    bool exitOnLostPPS;
    bool exit_loop;

    bool doCalibration;
    bool doNTPsettime;

    bool doSerialsettime;
    int blockDetectClockChange;

    int serialTimeError;

    int recIndex;
    int recIndex2;

    time_t pps_t_sec;
    int pps_t_usec;

    unsigned int config_select;

    int intervalCount;

    int jitter;

    int seq_numRec[SECS_PER_10_MIN];

    double lastFreqOffset;
    double freqOffsetSum;
    double freqOffsetDiff[FREQDIFF_INTRVL];

    unsigned int lastActiveCount;

    double intrptErrorDistrib[ERROR_DISTRIB_LEN];       

    int intrptDistrib[NUM_PARAMS][INTRPT_DISTRIB_LEN];
    int delayLabel[NUM_PARAMS];

    int interruptDistrib[INTRPT_DISTRIB_LEN];
    int interruptCount;

    int sysDelayDistrib[INTRPT_DISTRIB_LEN];
    int sysDelayCount;

    int jitterDistrib[JITTER_DISTRIB_LEN];
    int jitterCount;

    int errorDistrib[ERROR_DISTRIB_LEN];
    int errorCount;
    int queryCount;

    double freqAllanDev[NUM_5_MIN_INTERVALS];
    double freqOffsetRec[NUM_5_MIN_INTERVALS];
    double freqOffsetRec2[SECS_PER_10_MIN];
    __time_t timestampRec[NUM_5_MIN_INTERVALS];
    int offsetRec[SECS_PER_10_MIN];
    char serialPort[50];
    char configBuf[CONFIG_FILE_SZ];
};                                                  

int allocNTPServerList(timeCheckParams *);
time_t getServerTime(const char *, int, char *, char *);
int allocInitializeSNTPThreads(timeCheckParams *);
void freeSNTPThreads(timeCheckParams *);
void makeSNTPTimeQuery(timeCheckParams *);
int waitForNTPServers(void);

int allocInitializeSerialThread(timeCheckParams *tcp);
void freeSerialThread(timeCheckParams *tcp);
int makeSerialTimeQuery(timeCheckParams *tcp);

struct saveFileData {
    const char *label;          
    void *array;                    
    const char *filename;       
    int arrayLen;               
    int arrayType;              
    int arrayZero;              
};

int sysCommand(const char *);
void initFileLocalData(void);
void initSerialLocalData(void);
void bufferStatusMsg(const char *);
int writeStatusStrings(void);
bool ppsIsRunning(void);
int writeFileMsgToLog(const char *);
int writeFileMsgToLogbuf(const char *, char *);
void writeToLog(char *);
pid_t getChildPID(void);
int createPIDfile(void);
int readConfigFile(void);
void writeOffsets(void);
void writeTimestamp(double);
void writeSysDelay(void);
int bufferStateParams(void);
int disableNTP(void);
int enableNTP(void);
int open_logerr(const char*, int);
int read_logerr(int fd, char *, int, const char *);
void writeInterruptDistribFile(void);
int processFiles(void);
bool isEnabled(int);
bool isDisabled(int);
void writeSysdelayDistribFile(void);
void showStatusEachSecond(void);
struct timespec setSyncDelay(int, int);
int accessDaemon(int argc, char *argv[]);
int driver_load(int, int, int);
void driver_unload(void);
void buildErrorDistrib(int);
void buildJitterDistrib(int);
void TERMhandler(int);
void HUPhandler(int);
void buildInterruptDistrib(int);
void buildInterruptJitterDistrib(int);
void buildSysDelayDistrib(int);
void recordFrequencyVars(void);
void recordOffsets(int timeCorrection);
bool configHasValue(int, char *[], void *);
int getDriverGPIOvals(void);
void writeToLogNoTimestamp(char *);
int getTimeErrorOverSerial(int *);
#endif /* PPS_CLIENT_OLD_PPS_CLIENT_H_ */