d4/d6a/pps-client_8h_source.html

/*

 * Copyright (C) 2016-2020  Raymond S. Connell

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */


#ifndef PPS_CLIENT_H_

#define 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 <sys/time.h>

#include <math.h>

#include <sys/types.h>

#include <errno.h>

#include <poll.h>

#include <sys/mman.h>

#include "timepps.h"

#include <inttypes.h>


#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 FREQDIFF_INTRVL 5

#define PPS_WINDOW 500

#define PTHREAD_STACK_REQUIRED 16384


#define ZERO_OFFSET_RPI3 8

#define ZERO_OFFSET_RPI4 4


#define OFFSETFIFO_LEN 80

#define NUM_INTEGRALS 10

#define PER_NUM_INTEGRALS (1.0 / (double)NUM_INTEGRALS)


#define ADJTIMEX_SCALE 65536.0


#define RAW_ERROR_ZERO  20

#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 10


#define MAX_SPIKES 60

#define MAX_SPIKE_LEVEL 1000000

#define CLK_CHANGED_LEVEL 1000


#define LARGE_SPIKE 80

#define NOISE_ACCUM_RATE 0.1

#define NOISE_LEVEL_MIN 4

#define SLEW_LEN 10

#define SLEW_MAX 300


#define MAX_LINE_LEN 50

#define STRBUF_SZ 1000

#define LOGBUF_SZ 1000

#define MSGBUF_SZ 1000

#define NIST_MSG_SZ 200

#define CONFIG_FILE_SZ 10000


#define NUM_PARAMS 5

#define ERROR_DISTRIB_LEN 121

#define JITTER_DISTRIB_LEN 181

#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 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 EXIT_LOST_PPS 8

#define PPS_GPIO 16

#define OUTPUT_GPIO 32

#define INTRPT_GPIO 64

#define NIST 128

#define SERIAL 256

#define SERIAL_PORT 512

#define EXECDIR 1024

#define SERVICEDIR 2048

#define CONFIGDIR 4096

#define DOCDIR 8192

#define RUNDIR 16384

#define SHMDIR 32768

#define TSTDIR 65536

#define LOGDIR 131072

#define PPSDELAY 262144

#define MODULEDIR 524288

#define PPSDEVICE 1048576

#define PPSPHASE 2097152

#define PROCDIR 4194304

#define SEGREGATE 8388608


/*

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

    char *gmtTime_file;

    char *nistTime_file;

};


/*

 * Struct for program-wide global variables.

 */

struct G {

    int nCores;

    int useCore;

    int cpuVersion;


    bool isVerbose;


    bool configWasRead;


    unsigned int seq_num;


    int ppsTimestamp;


    bool isControlling;

    unsigned int activeCount;


    bool interruptReceived;

    bool interruptLost;

    int interruptLossCount;


    struct timeval t;


    int tm[6];


    int t_now;

    int t_count;

    double t_mono_now;

    double t_mono_last;


    int zeroOffset;

    double noiseLevel;

    int ppsPhase;


    int rawError;


    double rawErrorDistrib[ERROR_DISTRIB_LEN];

    unsigned int ppsCount;


    int nDelaySpikes;

    bool isDelaySpike;

    int minSustainedDelay;

    bool clockChanged;


    double slewAccum;

    int slewAccum_cnt;

    double avgSlew;

    bool slewIsLow;


    int zeroError;

    int hardLimit;

    bool clampAbsolute;


    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;


    bool doNISTsettime;

    bool nistTimeUpdated;

    int consensusTimeError;


    bool doSerialsettime;

    bool serialTimeUpdated;

    int serialTimeError;


    char linuxVersion[20];


    int startingFromRestore;


    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;


    int blockDetectClockChange;


    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;


    int delayLabel[NUM_PARAMS];


    int interruptDistrib[INTRPT_DISTRIB_LEN];

    int interruptCount;


    int jitterDistrib[JITTER_DISTRIB_LEN];

    int jitterCount;


    int errorDistrib[ERROR_DISTRIB_LEN];

    int errorCount;

    bool queryWait;


    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];

};


time_t getServerTime(const char *, int, char *, char *);

int allocInitializeNISTThreads(timeCheckParams *);

void freeNISTThreads(timeCheckParams *);

void makeNISTTimeQuery(timeCheckParams *);


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;

};


struct ppsFiles {

    char last_distrib_file[100];

    char distrib_file[100];

    char last_jitter_distrib_file[100];

    char jitter_distrib_file[100];

    char log_file[100];

    char old_log_file[100];

    char pidFilename[100];

    char config_file[100];

    char assert_file[100];

    char displayParams_file[100];

    char arrayData_file[100];

    char pps_device[100];

    char module_file[100];

    char pps_msg_file[100];

    char linuxVersion_file[50];

    char gmtTime_file[50];

    char nistTime_file[50];

    char integral_state_file[50];

    char home_file[50];

    char cpuinfo_file[50];

};


struct intPair {

    int val;

    int nVals;

};


class List {


private:

    int ln;

    int size;

    int count;


    void insert(int idx, int val){

        for (int i = ln; i >= idx; i--){

            lst[i+1] = lst[i];

        }

        lst[idx].val = val;

        lst[idx].nVals = 1;

        ln += 1;

    }


public:

    struct intPair *lst;


    void clear(void){

        for (int i = 0; i < size; i++){

            lst[i].val = 0;

            lst[i].nVals = 0;

        }

        ln = 0;

        count = 0;

    }


    List(int sz){

        size = sz;

        lst = new intPair[size];


        clear();

    }


    ~List(){

        delete[] lst;

    }


    int binaryInsert(int val);

    double averageBelow(int maxVal);

};


int sysCommand(const char *);

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 *, const char *);

pid_t getChildPID(void);

int createPIDfile(void);

void writeOffsets(void);

void writeTimestamp(double);

int bufferStateParams(void);

int disableNTP(void);

int enableNTP(void);

int open_logerr(const char*, int, const char *);

int read_logerr(int fd, char *, int, const char *);

void writeInterruptDistribFile(void);

int getConfigs(void);

bool isEnabled(int);

bool isDisabled(int);

void writeSysdelayDistribFile(void);

void showStatusEachSecond(void);

struct timespec setSyncDelay(int, int);

int accessDaemon(int argc, char *argv[]);

void buildErrorDistrib(int);

void buildJitterDistrib(int);

void TERMhandler(int);

void HUPhandler(int);

void buildInterruptJitterDistrib(int);

void recordFrequencyVars(void);

void recordOffsets(int timeCorrection);

void writeToLogNoTimestamp(char *);

int getTimeErrorOverSerial(int *);

int find_source(const char *path, pps_handle_t *handle, int *avail_mode);

int readPPSTimestamp(pps_handle_t *handle, int *avail_mode, int *tm);

void saveGPSTime(timeCheckParams *tcp);

int saveLastState(void);

int loadLastState(void);

int getRootHome(void);

int getRPiCPU(void);

int assignProcessorAffinity(void);

#endif /* PPS_CLIENT_H_ */