MCU8MASS-1842 Catch SQNHTTPSH URC for better error logging

Author: M65649

src/http_client.cpp

@@ -4,12 +4,14 @@
 #include "log.h"
 #include "security_profile.h"
 #include "sequans_controller.h"
+#include "timeout_timer.h"
 
 #include <Arduino.h>
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <util/delay.h>
 
 #define HTTPS_SECURITY_PROFILE_NUMBER (3)
 
@@ -41,10 +43,132 @@ const char HTTP_CONTENT_TYPE_APPLICATION_OCTET_STREAM[] PROGMEM          = "2";
 const char HTTP_CONTENT_TYPE_APPLICATION_MULTIPART_FORM_DATA[] PROGMEM   = "3";
 const char HTTP_CONTENT_TYPE_APPLICATION_APPLICATION_JSON[] PROGMEM      = "4";
 
-const char HTTP_RING_URC[] PROGMEM = "SQNHTTPRING";
+const char HTTP_RING_URC[] PROGMEM     = "SQNHTTPRING";
+const char HTTP_SHUTDOWN_URC[] PROGMEM = "SQNHTTPSH";
 
 HttpClientClass HttpClient = HttpClientClass::instance();
 
+static volatile bool got_shutdown_callback   = false;
+static volatile uint16_t shutdown_error_code = 0;
+
+/**
+ * @brief Registered as a callback for the HTTP shutdown URC.
+ */
+static void httpShutdownCallback(char* urc) {
+    char error_code_buffer[8] = "";
+
+    const bool got_error_code =
+        SequansController.extractValueFromCommandResponse(
+            urc,
+            1,
+            error_code_buffer,
+            sizeof(error_code_buffer) - 1,
+            0);
+
+    if (!got_error_code) {
+        return;
+    }
+
+    got_shutdown_callback = true;
+    shutdown_error_code   = atoi(error_code_buffer);
+}
+
+/**
+ * @brief Waits for the HTTP response URC from the modem and returns the HTTP
+ * response codes. This function also checks for an abrupt shutdown of the HTTP
+ * connection, where the shutdown URC is sent with a cURL status code.
+ */
+static HttpResponse waitForResponse(const uint32_t timeout_ms) {
+
+    HttpResponse http_response = {0, 0, 0};
+
+    char http_response_buffer[HTTP_RESPONSE_MAX_LENGTH]                = "";
+    char http_status_code_buffer[HTTP_RESPONSE_STATUS_CODE_LENGTH + 1] = "";
+    char data_size_buffer[HTTP_RESPONSE_DATA_SIZE_LENGTH]              = "";
+
+    const auto toggle_led_whilst_waiting = [] {
+        LedCtrl.toggle(Led::DATA, true);
+    };
+
+    // If the request fails for some reason, we will retrieve the SQNHTTPSH
+    // (shutdown) URC which has the reason for failure, so we want to listen for
+    // that as well
+    got_shutdown_callback = false;
+    SequansController.registerCallback(FV(HTTP_SHUTDOWN_URC),
+                                       httpShutdownCallback);
+
+    if (!SequansController.waitForURC(FV(HTTP_RING_URC),
+                                      http_response_buffer,
+                                      sizeof(http_response_buffer),
+                                      timeout_ms,
+                                      toggle_led_whilst_waiting,
+                                      500)) {
+        LedCtrl.off(Led::DATA, true);
+
+        SequansController.unregisterCallback(FV(HTTP_SHUTDOWN_URC));
+
+        Log.warnf(F("Did not get HTTP response before timeout on %d ms. "
+                    "Consider increasing the timeout.\r\n"),
+                  timeout_ms);
+
+        return http_response;
+    }
+
+    // We pass 0 as the start character here as the URC data will only
+    // contain the payload, not the URC identifier
+    const bool got_response_code =
+        SequansController.extractValueFromCommandResponse(
+            http_response_buffer,
+            HTTP_RESPONSE_STATUS_CODE_INDEX,
+            http_status_code_buffer,
+            HTTP_RESPONSE_STATUS_CODE_LENGTH + 1,
+            0);
+
+    const bool got_data_size =
+        SequansController.extractValueFromCommandResponse(
+            http_response_buffer,
+            HTTP_RESPONSE_DATA_SIZE_INDEX,
+            data_size_buffer,
+            HTTP_RESPONSE_DATA_SIZE_LENGTH,
+            0);
+
+    if (got_response_code) {
+        http_response.status_code = atoi(http_status_code_buffer);
+
+        // The modem reports 0 as the status code if the connection has been
+        // shut down with an error
+        if (http_response.status_code == 0) {
+            // The request failed, check if we got a shutdown URC. We give the
+            // URC some time to arrive here.
+            TimeoutTimer timer(1000);
+
+            while (!got_shutdown_callback && !timer.hasTimedOut()) {
+                _delay_ms(1);
+            }
+
+            if (got_shutdown_callback) {
+                if (shutdown_error_code != 0) {
+                    Log.errorf(
+                        F("HTTP request failed with cURL error code: %d\r\n"),
+                        shutdown_error_code);
+                }
+
+                http_response.curl_error_code = shutdown_error_code;
+            }
+        }
+    }
+
+    if (got_data_size) {
+        http_response.data_size = atoi(data_size_buffer);
+    }
+
+    SequansController.unregisterCallback(FV(HTTP_SHUTDOWN_URC));
+
+    LedCtrl.off(Led::DATA, true);
+
+    return http_response;
+}
+
 /**
  * @brief Generic method for sending data via HTTP, either with POST or PUT.
  *
@@ -72,7 +196,7 @@ sendData(const char* endpoint,
     // other, this alleviates this
     SequansController.writeCommand(F("AT"));
 
-    HttpResponse http_response = {0, 0};
+    HttpResponse http_response = {0, 0, 0};
 
     if (!SequansController.writeString(
             F("AT+SQNHTTPSND=0,%u,\"%s\",%lu,\"%s\",\"%s\""),
@@ -105,56 +229,8 @@ sendData(const char* endpoint,
         SequansController.writeBytes(data, data_length, true);
     }
 
-    char http_response_buffer[HTTP_RESPONSE_MAX_LENGTH]                = "";
-    char http_status_code_buffer[HTTP_RESPONSE_STATUS_CODE_LENGTH + 1] = "";
-    char data_size_buffer[HTTP_RESPONSE_DATA_SIZE_LENGTH]              = "";
+    http_response = waitForResponse(timeout_ms);
 
-    const auto toggle_led_whilst_waiting = [] {
-        LedCtrl.toggle(Led::DATA, true);
-    };
-
-    // Now we wait for the URC
-    if (!SequansController.waitForURC(FV(HTTP_RING_URC),
-                                      http_response_buffer,
-                                      sizeof(http_response_buffer),
-                                      timeout_ms,
-                                      toggle_led_whilst_waiting,
-                                      500)) {
-        LedCtrl.off(Led::DATA, true);
-        LedCtrl.off(Led::CON, true);
-
-        Log.warnf(F("Did not get HTTP response before timeout on %d ms. "
-                    "Consider increasing the timeout.\r\n"),
-                  timeout_ms);
-
-        return http_response;
-    }
-
-    // We pass in NULL as the start character here as the URC data will only
-    // contain the payload, not the URC identifier
-    bool got_response_code = SequansController.extractValueFromCommandResponse(
-        http_response_buffer,
-        HTTP_RESPONSE_STATUS_CODE_INDEX,
-        http_status_code_buffer,
-        HTTP_RESPONSE_STATUS_CODE_LENGTH + 1,
-        (char)NULL);
-
-    bool got_data_size = SequansController.extractValueFromCommandResponse(
-        http_response_buffer,
-        HTTP_RESPONSE_DATA_SIZE_INDEX,
-        data_size_buffer,
-        HTTP_RESPONSE_DATA_SIZE_LENGTH,
-        (char)NULL);
-
-    if (got_response_code) {
-        http_response.status_code = atoi(http_status_code_buffer);
-    }
-
-    if (got_data_size) {
-        http_response.data_size = atoi(data_size_buffer);
-    }
-
-    LedCtrl.off(Led::DATA, true);
     LedCtrl.off(Led::CON, true);
 
     return http_response;
@@ -182,7 +258,7 @@ static HttpResponse queryData(const char* endpoint,
     // other, this alleviates this
     SequansController.writeCommand(F("AT"));
 
-    HttpResponse http_response = {0, 0};
+    HttpResponse http_response = {0, 0, 0};
 
     const ResponseResult response = SequansController.writeCommand(
         F("AT+SQNHTTPQRY=0,%u,\"%s\",\"%s\""),
@@ -198,52 +274,8 @@ static HttpResponse queryData(const char* endpoint,
         return http_response;
     }
 
-    char http_response_buffer[HTTP_RESPONSE_MAX_LENGTH]                = "";
-    char http_status_code_buffer[HTTP_RESPONSE_STATUS_CODE_LENGTH + 1] = "";
-    char data_size_buffer[HTTP_RESPONSE_DATA_SIZE_LENGTH]              = "";
+    http_response = waitForResponse(timeout_ms);
 
-    const auto toggle_led_whilst_waiting = [] {
-        LedCtrl.toggle(Led::DATA, true);
-    };
-
-    if (!SequansController.waitForURC(FV(HTTP_RING_URC),
-                                      http_response_buffer,
-                                      sizeof(http_response_buffer),
-                                      timeout_ms,
-                                      toggle_led_whilst_waiting,
-                                      500)) {
-        Log.warnf(F("Did not get HTTP response before timeout on %d ms. "
-                    "Consider increasing the timeout.\r\n"),
-                  timeout_ms);
-
-        LedCtrl.off(Led::DATA, true);
-        LedCtrl.off(Led::CON, true);
-        return http_response;
-    }
-
-    bool got_response_code = SequansController.extractValueFromCommandResponse(
-        http_response_buffer,
-        HTTP_RESPONSE_STATUS_CODE_INDEX,
-        http_status_code_buffer,
-        HTTP_RESPONSE_STATUS_CODE_LENGTH + 1,
-        (char)NULL);
-
-    bool got_data_size = SequansController.extractValueFromCommandResponse(
-        http_response_buffer,
-        HTTP_RESPONSE_DATA_SIZE_INDEX,
-        data_size_buffer,
-        HTTP_RESPONSE_DATA_SIZE_LENGTH,
-        (char)NULL);
-
-    if (got_response_code) {
-        http_response.status_code = atoi(http_status_code_buffer);
-    }
-
-    if (got_data_size) {
-        http_response.data_size = atoi(data_size_buffer);
-    }
-
-    LedCtrl.off(Led::DATA, true);
     LedCtrl.off(Led::CON, true);
 
     return http_response;

src/http_client.h

@@ -13,6 +13,7 @@
 typedef struct {
     uint16_t status_code;
     uint32_t data_size;
+    uint16_t curl_error_code;
 } HttpResponse;
 
 class HttpClientClass {