pps-client.cpp

Go to the documentation of this file.

#include "../client/pps-client.h"

extern int adjtimex (struct timex *timex);

const char *version = "1.4.0";                          

struct G g;                                             

void setDelayTrackers(void){
    g.noiseLevel = (int)round((double)g.sysDelay * NOISE_FACTOR) + 1;
    if (g.noiseLevel < NOISE_LEVEL_MIN){
        g.noiseLevel = NOISE_LEVEL_MIN;
    }
}

void initialize(bool verbose){
    memset(&g, 0, sizeof(struct G));

    g.isVerbose = verbose;
    g.sysDelay = INTERRUPT_LATENCY;
    g.delayMedian = (double)INTERRUPT_LATENCY;
    g.integralGain = INTEGRAL_GAIN;
    g.invProportionalGain = INV_GAIN_0;
    g.hardLimit = HARD_LIMIT_NONE;
    g.exitOnLostPPS = true;
    g.doCalibration = true;
    g.doNTPsettime = true;

    g.t3.modes = ADJ_FREQUENCY;         // Initialize system clock
    g.t3.freq = 0;                      // frequency offset to zero.
}

bool getAcquireState(void){

    if (! g.slewIsLow && g.slewAccum_cnt == 0
            && fabs(g.avgSlew) < SLEW_MAX){                 // SLEW_MAX only needs to be low enough
        g.slewIsLow = true;                                 // that the controller can begin locking
    }                                                       // at limitValue == HARD_LIMIT_NONE

    return (g.slewIsLow && g.seq_num >= SECS_PER_MINUTE);       // The g.seq_num requirement sets a limit on the
}                                                           // length of time to run the Type 1 controller
                                                            // that initially pushes avgSlew below SLEW_MAX.

void setHardLimit(double avgCorrection){

    double avgMedianMag = fabs(avgCorrection);

    if (g.activeCount < SECS_PER_MINUTE){
        g.hardLimit = HARD_LIMIT_NONE;
        return;
    }

    if (abs(g.avgSlew) > SLEW_MAX){                         // As long as average time slew is
        int d_4 = abs(g.avgSlew) * 4;                       // outside of range SLEW_MAX this keeps
        while (g.hardLimit < d_4                                // g.hardLimit above 4 * g.avgSlew
                && g.hardLimit < HARD_LIMIT_NONE){          // which is high enough to allow the
            g.hardLimit = g.hardLimit << 1;                 // controller to pull avgSlew within
        }                                                   // SLEW_MAX.
        return;
    }

    if (g.hardLimit == HARD_LIMIT_1){
        if (avgMedianMag > HARD_LIMIT_05){
            g.hardLimit = g.hardLimit << 1;
        }
    }
    else if (avgMedianMag < HARD_LIMIT_05){
        g.hardLimit = HARD_LIMIT_1;
    }
    else if (avgMedianMag < (g.hardLimit >> 2)){                // If avgCorrection is below 1/4 of limitValue
        g.hardLimit = g.hardLimit >> 1;                     // then halve limitValue.
    }
    else if (avgMedianMag > (g.hardLimit >> 1)){                // If avgCorrection is above 1/2 of limitValue
        g.hardLimit = g.hardLimit << 1;                     // then double limitValue.

        if (g.hardLimit > HARD_LIMIT_NONE){
            g.hardLimit = HARD_LIMIT_NONE;
        }
    }
}

bool detectDelaySpike(int rawError){
    bool isDelaySpike = false;

    if (g.hardLimit <= HARD_LIMIT_4 && rawError >= g.noiseLevel){

        if (g.nDelaySpikes < MAX_SPIKES) {
            g.nDelaySpikes += 1;                        // Record unbroken sequence of delay spikes

            isDelaySpike = true;
        }
        else {                                      // If nDelaySpikes == MAX_SPIKES stop the
            isDelaySpike = false;                   // suspend even if spikes continue.
        }
    }
    else {
        isDelaySpike = false;

        if (g.nDelaySpikes > 0){
            g.nDelaySpikes = 0;
        }
    }
    return isDelaySpike;
}

void getTimeSlew(int rawError){

    g.slewAccum += (double)rawError;

    g.slewAccum_cnt += 1;
    if (g.slewAccum_cnt >= SLEW_LEN){
        g.slewAccum_cnt = 0;

        g.avgSlew = g.slewAccum / (double)SLEW_LEN;

        g.slewAccum = 0.0;
    }
}

int clampJitter(int rawError){

    int zeroError = rawError;

    if (rawError > g.hardLimit){
        zeroError = g.hardLimit;
    }
    else if (rawError < -g.hardLimit){
        zeroError = -g.hardLimit;
    }

    return zeroError;
}

void makeAverageIntegral(double avgCorrection){

    int indexOffset = SECS_PER_MINUTE - NUM_INTEGRALS;

    if (g.correctionFifo_idx >= indexOffset){                   // Over the last NUM_INTEGRALS seconds in each minute

        int i = g.correctionFifo_idx - indexOffset;
        if (i == 0){
            g.avgIntegral = 0.0;
            g.integralCount = 0;
        }

        g.integral[i] = g.integral[i] + avgCorrection;          // avgCorrection sums into g.integral[i] once each
                                                                // minute forming the ith integral over the last minute.
        if (g.hardLimit == HARD_LIMIT_1){
            g.avgIntegral += g.integral[i];                     // Accumulate each integral that is being formed
            g.integralCount += 1;                               // into g.avgIntegral for averaging.
        }
    }

    if (g.correctionFifo_idx == SECS_PER_MINUTE - 1             // just before the minute rolls over.
            && g.integralCount == NUM_INTEGRALS){

        g.avgIntegral *= PER_NUM_INTEGRALS;                     // Normalize g.avgIntegral.
    }
}

bool integralIsReady(void){
    bool isReady = false;

    if (g.correctionFifo_idx == 0){
        setDelayTrackers();
        isReady = true;
    }

    g.correctionFifo_idx += 1;
    if (g.correctionFifo_idx >= SECS_PER_MINUTE){
        g.correctionFifo_idx = 0;
    }

    return isReady;
}

double getAverageCorrection(int timeCorrection){

    double avgCorrection;

    if (g.seq_num > SETTLE_TIME && (g.config_select & ERROR_DISTRIB)){
        buildErrorDistrib(timeCorrection);
    }

    g.correctionAccum += timeCorrection;                // Add the new timeCorrection into the error accumulator.

    if (g.correctionFifoCount == SECS_PER_MINUTE){  // Once the FIFO is full, maintain the continuous
                                                    // rolling sum accumulator by subtracting the
        int oldError = g.correctionFifo[g.correctionFifo_idx];
        g.correctionAccum -= oldError;              // old timeCorrection value at the current correctionFifo_idx.
    }

    g.correctionFifo[g.correctionFifo_idx] = timeCorrection;    // and replacing the old value in the FIFO with the new.

    if (g.correctionFifoCount < SECS_PER_MINUTE){   // When correctionFifoCount == SECS_PER_MINUTE
        g.correctionFifoCount += 1;                 // the FIFO is full and ready to use.
    }

    avgCorrection = g.correctionAccum * PER_MINUTE;
    return avgCorrection;
}

int setClockToNTPtime(int pps_fd){

    sprintf(g.logbuf, "seq_num: %d consensusTimeError: %d\n", g.seq_num, g.consensusTimeError);
    writeToLog(g.logbuf);

    int msg[2];
    msg[0] = 3;
    msg[1] = g.consensusTimeError;
    int rv = write(pps_fd, msg, 2 * sizeof(int));
    if (rv == -1){
        sprintf(g.logbuf, "setClockToNTPtime() write to driver failed with msg: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    g.consensusTimeError = 0;
    return 0;
}

int setClockToSerialTime(int pps_fd){
    sprintf(g.logbuf, "setClockToSerialTime() Corrected time by %d seconds\n", g.serialTimeError);
    writeToLog(g.logbuf);

    int msg[2];
    msg[0] = 3;
    msg[1] = g.serialTimeError;
    int rv = write(pps_fd, msg, 2 * sizeof(int));
    if (rv == -1){
        sprintf(g.logbuf, "setClockToSerialTime() write to driver failed with msg: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    g.t_count += g.serialTimeError;
    g.serialTimeError = 0;

    return 0;
}

int setClockFractionalSecond(int correction, int pps_fd){

    sprintf(g.logbuf, "setClockFractionalSecond() Made correction: %d\n", correction);
    writeToLog(g.logbuf);

    int msg[2];
    msg[0] = 2;
    msg[1] = correction;                        // Make a correction equal and opposite to the fractional
                                            // second that was set externally in order to cancel it.
    int rv = write(pps_fd, msg, 2 * sizeof(int));
    if (rv == -1){
        sprintf(g.logbuf, "setClockFractionalSecond() write to driver failed with msg: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }
    return 0;
}

void buildRawErrorDistrib(int rawError, double errorDistrib[], unsigned int *count){
    int len = ERROR_DISTRIB_LEN - 1;

    int idx = rawError + RAW_ERROR_ZERO;
    if (idx > len){
        idx = len;
    }
    else if (idx < 0){
        idx = 0;
    }

    if (g.hardLimit == HARD_LIMIT_1){

        if (*count > 600 && *count % 60 == 0){                      // About once a minute

            for (int i = 0; i < len; i++){                          // Scale errorDistrib to allow older
                errorDistrib[i] *= RAW_ERROR_DECAY;                 // values to decay (halflife 1 hour).
            }
        }
        errorDistrib[idx] += 1.0;
    }

    *count += 1;
}

int removeNoise(int rawError){

    int zeroError;

    buildRawErrorDistrib(rawError, g.rawErrorDistrib, &(g.ppsCount));

    g.sysDelayShift = 0;

    g.jitter = rawError;

    if ((g.config_select & JITTER_DISTRIB) && g.seq_num > SETTLE_TIME){
        buildJitterDistrib(rawError);
    }

    g.isDelaySpike = detectDelaySpike(rawError);        // g.isDelaySpike == true will prevent time and
                                                    // frequency updates during a delay spike.
    if (g.isDelaySpike){
        return 0;
    }

    getTimeSlew(rawError);

    setHardLimit(g.avgCorrection);
    zeroError = clampJitter(rawError);              // Recover the time error by
                                                    // limiting away the jitter.
    if (g.isControlling){
        g.invProportionalGain = INV_GAIN_1;
    }
    return zeroError;
}

double getIntegral(void){
    double integral;

    if (g.hardLimit == HARD_LIMIT_1
            && g.integralCount == NUM_INTEGRALS){
        integral = g.avgIntegral;                   // Use average of last 10 integrals
    }                                               // in the last minute.
    else {
        integral = g.integral[9];                   // Use only the last integral from
                                                    // the last minute
    }

    recordFrequencyVars();

    return integral;
}

void getPPStime(timeval t, int timeCorrection){
    g.pps_t_sec = t.tv_sec;
    g.pps_t_usec = -timeCorrection;
    if (timeCorrection > 0){
        g.pps_t_sec -= 1;
        g.pps_t_usec = 1000000 - timeCorrection;
    }

    double timestamp = t.tv_sec - 1e-6 * (double)timeCorrection;
    writeTimestamp(timestamp);
}

int getFractionalSeconds(timeval pps_t){
    int interruptTime = pps_t.tv_usec;

    if (interruptTime > 500000){
        interruptTime -= USECS_PER_SEC;
    }
    return interruptTime;
}

void increaseMonotonicCount(void){
    struct timespec t_mono;
    struct timeval t_now;

    clock_gettime(CLOCK_MONOTONIC, &t_mono);
    g.t_mono_now = (double)t_mono.tv_sec + 1e-9 * (double)t_mono.tv_nsec;

    if (g.seq_num < 2){                         // Initialize g.t_mono_last
        g.t_mono_last = g.t_mono_now - 1;
    }

    gettimeofday(&t_now, NULL);
    g.t_now = (int)t_now.tv_sec;

    if (g.seq_num == 0){                            // Initialize g.t_count
        g.t_count = g.t_now;
    }

    double diff = g.t_mono_now - g.t_mono_last;
    int iDiff = round(diff);

    if (iDiff != 1){
        sprintf(g.logbuf, "increaseMonotonicCount() lost a cycle. diff: %lf\n", diff);
        writeToLog(g.logbuf);
    }

    g.t_count += iDiff;                         // Advance the counter
    g.t_mono_last = g.t_mono_now;               // Set value of g.t_mono_last to be used next

    if (g.blockDetectClockChange > 0){
        g.blockDetectClockChange -= 1;
    }
}


bool isNearZero(double val){
    double accFrac = 0.9;
    g.zeroAccum = accFrac * g.zeroAccum + (1.0 - accFrac) * val;

    if (g.hardLimit == HARD_LIMIT_1 && fabs(g.zeroAccum) < 0.05){       // NEAR_ZERO
        return true;
    }
    return false;
}


bool detectExteralSystemClockChange(void){
    bool clockChanged = false;

    if (isNearZero(g.avgCorrection)) {

        if (g.t_now != g.t_count){

            sprintf(g.logbuf, "detectExteralSystemClockChange() Got error g.t_now: %d g.t_count: %d\n", g.t_now, g.t_count);
            writeToLog(g.logbuf);

            clockChanged = true;                // The clock was set externally.
            g.t_count = g.t_now;                    // Update the seconds counter.
        }
    }
    return clockChanged;
}

int makeTimeCorrection(struct timeval pps_t, int pps_fd){
    int rv = 0;
    g.interruptReceived = true;

    if (g.doNTPsettime && g.consensusTimeError != 0){       // When an NTP time correction is needed
        rv = setClockToNTPtime(pps_fd);                 // apply it here.
        if (rv == -1){
            return rv;
        }
    }

    if (g.doSerialsettime && g.serialTimeError != 0){
        rv = setClockToSerialTime(pps_fd);
        if (rv == -1){
            return rv;
        }
    }

    if (g.blockDetectClockChange == 0 &&
            detectExteralSystemClockChange()){              // If the time was changed by an external clock setting,
        int correction = -getFractionalSeconds(pps_t);      // this cancels the change that may have
        rv = setClockFractionalSecond(correction, pps_fd);  // been made to the fractional second.
        if (rv == -1){
            return rv;
        }
        pps_t.tv_usec = g.sysDelay;                         // Temporarily zero the time correction.
    }

    g.seq_num += 1;

    g.interruptTime = getFractionalSeconds(pps_t);
    g.rawError = g.interruptTime - g.sysDelay;          // References the controller to g.sysDelay which sets the time
                                                        // of the PPS rising edge to zero at the start of each second.
    g.zeroError = removeNoise(g.rawError);

    if (g.isDelaySpike){                                    // Skip a delay spike.
        getPPStime(pps_t, 0);
        return 0;
    }

    g.timeCorrection = -g.zeroError
            / g.invProportionalGain;                        // Apply controller proportional gain factor.

    g.t3.modes = ADJ_OFFSET_SINGLESHOT;                 // Adjust the time slew. adjtimex() limits the maximum
    g.t3.offset = g.timeCorrection;                     // correction to about 500 microseconds each second so
                                                        // it can take up to 20 minutes to start pps-client.
    adjtimex(&g.t3);

    g.isControlling = getAcquireState();                    // Provides enough time to reduce time slew on startup.
    if (g.isControlling){

        g.avgCorrection = getAverageCorrection(g.timeCorrection);

        makeAverageIntegral(g.avgCorrection);           // Constructs an average of integrals of one
                                                        // minute rolling averages of time corrections.
        if (integralIsReady()){                         // Get a new frequency offset.
            g.integralTimeCorrection = getIntegral();
            g.freqOffset = g.integralTimeCorrection * g.integralGain;

            g.t3.modes = ADJ_FREQUENCY;
            g.t3.freq = (long)round(ADJTIMEX_SCALE * g.freqOffset);
            adjtimex(&g.t3);                                // Adjust the system clock frequency.
        }

        recordOffsets(g.timeCorrection);

        g.activeCount += 1;
        writeSysDelay();
    }
    else {
        g.t_count = g.t_now;                                // Unless g.isControlling let g.t_count copy pps_t.tv_sec.
    }                                                   // If g.isControlling then g.t_count is an independent counter.

    getPPStime(pps_t, g.timeCorrection);
    return 0;
}

int checkPPSInterrupt(int pps_fd){
    int rv = 0;
    int output;

    if (g.seq_num > 0 && g.exit_requested == false){
        if (g.interruptReceived == false){
            g.interruptLossCount += 1;

            if (g.interruptLossCount == INTERRUPT_LOST){
                sprintf(g.logbuf, "WARNING: PPS interrupt lost\n");
                writeToLog(g.logbuf);

                if (g.config_select & ALERT_PPS_LOST){
                    output = HIGH;
                    rv = write(pps_fd, &output, sizeof(int));
                    if (rv == -1){
                        sprintf(g.logbuf, "checkPPSInterrupt() write to driver failed with msg: %s\n", strerror(errno));
                        writeToLog(g.logbuf);
                        return rv;
                    }
                }
            }
            if (g.exitOnLostPPS &&  g.interruptLossCount >= SECS_PER_HOUR){
                sprintf(g.logbuf, "ERROR: Lost PPS for one hour.");
                writeToLog(g.logbuf);
                return -1;
            }
        }
        else {
            if (g.interruptLossCount >= INTERRUPT_LOST){
                sprintf(g.logbuf, "PPS interrupt resumed\n");
                writeToLog(g.logbuf);

                if (g.config_select & ALERT_PPS_LOST){
                    output = LOW;
                    rv = write(pps_fd, &output, sizeof(int));
                    if (rv == -1){
                        sprintf(g.logbuf, "checkPPSInterrupt() write to driver failed with msg: %s\n", strerror(errno));
                        writeToLog(g.logbuf);
                        return -1;
                    }
                }
            }
            g.interruptLossCount = 0;
        }
    }

    g.interruptReceived = false;

    return 0;
}

bool detectIntrptDelaySpike(int intrptError){
    bool isDelaySpike = false;

    if (g.hardLimit <= HARD_LIMIT_4 && intrptError >= g.noiseLevel){
        if (g.nIntrptDelaySpikes < MAX_SPIKES) {
            g.nIntrptDelaySpikes += 1;              // Record unbroken sequence of delay spikes

            isDelaySpike = true;
        }
        else {                                      // If nIntrptDelaySpikes == MAX_SPIKES stop the
            isDelaySpike = false;                   // suspend even if spikes continue.
        }
    }
    else {
        isDelaySpike = false;

        if (g.nIntrptDelaySpikes > 0){
            g.nIntrptDelaySpikes = 0;
        }
    }
    return isDelaySpike;
}

int removeIntrptNoise(int intrptError){

    int zeroError;

    buildRawErrorDistrib(intrptError, g.intrptErrorDistrib, &(g.intrptCount));

    bool isDelaySpike = detectIntrptDelaySpike(intrptError);
    if (isDelaySpike){
        return 0;
    }

    zeroError = clampJitter(intrptError);                   // Recover the time error by
                                                            // limiting away the jitter.
    return zeroError;
}

struct timespec setSyncDelay(int timeAt, int fracSec){

    struct timespec ts2;

    int timerVal = USECS_PER_SEC + timeAt - fracSec;

    if (timerVal >= USECS_PER_SEC){
        ts2.tv_sec = 1;
        ts2.tv_nsec = (timerVal - USECS_PER_SEC) * 1000;
    }
    else if (timerVal < 0){
        ts2.tv_sec = 0;
        ts2.tv_nsec = (USECS_PER_SEC + timerVal) * 1000;
    }
    else {
        ts2.tv_sec = 0;
        ts2.tv_nsec = timerVal * 1000;
    }

    return ts2;
}

int getInterruptDelay(int pps_fd){
    ssize_t rv;

    int out = 1;
    rv = write(pps_fd, &out, sizeof(int));                  // Set the output pin to generate an interrupt
    if (rv == -1){                                          // and disable reads of the PPS interrupt.
        sprintf(g.logbuf, "getInterruptDelay() write to driver failed with msg: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    rv = read(pps_fd, (void *)g.tm, 6 * sizeof(int));           // Read the interrupt write and response times.
    if (rv > 0){

        g.intrptDelay = g.tm[5] - g.tm[3];

        g.intrptError = g.intrptDelay - g.sysDelay;

        if (g.seq_num > SETTLE_TIME && (g.config_select & INTERRUPT_DISTRIB)){
            buildInterruptDistrib(g.intrptDelay);
        }

        int zeroError = removeIntrptNoise(g.intrptError);

        g.delayMedian += (double)zeroError * INV_DELAY_SAMPLES_PER_MIN;
        g.sysDelay = (int)round(g.delayMedian);

        if (g.activeCount > SETTLE_TIME && g.hardLimit == HARD_LIMIT_1 && (g.config_select & SYSDELAY_DISTRIB)){
            buildSysDelayDistrib(g.sysDelay);
        }

        if (g.activeCount % SHOW_INTRPT_DATA_INTVL == 0 && g.activeCount != g.lastActiveCount){
            g.lastActiveCount = g.activeCount;

            sprintf(g.msgbuf, "Interrupt delay: %d usec, Delay median: %lf usec  sysDelay: %d usec\n",
                    g.intrptDelay, g.delayMedian, g.sysDelay);
            bufferStatusMsg(g.msgbuf);
        }
    }
    else {
        sprintf(g.logbuf, "getInterruptDelay() Device driver read returned: %d Error: %s\n", rv, strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    out = 0;
    rv = write(pps_fd, &out, sizeof(int));      // Reset the output pin and resume PPS interrupt reads.
    if (rv == -1){
        sprintf(g.logbuf, "getInterruptDelay() write to driver failed with msg: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    return 0;
}

int readPPS_SetTime(bool verbose, int pps_fd){
    int restart = 0;

    ssize_t rv = read(pps_fd, (void *)g.tm, 2 * sizeof(int));

    increaseMonotonicCount();

    g.interruptLost = false;
    if (rv <= 0){
        if (rv == 0 && ! g.exit_requested){
            time_t t = time(NULL);
            struct tm *tmp = localtime(&t);
            strftime(g.strbuf, STRBUF_SZ, "%F %H:%M:%S ", tmp);
            strcat(g.strbuf, "Read PPS interrupt failed\n");
            bufferStatusMsg(g.strbuf);
        }
        else {
            sprintf(g.logbuf, "gps-pps-io PPS read() returned: %d Error: %s\n", rv, strerror(errno));
            writeToLog(g.logbuf);
        }
        g.interruptLost = true;
    }
    else {
        g.t.tv_sec = g.tm[0];                   // Seconds value read by gps-pps-io driver from system clock
                                                // at rising edge of PPS signal.
        g.t.tv_usec = g.tm[1];                  // Fractional seconds read from clock at rising edge of PPS signal.

        if (makeTimeCorrection(g.t, pps_fd) == -1)
            return -1;

        if ((! g.isControlling && g.seq_num >= SECS_PER_MINUTE)     // If time slew on startup is too large
                || (g.isControlling && g.hardLimit > HARD_LIMIT_1024    // or if g.avgSlew becomes too large
                && abs(g.avgSlew) > SLEW_MAX)){                     // after acquiring

            sprintf(g.logbuf, "pps-client is restarting...\n");
            writeToLog(g.logbuf);

            initialize(verbose);                    // then restart the controller.
            adjtimex(&g.t3);
            setDelayTrackers();

            restart = 1;
        }
    }
    return restart;
}

//void reportLeak(const char *msg){
//  sprintf(g.logbuf, msg);
//  writeToLog(g.logbuf);
//}

//void testForArrayLeaks(void){
//  if (g.seq_num % SECS_PER_10_MIN == 0){
//      for (int i = 0; i < 100; i++){
//          if (g.pad1[i] != 0){
//              reportLeak("Leak in g.pad1 .................................\n");
//          }
//
//          if (g.pad2[i] != 0){
//              reportLeak("Leak in g.pad2 .................................\n");
//          }
//
//      }
//  }
//}

void waitForPPS(bool verbose, int pps_fd){
    struct timeval tv1;
    struct timespec ts2;
    int timePPS;
    int rv;
    timeCheckParams tcp;
    int restart = 0;

    adjtimex(&g.t3);
    setDelayTrackers();

    initFileLocalData();

    if (g.doNTPsettime){
        rv = allocInitializeSNTPThreads(&tcp);
        if (rv == -1){
            goto end;
        }
    }
    if (g.doSerialsettime){
        char cmd[80];
        strcpy(cmd, "stty -F ");

        printf("g.serialPort: %s\n", g.serialPort);

        strcat(cmd, g.serialPort);
        strcat(cmd, " raw 9600 cs8 clocal -cstopb");
        rv = sysCommand(cmd);
        if (rv == -1){
            return;
        }
        allocInitializeSerialThread(&tcp);
    }


    signal(SIGHUP, HUPhandler);         // Handler used to ignore SIGHUP.
    signal(SIGTERM, TERMhandler);       // Handler for the termination signal.

    sprintf(g.logbuf, "PPS-Client v%s is starting ...\n", version);
    writeToLog(g.logbuf);
                                        // Set up a one-second delay loop that stays in synch by
    timePPS = -150;                         // continuously re-timing to before the roll-over of the second.
                                        // This allows for a delay of about 50 microseconds coming out
                                        // of sleep plus interrupt latencies up to 100 microseconds.
    gettimeofday(&tv1, NULL);
    ts2 = setSyncDelay(timePPS, tv1.tv_usec);

    writeStatusStrings();

    for (;;){                           // Delay loop
        if (g.exit_requested){
            sprintf(g.logbuf, "PPS-Client stopped.\n");
            writeToLog(g.logbuf);
            break;
        }

        nanosleep(&ts2, NULL);          // Sleep until ready to look for PPS interrupt

        restart = readPPS_SetTime(verbose, pps_fd);
        if (restart == -1){
            break;
        }
        if (restart == 1) {
            readConfigFile();
        }
        else{
            if (checkPPSInterrupt(pps_fd) != 0){
                sprintf(g.logbuf, "Lost PPS or system error. pps-client is exiting.\n");
                writeToLog(g.logbuf);
                break;
            }

            if (bufferStateParams() == -1){
                break;
            }

            if (g.doNTPsettime){
                g.blockDetectClockChange = BLOCK_FOR_10;        // Prevent interaction with detectExteralSystemClockChange()
                makeSNTPTimeQuery(&tcp);
            }

            if (g.doSerialsettime){
                rv = makeSerialTimeQuery(&tcp);
                if (rv == -1){
                    break;
                }
            }

            writeStatusStrings();

            if (! g.interruptLost && ! g.isDelaySpike){
                if (g.doCalibration && g.hardLimit == HARD_LIMIT_1){
                    rv = getInterruptDelay(pps_fd);
                    if (rv == -1){
                        break;
                    }
                }

                processFiles();
            }
        }

        gettimeofday(&tv1, NULL);

        ts2 = setSyncDelay(timePPS, tv1.tv_usec);
    }
end:
    if (g.doNTPsettime){
        freeSNTPThreads(&tcp);
    }
    if (g.doSerialsettime){
        freeSerialThread(&tcp);
    }
    return;
}

int main(int argc, char *argv[])
{
    int rv = 0;
    int ppid, pps_fd;
    bool verbose = false;

    if (argc > 1){
        if (strcmp(argv[1], "-v") == 0){
            verbose = true;
        }
    }

    int prStat = accessDaemon(argc, argv);              // Send commands to the daemon.
    if (prStat == 0 || prStat == -2){                   // Program is running or an error occurred.
        return rv;
    }

    if (geteuid() != 0){                                    // Superuser only!
        printf("pps-client is not running. \"sudo pps-client\" to start.\n");
        return rv;
    }

    pid_t pid = fork();                                 // Fork a duplicate child of this process.

    if (pid > 0){                                       // This is the parent process.
        bufferStatusMsg("Spawning pps-client daemon.\n");
        return rv;                                      // Return from the parent process and leave
    }                                                   // the child running.

    if (pid == -1){                                     // Error: unable to fork a child from parent,
        sprintf(g.logbuf, "Fork in main() failed: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return pid;
    }
                        // pid == 0 for the child process which now will run this code as a daemon

    struct sched_param param;                           // Process must be run as root
    mlockall(MCL_CURRENT | MCL_FUTURE);

    initialize(verbose);
    rv = processFiles();
    if (rv == -1){
        goto end0;
    }

    rv = disableNTP();                                  // Always disable NTP, to prevent it from disciolining the clock.
    if (g.doNTPsettime && rv != 0){                     // But disableNTP() warns if it fails.
        goto end0;
    }

    param.sched_priority = 99;                          // to get real-time priority.
    sched_setscheduler(0, SCHED_FIFO, &param);          // SCHED_FIFO: Don't yield to scheduler until sleep.

    if(getDriverGPIOvals() == -1){
        sprintf(g.logbuf, "Could not get GPIO vals for driver. Exiting.\n");
        fprintf(stderr, "%s", g.logbuf);
        writeToLog(g.logbuf);
        goto end0;
    }

    if (driver_load(g.ppsGPIO, g.outputGPIO, g.intrptGPIO) == -1){
        sprintf(g.logbuf, "Could not load PPS-Client driver. Exiting.\n");
        fprintf(stderr, "%s", g.logbuf);
        writeToLog(g.logbuf);
        rv = -1;
        goto end0;
    }

    ppid = createPIDfile();                             // Create the PID file for this process.
    if (ppid == -1){                                        // Either already running or could not
        rv = -1;                                            // create a pid file. In either case, exit.
        goto end1;
    }

    pps_fd = open_logerr("/dev/gps-pps-io", O_RDWR);        // Open the gps-pps-io device driver.
    if (pps_fd == -1){
        rv = -1;
        goto end2;
    }

    sprintf(g.msgbuf, "Process PID: %d\n", ppid);       // PPS client is starting.
    bufferStatusMsg(g.msgbuf);

    waitForPPS(verbose, pps_fd);                            // Synchronize to the PPS.

    close(pps_fd);                                      // Close the interrupt device driver.

    sprintf(g.logbuf, "PPS-Client closed driver\n");
    writeToLog(g.logbuf);

end2:
    sysCommand("rm /var/run/pps-client.pid");           // Remove PID file with system() which blocks until
                                                        // rm completes keeping shutdown correctly sequenced.
    end1:
    enableNTP();                                            // Always try to re-enable NTP on shutdown.

    driver_unload();                                        // Driver will not be unloaded until a timeout occurs to
                                                        // prevent driver from being unloaded before being closed
    sprintf(g.logbuf, "PPS-Client unloaded driver.\n"); // by OS.
    writeToLog(g.logbuf);
end0:
    return rv;
}