Merge branch 'develop' of ssh://bitbucket.microchip.com/mcu8mass/avr-iot-cellular-arduino-library into low-power/decrease-power-consumption

Author: M65649

examples/mqtt_with_connection_loss_handling/mqtt_with_connection_loss_handling.ino

@@ -0,0 +1,166 @@
+/**
+ * @brief This example demonstrates a more robust MQTT program which takes into
+ * consideration network disconnection and broker disconnection.
+ */
+
+#include <Arduino.h>
+
+#include <ecc608.h>
+#include <led_ctrl.h>
+#include <log.h>
+#include <lte.h>
+#include <mqtt_client.h>
+#include <sequans_controller.h>
+
+#define MQTT_PUB_TOPIC_FMT "%s/sensors"
+
+static char mqtt_pub_topic[128];
+
+static volatile bool connecteded_to_network = false;
+static volatile bool connected_to_broker    = false;
+
+void connectedToBroker(void) { connected_to_broker = true; }
+void disconnectedFromBroker(void) { connected_to_broker = false; }
+
+void disconnectedFromNetwork(void) { connecteded_to_network = false; }
+
+bool initMQTTTopics() {
+    ECC608.begin();
+
+    // Find the thing ID and set the publish and subscription topics
+    uint8_t thingName[128];
+    uint8_t thingNameLen = sizeof(thingName);
+
+    // -- Get the thingname
+    uint8_t err = ECC608.getThingName(thingName, &thingNameLen);
+    if (err != ECC608.ERR_OK) {
+        Log.error("Could not retrieve thingname from the ECC");
+        return false;
+    }
+
+    sprintf(mqtt_pub_topic, MQTT_PUB_TOPIC_FMT, thingName);
+
+    return true;
+}
+
+static bool connectLTE() {
+    // Connect with a maximum timeout value of 30 000 ms, if the connection is
+    // not up and running within 30 seconds, abort and retry later
+    if (!Lte.begin(30000)) {
+        Log.warn("Failed to connect to operator.");
+        return false;
+    } else {
+        return true;
+    }
+}
+
+static bool connectMqtt() {
+
+    uint32_t start = millis();
+
+    // Attempt to connect to the broker
+    if (MqttClient.beginAWS()) {
+        Log.infof("Connecting to broker");
+
+        // Wait for 60 seconds max
+        while (!MqttClient.isConnected() && millis() - start < 60000) {
+            Log.rawf(".");
+            delay(500);
+        }
+
+        if (millis() - start >= 60000) {
+            Log.rawf(" Failed to connect\r\n");
+            return false;
+        }
+
+        Log.rawf(" OK!\r\n");
+
+        connected_to_broker = true;
+    } else {
+        Log.rawf("\r\n");
+        Log.error("Failed to connect to broker");
+
+        return false;
+    }
+
+    return true;
+}
+
+void setup() {
+    Log.begin(115200);
+    LedCtrl.begin();
+    LedCtrl.startupCycle();
+
+    Log.info("Starting MQTT with Connection Loss Handling\r\n");
+
+    if (initMQTTTopics() == false) {
+        Log.error("Unable to initialize the MQTT topics. Stopping...");
+        while (1) {}
+    }
+
+    Lte.onDisconnect(disconnectedFromNetwork);
+    MqttClient.onConnectionStatusChange(connectedToBroker,
+                                        disconnectedFromBroker);
+
+    SequansController.begin();
+
+    SequansController.writeCommand("at+cmee=2");
+}
+
+/**
+ * @brief Used to keep track of the number of publishes.
+ */
+static uint32_t counter = 0;
+
+/**
+ * @brief Counts the times the publish has failed due to a timeout.
+ */
+static uint32_t failed_publishes = 0;
+
+/**
+ * @brief Used for keeping track of time so that a message is published every
+ * 10th second under normal operations (when connected to the network and
+ * broker).
+ */
+static uint32_t timer = 0;
+
+void loop() {
+
+    if (!connecteded_to_network) {
+        Log.info("Not connected to the network. Attempting to connect!");
+        if (connectLTE()) {
+            connecteded_to_network = true;
+        }
+    }
+
+    if (!connected_to_broker && connecteded_to_network) {
+        Log.info("Not connected to broker. Attempting to connect!");
+
+        if (connectMqtt()) {
+            connected_to_broker = true;
+        }
+    }
+
+    if (millis() - timer > 10000) {
+        if (connected_to_broker) {
+            char message_to_publish[8] = {0};
+            sprintf(message_to_publish, "%lu", counter);
+
+            bool published_successfully = MqttClient.publish(mqtt_pub_topic,
+                                                             message_to_publish,
+                                                             AT_LEAST_ONCE,
+                                                             60000);
+            if (published_successfully) {
+                Log.infof("Published message: %s. Failed publishes: %d.\r\n",
+                          message_to_publish,
+                          failed_publishes);
+            } else {
+                failed_publishes++;
+            }
+
+            counter++;
+        }
+
+        timer = millis();
+    }
+}

examples/sandbox/sandbox.ino

@@ -288,7 +288,7 @@ void setup() {
     attachInterrupt(PIN_PD2, sendHeartbeatInterrupt, FALLING);
 
     // Set PF6 as input (reset button)
-    pinConfigure(PIN_PF6, PIN_DIR_INPUT);
+    pinConfigure(PIN_PF6, PIN_DIR_INPUT | PIN_PULLUP_ON);
     attachInterrupt(PIN_PF6, resetInterrupt, FALLING);
 
     sei();

src/lte.cpp

@@ -1,4 +1,5 @@
 #include "lte.h"
+
 #include "led_ctrl.h"
 #include "log.h"
 #include "mqtt_client.h"
@@ -97,14 +98,22 @@ static void timezoneCallback(__attribute__((unused)) char* buffer) {
     got_timezone = true;
 }
 
-bool LteClass::begin(const bool print_messages) {
+bool LteClass::begin(const uint32_t timeout_ms, const bool print_messages) {
+
+    const uint32_t start = millis();
 
     // If low power is utilized, sequans controller will already been
     // initialized, so don't reset it by calling begin again
     if (!SequansController.isInitialized()) {
         SequansController.begin();
     }
 
+    // Disconnect before configuration if already connected
+    SequansController.writeCommand(AT_DISCONNECT);
+
+    delay(100);
+    SequansController.clearReceiveBuffer();
+
     SequansController.registerCallback(TIMEZONE_CALLBACK, timezoneCallback);
 
     SequansController.writeCommand(AT_ENABLE_TIME_ZONE_UPDATE);
@@ -154,7 +163,7 @@ bool LteClass::begin(const bool print_messages) {
         Log.infof("Connecting to operator");
     }
 
-    while (!isConnected()) {
+    while (!isConnected() && millis() - start < timeout_ms) {
         LedCtrl.toggle(Led::CELL, true);
         delay(500);
 
@@ -163,6 +172,20 @@ bool LteClass::begin(const bool print_messages) {
         }
     }
 
+    if (millis() - start >= timeout_ms) {
+
+        Log.rawf(" Was not able to connect to the network within the timeout "
+                 "of %d ms. Consider increasing the timeout or checking your "
+                 "cellular coverage.\r\n",
+                 timeout_ms);
+
+        SequansController.unregisterCallback(CEREG_CALLBACK);
+        SequansController.unregisterCallback(TIMEZONE_CALLBACK);
+        SequansController.writeCommand(AT_DISCONNECT);
+
+        return false;
+    }
+
     if (print_messages) {
         Log.rawf(" OK!\r\n");
     }
@@ -267,6 +290,7 @@ void LteClass::end(void) {
         while (isConnected() && millis() - start < 2000) {}
         SequansController.unregisterCallback(CEREG_CALLBACK);
 
+        SequansController.clearReceiveBuffer();
         SequansController.end();
     }
 

src/lte.h

@@ -30,12 +30,15 @@ class LteClass {
      * @brief Initializes the LTE module and its controller interface. Connects
      * to the network.
      *
+     * @param timeout_ms The amount of time to wait for connection before
+     * aborting.
      * @param print_messages If set to true, the messages related to connection
      * will be logged.
      *
      * @return True if initialization was successful and connection was made.
      */
-    bool begin(const bool print_messages = true);
+    bool begin(const uint32_t timeout_ms = 600000,
+               const bool print_messages = true);
 
     /**
      * @brief Disables the interface with the LTE module. Disconnects from