Adding support for device method

Author: kbeaugrand

.vscode/arduino.json

@@ -1,6 +1,6 @@
 {
     "board": "esp32:esp32:esp32",
-    "sketch": "sample/device.ino",
+    "sketch": "examples\\ESP32_Device_OTA\\ESP32_Device_OTA.ino",
     "output": "./.build",
     "programmer": "AVR ISP",
     "port": "COM3",

.vscode/settings.json

@@ -12,7 +12,8 @@
         "deque": "cpp",
         "string": "cpp",
         "vector": "cpp",
-        "unordered_map": "cpp"
+        "unordered_map": "cpp",
+        "*.tcc": "cpp"
     },
     "cmake.configureOnOpen": false
 }

examples/ESP32_Device_OTA/ESP32_Device_OTA.ino

@@ -8,10 +8,12 @@
 
 #define DEFAULT_TELEMETRY_FREQUENCY 5000
 
-#define FIRMWARE_VERSION "0.0.1"
+#define FIRMWARE_VERSION "0.0.2"
 
 DHTesp dht;
 
+bool rebootRequired;
+
 DynamicJsonDocument CheckPropertiesState()
 {
   bool hasChanged = false;
@@ -43,6 +45,18 @@ DynamicJsonDocument CheckPropertiesState()
   return propertiesState;
 }
 
+int OnRebootInvoked(const unsigned char* payload, size_t size, unsigned char** response, size_t* response_size)
+{
+  const char deviceMethodResponse[] = "{ \"acknowledged\": \"true\" }";
+  *response_size = sizeof(deviceMethodResponse)-1;
+  *response = (unsigned char *)malloc(*response_size);
+  (void)memcpy(*response, deviceMethodResponse, *response_size);
+
+  rebootRequired = true;
+
+  return 200;
+}
+
 void setup()
 {
   Serial.begin(115200);
@@ -52,12 +66,18 @@ void setup()
   // Wait for device connection
   while(!IoTDevice_IsConnected()) { }
 
+  IoTDevice_RegisterForMethodInvoke("reboot", OnRebootInvoked);
+
   // début de la mesure
   dht.setup(15, DHTesp::DHT11);
 }
 
 void loop()
 { 
+  if (rebootRequired) {
+    ESP.restart();
+  }
+
   DynamicJsonDocument propertiesState = CheckPropertiesState();
   int waitTime = propertiesState["telemetry"]["frequency"] | DEFAULT_TELEMETRY_FREQUENCY;
 

src/ESP32_AzureIoT_OTA.h

@@ -17,6 +17,7 @@ extern "C"
 #include "core/iot_device_connection.h"
 #include "core/iot_device_d2c.h"
 #include "core/iot_device_ota.h"
+#include "core/iot_device_method.h"
 
 #ifdef __cplusplus
 }   // extern "C"

src/core/iot_device_connection.cpp

@@ -187,6 +187,8 @@ static void IoTDevice_ConfigureOptions()
 
   // Setting device twin callback
   (void)IoTHubDeviceClient_LL_SetDeviceTwinCallback(__hub_client_handle__, IoTDevice_DeviceTwinCallback, NULL);
+
+  IoTDevice_RegisterDeviceMethodCallback();
 }
 
 static void IoTDevice_ConnectToHub(const char *connectionString)

src/core/iot_device_core.h

@@ -17,6 +17,8 @@ extern IOTHUB_CLIENT_LL_HANDLE __hub_client_handle__;
 
 extern void IoTDevice_DeviceTwinCallback(DEVICE_TWIN_UPDATE_STATE update_state, const unsigned char *payLoad, size_t size, void *userContextCallback);
 
+extern void IoTDevice_RegisterDeviceMethodCallback();
+
 extern bool __twin_received__;
 
 #ifdef __cplusplus

src/core/iot_device_d2c.cpp

@@ -1,6 +1,3 @@
-#ifndef IOT_DEVICE_D2C_H
-#define IOT_DEVICE_D2C_H
-
 #include "logging.h"
 
 #include "iot_device_d2c.h"
@@ -33,6 +30,4 @@ bool IoTDevice_Send(const char *message)
 
   IoTHubDeviceClient_LL_DoWork(__hub_client_handle__);       
   ThreadAPI_Sleep(3);
-}
-
-#endif
+}

src/core/iot_device_method.cpp

@@ -0,0 +1,119 @@
+#include <ArduinoJson.h>
+
+#include <AzureIoTHub.h>
+#include <SPIFFS.h>
+
+#include "logging.h"
+#include "iot_device_core.h"
+#include "iot_device_method.h"
+
+struct MethodCallback {
+    const char* methodName;
+    IOT_DEVICE_METHOD_CALLBACK callback;
+};
+
+static MethodCallback methodCallbacks[IOT_DEVICE_MAX_METHOD_COUNT];
+static int registeredCount = 0;
+
+static int IoTDevice_DeviceMethodCallback(const char* method_name, const unsigned char* payload, size_t size, unsigned char** response, size_t* response_size, void* userContextCallback)
+{
+    (void)userContextCallback;
+    (void)payload;
+    (void)size;
+
+    bool methodFound = false;
+
+    int result;
+
+    Log_Debug("Direct method lookup: %s", method_name);
+
+    for(int i = 0; i < registeredCount; i++) 
+    {
+        Log_Trace("Trying %s", methodCallbacks[i].methodName);
+
+        if (strcmp(methodCallbacks[i].methodName, method_name) == 0)
+        {
+            Log_Debug("Method callback for %s found. Executing", method_name);
+        
+            methodFound = true;
+            result = methodCallbacks[i].callback(payload, size, response, response_size);        
+        }        
+    }
+
+    if (!methodFound)
+    {
+        Log_Info("Method %s not registered!", method_name);
+        const char deviceMethodResponse[] = "{ }";
+        *response_size = sizeof(deviceMethodResponse)-1;
+        *response = (unsigned char *)malloc(*response_size);
+        (void)memcpy(*response, deviceMethodResponse, *response_size);
+        result = -1;
+    }
+
+    return result;
+}
+
+int OnSystemInfoInvoked(const unsigned char* payload, size_t size, unsigned char** response, size_t* response_size)
+{    
+    String output;
+
+    DynamicJsonDocument doc(1024);
+
+    doc["chipRevision"] = ESP.getChipRevision();
+    doc["cpuFreqMHz"] = ESP.getCpuFreqMHz();
+    doc["cycleCount"] = ESP.getCycleCount();
+    doc["sdkVersion"] = ESP.getSdkVersion();
+
+    doc["flashChip"]["size"] = ESP.getFlashChipSize();
+    doc["flashChip"]["speed"] = ESP.getFlashChipSpeed();
+
+    doc["heap"]["size"] = ESP.getHeapSize(); //total heap size
+    doc["heap"]["free"] = ESP.getFreeHeap(); //available heap
+    doc["heap"]["minFree"] = ESP.getMinFreeHeap(); //lowest level of free heap since boot
+    doc["heap"]["maxAlloc"] = ESP.getMaxAllocHeap();  //largest block of heap that can be allocated at once
+
+    doc["spi"]["size"] = ESP.getPsramSize();
+    doc["spi"]["free"] = ESP.getFreePsram();
+    doc["spi"]["minFree"] = ESP.getMinFreePsram();
+    doc["spi"]["maxAlloc"] = ESP.getMaxAllocPsram();
+
+    doc["sketch"]["MD5"] = ESP.getSketchMD5();
+    doc["sketch"]["size"] = ESP.getSketchSize();
+    doc["sketch"]["space"] = ESP.getFreeSketchSpace();
+
+    doc["fs"]["usedBytes"] =  SPIFFS.usedBytes();
+    doc["fs"]["totalBytes"] = SPIFFS.totalBytes();
+
+    serializeJsonPretty(doc, output);
+
+    const char *deviceMethodResponse = output.c_str();
+    *response_size = strlen(deviceMethodResponse);
+    *response = (unsigned char *)malloc(*response_size);
+    (void)memcpy(*response, deviceMethodResponse, *response_size);
+
+    return 200;
+}
+
+void IoTDevice_RegisterDeviceMethodCallback(){
+    (void)IoTHubClient_LL_SetDeviceMethodCallback(__hub_client_handle__, IoTDevice_DeviceMethodCallback, NULL);
+    
+    IoTDevice_RegisterForMethodInvoke("systemInfo", OnSystemInfoInvoked);
+}
+
+void IoTDevice_RegisterForMethodInvoke(const char *methodName, IOT_DEVICE_METHOD_CALLBACK callback) {
+    Log_Debug("Registering method %s at index: %d", methodName, registeredCount);
+
+    if(registeredCount >= IOT_DEVICE_MAX_METHOD_COUNT)
+    {
+        Log_Error("Cannot regiter more than %d methods. Increase the IOT_DEVICE_MAX_METHOD_COUNT variable.", IOT_DEVICE_MAX_METHOD_COUNT);
+        return;
+    }
+
+    MethodCallback item = {
+        .methodName = methodName,
+        .callback = callback
+    };
+
+    methodCallbacks[registeredCount] = item;
+    registeredCount++;
+}

src/core/iot_device_method.h

@@ -0,0 +1,31 @@
+#ifndef __ESP32_AzureIoT_DEVICE_METHOD_H__
+#define __ESP32_AzureIoT_DEVICE_METHOD_H__
+
+#include <stddef.h>
+
+typedef int(*IOT_DEVICE_METHOD_CALLBACK)(const unsigned char* payload, size_t size, unsigned char** response, size_t* response_size);
+
+
+#ifndef IOT_DEVICE_MAX_METHOD_COUNT
+#define IOT_DEVICE_MAX_METHOD_COUNT 10
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+* @brief   Register for Cloud To Device Method invoke.
+*
+* @param    methodName      Pointer to a character string containing the message to send.
+* @param    callback        Pointer to a method callback.
+*
+*/
+void IoTDevice_RegisterForMethodInvoke(const char *methodName, IOT_DEVICE_METHOD_CALLBACK callback);
+
+#ifdef __cplusplus
+}   // extern "C"
+#endif /* __cplusplus */
+
+#endif