Merge pull request #20 from sparkfun/v1.0.0

V1.0.0

Author: sfe-SparkFro

examples/Audio_Examples/AudioExample1_PlayTone/AudioExample1_PlayTone.ino

@@ -0,0 +1,145 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular_Voice myModule; // This example works with all voice-enabled modules, so this base class can be used
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+
+void setup()
+{
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Audio Example 1 - Play Tone"));
+
+    Serial.println();
+    Serial.println(F("! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! !"));
+    Serial.println(F("This example requires an audio codec attached to the I2S interface"));
+    Serial.println(F("of the cellular modem. Please add one and update this example as"));
+    Serial.println(F("needed to configure your audio codec!"));
+    Serial.println(F("! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! !"));
+    Serial.println();
+
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+}
+
+void loop()
+{
+    String inputString;
+    char dtmfChar = 0;
+    uint16_t frequency = 0;
+    uint16_t duration = 0;
+    uint8_t volume = 0;
+
+    while (true)
+    {
+        while (Serial.available() != 0)
+        {
+            Serial.read();
+        }
+        Serial.println(F("Enter a frequency in Hz (300-3400) or a DTMF character (0-9, *, #)"));
+        while (Serial.available() == 0)
+        {
+        }
+
+        inputString = Serial.readStringUntil('\n');
+
+        if (inputString.length() == 1)
+        {
+            dtmfChar = inputString.charAt(0);
+            if ((dtmfChar >= '0' && dtmfChar <= '9') || dtmfChar == '*' || dtmfChar == '#')
+            {
+                break;
+            }
+        }
+        else
+        {
+            frequency = inputString.toInt();
+            if (frequency >= 300 && frequency <= 3400)
+            {
+                dtmfChar == 0;
+                break;
+            }
+        }
+    }
+
+    while (true)
+    {
+        while (Serial.available() != 0)
+        {
+            Serial.read();
+        }
+        Serial.println(F("Enter a duration in ms (50-1360)"));
+        while (Serial.available() == 0)
+        {
+        }
+
+        inputString = Serial.readStringUntil('\n');
+        duration = inputString.toInt();
+        if (duration >= 50 && duration <= 1360)
+        {
+            break;
+        }
+    }
+
+    while (true)
+    {
+        while (Serial.available() != 0)
+        {
+            Serial.read();
+        }
+        Serial.println(F("Enter a volume (0-100)"));
+        while (Serial.available() == 0)
+        {
+        }
+
+        inputString = Serial.readStringUntil('\n');
+        volume = inputString.toInt();
+        if (volume <= 100)
+        {
+            break;
+        }
+    }
+
+    if (dtmfChar == 0)
+    {
+        myModule.generateToneFreq(frequency, duration, volume);
+    }
+    else
+    {
+        myModule.generateToneDTMF(dtmfChar, duration, volume);
+    }
+}

examples/Audio_Examples/AudioExample2_Loopback/AudioExample2_Loopback.ino

@@ -0,0 +1,82 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular_Voice myModule; // This example works with all voice-enabled modules, so this base class can be used
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+
+void setup()
+{
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Audio Example 2 - Loopback"));
+
+    Serial.println();
+    Serial.println(F("! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! !"));
+    Serial.println(F("This example requires an audio codec attached to the I2S interface"));
+    Serial.println(F("of the cellular modem. Please add one and update this example as"));
+    Serial.println(F("needed to configure your audio codec!"));
+    Serial.println(F("! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! !"));
+    Serial.println();
+
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+}
+
+void loop()
+{
+    while (Serial.available() != 0)
+    {
+        Serial.read();
+    }
+    Serial.println(F("Enter any key to begin loopback"));
+    while (Serial.available() == 0)
+    {
+    }
+
+    myModule.playAudioResource(UBX_CELL_AUDIO_RESOURCE_LOOPBACK);
+
+    while (Serial.available() != 0)
+    {
+        Serial.read();
+    }
+    Serial.println(F("Enter any key to stop loopback"));
+    while (Serial.available() == 0)
+    {
+    }
+
+    myModule.stopAudioResource(UBX_CELL_AUDIO_RESOURCE_LOOPBACK);
+}

examples/Audio_Examples/AudioExample3_CallControl/AudioExample3_CallControl.ino

@@ -0,0 +1,137 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular_Voice myModule; // This example works with all voice-enabled modules, so this base class can be used
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+
+bool callInProgress = false;
+bool incomingCall = false;
+
+void ringCallback()
+{
+    Serial.println(F("Incoming call! Enter \"A\" to answer, or anything else to reject"));
+    incomingCall = true;
+}
+
+void setup()
+{
+    String currentOperator = "";
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Audio Example 3 - Call Control"));
+
+    Serial.println();
+    Serial.println(F("! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! !"));
+    Serial.println(F("This example requires an audio codec attached to the I2S interface"));
+    Serial.println(F("of the cellular modem. Please add one and update this example as"));
+    Serial.println(F("needed to configure your audio codec!"));
+    Serial.println(F("! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! ! ATTENTION ! ! ! ! !"));
+    Serial.println();
+
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // First check to see if we're connected to an operator:
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Connected to: "));
+        Serial.println(currentOperator);
+    }
+    else
+    {
+        Serial.print(F("The module is not yet connected to an operator. Please use the previous examples to connect. "
+                       "Or wait and retry. Freezing..."));
+        while (1)
+            ; // Do nothing more
+    }
+
+    // Set callback function for when a new call is received
+    myModule.setRingCallback(&ringCallback);
+
+    Serial.println(F("Enter a number to dial"));
+
+    // Clear any input
+    while (Serial.available())
+    {
+        Serial.read();
+    }
+}
+
+void loop()
+{
+    String inputString;
+
+    myModule.bufferedPoll();
+
+    if (Serial.available())
+    {
+        inputString = Serial.readStringUntil('\n');
+        while (Serial.available())
+        {
+            Serial.read();
+        }
+
+        if (incomingCall)
+        {
+            if (inputString == "A" || inputString == "a")
+            {
+                Serial.println(F("Answering call, enter any key to hang up"));
+                myModule.answer();
+                callInProgress = true;
+            }
+            else
+            {
+                Serial.println(F("Rejecting call"));
+                myModule.hangUp();
+            }
+            incomingCall = false;
+        }
+        else if (callInProgress == false)
+        {
+            Serial.println("Dialing " + inputString + ", enter any key to hang up");
+            myModule.dial(inputString);
+            callInProgress = true;
+        }
+        else
+        {
+            Serial.println(F("Hanging up, enter a new number to dial"));
+            myModule.hangUp();
+            callInProgress = false;
+        }
+    }
+}

examples/Example1_DeviceIdentification/Example1_DeviceIdentification.ino

@@ -0,0 +1,101 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+// Map SIM states to more readable strings
+String simStateString[] = {
+    "Not present",     // 0
+    "PIN needed",      // 1
+    "PIN blocked",     // 2
+    "PUK blocked",     // 3
+    "Not operational", // 4
+    "Restricted",      // 5
+    "Operational"      // 6
+};
+
+// processSIMstate is provided to the u-blox cellular library via a
+// callback setter -- setSIMstateReadCallback. (See setup())
+void processSIMstate(UBX_CELL_sim_states_t state)
+{
+    Serial.println();
+    Serial.print(F("SIM state:           "));
+    Serial.print(String(state));
+    Serial.println();
+}
+
+void setup()
+{
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 1 - Device Identification"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    Serial.println("Manufacturer ID:     " + String(myModule.getManufacturerID()));
+    Serial.println("Model ID:            " + String(myModule.getModelID()));
+    Serial.println("Firmware Version:    " + String(myModule.getFirmwareVersion()));
+    Serial.println("Product Serial No.:  " + String(myModule.getSerialNo()));
+    Serial.println("IMEI:                " + String(myModule.getIMEI()));
+    Serial.println("IMSI:                " + String(myModule.getIMSI()));
+    Serial.println("SIM CCID:            " + String(myModule.getCCID()));
+    Serial.println("Subscriber No.:      " + String(myModule.getSubscriberNo()));
+    Serial.println("Capabilities:        " + String(myModule.getCapabilities()));
+
+    // Set a callback to return the SIM state once requested
+    myModule.setSIMstateReportCallback(&processSIMstate);
+    // Now enable SIM state reporting for states 0 to 6 (by setting the reporting mode LSb)
+    if (myModule.setSIMstateReportingMode(1) == UBX_CELL_SUCCESS)
+        Serial.println("SIM state reports requested...");
+    // You can disable the SIM staus reports again by calling assetTracker.setSIMstateReportingMode(0)
+}
+
+void loop()
+{
+    myModule.poll(); // Keep processing data from the module so we can extract the SIM status
+}

examples/Example2_NetworkInfo/Example2_NetworkInfo.ino

@@ -0,0 +1,124 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+// Map registration status messages to more readable strings
+String registrationString[] = {
+    "Not registered",                        // 0
+    "Registered, home",                      // 1
+    "Searching for operator",                // 2
+    "Registration denied",                   // 3
+    "Registration unknown",                  // 4
+    "Registered, roaming",                   // 5
+    "Registered, home (SMS only)",           // 6
+    "Registered, roaming (SMS only)",        // 7
+    "Registered, emergency service only",    // 8
+    "Registered, home, CSFB not preferred",  // 9
+    "Registered, roaming, CSFB not prefered" // 10
+};
+
+// If you are based in Europe, you will (probably) need to select MNO_STD_EUROPE
+const mobile_network_operator_t MOBILE_NETWORK_OPERATOR = MNO_GLOBAL;
+
+void setup()
+{
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 2 - Network Info"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    if (!myModule.setNetworkProfile(MOBILE_NETWORK_OPERATOR))
+    {
+        Serial.println(F("Error setting network. Try cycling the power."));
+        while (1)
+            ;
+    }
+
+    Serial.println(F("Network profile set. Ready to go!"));
+
+    // RSSI: Received signal strength:
+    Serial.println("RSSI: " + String(myModule.rssi()));
+    // Registration Status
+    int regStatus = myModule.registration();
+    if ((regStatus >= 0) && (regStatus <= 10))
+    {
+        Serial.println("Network registration: " + registrationString[regStatus]);
+    }
+
+    // Print the Context IDs, Access Point Names and IP Addresses
+    Serial.println(F("Available PDP (Packet Data Protocol) APNs (Access Point Names) and IP Addresses:"));
+    Serial.println(F("Context ID:\tAPN Name:\tIP Address:"));
+    for (int cid = 0; cid < UBX_CELL_NUM_PDP_CONTEXT_IDENTIFIERS; cid++)
+    {
+        String apn = "";
+        IPAddress ip(0, 0, 0, 0);
+        myModule.getAPN(cid, &apn, &ip);
+        if (apn.length() > 0)
+        {
+            Serial.print(cid);
+            Serial.print(F("\t\t"));
+            Serial.print(apn);
+            Serial.print(F("\t"));
+            Serial.println(ip);
+        }
+    }
+
+    Serial.println();
+
+    if (regStatus > 0)
+    {
+        Serial.println(F("All set. Go to the next example!"));
+    }
+}
+
+void loop()
+{
+    // Do nothing. Now that we're registered move on to the next example.
+}

examples/Example3_RegisterOperator/Example3_RegisterOperator.ino

@@ -0,0 +1,359 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+// Map registration status messages to more readable strings
+String registrationString[] = {
+    "Not registered",                        // 0
+    "Registered, home",                      // 1
+    "Searching for operator",                // 2
+    "Registration denied",                   // 3
+    "Registration unknown",                  // 4
+    "Registered, roaming",                   // 5
+    "Registered, home (SMS only)",           // 6
+    "Registered, roaming (SMS only)",        // 7
+    "Registered, emergency service only",    // 8
+    "Registered, home, CSFB not preferred",  // 9
+    "Registered, roaming, CSFB not prefered" // 10
+};
+
+// If you are based in Europe, you will (probably) need to select MNO_STD_EUROPE
+const mobile_network_operator_t MOBILE_NETWORK_OPERATOR = MNO_GLOBAL;
+
+const String MOBILE_NETWORK_STRINGS[] = {"default (Undefined/Regulatory)",
+                                         "SIM ICCID",
+                                         "AT&T",
+                                         "Verizon",
+                                         "Telstra",
+                                         "T-Mobile US",
+                                         "China Telecom",
+                                         "Sprint",
+                                         "Vodafone",
+                                         "NTT DoCoMo",
+                                         "Telus",
+                                         "SoftBank",
+                                         "Deutsche Telekom",
+                                         "US Cellular",
+                                         "SKT",
+                                         "global (factory default)",
+                                         "standard Europe",
+                                         "standard Europe No-ePCO",
+                                         "NOT RECOGNIZED"};
+
+// Convert the operator number into an index for MOBILE_NETWORK_STRINGS
+int convertOperatorNumber(mobile_network_operator_t mno)
+{
+    switch (mno)
+    {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+        return ((int)mno);
+    case 8:
+        return 7;
+    case 19:
+        return 8;
+    case 20:
+        return 9;
+    case 21:
+        return 10;
+    case 28:
+        return 11;
+    case 31:
+        return 12;
+    case 32:
+        return 13;
+    case 39:
+        return 14;
+    case 90:
+        return 15;
+    case 100:
+        return 16;
+    case 101:
+        return 17;
+    default: // NOT RECOGNIZED
+        return 18;
+    }
+}
+
+// This defines the size of the ops struct array. To narrow the operator
+// list, set MOBILE_NETWORK_OPERATOR to AT&T, Verizon etc. instead
+// of MNO_SW_DEFAULT.
+#define MAX_OPERATORS 10
+
+// Uncomment this line if you want to be able to communicate directly with the module in the main loop
+// #define DEBUG_PASSTHROUGH_ENABLED
+
+void setup()
+{
+    int opsAvailable;
+    struct operator_stats ops[MAX_OPERATORS];
+    String currentOperator = "";
+    bool newConnection = true;
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 3 - Register Operator"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // First check to see if we're already connected to an operator:
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Already connected to: "));
+        Serial.println(currentOperator);
+        // If already connected provide the option to type y to connect to new operator
+        Serial.println(F("Press y to connect to a new operator, or any other key to continue.\r\n"));
+        while (!Serial.available())
+            ;
+        if (Serial.read() != 'y')
+        {
+            newConnection = false;
+        }
+        else
+        {
+            myModule.deregisterOperator(); // Deregister from the current operator so we can connect to a new one
+        }
+        while (Serial.available())
+            Serial.read();
+    }
+
+    if (newConnection)
+    {
+        // Set MNO to either Verizon, T-Mobile, AT&T, Telstra, etc.
+        // This will narrow the operator options during our scan later
+        Serial.println(F("Setting mobile-network operator"));
+        if (myModule.setNetworkProfile(MOBILE_NETWORK_OPERATOR))
+        {
+            Serial.print(F("Set mobile network operator to "));
+            Serial.println(MOBILE_NETWORK_STRINGS[convertOperatorNumber(MOBILE_NETWORK_OPERATOR)] + "\r\n");
+        }
+        else
+        {
+            Serial.println(F("Error setting MNO. Try cycling the power. Freezing..."));
+            while (1)
+                ;
+        }
+
+        // Wait for user to press button before initiating network scan.
+        Serial.println(F("Press any key scan for networks.."));
+        serialWait();
+
+        Serial.println(F("Scanning for networks...this may take up to 3 minutes\r\n"));
+        // myModule.getOperators takes in a operator_stats struct pointer and max number of
+        // structs to scan for, then fills up those objects with operator names and numbers
+        opsAvailable = myModule.getOperators(ops, MAX_OPERATORS); // This will block for up to 3 minutes
+
+        if (opsAvailable > 0)
+        {
+            // Pretty-print operators we found:
+            Serial.println("Found " + String(opsAvailable) + " operators:");
+            printOperators(ops, opsAvailable);
+            Serial.println(String(opsAvailable + 1) + ": use automatic selection");
+            Serial.println();
+
+            // Wait until the user presses a key to initiate an operator connection
+            Serial.println("Press 1-" + String(opsAvailable + 1) + " to select an operator.");
+            char c = 0;
+            bool selected = false;
+            while (!selected)
+            {
+                while (!Serial.available())
+                    ;
+                c = Serial.read();
+                int selection = c - '0';
+                if ((selection >= 1) && (selection <= (opsAvailable + 1)))
+                {
+                    selected = true;
+                    Serial.println("Connecting to option " + String(selection));
+                    if (selection == (opsAvailable + 1))
+                    {
+                        if (myModule.automaticOperatorSelection() == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println("Automatic operator selection: successful\r\n");
+                        }
+                        else
+                        {
+                            Serial.println(
+                                F("Automatic operator selection: error. Reset and try again, or try another network."));
+                        }
+                    }
+                    else
+                    {
+                        if (myModule.registerOperator(ops[selection - 1]) == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println("Network " + ops[selection - 1].longOp + " registered\r\n");
+                        }
+                        else
+                        {
+                            Serial.println(
+                                F("Error connecting to operator. Reset and try again, or try another network."));
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            Serial.println(F("Did not find an operator. Double-check SIM and antenna, reset and try again, or try "
+                             "another network."));
+            while (1)
+                ;
+        }
+    }
+
+    // At the very end print connection information
+    printInfo();
+}
+
+void loop()
+{
+    // Loop provides a debugging interface.
+    if (mySerial.available())
+    {
+        Serial.write((char)mySerial.read());
+    }
+#ifdef DEBUG_PASSTHROUGH_ENABLED
+    if (Serial.available())
+    {
+        mySerial.write((char)Serial.read());
+    }
+#endif
+}
+
+void printInfo(void)
+{
+    String currentApn = "";
+    IPAddress ip(0, 0, 0, 0);
+    String currentOperator = "";
+
+    Serial.println(F("Connection info:"));
+    Serial.println(F("Context ID:\tAPN Name:\tIP Address:"));
+    for (int cid = 0; cid < UBX_CELL_NUM_PDP_CONTEXT_IDENTIFIERS; cid++)
+    {
+        String apn = "";
+        IPAddress ip(0, 0, 0, 0);
+        myModule.getAPN(cid, &apn, &ip);
+        if (apn.length() > 0)
+        {
+            Serial.print(cid);
+            Serial.print(F("\t\t"));
+            Serial.print(apn);
+            Serial.print(F("\t"));
+            Serial.println(ip);
+        }
+    }
+
+    // Operator name or number
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Operator: "));
+        Serial.println(currentOperator);
+    }
+
+    // Received signal strength
+    Serial.println("RSSI: " + String(myModule.rssi()));
+    Serial.println();
+}
+
+void printOperators(struct operator_stats *ops, int operatorsAvailable)
+{
+    for (int i = 0; i < operatorsAvailable; i++)
+    {
+        Serial.print(String(i + 1) + ": ");
+        Serial.print(ops[i].longOp + " (" + String(ops[i].numOp) + ") - ");
+        switch (ops[i].stat)
+        {
+        case 0:
+            Serial.print(F("UNKNOWN"));
+            break;
+        case 1:
+            Serial.print(F("AVAILABLE"));
+            break;
+        case 2:
+            Serial.print(F("CURRENT"));
+            break;
+        case 3:
+            Serial.print(F("FORBIDDEN"));
+            break;
+        }
+        switch (ops[i].act)
+        {
+        case 0:
+            Serial.print(F(" - GSM"));
+            break;
+        case 2:
+            Serial.print(F(" - UTRAN"));
+            break;
+        case 3:
+            Serial.print(F(" - GSM/GPRS with EDGE"));
+            break;
+        case 7:
+            Serial.print(F(" - LTE")); // SARA-R5 only supports LTE
+            break;
+        }
+        Serial.println();
+    }
+    Serial.println();
+}
+
+void serialWait()
+{
+    while (Serial.available())
+        Serial.read();
+    while (!Serial.available())
+        ;
+    delay(100);
+    while (Serial.available())
+        Serial.read();
+}

examples/Example4_Clock/Example4_Clock.ino

@@ -0,0 +1,82 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+void setup()
+{
+    String currentOperator = "";
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 4 - Clock"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // Make sure automatic time zone updates are enabled
+    if (myModule.autoTimeZone(true) != UBX_CELL_SUCCESS)
+        Serial.println(F("Enable autoTimeZone failed!"));
+
+    // Read and print the clock as a String
+    String theTime = myModule.clock();
+    Serial.println(theTime);
+
+    // Read and print the hour, minute, etc. separately
+    uint8_t year, month, day, hour, minute, second;
+    int8_t timeZone;
+    if (myModule.clock(&year, &month, &day, &hour, &minute, &second, &timeZone) == UBX_CELL_SUCCESS)
+        // Note: not all Arduino boards implement printf correctly. The formatting may not be correct on some boards.
+        // Note: the timeZone is defined in 15 minute increments, not hours. -28 indicates the time zone is 7 hours
+        // behind UTC/GMT.
+        Serial.printf("%02d/%02d/%02d %02d:%02d:%02d %+d\r\n", year, month, day, hour, minute, second, timeZone);
+}
+
+void loop()
+{
+    // Nothing to do here
+}

examples/Example5_Ping/Example5_Ping.ino

@@ -0,0 +1,142 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+String pingMe = ""; // The name of the server we are going to ping
+
+// processPingResult is provided to the u-blox cellular library via a
+// callback setter -- setPingCallback. (See the end of setup())
+void processPingResult(int retry, int p_size, String remote_hostname, IPAddress ip, int ttl, long rtt)
+{
+    Serial.println();
+    Serial.print(F("Ping Result:  Retry #:"));
+    Serial.print(retry);
+    Serial.print(F("  Ping Size (Bytes):"));
+    Serial.print(p_size);
+    Serial.print(F("  Remote Host:\""));
+    Serial.print(remote_hostname);
+    Serial.print(F("\"  IP Address:\""));
+    Serial.print(String(ip[0]));
+    Serial.print(F("."));
+    Serial.print(String(ip[1]));
+    Serial.print(F("."));
+    Serial.print(String(ip[2]));
+    Serial.print(F("."));
+    Serial.print(String(ip[3]));
+    Serial.print(F("\"  Time To Live (hops):"));
+    Serial.print(ttl);
+    Serial.print(F("  Round Trip (ms):"));
+    Serial.print(rtt);
+    Serial.println();
+}
+
+void setup()
+{
+    String currentOperator = "";
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 5 - Ping"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // First check to see if we're connected to an operator:
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Connected to: "));
+        Serial.println(currentOperator);
+    }
+    else
+    {
+        Serial.print(F("The module is not yet connected to an operator. Please use the previous examples to connect. "
+                       "Or wait and retry. Freezing..."));
+        while (1)
+            ; // Do nothing more
+    }
+
+    Serial.println();
+    Serial.println(F("*** Set the Serial Monitor line ending to Newline ***"));
+
+    Serial.println();
+    Serial.println(F("Enter the name of the server you want to ping (followed by LF / Newline): "));
+    Serial.println(F("Example: \"www.google.com\""));
+
+    // Set a callback to process the Ping result
+    myModule.setPingCallback(&processPingResult);
+}
+
+void loop()
+{
+    if (Serial.available())
+    {
+        char c = Serial.read();
+        if (c == '\n')
+        {
+            // Newline received so let's do that ping!
+            Serial.println("Pinging " + pingMe + "...");
+            myModule.ping(pingMe); // Use the default parameters
+
+            // Use custom parameters
+            // int retries = 4; // number of retries
+            // int p_size = 32; // packet size (bytes)
+            // unsigned long timeout = 5000; // timeout (ms)
+            // int ttl = 32; // Time To Live
+            // myModule.ping(pingMe, retries, p_size, timeout, ttl);
+
+            pingMe = ""; // Clear the server name for the next try
+        }
+        else
+        {
+            // Add serial characters to the server address
+            pingMe += c;
+        }
+    }
+
+    myModule.poll(); // Keep processing data from the module so we can catch the Ping result
+}

examples/Example6_ReceiveSMS/Example6_ReceiveSMS.ino

@@ -0,0 +1,261 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+void setup()
+{
+    String currentOperator = "";
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 6 - Receive SMS"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // First check to see if we're connected to an operator:
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Connected to: "));
+        Serial.println(currentOperator);
+    }
+    else
+    {
+        Serial.print(F("The module is not yet connected to an operator. Please use the previous examples to connect. "
+                       "Or wait and retry. Freezing..."));
+        while (1)
+            ; // Do nothing more
+    }
+
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+}
+
+void loop()
+{
+    static bool printReadMessages =
+        true;                     // Print all messages once. Then only print new messages. Unless a message is deleted.
+    static int previousUsed = -1; // Store the previous number of used memory locations
+
+    // Read the number of used and total messages
+    int used;
+    int total;
+    if (myModule.getPreferredMessageStorage(&used, &total) != UBX_CELL_SUCCESS)
+    {
+        Serial.println(F("An error occurred when trying to read ME memory!"));
+    }
+    else
+    {
+        if ((used != previousUsed) || printReadMessages) // Has a new message arrived? Or was the delete menu opened?
+        {
+            Serial.print(F("\r\nNumber of used memory locations: "));
+            Serial.println(used);
+            Serial.print(F("Total number of memory locations: "));
+            Serial.println(total);
+            Serial.println();
+
+            int memoryLocation = 0;
+            int foundMessages = 0;
+            // Keep reading until we find all the messages or we reach the end of the memory
+            while ((foundMessages < used) && (memoryLocation <= total))
+            {
+                String unread = "";
+                String from = "";
+                String dateTime = "";
+                String message = "";
+                // Read the message from this location. Reading from empty message locations returns an ERROR
+                // unread can be: "REC UNREAD", "REC READ", "STO UNSENT", "STO SENT"
+                // If the location is empty, readSMSmessage will return a UBX_CELL_ERROR_UNEXPECTED_RESPONSE
+                if (myModule.readSMSmessage(memoryLocation, &unread, &from, &dateTime, &message) == UBX_CELL_SUCCESS)
+                {
+                    if (printReadMessages || (unread == "REC UNREAD"))
+                    {
+                        Serial.print(F("Message location: "));
+                        Serial.println(memoryLocation);
+                        Serial.print(F("Status: "));
+                        Serial.println(unread);
+                        Serial.print(F("Originator: "));
+                        Serial.println(from);
+                        Serial.print(F("Date and time: "));
+                        Serial.println(dateTime);
+                        Serial.println(message);
+                        Serial.println();
+                    }
+                    foundMessages++; // We found a message
+                }
+                memoryLocation++; // Move on to the next memory location
+            }
+
+            printReadMessages = false;
+            previousUsed = used; // Update previousUsed
+
+            Serial.println(F("Waiting for a new message..."));
+            Serial.println();
+            Serial.println(F("Hit any key to delete a message..."));
+            Serial.println();
+        }
+    }
+
+    int delayCount = 0;
+    while (delayCount < 5000)
+    {
+        delay(1); // Delay for five seconds, unless the user presses a key
+        delayCount++;
+
+        if (Serial.available())
+        {
+            Serial.println(
+                F("To delete a single message:                        enter its location followed by LF / Newline"));
+            Serial.println(F("To delete all read messages:                       enter r followed by LF / Newline"));
+            Serial.println(F("To delete all read and sent messages:              enter s followed by LF / Newline"));
+            Serial.println(F("To delete all read, sent and unsent messages:      enter u followed by LF / Newline"));
+            Serial.println(F("To delete all messages, including unread messages: enter a followed by LF / Newline"));
+            Serial.println(F("To exit:                                           enter LF / Newline"));
+
+            Serial.read(); // Read and discard the char that opened the menu
+
+            int location = 0;
+            bool selected = false;
+            while (!selected)
+            {
+                while (!Serial.available())
+                    ;                   // Wait for a character to arrive
+                char c = Serial.read(); // Read it
+                if (c == '\n')          // Is it a LF?
+                {
+                    if ((location >= 1) && (location <= total)) // Delete a single message at location
+                    {
+                        if (myModule.deleteSMSmessage(location) == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println(F("\r\nMessage deleted!\r\n"));
+                            printReadMessages = true;
+                        }
+                        else
+                        {
+                            Serial.println(F("\r\nMessage not deleted!\r\n"));
+                        }
+                    }
+                    else if (location == 1001) // r
+                    {
+                        if (myModule.deleteReadSMSmessages() == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println(F("\r\nRead messages deleted!\r\n"));
+                            printReadMessages = true;
+                        }
+                        else
+                        {
+                            Serial.println(F("\r\nMessages not deleted!\r\n"));
+                        }
+                    }
+                    else if (location == 1002) // s
+                    {
+                        if (myModule.deleteReadSentSMSmessages() == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println(F("\r\nRead and sent messages deleted!\r\n"));
+                            printReadMessages = true;
+                        }
+                        else
+                        {
+                            Serial.println(F("\r\nMessages not deleted!\r\n"));
+                        }
+                    }
+                    else if (location == 1003) // u
+                    {
+                        if (myModule.deleteReadSentUnsentSMSmessages() == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println(F("\r\nRead, sent and unsent messages deleted!\r\n"));
+                            printReadMessages = true;
+                        }
+                        else
+                        {
+                            Serial.println(F("\r\nMessages not deleted!\r\n"));
+                        }
+                    }
+                    else if (location == 1004) // a
+                    {
+                        if (myModule.deleteAllSMSmessages() == UBX_CELL_SUCCESS)
+                        {
+                            Serial.println(F("\r\nAll messages deleted!\r\n"));
+                            printReadMessages = true;
+                        }
+                        else
+                        {
+                            Serial.println(F("\r\nMessages not deleted!\r\n"));
+                        }
+                    }
+                    else
+                        Serial.println(F("\r\nExit...\r\n"));
+                    selected = true;
+                }
+                else if ((c >= '0') && (c <= '9'))
+                {
+                    location *= 10;      // Multiply by 10
+                    location += c - '0'; // Add the digit
+                }
+                else if (c == 'r')
+                {
+                    location = 1001;
+                }
+                else if (c == 's')
+                {
+                    location = 1002;
+                }
+                else if (c == 'u')
+                {
+                    location = 1003;
+                }
+                else if (c == 'a')
+                {
+                    location = 1004;
+                }
+            }
+
+            delayCount = 5000;
+        }
+    }
+}

examples/Example7_SendSMS/Example7_SendSMS.ino

@@ -0,0 +1,131 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+void setup()
+{
+    String currentOperator = "";
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 7 - Send SMS"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // First check to see if we're connected to an operator:
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Connected to: "));
+        Serial.println(currentOperator);
+    }
+    else
+    {
+        Serial.print(F("The module is not yet connected to an operator. Please use the previous examples to connect. "
+                       "Or wait and retry. Freezing..."));
+        while (1)
+            ; // Do nothing more
+    }
+
+    Serial.println();
+    Serial.println(F("*** Set the Serial Monitor line ending to Newline ***"));
+}
+
+void loop()
+{
+    String destinationNumber = "";
+    String message = "";
+    boolean keepGoing = true;
+
+    Serial.println();
+    Serial.println(F("Enter the destination number (followed by LF / Newline): "));
+
+    while (keepGoing)
+    {
+        if (Serial.available())
+        {
+            char c = Serial.read();
+            if (c == '\n')
+            {
+                keepGoing = false; // Stop if we receive a newline
+            }
+            else
+            {
+                destinationNumber += c; // Add serial characters to the destination number
+            }
+        }
+    }
+
+    keepGoing = true;
+    Serial.println();
+    Serial.println(F("Enter the message (followed by LF): "));
+
+    while (keepGoing)
+    {
+        if (Serial.available())
+        {
+            char c = Serial.read();
+            if (c == '\n')
+            {
+                keepGoing = false; // Stop if we receive a newline
+            }
+            else
+            {
+                message += c; // Add serial characters to the destination number
+            }
+        }
+    }
+
+    // Once we receive a newline, send the text.
+    Serial.println("Sending: \"" + message + "\" to " + destinationNumber);
+    // Call myModule.sendSMS(String number, String message) to send an SMS message.
+    if (myModule.sendSMS(destinationNumber, message) == UBX_CELL_SUCCESS)
+    {
+        Serial.println(F("sendSMS was successful"));
+    }
+}

examples/Example8_MQTT/Example8_MQTT.ino

@@ -0,0 +1,268 @@
+#include "SparkFun_u-blox_Cellular_Arduino_Library.h"
+
+// Uncomment the line below that you need for Serial on your platform
+#define mySerial Serial1
+// SoftwareSerial mySerial(16, 17);
+
+// Uncomment the module you're using. If your module is not listed below, then
+// it's not supported for this example
+SparkFun_ublox_Cellular myModule; // This example works with all modules, so the base class can be used
+// SparkFun_ublox_SARA_R5 myModule; // Base SARA-R5 class
+// SparkFun_ublox_SARA_R500S myModule;
+// SparkFun_ublox_SARA_R500S_01B myModule;
+// SparkFun_ublox_SARA_R500S_61B myModule;
+// SparkFun_ublox_SARA_R510M8S_61B myModule;
+// SparkFun_ublox_SARA_R510S myModule;
+// SparkFun_ublox_LARA_R6 myModule; // Base LARA-R6 class
+// SparkFun_ublox_LARA_R6001 myModule;
+// SparkFun_ublox_LARA_R6001D myModule;
+// SparkFun_ublox_LARA_R6401 myModule;
+// SparkFun_ublox_LARA_R6401D myModule;
+// SparkFun_ublox_LARA_R6801_00B myModule;
+// SparkFun_ublox_LARA_R6801D myModule;
+
+// You can change the Quality of Service (QoS) here if you want
+int qos = 0;
+
+// Topics that will be used for publishing and subscribing
+String publishTopic;
+String subscribeTopic;
+
+// Whether we're connected to the MQTT broker
+bool mqttConnected = false;
+
+// Callback function for handling MQTT responses from the module
+void mqttCallback(int command, int result)
+{
+    if (command == UBX_CELL_MQTT_COMMAND_LOGIN && result == 1)
+    {
+        // Connected to broker
+        mqttConnected = true;
+        Serial.println(F("Connected to broker!"));
+    }
+    else if (command == UBX_CELL_MQTT_COMMAND_LOGOUT && result == 1)
+    {
+        // Disconnected from broker
+        mqttConnected = false;
+        Serial.println(F("Disconnected from broker!"));
+    }
+    else if (command == UBX_CELL_MQTT_COMMAND_SUBSCRIBE && result == 1)
+    {
+        // Topic subscription successful
+        Serial.println(F("Subscribed to topic!"));
+        Serial.println(F("Enter any text to post to the topic"));
+        Serial.println();
+    }
+    else if (command == UBX_CELL_MQTT_COMMAND_READ)
+    {
+        // New message available
+        Serial.print(F("A new message is available! Total messages to read: "));
+        Serial.println(result);
+        Serial.println(F("Enter a blank line to read the oldest message"));
+        Serial.println();
+    }
+    else
+    {
+        // Other response
+        Serial.print(F("Unknown MQTT reponse! Command: "));
+        Serial.print(command);
+        Serial.print(F(" Result: "));
+        Serial.println(result);
+    }
+}
+
+void setup()
+{
+    String currentOperator = "";
+
+    Serial.begin(115200); // Start the serial console
+
+    // Wait for user to press key to begin
+    Serial.println(F("u-blox Cellular Example 8 - MQTT"));
+    Serial.println(F("Press any key to begin"));
+
+    while (!Serial.available()) // Wait for the user to press a key (send any serial character)
+        ;
+    while (Serial.available()) // Empty the serial RX buffer
+        Serial.read();
+
+    Serial.println(F("Beginning..."));
+
+    // myModule.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+    // For the MicroMod Asset Tracker, we need to invert the power pin so it pulls high instead of low
+    // Uncomment the next line if required
+    // myModule.invertPowerPin(true);
+
+    // Initialize the module
+    if (myModule.begin(mySerial, UBX_CELL_DEFAULT_BAUD_RATE))
+    {
+        Serial.println(F("Module connected!"));
+    }
+    else
+    {
+        Serial.println(F("Unable to communicate with the module."));
+        Serial.println(F("Manually power-on (hold the module's On button for 3 seconds) and try again."));
+        while (1)
+            ; // Loop forever on fail
+    }
+    Serial.println();
+
+    // First check to see if we're connected to an operator:
+    if (myModule.getOperator(&currentOperator) == UBX_CELL_SUCCESS)
+    {
+        Serial.print(F("Connected to: "));
+        Serial.println(currentOperator);
+    }
+    else
+    {
+        Serial.print(F("The module is not yet connected to an operator. Please use the previous examples to connect. "
+                       "Or wait and retry. Freezing..."));
+        while (1)
+            ; // Do nothing more
+    }
+
+    Serial.println();
+
+    // Make sure any previous MQTT connection is closed
+    myModule.disconnectMQTT();
+
+    // Set callback for any MQTT responses from the module
+    myModule.setMQTTCommandCallback(mqttCallback);
+
+    Serial.println(F("Enter the MQTT broker server name"));
+
+    // Clear any previous input and wait for new input
+    while (Serial.available())
+        Serial.read();
+    while (!Serial.available())
+        ;
+
+    // Get the broker server name
+    String serverName = Serial.readStringUntil('\n');
+    Serial.print(F("Server name: "));
+    Serial.println(serverName);
+    Serial.println();
+
+    Serial.println(F("Enter the MQTT broker server port number"));
+    Serial.println(F("(or enter nothing for default port of 1883)"));
+
+    // Clear any previous input and wait for new input
+    while (Serial.available())
+        Serial.read();
+    while (!Serial.available())
+        ;
+
+    // Get the broker server port
+    String serverPort = Serial.readStringUntil('\n');
+
+    // Attempt to parse the port number. If it fails, just set 1883
+    int port = serverPort.toInt();
+    if (port == 0)
+        port = 1883;
+
+    Serial.print(F("Server port: "));
+    Serial.println(port);
+    Serial.println();
+
+    // Now set the MQTT server
+    myModule.setMQTTserver(serverName, port);
+
+    Serial.println(F("Enter the client ID"));
+
+    // Clear any previous input and wait for new input
+    while (Serial.available())
+        Serial.read();
+    while (!Serial.available())
+        ;
+
+    // Get the client ID
+    String clientID = Serial.readStringUntil('\n');
+    Serial.print(F("Client ID: "));
+    Serial.println(clientID);
+    Serial.println();
+
+    // Set the client ID
+    myModule.setMQTTclientId(clientID);
+
+    Serial.println(F("Connecting to MQTT broker..."));
+    myModule.connectMQTT();
+
+    // Wait for module to connect
+    while (!mqttConnected)
+        myModule.poll();
+
+    Serial.println();
+    Serial.println(F("Enter a topic to publish to"));
+
+    // Clear any previous input and wait for new input
+    while (Serial.available())
+        Serial.read();
+    while (!Serial.available())
+        ;
+
+    // Get the topic name
+    publishTopic = Serial.readStringUntil('\n');
+    Serial.print(F("Publish topic: "));
+    Serial.println(publishTopic);
+    Serial.println();
+
+    Serial.println();
+    Serial.println(F("Enter a topic to subscribe to"));
+
+    // Clear any previous input and wait for new input
+    while (Serial.available())
+        Serial.read();
+    while (!Serial.available())
+        ;
+
+    // Get the topic name
+    subscribeTopic = Serial.readStringUntil('\n');
+    Serial.print(F("Subscribe topic: "));
+    Serial.println(subscribeTopic);
+    Serial.println();
+
+    // Subscribe to the topic
+    myModule.subscribeMQTTtopic(qos, subscribeTopic);
+}
+
+void loop()
+{
+    // Need to call poll() frequently to receive updates from the module.
+    myModule.poll();
+
+    // Check for user input
+    if (Serial.available())
+    {
+        // Get user's input
+        String inputString = Serial.readStringUntil('\n');
+
+        // Clear any remaining input
+        while (Serial.available())
+            Serial.read();
+
+        // Check whether the user entered anything
+        if (inputString.length() > 0)
+        {
+            // Publish the user's input to the topic
+            Serial.println(F("Publishing message:"));
+            Serial.println(inputString);
+            Serial.println();
+            myModule.mqttPublishTextMsg(publishTopic, inputString.c_str());
+        }
+        else
+        {
+            // Read next received message
+            uint8_t buffer[MAX_MQTT_DIRECT_MSG_LEN];
+            int bytesRead = 0;
+            myModule.readMQTT(&qos, &subscribeTopic, buffer, MAX_MQTT_DIRECT_MSG_LEN, &bytesRead);
+
+            // Print out message
+            Serial.println(F("Received message:"));
+            for (int i = 0; i < bytesRead; i++)
+                Serial.print((char)buffer[i]);
+            Serial.println();
+            Serial.println();
+        }
+    }
+}

library.properties

@@ -0,0 +1,9 @@
+name=SparkFun u-blox Cellular Arduino Library
+version=1.0.0
+author=SparkFun Electronics <techsupport@sparkfun.com>
+maintainer=SparkFun Electronics <sparkfun.com>
+sentence=Library for u-blox cellular modules
+paragraph=
+category=Communication
+url=https://github.com/sparkfun/SparkFun_u-blox_Cellular_Arduino_Library
+architectures=*

src/SparkFun_u-blox_Cellular_Arduino_Library.h

@@ -0,0 +1,4 @@
+#include "sfe_lara_r6.h"
+#include "sfe_sara_r5.h"
+#include "sfe_ublox_cellular.h"
+#include "sfe_ublox_cellular_voice.h"

src/SparkFun_u-blox_SARA-R5_Arduino_Library.h

@@ -0,0 +1,36 @@
+#ifndef SFE_LARA_R6_LIBRARY_H
+#define SFE_LARA_R6_LIBRARY_H
+
+#include "sfe_ublox_cellular.h"
+#include "sfe_ublox_cellular_voice.h"
+
+// Base LARA-R6 class
+class SparkFun_ublox_LARA_R6 : public SparkFun_ublox_Cellular
+{
+};
+
+class SparkFun_ublox_LARA_R6001 : public SparkFun_ublox_LARA_R6, public SparkFun_ublox_Cellular_Voice_Base<SparkFun_ublox_LARA_R6001>
+{
+};
+
+class SparkFun_ublox_LARA_R6001D : public SparkFun_ublox_LARA_R6
+{
+};
+
+class SparkFun_ublox_LARA_R6401 : public SparkFun_ublox_LARA_R6, public SparkFun_ublox_Cellular_Voice_Base<SparkFun_ublox_LARA_R6401>
+{
+};
+
+class SparkFun_ublox_LARA_R6401D : public SparkFun_ublox_LARA_R6
+{
+};
+
+class SparkFun_ublox_LARA_R6801_00B : public SparkFun_ublox_LARA_R6, public SparkFun_ublox_Cellular_Voice_Base<SparkFun_ublox_LARA_R6801_00B>
+{
+};
+
+class SparkFun_ublox_LARA_R6801D : public SparkFun_ublox_LARA_R6
+{
+};
+
+#endif

src/sfe_lara_r6.h

@@ -0,0 +1,330 @@
+#include "sfe_sara_r5.h"
+
+SparkFun_ublox_SARA_R5::SparkFun_ublox_SARA_R5()
+{
+    addURCHandler(UBX_CELL_MESSAGE_PDP_ACTION_URC,
+                  [this](const char *event) { return this->urcHandlerPDPAction(event); });
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setUtimeMode(UBX_CELL_utime_mode_t mode, UBX_CELL_utime_sensor_t sensor)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_GNSS_REQUEST_TIME) + 16;
+    char command[cmdLen];
+
+    if (mode == UBX_CELL_UTIME_MODE_STOP) // stop UTIME does not require a sensor
+        snprintf(command, cmdLen, "%s=%d", UBX_CELL_GNSS_REQUEST_TIME, mode);
+    else
+        snprintf(command, cmdLen, "%s=%d,%d", UBX_CELL_GNSS_REQUEST_TIME, mode, sensor);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_10_SEC_TIMEOUT);
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::getUtimeMode(UBX_CELL_utime_mode_t *mode, UBX_CELL_utime_sensor_t *sensor)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_GNSS_REQUEST_TIME) + 2;
+    char command[cmdLen];
+    char response[minimumResponseAllocation];
+
+    UBX_CELL_utime_mode_t m;
+    UBX_CELL_utime_sensor_t s;
+
+    snprintf(command, cmdLen, "%s?", UBX_CELL_GNSS_REQUEST_TIME);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, response, UBX_CELL_10_SEC_TIMEOUT);
+
+    // Response format: \r\n+UTIME: <mode>[,<sensor>]\r\n\r\nOK\r\n
+    if (err == UBX_CELL_ERROR_SUCCESS)
+    {
+        int mStore, sStore, scanned = 0;
+        char *searchPtr = strnstr(response, "+UTIME:", minimumResponseAllocation);
+        if (searchPtr != nullptr)
+        {
+            searchPtr += strlen("+UTIME:"); // Move searchPtr to first character - probably a space
+            while (*searchPtr == ' ')
+                searchPtr++; // skip spaces
+            scanned = sscanf(searchPtr, "%d,%d\r\n", &mStore, &sStore);
+        }
+        m = (UBX_CELL_utime_mode_t)mStore;
+        s = (UBX_CELL_utime_sensor_t)sStore;
+        if (scanned == 2)
+        {
+            *mode = m;
+            *sensor = s;
+        }
+        else if (scanned == 1)
+        {
+            *mode = m;
+            *sensor = UBX_CELL_UTIME_SENSOR_NONE;
+        }
+        else
+            err = UBX_CELL_ERROR_UNEXPECTED_RESPONSE;
+    }
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setUtimeIndication(UBX_CELL_utime_urc_configuration_t config)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_GNSS_TIME_INDICATION) + 16;
+    char command[cmdLen];
+
+    snprintf(command, cmdLen, "%s=%d", UBX_CELL_GNSS_TIME_INDICATION, config);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::getUtimeIndication(UBX_CELL_utime_urc_configuration_t *config)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_GNSS_TIME_INDICATION) + 2;
+    char command[cmdLen];
+    char response[minimumResponseAllocation];
+
+    UBX_CELL_utime_urc_configuration_t c;
+
+    snprintf(command, cmdLen, "%s?", UBX_CELL_GNSS_TIME_INDICATION);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, response, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    // Response format: \r\n+UTIMEIND: <mode>\r\n\r\nOK\r\n
+    if (err == UBX_CELL_ERROR_SUCCESS)
+    {
+        int cStore, scanned = 0;
+        char *searchPtr = strnstr(response, "+UTIMEIND:", minimumResponseAllocation);
+        if (searchPtr != nullptr)
+        {
+            searchPtr += strlen("+UTIMEIND:"); //  Move searchPtr to first char
+            while (*searchPtr == ' ')
+                searchPtr++; // skip spaces
+            scanned = sscanf(searchPtr, "%d\r\n", &cStore);
+        }
+        c = (UBX_CELL_utime_urc_configuration_t)cStore;
+        if (scanned == 1)
+        {
+            *config = c;
+        }
+        else
+            err = UBX_CELL_ERROR_UNEXPECTED_RESPONSE;
+    }
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setUtimeConfiguration(int32_t offsetNanoseconds, int32_t offsetSeconds)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_GNSS_TIME_CONFIGURATION) + 48;
+    char command[cmdLen];
+
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+    snprintf(command, cmdLen, "%s=%d,%d", UBX_CELL_GNSS_TIME_CONFIGURATION, offsetNanoseconds, offsetSeconds);
+#else
+    snprintf(command, cmdLen, "%s=%ld,%ld", UBX_CELL_GNSS_TIME_CONFIGURATION, offsetNanoseconds, offsetSeconds);
+#endif
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::getUtimeConfiguration(int32_t *offsetNanoseconds, int32_t *offsetSeconds)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_GNSS_TIME_CONFIGURATION) + 2;
+    char command[cmdLen];
+    char response[minimumResponseAllocation];
+
+    int32_t ons;
+    int32_t os;
+
+    snprintf(command, cmdLen, "%s?", UBX_CELL_GNSS_TIME_CONFIGURATION);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, response, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    // Response format: \r\n+UTIMECFG: <offset_nano>,<offset_sec>\r\n\r\nOK\r\n
+    if (err == UBX_CELL_ERROR_SUCCESS)
+    {
+        int scanned = 0;
+        char *searchPtr = strnstr(response, "+UTIMECFG:", minimumResponseAllocation);
+        if (searchPtr != nullptr)
+        {
+            searchPtr += strlen("+UTIMECFG:"); //  Move searchPtr to first char
+            while (*searchPtr == ' ')
+                searchPtr++; // skip spaces
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+            scanned = sscanf(searchPtr, "%d,%d\r\n", &ons, &os);
+#else
+            scanned = sscanf(searchPtr, "%ld,%ld\r\n", &ons, &os);
+#endif
+        }
+        if (scanned == 2)
+        {
+            *offsetNanoseconds = ons;
+            *offsetSeconds = os;
+        }
+        else
+            err = UBX_CELL_ERROR_UNEXPECTED_RESPONSE;
+    }
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter, int value)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_MESSAGE_PDP_CONFIG) + 24;
+    char command[cmdLen];
+
+    if (profile >= UBX_CELL_NUM_PSD_PROFILES)
+        return UBX_CELL_ERROR_ERROR;
+
+    snprintf(command, cmdLen, "%s=%d,%d,%d", UBX_CELL_MESSAGE_PDP_CONFIG, profile, parameter, value);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+                                              UBX_CELL_pdp_protocol_type_t value)
+{
+    return (setPDPconfiguration(profile, parameter, (int)value));
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+                                              String value)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_MESSAGE_PDP_CONFIG) + 64;
+    char command[cmdLen];
+
+    if (profile >= UBX_CELL_NUM_PSD_PROFILES)
+        return UBX_CELL_ERROR_ERROR;
+
+    snprintf(command, cmdLen, "%s=%d,%d,\"%s\"", UBX_CELL_MESSAGE_PDP_CONFIG, profile, parameter, value.c_str());
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+                                              IPAddress value)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_MESSAGE_PDP_CONFIG) + 64;
+    char command[cmdLen];
+
+    if (profile >= UBX_CELL_NUM_PSD_PROFILES)
+        return UBX_CELL_ERROR_ERROR;
+
+    snprintf(command, cmdLen, "%s=%d,%d,\"%d.%d.%d.%d\"", UBX_CELL_MESSAGE_PDP_CONFIG, profile, parameter, value[0],
+             value[1], value[2], value[3]);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::performPDPaction(int profile, UBX_CELL_pdp_actions_t action)
+{
+    UBX_CELL_error_t err;
+    size_t cmdLen = strlen(UBX_CELL_MESSAGE_PDP_ACTION) + 32;
+    char command[cmdLen];
+
+    if (profile >= UBX_CELL_NUM_PSD_PROFILES)
+        return UBX_CELL_ERROR_ERROR;
+
+    snprintf(command, cmdLen, "%s=%d,%d", UBX_CELL_MESSAGE_PDP_ACTION, profile, action);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    return err;
+}
+
+UBX_CELL_error_t SparkFun_ublox_SARA_R5::getNetworkAssignedIPAddress(int profile, IPAddress *address)
+{
+    size_t cmdLen = strlen(UBX_CELL_NETWORK_ASSIGNED_DATA) + 16;
+    char command[cmdLen];
+    char response[minimumResponseAllocation];
+    UBX_CELL_error_t err;
+    int scanNum = 0;
+    int profileStore = 0;
+    int paramTag = 0; // 0: IP address: dynamic IP address assigned during PDP context activation
+    int paramVals[4];
+
+    snprintf(command, cmdLen, "%s=%d,%d", UBX_CELL_NETWORK_ASSIGNED_DATA, profile, paramTag);
+
+    err = sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, response, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+
+    if (err == UBX_CELL_ERROR_SUCCESS)
+    {
+        char *searchPtr = strnstr(response, "+UPSND:", minimumResponseAllocation);
+        if (searchPtr != nullptr)
+        {
+            searchPtr += strlen("+UPSND:"); //  Move searchPtr to first char
+            while (*searchPtr == ' ')
+                searchPtr++; // skip spaces
+            scanNum = sscanf(searchPtr, "%d,%d,\"%d.%d.%d.%d\"", &profileStore, &paramTag, &paramVals[0], &paramVals[1],
+                             &paramVals[2], &paramVals[3]);
+        }
+        if (scanNum != 6)
+        {
+            if (_printDebug == true)
+            {
+                _debugPort->print(F("getNetworkAssignedIPAddress: error: scanNum is "));
+                _debugPort->println(scanNum);
+            }
+            return UBX_CELL_ERROR_UNEXPECTED_RESPONSE;
+        }
+
+        IPAddress tempAddress = {(uint8_t)paramVals[0], (uint8_t)paramVals[1], (uint8_t)paramVals[2],
+                                 (uint8_t)paramVals[3]};
+        *address = tempAddress;
+    }
+
+    return err;
+}
+
+bool SparkFun_ublox_SARA_R5::urcHandlerPDPAction(const char *event)
+{
+    // URC: +UUPSDA (Packet Switched Data Action)
+    int result;
+    IPAddress remoteIP = {0, 0, 0, 0};
+    int scanNum;
+    int remoteIPstore[4];
+
+    char *searchPtr = strnstr(event, UBX_CELL_MESSAGE_PDP_ACTION_URC, _RXBuffSize);
+    if (searchPtr != nullptr)
+    {
+        searchPtr += strlen(UBX_CELL_MESSAGE_PDP_ACTION_URC); // Move searchPtr to first character - probably a space
+        while (*searchPtr == ' ')
+            searchPtr++; // skip spaces
+        scanNum = sscanf(searchPtr, "%d,\"%d.%d.%d.%d\"", &result, &remoteIPstore[0], &remoteIPstore[1],
+                         &remoteIPstore[2], &remoteIPstore[3]);
+
+        if (scanNum == 5)
+        {
+            if (_printDebug == true)
+                _debugPort->println(F("processReadEvent: packet switched data action"));
+
+            for (int i = 0; i <= 3; i++)
+            {
+                remoteIP[i] = (uint8_t)remoteIPstore[i];
+            }
+
+            if (_psdActionRequestCallback != nullptr)
+            {
+                _psdActionRequestCallback(result, remoteIP);
+            }
+
+            return true;
+        }
+    }
+
+    return false;
+}

src/sfe_sara_r5.cpp

@@ -0,0 +1,73 @@
+#ifndef SFE_SARA_R5_LIBRARY_H
+#define SFE_SARA_R5_LIBRARY_H
+
+#include "sfe_ublox_cellular.h"
+
+const char *const UBX_CELL_MESSAGE_PDP_CONFIG = "+UPSD";     // Packet switched Data Profile configuration
+const char *const UBX_CELL_MESSAGE_PDP_ACTION = "+UPSDA";    // Perform the action for the specified PSD profile
+const char *const UBX_CELL_NETWORK_ASSIGNED_DATA = "+UPSND"; // Packet switched network-assigned data
+const char *const UBX_CELL_GNSS_REQUEST_TIME = "+UTIME";     // Ask for time information from cellular modem (CellTime)
+const char *const UBX_CELL_GNSS_TIME_INDICATION = "+UTIMEIND"; // Time information request status unsolicited indication
+const char *const UBX_CELL_GNSS_TIME_CONFIGURATION = "+UTIMECFG"; // Sets time configuration
+
+const char *const UBX_CELL_MESSAGE_PDP_ACTION_URC = "+UUPSDA:";
+
+// Base SARA-R5 class
+class SparkFun_ublox_SARA_R5 : public SparkFun_ublox_Cellular
+{
+  public:
+    SparkFun_ublox_SARA_R5();
+
+    UBX_CELL_error_t setUtimeMode(
+        UBX_CELL_utime_mode_t mode = UBX_CELL_UTIME_MODE_PPS,
+        UBX_CELL_utime_sensor_t sensor = UBX_CELL_UTIME_SENSOR_GNSS_LTE); // Time mode, source etc. (+UTIME)
+    UBX_CELL_error_t getUtimeMode(UBX_CELL_utime_mode_t *mode, UBX_CELL_utime_sensor_t *sensor);
+    UBX_CELL_error_t setUtimeIndication(
+        UBX_CELL_utime_urc_configuration_t config = UBX_CELL_UTIME_URC_CONFIGURATION_ENABLED); // +UTIMEIND
+    UBX_CELL_error_t getUtimeIndication(UBX_CELL_utime_urc_configuration_t *config);
+    UBX_CELL_error_t setUtimeConfiguration(int32_t offsetNanoseconds = 0, int32_t offsetSeconds = 0); // +UTIMECFG
+    UBX_CELL_error_t getUtimeConfiguration(int32_t *offsetNanoseconds, int32_t *offsetSeconds);
+
+    // Packet Switched Data
+    // Configure the PDP using +UPSD. See UBX_CELL_pdp_configuration_parameter_t for the list of parameters: protocol,
+    // APN, username, DNS, etc.
+    UBX_CELL_error_t setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+                                         int value); // Set parameters in the chosen PSD profile
+    UBX_CELL_error_t setPDPconfiguration(
+        int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+        UBX_CELL_pdp_protocol_type_t value); // Set parameters in the chosen PSD profile
+    UBX_CELL_error_t setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+                                         String value); // Set parameters in the chosen PSD profile
+    UBX_CELL_error_t setPDPconfiguration(int profile, UBX_CELL_pdp_configuration_parameter_t parameter,
+                                         IPAddress value); // Set parameters in the chosen PSD profile
+    UBX_CELL_error_t performPDPaction(
+        int profile, UBX_CELL_pdp_actions_t action); // Performs the requested action for the specified PSD profile:
+                                                     // reset, store, load, activate, deactivate
+    UBX_CELL_error_t getNetworkAssignedIPAddress(
+        int profile, IPAddress *address); // Get the dynamic IP address assigned during PDP context activation
+
+  protected:
+    bool urcHandlerPDPAction(const char *event);
+};
+
+class SparkFun_ublox_SARA_R500S : public SparkFun_ublox_SARA_R5
+{
+};
+
+class SparkFun_ublox_SARA_R500S_01B : public SparkFun_ublox_SARA_R5
+{
+};
+
+class SparkFun_ublox_SARA_R500S_61B : public SparkFun_ublox_SARA_R5
+{
+};
+
+class SparkFun_ublox_SARA_R510M8S_61B : public SparkFun_ublox_SARA_R5
+{
+};
+
+class SparkFun_ublox_SARA_R510S : public SparkFun_ublox_SARA_R5
+{
+};
+
+#endif

src/sfe_sara_r5.h

@@ -0,0 +1,166 @@
+#ifndef SPARKFUN_UBX_CELL_VOICE_ARDUINO_LIBRARY_H
+#define SPARKFUN_UBX_CELL_VOICE_ARDUINO_LIBRARY_H
+
+#include "sfe_ublox_cellular.h"
+
+const char *const UBX_CELL_COMMAND_DIAL = "D";              // Dial command
+const char *const UBX_CELL_COMMAND_ANSWER = "A";            // Answer call
+const char *const UBX_CELL_COMMAND_HANG_UP = "+CHUP";       // Hang up call
+const char *const UBX_CELL_COMMAND_PLAY_AUDIO = "+UPAR";    // Play audio resource
+const char *const UBX_CELL_COMMAND_STOP_AUDIO = "+USAR";    // Stop audio resource
+const char *const UBX_CELL_COMMAND_GENERATE_TONE = "+UTGN"; // Tone generator
+
+const char *const UBX_CELL_RING_URC = "RING";
+
+typedef enum
+{
+    UBX_CELL_AUDIO_RESOURCE_TONE = 0,
+    UBX_CELL_AUDIO_RESOURCE_MIDI = 1,
+    UBX_CELL_AUDIO_RESOURCE_LOOPBACK = 2
+} UBX_CELL_audio_resource_t;
+
+// Base class for any modules supporting voice calls
+template <typename T> class SparkFun_ublox_Cellular_Voice_Base
+{
+  public:
+    SparkFun_ublox_Cellular_Voice_Base(void)
+    {
+        // Set ring URC callback to nullptr
+        _ringCallback = nullptr;
+
+        // Add handler for ring URC
+        static_cast<T *>(this)->addURCHandler(UBX_CELL_RING_URC,
+                                              [this](const char *event) { return this->urcCheckRing(event); });
+    }
+
+    UBX_CELL_error_t dial(String number)
+    {
+        char *command;
+        char *numberCStr;
+        UBX_CELL_error_t err;
+
+        numberCStr = static_cast<T *>(this)->ubx_cell_calloc_char(number.length() + 1);
+        if (numberCStr == nullptr)
+            return UBX_CELL_ERROR_OUT_OF_MEMORY;
+        number.toCharArray(numberCStr, number.length() + 1);
+
+        size_t cmdLen = strlen(UBX_CELL_COMMAND_DIAL) + strlen(numberCStr) + 3;
+        command = static_cast<T *>(this)->ubx_cell_calloc_char(cmdLen);
+        if (command != nullptr)
+        {
+            // Heads up! The dial command is one of the only commands that requires a
+            // semicolon at the end of it!
+            snprintf(command, cmdLen, "%s=%s;", UBX_CELL_COMMAND_DIAL, numberCStr);
+
+            err = static_cast<T *>(this)->sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK, nullptr,
+                                                                  UBX_CELL_10_SEC_TIMEOUT);
+
+            free(command);
+        }
+        else
+        {
+            err = UBX_CELL_ERROR_OUT_OF_MEMORY;
+        }
+
+        free(numberCStr);
+
+        return err;
+    }
+
+    UBX_CELL_error_t answer(void)
+    {
+        return static_cast<T *>(this)->sendCommandWithResponse(UBX_CELL_COMMAND_ANSWER, UBX_CELL_RESPONSE_OK_OR_ERROR,
+                                                               nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+    }
+
+    UBX_CELL_error_t hangUp(void)
+    {
+        return static_cast<T *>(this)->sendCommandWithResponse(UBX_CELL_COMMAND_HANG_UP, UBX_CELL_RESPONSE_OK_OR_ERROR,
+                                                               nullptr, UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+    }
+
+    UBX_CELL_error_t playAudioResource(uint8_t audio_resource, uint8_t tone_id = 0, uint8_t nof_repeat = 0)
+    {
+        UBX_CELL_error_t err;
+        size_t cmdLen = strlen(UBX_CELL_COMMAND_PLAY_AUDIO) + 13;
+        char command[cmdLen];
+
+        snprintf(command, cmdLen, "%s=%d,%d,%d", UBX_CELL_COMMAND_PLAY_AUDIO, audio_resource, tone_id, nof_repeat);
+
+        err = static_cast<T *>(this)->sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr,
+                                                              UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+        return err;
+    }
+
+    UBX_CELL_error_t stopAudioResource(uint8_t audio_resource)
+    {
+        UBX_CELL_error_t err;
+        size_t cmdLen = strlen(UBX_CELL_COMMAND_STOP_AUDIO) + 5;
+        char command[cmdLen];
+
+        snprintf(command, cmdLen, "%s=%d", UBX_CELL_COMMAND_STOP_AUDIO, audio_resource);
+
+        err = static_cast<T *>(this)->sendCommandWithResponse(command, UBX_CELL_RESPONSE_OK_OR_ERROR, nullptr,
+                                                              UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+        return err;
+    }
+
+    UBX_CELL_error_t generateToneFreq(uint16_t frequency, uint16_t duration, uint8_t volume)
+    {
+        UBX_CELL_error_t err;
+        size_t cmdLen = strlen(UBX_CELL_COMMAND_GENERATE_TONE) + 15;
+        char command[cmdLen];
+        char response[] = "\r\nOK\r\n\r\n+UUTGN: 0\r\n";
+
+        snprintf(command, cmdLen, "%s=%d,%d,%d", UBX_CELL_COMMAND_GENERATE_TONE, frequency, duration, volume);
+
+        err = static_cast<T *>(this)->sendCommandWithResponse(command, response, nullptr,
+                                                              UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+        return err;
+    }
+
+    UBX_CELL_error_t generateToneDTMF(char dtmf_character, uint16_t duration, uint8_t volume)
+    {
+        UBX_CELL_error_t err;
+        size_t cmdLen = strlen(UBX_CELL_COMMAND_GENERATE_TONE) + 14;
+        char command[cmdLen];
+        char response[] = "\r\nOK\r\n\r\n+UUTGN: 0\r\n";
+
+        snprintf(command, cmdLen, "%s=\"%c\",%d,%d", UBX_CELL_COMMAND_GENERATE_TONE, dtmf_character, duration, volume);
+
+        err = static_cast<T *>(this)->sendCommandWithResponse(command, response, nullptr,
+                                                              UBX_CELL_STANDARD_RESPONSE_TIMEOUT);
+        return err;
+    }
+
+    void setRingCallback(void (*callback)(void))
+    {
+        _ringCallback = callback;
+    }
+
+  protected:
+    // Callback for incoming calls
+    void (*_ringCallback)(void);
+
+    bool urcCheckRing(const char *event)
+    {
+        int socket, length;
+        char *searchPtr = strnstr(event, UBX_CELL_RING_URC, _RXBuffSize);
+        if (searchPtr != nullptr)
+        {
+            if (_ringCallback != nullptr)
+            {
+                _ringCallback();
+            }
+            return true;
+        }
+
+        return false;
+    }
+};
+
+class SparkFun_ublox_Cellular_Voice : public SparkFun_ublox_Cellular, public SparkFun_ublox_Cellular_Voice_Base<SparkFun_ublox_Cellular_Voice>
+{
+};
+
+#endif