pps-serial.cpp

Go to the documentation of this file.

#include "../client/pps-client.h"
extern struct G g;

static struct serialLocalVars {
    int serverTimeDiff[1];
    bool threadIsBusy[1];
    pthread_t tid[1];
    int timeCheckEnable;
    bool allServersQueried;
    unsigned int lastServerUpdate;


    char *serialPort;
    int lostGPSCount;
    bool doReadSerial;
    int lastSerialTimeDif;
} f;

bool getUTCfromGPSmessages(const char *msgbuf, timeCheckParams *tcp, time_t *gmtSeconds){

    char scnbuf[10];
    memset(scnbuf, 0, 10);

    struct tm gmt;
    memset(&gmt, 0, sizeof(struct tm));

    char *active, *ctmp2, *ctmp4;

    active = scnbuf;
    ctmp2 = active + 2;
    ctmp4 = ctmp2 + 2;

    float ftmp1, ftmp3, ftmp5, ftmp6;
    int frac;

    char *pstr = strstr((char *)msgbuf, "$GPRMC");  // $GPRMC,205950.000,A,3614.5277,N,08051.3851,W,0.02,288.47,051217, ,,D*75
    if (pstr != NULL){                              // If a GPRMC message was received, continue.
        char *end = pstr + 64;
        char *pNext = strstr(pstr + 10, "$");       // Verify this is a complete message by looking for next message start symbol
        if (pNext != NULL){                         // If the message is complete, continue.
            *end = '\0';
            sscanf(pstr, "$GPRMC,%2d%2d%2d.%d,%1c,%f,%1c,%f,%1c,%f,%f,%2d%2d%2d,", &gmt.tm_hour, &gmt.tm_min, &gmt.tm_sec,
                    &frac, active, &ftmp1, ctmp2, &ftmp3, ctmp4, &ftmp5, &ftmp6, &gmt.tm_mday, &gmt.tm_mon, &gmt.tm_year);

            if (active[0] == 'A'){                  // Verify this is an active message
                gmt.tm_mon -= 1;                        // Convert to tm struct format with months: 0 to 11
                gmt.tm_year += 100;                 // Convert to tm struct format with year since 1900
                *gmtSeconds =  mktime(&gmt);            // True UTC seconds

                f.lostGPSCount = 0;
            }
            else {
                sprintf(tcp->strbuf, "getUTCfromGPSmessages() A GPS message was received but it is not active.\n");
                writeToLog(tcp->strbuf);

                if (f.lostGPSCount == 0) {
                    f.lostGPSCount = 1;
                }
                else {
                    f.lostGPSCount += 1;
                    if (f.lostGPSCount == 5){
                        sprintf(tcp->strbuf, "getUTCfromGPSmessages() Unable to connect to GPS. Will retry in %d minutes.\n", CHECK_TIME_SERIAL / 60);
                        writeToLog(tcp->strbuf);

                        f.lostGPSCount = 0;
                        tcp->doReadSerial = false;
                    }
                }
            }
        }
        else {                                      // Did not get a usable GPRMC message
            return false;
        }
    }
    else {                                          // Did not get GPRMC message
        return false;
    }
    return true;
}

int waitForGPSmessages(char *msgbuf, timeCheckParams *tcp, struct timeval *t_gmt, time_t *gmtSeconds){

    int rfd = open(tcp->serialPort, O_RDONLY);
    if (rfd == -1){
        sprintf(tcp->strbuf, "waitForGPSmessages() Unable to open %s\n", tcp->serialPort);
        writeToLog(tcp->strbuf);
        close(rfd);
        return -1;
    }
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(rfd, &rfds);

    struct timeval wait;
    wait.tv_sec = 1;
    wait.tv_usec = 0;
                                // select blocks until the serial port starts receiving GPS messages.

    int rv = select(rfd + 1, &rfds, NULL, NULL, &wait);
    if (rv == -1){
        sprintf(tcp->strbuf,"waitForGPSmessages() select failed with error %s.\n", strerror(errno));
        writeToLog(tcp->strbuf);
        close(rfd);
        return -1;
    }
    if (rv == 0){
        sprintf(tcp->strbuf,"waitForGPSmessages() No messages were available within one second.\n");
        writeToLog(tcp->strbuf);
        close(rfd);
        return 0;
    }
                            // Serial port starts buffering GPS messages here

    time_t clkSeconds = time(0);                        // Get local time in seconds
    struct tm *gmt = gmtime(&clkSeconds);           // Get a tm struct for UTC according to system clock
    *gmtSeconds = mktime(gmt);                      // Get UTC seconds according to system clock

    gettimeofday(t_gmt, NULL);                      // Time at start of buffering GPS messages.

    struct timespec slp;
    slp.tv_sec = 0;
    slp.tv_nsec = 250000000;                            // ~250 chars

    nanosleep(&slp, NULL);                          // Sleep long enough to get ~250 chars at 9600 baud ~ 1 char per msec.

                            // Read the buffered serial port messages here

    int nchars = read(rfd, msgbuf, 250);
    if (nchars == -1){
        sprintf(tcp->strbuf,"waitForGPSmessages() read on serial port received empty buffer.\n");
        writeToLog(tcp->strbuf);
        close(rfd);
        return 0;
    }

    close(rfd);
    return 1;
}

//void writeTimeToLog(char *strbuf, struct timeval t_gmt, struct timeval t_gmt0, struct timeval t_rdy){
//  writeToLog(strbuf);
//  sprintf(strbuf, "  t_gmt.tv_sec: %d t_gmt.tv_usec: %d\n", (int)t_gmt.tv_sec, (int)t_gmt.tv_usec);
//  writeToLog(strbuf);
//  sprintf(strbuf, "  t_gmt0.tv_sec: %d t_gmt0.tv_usec: %d\n", (int)t_gmt0.tv_sec, (int)t_gmt0.tv_usec);
//  writeToLog(strbuf);
//  sprintf(strbuf, "  t_rdy.tv_sec: %d t_rdy.tv_usec: %d\n", (int)t_rdy.tv_sec, (int)t_rdy.tv_usec);
//  writeToLog(strbuf);
//}

int getTimeOffsetOverSerial(int *timeDif, timeCheckParams *tcp){

    time_t difSeconds = 0, gmt0Seconds = 0, gmtSeconds;

    char msgbuf[300];
    memset(msgbuf, 0, 300 * sizeof(char));

    struct timeval t_gmt, t_rdy;

    int rv = waitForGPSmessages(msgbuf, tcp, &t_gmt, &gmtSeconds);
    if (rv == 0 || rv == -1){
        return rv;
    }

    if (!getUTCfromGPSmessages(msgbuf, tcp, &gmt0Seconds)){
        return 0;
    }

    gettimeofday(&t_rdy, NULL);                 // Time at completion of UTC time extraction

    bool finishedInSameSecond = (t_gmt.tv_sec == t_rdy.tv_sec);
    if (finishedInSameSecond){
        difSeconds = gmt0Seconds - gmtSeconds;
        *timeDif = (int)difSeconds;
        return 1;
    }
    else {
        sprintf(tcp->strbuf, "getTimeOffsetOverSerial() Discarded the data. Took over 1 second. OS latency!\n");
        writeToLog(tcp->strbuf);
        return 0;
    }
}

void doSerialTimeCheck(timeCheckParams *tcp){

    tcp->threadIsBusy[0] = true;
    int timeDif = 0;

    int isValidDif = getTimeOffsetOverSerial(&timeDif, tcp);
    if (isValidDif > 0){
        if (timeDif == 0){                              // No time difference
            if (f.lastSerialTimeDif != 0){
                sprintf(tcp->strbuf, "doSerialTimeCheck() No timeDif on second read. First read was GPS error.\n");
                writeToLog(tcp->strbuf);
            }
            tcp->doReadSerial = false;

            tcp->serverTimeDiff[0] = 0;
            f.lastSerialTimeDif = 0;

            tcp->rv = 1;
            goto end;
        }
        if (timeDif != 0 && f.lastSerialTimeDif == 0){  // No previous read.
            sprintf(tcp->strbuf, "doSerialTimeCheck() timeDif detected on first read: %d\n", timeDif);
            writeToLog(tcp->strbuf);

            tcp->serverTimeDiff[0] = 0;
            f.lastSerialTimeDif = timeDif;              // So flag timeDif for verification and continue read serial.

            tcp->rv = 0;
            goto end;
        }
        if (timeDif != 0 && f.lastSerialTimeDif != 0){  // Got a timeDif on second read
            if (timeDif == f.lastSerialTimeDif ){       // timeDif is valid.
                sprintf(tcp->strbuf, "doSerialTimeCheck() Verified timeDif on second read: %d\n", timeDif);
                writeToLog(tcp->strbuf);

                tcp->doReadSerial = false;              // So stop read serial

                tcp->serverTimeDiff[0] = timeDif;       // and send back the timeDif.
                f.lastSerialTimeDif = 0;

                tcp->rv = 1;
                goto end;
            }
            else {                                      // timeDifs don't match
                sprintf(tcp->strbuf, "doSerialTimeCheck() Second timeDif read: %d does not match the first: %d. Not valid.\n", timeDif, f.lastSerialTimeDif);
                writeToLog(tcp->strbuf);

                tcp->doReadSerial = false;

                tcp->serverTimeDiff[0] = 0;             // No valid timeDif so send back zero.
                f.lastSerialTimeDif = 0;

                tcp->rv = 0;
                goto end;
            }
        }
    }
    else if (isValidDif == 0){
        sprintf(tcp->strbuf, "doSerialTimeCheck() Did not see a GPRMC message. Retrying.\n");
        writeToLog(tcp->strbuf);
        tcp->doReadSerial = true;
    }
    else if (isValidDif == -1){
        tcp->rv = -1;
        goto end;
    }
    tcp->rv = 0;
end:
    tcp->threadIsBusy[0] = false;
    return;
}

int makeSerialTimeQuery(timeCheckParams *tcp){

    int rv = 0;

    if (tcp->threadIsBusy[0] == false){
        rv = tcp->rv;
        if (rv == -1){
            sprintf(tcp->strbuf, "Time check failed with an error. See the pps-client.log\n");
            bufferStatusMsg(tcp->strbuf);
            return rv;
        }
        if (rv == 1){
            sprintf(tcp->strbuf, "GPS Reported clock offset: %d\n", tcp->serverTimeDiff[0]);
            bufferStatusMsg(tcp->strbuf);
            tcp->rv = 0;
            rv = 0;
        }
        g.serialTimeError = tcp->serverTimeDiff[0];
        tcp->serverTimeDiff[0] = 0;

        f.doReadSerial = tcp->doReadSerial;
    }
    else {
        sprintf(g.msgbuf, "Thread is busy.\n");
        bufferStatusMsg(g.msgbuf);
        return rv;
    }

    if (g.seq_num == 1 ||
            g.seq_num % CHECK_TIME_SERIAL == 0){                // Start a time check every CHECK_TIME_SERIAL
        f.doReadSerial = true;                              // Read continues until f.doReadSerial is set false.

        sprintf(g.logbuf, "Requesting a GPS time check.\n");
        bufferStatusMsg(g.logbuf);
    }

    if (f.doReadSerial){
        g.blockDetectClockChange = BLOCK_FOR_3;

        int rv = pthread_create(&((tcp->tid)[0]), &(tcp->attr), (void* (*)(void*))&doSerialTimeCheck, tcp);
        if (rv != 0){
            sprintf(g.logbuf, "Can't create thread : %s\n", strerror(errno));
            writeToLog(g.logbuf);
            return -1;
        }
    }
    return rv;
}

int allocInitializeSerialThread(timeCheckParams *tcp){
    memset(&f, 0, sizeof(struct serialLocalVars));

    int buflen = strlen(g.serialPort);
    f.serialPort = new char[buflen + 1];
    strcpy(f.serialPort, g.serialPort);

    f.serverTimeDiff[0] = 0;
    f.threadIsBusy[0] = false;

    tcp->tid = f.tid;
    tcp->serverTimeDiff = f.serverTimeDiff;
    tcp->strbuf = new char[STRBUF_SZ];
    tcp->threadIsBusy = f.threadIsBusy;
    tcp->serialPort = f.serialPort;

    printf("allocInitializeSerialThread() tcp->serialPort: %s\n", tcp->serialPort);

    tcp->rv = 0;
    tcp->doReadSerial = false;

    int rv = pthread_attr_init(&(tcp->attr));
    if (rv != 0) {
        sprintf(g.logbuf, "Can't init pthread_attr_t object: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    rv = pthread_attr_setstacksize(&(tcp->attr), PTHREAD_STACK_REQUIRED);
    if (rv != 0){
        sprintf(g.logbuf, "Can't set pthread_attr_setstacksize(): %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    rv = pthread_attr_setdetachstate(&(tcp->attr), PTHREAD_CREATE_DETACHED);
    if (rv != 0){
        sprintf(g.logbuf, "Can't set pthread_attr_t object state: %s\n", strerror(errno));
        writeToLog(g.logbuf);
        return -1;
    }

    return 0;
}

void freeSerialThread(timeCheckParams *tcp){
    pthread_attr_destroy(&(tcp->attr));
    delete[] tcp->strbuf;
    if (tcp->serialPort != NULL){
        delete[] tcp->serialPort;
        tcp->serialPort = NULL;
    }
}