gps.c

Open DMT Client C Source code

            gpsAquireRequest = utFalse;
        } AQUIRE_UNLOCK
        // We are now either NOT in powerSaveMode, or 'gpsAquire(...)' has been called.
        
        /* exit now if this thread has been told to quit */
        if (!gpsRunThread) {
            break;
        }

        /* open port to GPS */
        if (!_gpsOpen()) {
            // Open failed.  Wait, then retry open.
            // This should be a critical error.
            if (utcIsTimerExpired(gpsLastOpenErrorTimer,900L)) {
                gpsPortName = propGetString(PROP_CFG_GPS_PORT, DEFAULT_GPS_PORT); // refresh name
                gpsLastOpenErrorTimer = utcGetTimer();
                if (!comPortIsValidName(gpsPortName)) {
                    logERROR(LOGSRC,"GPS port invalid: %s", gpsPortName);
                } else {
                    logCRITICAL(LOGSRC,"Unable to open GPS port: %s", gpsPortName); // strerror(errno));
                }
            }
            threadSleepMS(5000L);
            continue;
        }

        // The HP hw6945 GPS receiver should be powering up from a cold-start at this point.
        // If the device always keeps the GPS hot, then we will just be able to aquire a
        // fix much sooner.

        /* read GPS (forever, or until error) */
        // We want to make sure we stay in '_gpsReadGPSFix' long enough to get at least one
        // GPS fix (assuming that the receiver may be coming up from a cold-start).  If the 
        // GPS receiver is already hot, then we'll just get a fix much sooner.
        UInt32 timeoutMS = 0L;
        if (powerSaveMode) {
            // If we are in power-save mode, then 'gpsAquire(...)' was called and is waiting
            // for a valid GPS fix (hopefully with a reasonable timeout value).  We will wait
            // here for a GPS fix with the same timeout value.
            timeoutMS = powerSaveTimeoutMS; // from 'gpsAquireTimeoutMS'
            UInt32 MIN_TIMOUT = 90L * 1000L; // 90 seconds (should be enough for a cold GPS start)
            if (timeoutMS < MIN_TIMOUT) {
                timeoutMS = MIN_TIMOUT;
            }
        }
        int gpsErr = _gpsReadGPSFix(timeoutMS);
        if (gpsErr <= 0) {
            // (gpsErr <  0) we've received an error, increment restart counter
            // (gpsErr == 0) powerSaveMode timeout, increment restart counter
            SAMPLE_LOCK {
                gpsRestartCount++;
                logDEBUG(LOGSRC,"Error/Timeout - closing GPS port [%lu]", gpsRestartCount);
            } SAMPLE_UNLOCK
        } else {
            // (gpsErr >  0) powerSaveMode GPS fix received
            logDEBUG(LOGSRC,"PowerSave - closing GPS port ...");
        }

        /*close GPS port */
        _gpsClose();
        
    } //while (gpsRunThread)
    
    /* once this thread stops, it isn't starting again */
    // The following resources should be released:
    //  - gpsComPort
    //  - gpsMutex
    //  - gpsSampleMutex
    //  - gpsAquireMutex
    //  - gpsAquireCond
    //  - And everything in the supported GPS modules
    //  - ???
    logERROR(LOGSRC,"GPS thread is terminating ...");
    threadExit();    

}

/* indicate thread should stop */
static void _gpsStopThread(void *arg)
{
    gpsRunThread = utFalse;
    AQUIRE_LOCK {
        // nudge thread
        AQUIRE_NOTIFY
    } AQUIRE_UNLOCK
    _gpsClose();
}

/* start the thread */
static utBool _gpsStartThread()
{
    /* create thread */
    gpsRunThread = utTrue; // must set BEFORE we start the thread!
    if (threadCreate(&gpsThread,&_gpsThreadRunnable,0,"GPS") == 0) {
        // thread started successfully
        threadAddThreadStopFtn(&_gpsStopThread,0);
    } else {
        logCRITICAL(LOGSRC,"Unable to start GPS thread");
        gpsRunThread = utFalse;
    }
    return gpsRunThread;
}

#endif // defined(GPS_THREAD)

// ----------------------------------------------------------------------------

/* GPS module initialization */
static utBool _gpsDidInit = utFalse;
void gpsInitialize(eventAddFtn_t queueEvent)
{

    /* already initialized? */
    if (_gpsDidInit) {
        return;
    }
    _gpsDidInit = utTrue;

    /* init gps comport */
    comPortInitStruct(&gpsComPort);

    /* clear gps struct */
    gpsClear(&gpsFixLast);
    gpsClear(&gpsFixUnsafe);
    
#if defined(GPS_THREAD)
    /* create mutex's */
    threadMutexInit(&gpsMutex);
    threadMutexInit(&gpsSampleMutex);
    threadMutexInit(&gpsAquireMutex);
    threadConditionInit(&gpsAquireCond);
#endif

    /* GPS module initialization */
    gpsModuleInitialize(queueEvent);

#if defined(GPS_THREAD)
    /* start thread */
    _gpsStartThread();
#endif

}

// ----------------------------------------------------------------------------

/* set flag indicating GPS fix is stale (or not) */
void gpsSetFixStale(utBool stale)
{
    // this value is currently only set in 'mainloop.c'
    gpsIsStale = stale;
}

/* return true if current GPS fix is stale */
utBool gpsIsFixStale()
{
    // Note: this may be accessed from multiple threads, but since this is not
    // a critical value, no locking is performed.
    return gpsIsStale;
}

// ----------------------------------------------------------------------------

/* check minimum values in GPS record */
GPS_t *gpsCheckMinimums(GPS_t *gps)
{
    if (gps) {
        // check minimum speed 
        double minSpeedKPH = propGetDouble(PROP_GPS_MIN_SPEED, 7.0);
        if (gps->speedKPH < minSpeedKPH) {
            // the reported speed does not meet our minimum requirement
            // mark the speed as 'not moving'
            gps->speedKPH = 0.0;
            gps->heading  = 0.0; // clear the heading when the speed is '0'
        } 
    }
    return gps;
}

// ----------------------------------------------------------------------------

/* aquire GPS fix */
GPS_t *gpsAquire(GPS_t *gps, UInt32 timeoutMS)
{

    /* null gps pointer specified */
    if (!gps) {
        return (GPS_t*)0;
    }
    
    /* clear gps point */
    gpsClear(gps);

#if defined(GPS_THREAD)

    /* no timeout, return last fix */
    if (timeoutMS <= 0L) {
        // no timeout specified, just return the latest fix that we have (if any)
        // the caller can determine if he wants to use the fix
        return gpsGetLastGPS(gps, -1);
    }
    
    /* indicate to GPS thread that we want a fix */
    // This is only necessary if the gps interval is long and the gps thread is
    // waiting to be told to make a gps aquisition.
    AQUIRE_LOCK {
        gpsAquireTimeoutMS = timeoutMS; // this value is > 0
        gpsAquireRequest   = utTrue;
        AQUIRE_NOTIFY
    } AQUIRE_UNLOCK
    // at this point, the gps thread should be working on getting a fix

    /* wait until a fix is available */
    UInt32 accumTimeoutMS = 0L;
    for (;accumTimeoutMS < timeoutMS;) {
        
        /* get latest fix */
        GPS_t *g = gpsGetLastGPS(gps, -1);
        if (g && (utcGetTimerAgeSec(g->ageTimer) <= 7L)) {
            // The latest fix occurred within the last 7 seconds.
            return g;
        }
        
        /* wait for next fix */
        UInt32 tmo = timeoutMS - accumTimeoutMS;
        if (tmo > 1000L) { tmo = 1000L; }
        threadSleepMS(tmo);
        accumTimeoutMS += tmo;

    }

    /* no fix (timeout?) */
    return (GPS_t*)0;

#else

    /* timeout mode: block while reading GPS fix */
    UInt32 tmo = (timeoutMS < 3000L)? 3000L : timeoutMS;
#if defined(GPS_DEVICE_SIMULATOR)
    const char *gpsPortName = propGetString(PROP_CFG_GPS_PORT, DEFAULT_GPS_PORT);
    gpsSimulator = strEqualsIgnoreCase(gpsPortName, GPS_SIMULATOR_PORT);
    if (gpsSimulator) {
        int rtn = _gpsReadGPSFix(tmo);
        if (rtn > 0) {
            // valid fix aquired
            return gpsGetLastGPS(gps, 15);
        } else {
            // timeout
            return (GPS_t*)0;
        }
    } else
#endif
    if (comPortIsOpen(&gpsComPort) || _gpsOpen()) {
        int rtn = _gpsReadGPSFix(tmo);
        _gpsClose(); // always close the port when runnin in non-thread mode
        if (rtn > 0) {
            // valid fix aquired (at least $GPRMC)
            GPS_t *g = gpsGetLastGPS(gps, 15);
            return g;
        } else
        if (rtn < 0) {
            // error
            return (GPS_t*)0;
        } else {
            // timeout 
            return (GPS_t*)0;
        }
    } else {
        // unable to open GPS port
        return (GPS_t*)0;
    }

#endif // defined(GPS_THREAD)

}

/* get last aquired GPS fix */
GPS_t *gpsGetLastGPS(GPS_t *gps, Int16 maxAgeSec)
{
    // no blocking
    if (gps) {
        
        /* get latest fix */
        GPS_LOCK {
            // gpsFixLast   - contains the most recent fix that has all the GPS components
            // gpsFixUnsafe - contains the fix-in-progress
            if (gpsFixUnsafe.fixtime < (gpsFixLast.fixtime + GP_EXPIRE)) {
                // The last fix is within 5 seconds of the new fix-in-process.
                // During normal GPS aquisition, the fix times will likely be the same.
                // If not the same, then the fix-in-process may have just started on 
                // the next sample.
                memcpy(gps, &gpsFixLast, sizeof(GPS_t));
            } else
            if (gpsFixUnsafe.nmea & NMEA0183_GPRMC) {
                // The last fix ('gpsFixLast') is stale.
                // The fix-in-process at least has the GPRMC
                // One of the following may have occured:
                //  - We stopped getting GPGGA records (or don't get them).
                //  - We just started getting valid GPS fixes again and we happen to have been 
                //    called when we are between GPRMC/GPGGA records (unlikely, but possible).
                //logDEBUG(LOGSRC,"We don't have a valid $GPGGA record"); 
                memcpy(gps, &gpsFixUnsafe, sizeof(GPS_t));
            } else {
                // The fix-in-process doesn't have a GPRMC.
                // The last fix is stale, but return it anyway.
                memcpy(gps, &gpsFixLast, sizeof(GPS_t)); 
                // fix may still be invalid
            }
        } GPS_UNLOCK
        
        /* check fix */
        if (!gpsIsValid(gps)) {
            //logINFO(LOGSRC,"Point is invalid ...");
            return (GPS_t*)0; // GPSPoint is invalid
        } else
        if ((maxAgeSec > 0) && (utcGetTimerAgeSec(gps->ageTimer) > maxAgeSec)) {
            //logINFO(LOGSRC,"Point is stale ... [%ld]", utcGetTimerAgeSec(gps->ageTimer));
            return (GPS_t*)0; // GPSPoint is stale
        } else {
            return gpsCheckMinimums(gps);
        }
        
    } else {
        
        /* no place to put fix */
        return (GPS_t*)0;
        
    }
}

// ----------------------------------------------------------------------------