Added command-response interface

 - Parse incoming data from rmaker_cmd_resp and call insights_config_update
 - Publish a message to rmaker that we support command resp
 - Subscribe to command response topic

Two command response APIs: init and enable
 - The init part is only used by ESP-Insights and is not needed by RainMaker.
This is because, RainMaker already does this.

Author: vikramdattu

components/esp_diagnostics/include/esp_diagnostics.h

@@ -103,6 +103,7 @@ typedef enum {
     ESP_DIAG_DATA_TYPE_STR,      /*!< Data type string */
     ESP_DIAG_DATA_TYPE_IPv4,     /*!< Data type IPv4 address */
     ESP_DIAG_DATA_TYPE_MAC,      /*!< Data type MAC address */
+    ESP_DIAG_DATA_TYPE_INVALID,  /*!< Not supported by diagnostics */
 } esp_diag_data_type_t;
 
 /**

components/esp_insights/CMakeLists.txt

@@ -3,6 +3,7 @@ set(srcs "src/esp_insights.c"
         "src/esp_insights_transport.c"
         "src/esp_insights_client_data.c"
         "src/esp_insights_encoder.c"
+        "src/esp_insights_cmd_resp.c"
         "src/esp_insights_cbor_decoder.c"
         "src/esp_insights_cbor_encoder.c")
 

components/esp_insights/Kconfig

@@ -41,6 +41,16 @@ menu "ESP Insights"
 
     endchoice
 
+    config ESP_INSIGHTS_CMD_RESP_ENABLED
+        depends on (ESP_INSIGHTS_ENABLED && ESP_INSIGHTS_TRANSPORT_MQTT)
+        bool "Enable command response module"
+        default n
+        help
+            Enabling this option adds control of certain insights options remotely.
+            When enabled, the available configurations, should be shown on the dashboard
+            and controllable from there.
+            Please note, the feature is only available with RainMaker MQTT nodes for now.
+
     config ESP_INSIGHTS_TRANSPORT_HTTPS_HOST
         depends on ESP_INSIGHTS_TRANSPORT_HTTPS
         string "Insights https host"

components/esp_insights/include/esp_insights.h

@@ -5,6 +5,7 @@
  */
 
 #pragma once
+
 #include <stdint.h>
 #include <esp_err.h>
 #include <esp_event_base.h>
@@ -200,6 +201,28 @@ void esp_insights_disable(void);
  * @return Pointer to a NULL terminated Node ID string.
  */
 const char *esp_insights_get_node_id(void);
+
+/**
+ * @brief Encode and parse the command directly using esp-insight's parser
+ *
+ * This tests only if the parser is working as expected.
+ */
+esp_err_t esp_insights_test_cmd_handler();
+
+/**
+ * @brief Enable esp-insights command-response module
+ *
+ * This API registers esp-insights command parser which when data is received,
+ * parses it to filter out insights specific data, modifies configs accordingly,
+ * and prepares and gives response data to the module
+ *
+ * The \ref esp_insights_init takes care of initializing command response and
+ * enabling the same. In cases where, only esp_insights_enable is called, e.g.,
+ * ESP Rainmaker's app_insights module, user needs to call this API, before or
+ * after \ref esp_insights_enable
+ */
+esp_err_t esp_insights_cmd_resp_enable(void);
+
 #ifdef __cplusplus
 }
 #endif

components/esp_insights/src/esp_insights.c

@@ -60,6 +60,7 @@
 
 #define SEND_INSIGHTS_META (CONFIG_DIAG_ENABLE_METRICS || CONFIG_DIAG_ENABLE_VARIABLES)
 
+/* TAG for reporting generic miscellaneous insights. Different from ESP_LOGx tag */
 #define TAG_DIAG            "diag"
 #define KEY_LOG_WR_FAIL     "log_wr_fail"
 
@@ -105,6 +106,8 @@ static const char *TAG = "esp_insights";
 static esp_insights_data_t s_insights_data;
 static esp_insights_entry_t *s_periodic_insights_entry;
 
+extern esp_err_t esp_insights_cmd_resp_init(void);
+
 static void esp_insights_first_call(void *priv_data)
 {
     if (!priv_data) {
@@ -927,6 +930,11 @@ esp_err_t esp_insights_init(esp_insights_config_t *config)
     }
 
     s_insights_data.init_done = true;
+
+    err = esp_insights_cmd_resp_init() || esp_insights_cmd_resp_enable();
+    if (err != ESP_OK) { /* device can keep working neverthless */
+        ESP_LOGE(TAG, "Failed to enable insights_cmd_resp");
+    }
     return ESP_OK;
 init_err:
     if (s_insights_data.node_id) {

components/esp_insights/src/esp_insights_cbor_decoder.c

@@ -11,6 +11,7 @@
 #include <esp_rmaker_utils.h>
 
 #include <cbor.h>
+#include "esp_insights_cbor_decoder.h"
 
 static const char *TAG = "insight_cbor_dec";
 
@@ -281,3 +282,101 @@ esp_err_t esp_insights_cbor_decode_dump(const uint8_t *buffer, int len)
 
     return ESP_OK;
 }
+
+bool esp_insights_cbor_decoder_at_end(cbor_parse_ctx_t *ctx)
+{
+    return cbor_value_at_end(&ctx->it[ctx->curr_itr]);
+}
+
+esp_err_t esp_insights_cbor_decoder_advance(cbor_parse_ctx_t *ctx)
+{
+    if (CborNoError == cbor_value_advance(&ctx->it[ctx->curr_itr])) {
+        return ESP_OK;
+    }
+    return ESP_FAIL;
+}
+
+CborType esp_insights_cbor_decode_get_value_type(cbor_parse_ctx_t *ctx)
+{
+    return cbor_value_get_type(&ctx->it[ctx->curr_itr]);
+}
+
+char *esp_insights_cbor_decoder_get_string(CborValue *val)
+{
+    CborError ret = CborNoError;
+    char *buf = NULL;
+    size_t n;
+    if (cbor_value_get_type(val) != CborTextStringType) {
+        return NULL;
+    }
+    ret = cbor_value_dup_text_string(val, &buf, &n, val);
+    if (ret == CborNoError) {
+        return (char *) buf;
+    }
+    return NULL;
+}
+
+esp_err_t esp_insights_cbor_decoder_enter_container(cbor_parse_ctx_t *ctx)
+{
+    CborError ret = CborNoError;
+    int curr_itr = ctx->curr_itr;
+    if (curr_itr >= INS_CBOR_MAX_DEPTH) {
+        ESP_LOGE(TAG, "Cannot parse depth more than %d", INS_CBOR_MAX_DEPTH);
+        return ESP_FAIL;
+    }
+    ret = cbor_value_enter_container(&ctx->it[curr_itr], &ctx->it[curr_itr + 1]);
+    if (ret != CborNoError) {
+        ESP_LOGE(TAG, "error entering container");
+        return ESP_FAIL;
+    }
+    if (esp_insights_cbor_decoder_at_end(ctx)) {
+        return ESP_FAIL;
+    }
+    ctx->curr_itr++;
+
+    return ESP_OK;
+}
+
+esp_err_t esp_insights_cbor_decoder_exit_container(cbor_parse_ctx_t *ctx)
+{
+    CborError ret = CborNoError;
+    if (ctx->curr_itr <= 0) {
+        ESP_LOGE(TAG, "cannot exit, already at top");
+        return ESP_FAIL;
+    }
+    ctx->curr_itr--;
+    int curr_itr = ctx->curr_itr;
+    ret = cbor_value_leave_container(&ctx->it[curr_itr], &ctx->it[curr_itr + 1]);
+    if (ret != CborNoError) {
+        ESP_LOGE(TAG, "error leaving container");
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_insights_cbor_decoder_done(cbor_parse_ctx_t *ctx)
+{
+    if (ctx) {
+        free(ctx);
+    }
+    return ESP_OK;
+}
+
+cbor_parse_ctx_t *esp_insights_cbor_decoder_start(const uint8_t *buffer, int len)
+{
+    if (!buffer || len == 0) {
+        return NULL;
+    }
+    cbor_parse_ctx_t *ctx = calloc(1, sizeof(cbor_parse_ctx_t));
+    if (!ctx) {
+        ESP_LOGE(TAG, "failed to allocate cbor ctx");
+        return NULL;
+    }
+    CborParser root_parser = ctx->root_parser;
+    CborValue *it = &ctx->it[0];
+    if (cbor_parser_init(buffer, len, 0, &root_parser, it) != CborNoError) {
+        ESP_LOGE(TAG, "Error initializing cbor parser");
+        return NULL;
+    }
+    return ctx;
+}

components/esp_insights/src/esp_insights_cbor_decoder.h

@@ -15,6 +15,30 @@
 
 #include <cbor.h>
 
+#include <esp_err.h>
+
+#define INS_CBOR_MAX_DEPTH 12 // depth to which we can traverse
+
+typedef struct cbor_parse_ctx {
+    CborParser root_parser;
+    CborValue it[INS_CBOR_MAX_DEPTH + 1];
+    int curr_itr;
+} cbor_parse_ctx_t;
+
+cbor_parse_ctx_t *esp_insights_cbor_decoder_start(const uint8_t *buffer, int len);
+esp_err_t esp_insights_cbor_decoder_enter_and_check_value(cbor_parse_ctx_t *ctx, const char *val);
+bool esp_insights_cbor_decoder_at_end(cbor_parse_ctx_t *ctx);
+
+esp_err_t esp_insights_cbor_decoder_advance(cbor_parse_ctx_t *ctx);
+CborType esp_insights_cbor_decode_get_value_type(cbor_parse_ctx_t *ctx);
+char *esp_insights_cbor_decoder_get_string(CborValue *val);
+
+esp_err_t esp_insights_cbor_decoder_enter_container(cbor_parse_ctx_t *ctx);
+esp_err_t esp_insights_cbor_decoder_exit_container(cbor_parse_ctx_t *ctx);
+
+/* Do cleanups if any */
+esp_err_t esp_insights_cbor_decoder_done(cbor_parse_ctx_t *ctx);
+
 /**
  * @brief   decodes a cbor message and prints into json format
  *