Filling out GPS request polling and adding GPS request example.

jimblom · jimblom · commit 7eecfd1ce4bb · 2018-11-01T11:54:30.000-06:00
diff --git a/examples/04_GPS_Interface/04_GPS_Interface.ino b/examples/04_GPS_Interface/04_GPS_Interface.ino
diff --git a/examples/04_GPS_Request/04_GPS_Request.ino b/examples/04_GPS_Request/04_GPS_Request.ino
@@ -0,0 +1,104 @@
+/*
+  Use the GPS Request feature to request GPS data and receive it in a callback
+  By: Jim Lindblom
+  SparkFun Electronics
+  Date: November 1, 2018
+  License: This code is public domain but you buy me a beer if you use this 
+  and we meet someday (Beerware license).
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/14997
+
+  This example demonstrates how to use the gpsRequest feature
+
+  Before beginning, you should have your shield connected to a supported u-blox
+  GPS module via the I2C (DDC) port.
+  Supported GPS modules include:
+  https://www.sparkfun.com/products/15005
+
+  Once programmed, open the serial monitor, set the baud rate to 9600,
+  and hit enter to watch GPS data begin to stream by.
+  
+  Hardware Connections:
+  Attach the SparkFun LTE Cat M1/NB-IoT Shield to your Arduino
+  Power the shield with your Arduino -- ensure the PWR_SEL switch is in
+    the "ARDUINO" position.
+*/
+
+//Click here to get the library: http://librarymanager/All#SparkFun_LTE_Shield_Arduino_Library
+#include <SparkFun_LTE_Shield_Arduino_Library.h>
+
+// Create a SoftwareSerial object to pass to the LTE_Shield library
+SoftwareSerial lteSerial(8, 9);
+// Create a LTE_Shield object to use throughout the sketch
+LTE_Shield lte;
+
+boolean requestingGPS = false;
+unsigned long lastRequest = 0;
+#define MIN_REQUEST_INTERVAL 60000 // How often we'll get GPS in loop (in ms)
+
+#define GPS_REQUEST_TIMEOUT 30 // Time to turn on GPS module and get a fix (in s)
+#define GPS_REQUEST_ACCURACY 1  // Desired accuracy from GPS module (in meters)
+
+void processGpsRead(ClockData clck, PositionData gps, 
+  SpeedData spd, unsigned long uncertainty) {
+
+  Serial.println();
+  Serial.println();
+  Serial.println(F("GPS Data Received"));
+  Serial.println(F("================="));
+  Serial.println("Date: " + String(clck.date.month) + "/" + 
+    String(clck.date.day) + "/" + String(clck.date.year));
+  Serial.println("Time: " + String(clck.time.hour) + ":" + 
+    String(clck.time.minute) + ":" + String(clck.time.second) + "." + String(clck.time.ms));
+  Serial.println("Lat/Lon: " + String(gps.lat, 7) + "/" + String(gps.lon, 7));
+  Serial.println("Alt: " + String(gps.alt));
+  Serial.println("Uncertainty: " + String(uncertainty));
+  Serial.println("Speed: " + String(spd.speed) + " @ " + String(spd.tack));
+  Serial.println();
+
+  requestingGPS = false;
+}
+
+void setup() {
+  Serial.begin(9600);
+
+  // Wait for user to press key in terminal to begin
+  Serial.println("Press any key to begin GPS'ing");
+  while (!Serial.available()) ;
+  while (Serial.available()) Serial.read();
+
+  // Initialize the LTE Shield
+  if ( lte.begin(lteSerial, 9600) ) {
+    Serial.println(F("LTE Shield connected!"));
+  }
+  // Set a callback to return GPS data once requested
+  lte.setGpsReadCallback(&processGpsRead);
+}
+
+void loop() {
+  // Poll as often as possible
+  lte.poll();
+
+  if (!requestingGPS) {
+    if ((lastRequest == 0) || (lastRequest + MIN_REQUEST_INTERVAL < millis())) {
+        Serial.println(F("Requesting GPS data...this can take up to 10 seconds"));
+        if (lte.gpsRequest(GPS_REQUEST_TIMEOUT, GPS_REQUEST_ACCURACY) == LTE_SHIELD_SUCCESS) {
+          Serial.println(F("GPS data requested."));
+          Serial.println("Wait up to " + String(GPS_REQUEST_TIMEOUT) + " seconds");
+          requestingGPS = true;
+          lastRequest = millis();
+        } else {
+          Serial.println(F("Error requesting GPS"));
+        }
+      }
+  } else {
+    // Print a '.' every ~1 second if requesting GPS data
+    // (Hopefully this doesn't mess with poll too much)
+    if ((millis() % 1000) == 0) {
+      Serial.print('.');
+      delay(1);
+    }
+  }
+
+
+}
diff --git a/src/SparkFun_LTE_Shield_Arduino_Library.cpp b/src/SparkFun_LTE_Shield_Arduino_Library.cpp
@@ -147,7 +147,7 @@ boolean LTE_Shield::poll(void)
 
     if (hwAvailable())
     {
-        while (c != '\n') ///(avail < hwAvailable())
+        while (c != '\n')
         {
             if (hwAvailable())
             {
@@ -197,16 +197,39 @@ boolean LTE_Shield::poll(void)
             }
         }
         {
+            ClockData clck;
+            PositionData gps;
+            SpeedData spd;
+            unsigned long uncertainty;
+            int scanNum;
+            unsigned int latH, lonH, altU, speedU, tackU;
+            char latL[10], lonL[10];
+
             if (strstr(lteShieldRXBuffer, "+UULOC")) 
             {
                 // Found a Location string!
-                Serial.println("Found location string!");
-                Serial.println(lteShieldRXBuffer);
+                scanNum = sscanf(lteShieldRXBuffer, 
+                    "+UULOC: %hhu/%hhu/%u,%hhu:%hhu:%hhu.%u,%u.%[^,],%u.%[^,],%u,%lu,%u,%u,*%s",
+                    &clck.date.day, &clck.date.month, &clck.date.year,
+                    &clck.time.hour, &clck.time.minute, &clck.time.second, &clck.time.ms,
+                    &latH, latL, &lonH, lonL, &altU, &uncertainty,
+                    &speedU, &tackU);
+                if (scanNum < 13) return false; // Break out if we didn't find enough
+
+                gps.lat = (float) latH + ((float)atol(latL) / pow(10, strlen(latL)));
+                gps.lon = (float) lonH + ((float)atol(lonL) / pow(10, strlen(lonL)));
+                gps.alt = (float) altU;
+                if (scanNum == 15) // If detailed response, get speed data
+                {
+                    spd.speed = (float) speedU;
+                    spd.tack = (float) tackU;
+                }
+
+                if (_gpsRequestCallback != NULL)
+                {
+                    _gpsRequestCallback(clck, gps, spd, uncertainty);
+                }
             }
-            // Look for +UULOC
-            // Either: +UULOC: DD/MM/YYYY,HH:MM:SS.sss,lat.lat,lon.lon,alt,uncertainty,
-                // speed,direction,vertical_acc,sv_used,antenna_status,jamming_status
-            // Or: DD/MM/YYYY,HH:MM:SS.sss,lat.lat,lon.lon,alt,uncertainty
         }
         
         if ( (handled == false) && (strlen(lteShieldRXBuffer) > 2) )
@@ -231,6 +254,12 @@ void LTE_Shield::setSocketCloseCallback(void (*socketCloseCallback)(int))
     _socketCloseCallback = socketCloseCallback;
 }
 
+void LTE_Shield::setGpsReadCallback(void (*gpsRequestCallback)(ClockData time, 
+    PositionData gps, SpeedData spd, unsigned long uncertainty))
+{
+    _gpsRequestCallback = gpsRequestCallback;
+}
+
 size_t LTE_Shield::write(uint8_t c)
 {
     if (_hardSerial != NULL)
@@ -864,6 +893,36 @@ IPAddress LTE_Shield::lastRemoteIP(void)
     return _lastRemoteIP;
 }
 
+boolean LTE_Shield::gpsOn(void)
+{
+    LTE_Shield_error_t err;
+    char * command;
+    char * response;
+    boolean on = false;
+
+    command = lte_calloc_char(strlen(LTE_SHIELD_GPS_POWER) + 2);
+    if (command == NULL) return LTE_SHIELD_ERROR_OUT_OF_MEMORY;
+    sprintf(command, "%s?", LTE_SHIELD_GPS_POWER);
+
+    response = lte_calloc_char(24);
+    if (response == NULL) return LTE_SHIELD_ERROR_OUT_OF_MEMORY;
+
+    err = sendCommandWithResponse(command, LTE_SHIELD_RESPONSE_OK, response, 
+        LTE_SHIELD_STANDARD_RESPONSE_TIMEOUT);
+
+    if (err == LTE_SHIELD_ERROR_SUCCESS)
+    {
+        // Example response: "+UGPS: 0" for off "+UGPS: 1,0,1" for on
+        // May be too lazy/simple, but just search for a '1'
+        if (strchr(response, '1') != NULL) on = true;
+    }
+
+    free(command);
+    free(response);
+
+    return on;
+}
+
 LTE_Shield_error_t LTE_Shield::gpsPower(boolean enable,  gnss_system_t gnss_sys)
 {
     LTE_Shield_error_t err;
@@ -953,6 +1012,12 @@ LTE_Shield_error_t LTE_Shield::gpsRequest(unsigned int timeout, unsigned int acc
     LTE_Shield_error_t err;
     char * command;
 
+    // This function will only work if the GPS module is initially turned off.
+    if (gpsOn())
+    {
+        gpsPower(false);
+    }
+
     if (timeout > 999) timeout = 999;
     if (accuracy > 999999) accuracy = 999999;
 
diff --git a/src/SparkFun_LTE_Shield_Arduino_Library.h b/src/SparkFun_LTE_Shield_Arduino_Library.h
@@ -93,13 +93,14 @@ typedef enum {
 struct DateData {
     uint8_t day;
     uint8_t month;
-    uint8_t year;
+    unsigned int year;
 };
 
 struct TimeData {
     uint8_t hour;
     uint8_t minute;
     uint8_t second;
+    unsigned int ms;
     uint8_t tzh;
     uint8_t tzm;
 };
@@ -148,6 +149,8 @@ class LTE_Shield : public Print {
     boolean poll(void);
     void setSocketReadCallback(void (*socketReadCallback)(int, String));
     void setSocketCloseCallback(void (*socketCloseCallback)(int));
+    void setGpsReadCallback(void (*gpsRequestCallback)(ClockData time, 
+        PositionData gps, SpeedData spd, unsigned long uncertainty));
 
     // Direct write/print to cell serial port
     virtual size_t write(uint8_t c);
@@ -164,6 +167,7 @@ class LTE_Shield : public Print {
 // Control and status AT commands
     LTE_Shield_error_t reset(void);
     String clock(void);
+    // TODO: Return a clock struct
     LTE_Shield_error_t clock(uint8_t * y, uint8_t * mo, uint8_t * d, 
         uint8_t * h, uint8_t * min, uint8_t * s, uint8_t * tz);
     LTE_Shield_error_t autoTimeZone(boolean enable);
@@ -238,6 +242,7 @@ class LTE_Shield : public Print {
         GNSS_SYSTEM_QZSS = 32,
         GNSS_SYSTEM_GLONASS = 64
     } gnss_system_t;
+    boolean gpsOn(void);
     LTE_Shield_error_t gpsPower(boolean enable = true,
         gnss_system_t gnss_sys = GNSS_SYSTEM_GPS);
     LTE_Shield_error_t gpsEnableClock(boolean enable = true);
@@ -256,7 +261,7 @@ class LTE_Shield : public Print {
     LTE_Shield_error_t gpsEnableSpeed(boolean enable = true);
     LTE_Shield_error_t gpsGetSpeed(struct SpeedData * speed);
 
-    LTE_Shield_error_t gpsRequest(unsigned int timeout, unsigned int accuracy, boolean detailed);
+    LTE_Shield_error_t gpsRequest(unsigned int timeout, unsigned int accuracy, boolean detailed = true);
 
 private:
 
@@ -273,7 +278,7 @@ class LTE_Shield : public Print {
     
     void (*_socketReadCallback)(int, String);
     void (*_socketCloseCallback)(int);
-    void (*_gpsRequestCallback)(ClockData time, PositionData gps, unsigned long uncertainty);
+    void (*_gpsRequestCallback)(ClockData, PositionData, SpeedData, unsigned long);
 
     typedef enum {
         LTE_SHIELD_INIT_STANDARD,
