Add option to clear urc data and fix external interrupt logic in low power

Author: M65649

src/examples/low_power/low_power.ino

@@ -4,32 +4,51 @@
 #include <log.h>
 #include <low_power.h>
 #include <lte.h>
+#include <sequans_controller.h>
 
-void setup() {
+#ifdef __AVR_AVR128DB48__ // MINI
 
-    LedCtrl.begin();
+#define SerialDebug Serial3
+
+#else
+#ifdef __AVR_AVR128DB64__ // Non-Mini
+
+#define SerialDebug Serial5
+
+#else
+#error "INCOMPATIBLE_DEVICE_SELECTED"
+#endif
+#endif
+
+void setup() {
 
     Log.begin(115200);
-    Log.setLogLevel(LogLevel::DEBUG);
+
+    LedCtrl.begin();
+    LedCtrl.startupCycle();
 
     // Configure the power save configuration, start the LTE modem and wait
     // until we are connected to the operator
     //
     // Here we say that we want to sleep for 30 seconds * 2 = 60 seconds each
     // time we invoke sleep
-    LowPower.begin(SleepMultiplier::THIRTY_SECONDS, 2, SleepMode::DEEP);
+    LowPower.begin(SleepMultiplier::THIRTY_SECONDS, 2, SleepMode::REGULAR);
     Lte.begin();
-
+    Log.infof("Connecting to operator");
     while (!Lte.isConnected()) {
-        Log.info("Waiting for connection...\r\n");
-        delay(2000);
+        Log.raw(".");
+        delay(1000);
     }
 
-    Log.info("Connected to operator!\r\n");
+    Log.raw("\r\n");
+    Log.infof("Connected to operator: %s\r\n", Lte.getOperator().c_str());
 }
 
 void loop() {
 
+    Log.raw("\r\n");
+    Log.info("Going to sleep...");
+    delay(100);
     WakeUpReason wakeup_reason = LowPower.sleep();
     Log.infof("Got out of sleep with wake up reason %d, doing work...\r\n",
               wakeup_reason);

src/examples/sandbox/sandbox.ino

@@ -15,6 +15,8 @@
 #include <mcp9808.h>
 #include <mqtt_client.h>
 
+#include <Wire.h>
+
 #define HEARTBEAT_INTERVAL_MS 10000
 
 // AWS defines which topic you are allowed to subscribe and publish too. This is
@@ -218,7 +220,6 @@ void decodeMessage(const char *message) {
 
 void setup() {
     Log.begin(115200);
-    Log.setLogLevel(LogLevel::DEBUG);
 
     LedCtrl.begin();
     LedCtrl.startupCycle();
@@ -229,7 +230,7 @@ void setup() {
     Log.infof("Starting sandbox / landing page procedure. Version = %s\r\n",
               SANDBOX_VERSION);
 
-    if (Mcp9808.begin(0x18) == -1) {
+    if (Mcp9808.begin(0x18)) {
         Log.error("Could not initialize the temperature sensor");
     }
 
@@ -257,6 +258,8 @@ void setup() {
 
 void loop() {
 
+    // ----------------------------------------------------------
+
     if (event_flags & NETWORK_CONN_FLAG) {
         switch (state) {
         case NOT_CONNECTED:

src/low_power.cpp

@@ -211,7 +211,7 @@ static uint32_t retrieveOperatorSleepTime(void) {
     SequansController.clearReceiveBuffer();
     SequansController.writeCommand(AT_COMMAND_CONNECTION_STATUS);
 
-    char response[RESPONSE_CONNECTION_STATUS_SIZE];
+    char response[RESPONSE_CONNECTION_STATUS_SIZE] = "";
     const ResponseResult response_result = SequansController.readResponse(
         response, RESPONSE_CONNECTION_STATUS_SIZE);
 
@@ -227,7 +227,7 @@ static uint32_t retrieveOperatorSleepTime(void) {
     }
 
     // Find the sleep timer token in the response
-    char sleep_timer_token[TIMER_LENGTH];
+    char sleep_timer_token[TIMER_LENGTH] = "";
     const bool found_token = SequansController.extractValueFromCommandResponse(
         response, TIMER_SLEEP_INDEX, sleep_timer_token, TIMER_LENGTH);
 
@@ -336,6 +336,7 @@ static WakeUpReason regularSleep(void) {
             Log.debugf("Got invalid sleep time: %d\r\n", sleep_time);
             return WakeUpReason::INVALID_SLEEP_TIME;
         } else {
+            Log.debugf("Sleep time set to: %d seconds\r\n", sleep_time);
             retrieved_sleep_time = true;
         }
     }
@@ -369,6 +370,12 @@ static WakeUpReason regularSleep(void) {
 
         sleep_cpu();
 
+        // Woken up by some external interrupt
+        if (!pit_triggered && modem_is_in_power_save) {
+            wakeup_reason = WakeUpReason::EXTERNAL_INTERRUPT;
+            break;
+        }
+
         // Got woken up by the PIT interrupt
         if (pit_triggered) {
             remaining_time_seconds -= 1;
@@ -385,9 +392,6 @@ static WakeUpReason regularSleep(void) {
                 wakeup_reason = WakeUpReason::AWOKEN_BY_MODEM_PREMATURELY;
                 break;
             }
-        } else {
-            wakeup_reason = WakeUpReason::EXTERNAL_INTERRUPT;
-            break;
         }
     }
 

src/low_power.h

@@ -20,20 +20,20 @@ enum class SleepMultiplier {
 
 enum class WakeUpReason {
     // Invoked if the sleep time retrieved from the operator wasn't valid
-    INVALID_SLEEP_TIME = 3,
+    INVALID_SLEEP_TIME = 4,
 
     // Invoked if it took so long to put the modem in sleep that it wasn't time
     // left for the CPU to sleep. The sleep time should be considered to be
     // increased.
-    MODEM_TIMEOUT = 2,
+    MODEM_TIMEOUT = 3,
 
     // The modem went out of sleep before the total time, which may happen if
     // e.g. the interval of needing to send MQTT heartbeat is lower than the
     // sleep time.
-    AWOKEN_BY_MODEM_PREMATURELY = 1,
+    AWOKEN_BY_MODEM_PREMATURELY = 2,
 
     // External interrup caused the AVR to go out of sleep
-    EXTERNAL_INTERRUPT,
+    EXTERNAL_INTERRUPT = 1,
 
     OK = 0,
 };

src/lte.cpp

@@ -125,7 +125,7 @@ void LteClass::begin(void) {
     }
 
     // Enable the default callback
-    SequansController.registerCallback(CEREG_CALLBACK, connectionStatus);
+    SequansController.registerCallback(CEREG_CALLBACK, connectionStatus, false);
 
     // This is convenient when the MCU has been issued a reset, but the lte
     // modem is already connected, which will be the case during development for

src/sequans_controller.cpp

@@ -88,10 +88,10 @@ static volatile uint16_t tx_num_elements = 0;
 // We keep two buffers for identifier and data so that data won't be overwritten
 // whilst we are looking for a new URC. In that way the data buffer will only be
 // overwritten if we find an URC we are looking for.
-static uint8_t urc_identifier_buffer[URC_IDENTIFIER_BUFFER_SIZE];
-static char urc_data_buffer[URC_DATA_BUFFER_SIZE];
-static volatile uint8_t urc_identifier_buffer_length = 0;
-static volatile uint8_t urc_data_buffer_length = 0;
+static volatile uint8_t urc_identifier_buffer[URC_IDENTIFIER_BUFFER_SIZE];
+static volatile char urc_data_buffer[URC_DATA_BUFFER_SIZE];
+static volatile uint16_t urc_identifier_buffer_length = 0;
+static volatile uint16_t urc_data_buffer_length = 0;
 
 typedef enum {
     URC_PARSING_IDENTIFIER,
@@ -101,8 +101,11 @@ typedef enum {
 
 static UrcParseState urc_parse_state = URC_NOT_PARSING;
 
-static char urc_lookup_table[MAX_URC_CALLBACKS][URC_IDENTIFIER_BUFFER_SIZE];
-static uint8_t urc_lookup_table_length[MAX_URC_CALLBACKS];
+static volatile uint8_t urc_index = 0;
+static volatile char urc_lookup_table[MAX_URC_CALLBACKS]
+                                     [URC_IDENTIFIER_BUFFER_SIZE];
+static volatile uint8_t urc_lookup_table_length[MAX_URC_CALLBACKS];
+static volatile bool urc_lookup_table_clear_data[MAX_URC_CALLBACKS];
 void (*urc_callbacks[MAX_URC_CALLBACKS])(char *);
 
 // Used to keep a pointer to the URC we are processing and found to be matching,
@@ -215,6 +218,8 @@ ISR(USART1_RXC_vect) {
                     if (memcmp(urc_identifier_buffer,
                                urc_lookup_table[i],
                                urc_lookup_table_length[i]) == 0) {
+
+                        urc_index = i;
                         urc_current_callback = urc_callbacks[i];
                         urc_parse_state = URC_PARSING_DATA;
 
@@ -243,9 +248,11 @@ ISR(USART1_RXC_vect) {
             if (urc_current_callback != NULL) {
                 // Clear the buffer for the URC since we're passing the data
                 // with the URC callback
-                rx_head_index =
-                    (rx_head_index - urc_data_buffer_length) & RX_BUFFER_MASK;
-                rx_num_elements -= urc_data_buffer_length;
+                if (urc_lookup_table_clear_data[urc_index]) {
+                    rx_head_index = (rx_head_index - urc_data_buffer_length) &
+                                    RX_BUFFER_MASK;
+                    rx_num_elements -= urc_data_buffer_length;
+                }
 
                 urc_current_callback(urc_data_buffer);
                 urc_current_callback = NULL;
@@ -623,14 +630,16 @@ bool SequansControllerClass::extractValueFromCommandResponse(
 }
 
 bool SequansControllerClass::registerCallback(const char *urc_identifier,
-                                              void (*urc_callback)(char *)) {
+                                              void (*urc_callback)(char *),
+                                              const bool clear_data) {
 
     // Check if we can override first
     uint8_t urc_identifier_length = strlen(urc_identifier);
     for (uint8_t i = 0; i < MAX_URC_CALLBACKS; i++) {
         if (urc_lookup_table_length[i] == urc_identifier_length &&
             strcmp(urc_identifier, urc_lookup_table[i]) == 0) {
             urc_callbacks[i] = urc_callback;
+            urc_lookup_table_clear_data[i] = clear_data;
             return true;
         }
     }
@@ -641,6 +650,7 @@ bool SequansControllerClass::registerCallback(const char *urc_identifier,
             strcpy(urc_lookup_table[i], urc_identifier);
             urc_lookup_table_length[i] = strlen(urc_identifier);
             urc_callbacks[i] = urc_callback;
+            urc_lookup_table_clear_data[i] = clear_data;
             return true;
         }
     }

src/sequans_controller.h

@@ -170,12 +170,15 @@ class SequansControllerClass {
      * registration.
      *
      * @param urc_callback Callback with URC data as argument.
+     * @param clear_data Whether the UART RX buffer will be cleared of the URC
+     * or not. This is to save space in the buffer.
      *
      * @return true if we didn't surpass the fixed amount of URC callbacks
      * allowed for registration.
      */
     bool registerCallback(const char *urc_identifier,
-                          void (*urc_callback)(char *));
+                          void (*urc_callback)(char *),
+                          const bool clear_data = true);
 
     /**
      * @brief Unregister callback for a given URC identifier.