begin adding temporary support for both NEMA and UBLOX gpses

src/GPS.cpp

@@ -4,16 +4,19 @@
 #include <sys/time.h>
 #include "configuration.h"
 
-// stuff that really should be in in the instance instead...
+
 HardwareSerial _serial_gps(GPS_SERIAL_NUM);
-uint32_t timeStartMsec;  // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time
-uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock
 
 RTC_DATA_ATTR bool timeSetFromGPS; // We only reset our time once per _boot_ after that point just run from the internal clock (even across sleeps)
 
 GPS gps;
-bool hasValidLocation; // default to false, until we complete our first read
-bool wantNewLocation = true;
+
+// stuff that really should be in in the instance instead...
+static uint32_t timeStartMsec;  // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time
+static uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock
+
+static bool hasValidLocation; // default to false, until we complete our first read
+static bool wantNewLocation = true;
 
 GPS::GPS() : PeriodicTask()
 {

src/GPS.h

@@ -49,3 +49,7 @@ private:
 };
 
 extern GPS gps;
+
+// Temporary support for the one TTGO in the world with a busted serial rx line (my old devboard)
+extern HardwareSerial _serial_gps;
+extern RTC_DATA_ATTR bool timeSetFromGPS; 

src/GPSNema.cpp

@@ -0,0 +1,156 @@
+
+#include "GPSNema.h"
+#include "time.h"
+#include <sys/time.h>
+#include "configuration.h"
+#include "GPS.h"
+
+// GPSNema gps;
+
+// stuff that really should be in in the instance instead...
+static uint32_t timeStartMsec;  // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time
+static uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock
+
+static bool hasValidLocation; // default to false, until we complete our first read
+static bool wantNewLocation = true;
+
+GPSNema::GPSNema() : PeriodicTask()
+{
+}
+
+void GPSNema::setup()
+{
+    readFromRTC();
+
+#ifdef GPS_RX_PIN
+    _serial_gps.begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
+#endif
+}
+
+void GPSNema::readFromRTC()
+{
+    struct timeval tv; /* btw settimeofday() is helpfull here too*/
+
+    if (!gettimeofday(&tv, NULL))
+    {
+        uint32_t now = millis();
+
+        DEBUG_MSG("Read RTC time as %ld (cur millis %u) valid=%d\n", tv.tv_sec, now, timeSetFromGPS);
+        timeStartMsec = now;
+        zeroOffsetSecs = tv.tv_sec;
+    }
+}
+
+/// If we haven't yet set our RTC this boot, set it from a GPS derived time
+void GPSNema::perhapsSetRTC(const struct timeval *tv)
+{
+    if (!timeSetFromGPS)
+    {
+        timeSetFromGPS = true;
+        DEBUG_MSG("Setting RTC %ld secs\n", tv->tv_sec);
+        settimeofday(tv, NULL);
+        readFromRTC();
+    }
+}
+
+#include <time.h>
+
+// for the time being we need to rapidly read from the serial port to prevent overruns
+void GPSNema::loop()
+{
+    PeriodicTask::loop();
+}
+
+uint32_t GPSNema::getTime()
+{
+    return ((millis() - timeStartMsec) / 1000) + zeroOffsetSecs;
+}
+
+uint32_t GPSNema::getValidTime()
+{
+    return timeSetFromGPS ? getTime() : 0;
+}
+
+/// Returns true if we think the board can enter deep or light sleep now (we might be trying to get a GPS lock)
+bool GPSNema::canSleep()
+{
+    return !wantNewLocation;
+}
+
+/// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
+void GPSNema::prepareSleep()
+{
+    // discard all rx serial bytes so we don't try to parse them when we come back
+    while (_serial_gps.available())
+    {
+        _serial_gps.read();
+    }
+
+    // make the parser bail on whatever it was parsing
+    encode('\n');
+}
+
+void GPSNema::doTask()
+{
+#ifdef GPS_RX_PIN
+    // Consume all characters that have arrived
+
+    while (_serial_gps.available())
+    {
+        encode(_serial_gps.read());
+        // DEBUG_MSG("Got GPS response\n");
+    }
+
+    if (!timeSetFromGPS && time.isValid() && date.isValid())
+    {
+        struct timeval tv;
+
+        DEBUG_MSG("Got time from GPS\n");
+
+        /* Convert to unix time 
+        The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970 (midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z). 
+        */
+        struct tm t;
+        t.tm_sec = time.second();
+        t.tm_min = time.minute();
+        t.tm_hour = time.hour();
+        t.tm_mday = date.day();
+        t.tm_mon = date.month() - 1;
+        t.tm_year = date.year() - 1900;
+        t.tm_isdst = false;
+        time_t res = mktime(&t);
+        tv.tv_sec = res;
+        tv.tv_usec = 0; // time.centisecond() * (10 / 1000);
+
+        perhapsSetRTC(&tv);
+    }
+#endif
+
+    if (location.isValid() && location.isUpdated())
+    { // we only notify if position has changed
+        // DEBUG_MSG("new gps pos\n");
+        hasValidLocation = true;
+        wantNewLocation = false;
+        notifyObservers();
+    }
+    else // we didn't get a location update, go back to sleep and hope the characters show up
+        wantNewLocation = true;
+
+    // Once we have sent a location once we only poll the GPS rarely, otherwise check back every 100ms until we have something over the serial
+    setPeriod(hasValidLocation && !wantNewLocation ? 30 * 1000 : 100);
+}
+
+void GPSNema::startLock()
+{
+    DEBUG_MSG("Looking for GPS lock\n");
+    wantNewLocation = true;
+    setPeriod(1);
+}
+
+String GPSNema::getTimeStr()
+{
+    static char t[12]; // used to sprintf for Serial output
+
+    snprintf(t, sizeof(t), "%02d:%02d:%02d", time.hour(), time.minute(), time.second());
+    return t;
+}

src/GPSNema.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <TinyGPS++.h>
+#include "PeriodicTask.h"
+#include "Observer.h"
+#include "sys/time.h"
+
+/**
+ * A gps class that only reads from the GPS periodically (and FIXME - eventually keeps the gps powered down except when reading)
+ * 
+ * When new data is available it will notify observers.
+ */
+class GPSNema : public PeriodicTask, public Observable, public TinyGPSPlus
+{
+public:
+    GPSNema();
+
+    /// Return time since 1970 in secs.  Until we have a GPS lock we will be returning time based at zero
+    uint32_t getTime();
+
+    /// Return time since 1970 in secs.  If we don't have a GPS lock return zero
+    uint32_t getValidTime();
+
+    String getTimeStr();
+
+    void setup();
+
+    virtual void loop();
+
+    virtual void doTask();
+
+    /// If we haven't yet set our RTC this boot, set it from a GPS derived time
+    void perhapsSetRTC(const struct timeval *tv);
+
+    /// Returns true if we think the board can enter deep or light sleep now (we might be trying to get a GPS lock)
+    bool canSleep();
+
+    /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
+    void prepareSleep();
+
+    /// Restart our lock attempt - try to get and broadcast a GPS reading ASAP
+    void startLock();
+
+private:
+    void readFromRTC();
+};
+
+// extern GPSNema gps;