Chapter 123: ESP RainMaker Cloud Integration

idf.py add-dependency "espressif/esp-rainmaker^1.0" 
# Check the component registry for the latest version: https://components.espressif.com/components/espressif/esp-rainmaker

#include <string.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_netif.h"

// ESP RainMaker specific headers
#include <esp_rmaker_core.h>
#include <esp_rmaker_standard_params.h>
#include <esp_rmaker_standard_devices.h>
#include <esp_rmaker_ota.h>
#include <esp_rmaker_schedule.h>
#include <esp_rmaker_common_events.h>

// Wi-Fi Provisioning (if you want to use it, otherwise hardcode for simplicity in example)
#include <wifi_provisioning/manager.h>

// GPIO for LED (example)
#include "driver/gpio.h"
#define OUTPUT_GPIO CONFIG_EXAMPLE_OUTPUT_GPIO // Configure this in Kconfig

static const char *TAG = "app_main";

// --- Device Parameter Variables ---
// These variables will hold the state of our light
static bool g_power_state = false;
static int g_brightness = 50; // Default brightness 0-100

/* Callback to handle write events from the ESP RainMaker cloud */
static esp_err_t write_callback(const esp_rmaker_device_t *device, const esp_rmaker_param_t *param,
                                 const esp_rmaker_param_val_t val, void *priv_data, esp_rmaker_write_ctx_t *ctx)
{
    if (ctx) {
        ESP_LOGI(TAG, "Received write context from: %s", esp_rmaker_device_cb_src_to_str(ctx->src));
    }

    const char *device_name = esp_rmaker_device_get_name(device);
    const char *param_name = esp_rmaker_param_get_name(param);

    if (strcmp(param_name, ESP_RMAKER_DEF_POWER_NAME) == 0) {
        ESP_LOGI(TAG, "Received value = %s for %s - %s",
                 val.val.b ? "true" : "false", device_name, param_name);
        g_power_state = val.val.b;
        // --- Control your actual light hardware here ---
        gpio_set_level(OUTPUT_GPIO, g_power_state); 
        ESP_LOGI(TAG, "Light is %s", g_power_state ? "ON" : "OFF");
        // Report the change back to RainMaker (optional if only cloud changes it, but good practice)
        esp_rmaker_param_update_and_report(param, esp_rmaker_bool(g_power_state));

    } else if (strcmp(param_name, ESP_RMAKER_DEF_BRIGHTNESS_NAME) == 0) {
        ESP_LOGI(TAG, "Received value = %d for %s - %s",
                 val.val.i, device_name, param_name);
        g_brightness = val.val.i;
        // --- Control your actual light brightness here ---
        ESP_LOGI(TAG, "Brightness set to %d%%", g_brightness);
        // Report the change back
        esp_rmaker_param_update_and_report(param, esp_rmaker_int(g_brightness));
    } else {
        /* Silently ignoring invalid params */
        return ESP_OK;
    }
    return ESP_OK;
}

// Event handler for Wi-Fi and RainMaker events
static void event_handler(void* arg, esp_event_base_t event_base,
                          int32_t event_id, void* event_data)
{
    if (event_base == WIFI_PROV_EVENT) {
        switch (event_id) {
            case WIFI_PROV_START:
                ESP_LOGI(TAG, "Provisioning Application Started");
                break;
            case WIFI_PROV_CRED_RECV: {
                wifi_sta_config_t *wifi_sta_cfg = (wifi_sta_config_t *)event_data;
                ESP_LOGI(TAG, "Received Wi-Fi credentials" SSID_FORMAT ", Password: %s",
                         SSID_ARGS(wifi_sta_cfg->ssid),
                         (const char *) wifi_sta_cfg->password);
                break;
            }
            case WIFI_PROV_CRED_FAIL: {
                wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *)event_data;
                ESP_LOGE(TAG, "Provisioning failed!\n\tReason : %s"
                         "\n\tPlease reset to factory and retry provisioning",
                         (*reason == WIFI_PROV_STA_AUTH_ERROR) ?
                         "Wi-Fi station authentication failed" : "Wi-Fi access-point not found");
                break;
            }
            case WIFI_PROV_CRED_SUCCESS:
                ESP_LOGI(TAG, "Provisioning Successful");
                break;
            case WIFI_PROV_END:
                /* De-initialize manager once provisioning is finished */
                // wifi_prov_mgr_deinit(); // Keep it running if you want to allow re-provisioning
                ESP_LOGI(TAG, "Provisioning Finished.");
                break;
            default:
                break;
        }
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        ESP_LOGI(TAG, "Wi-Fi disconnected. Reconnecting...");
        esp_wifi_connect(); // ESP RainMaker SDK handles reconnection logic internally too
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ESP_LOGI(TAG, "Wi-Fi Connected. Got IP Address.");
    } else if (event_base == RMAKER_COMMON_EVENT) {
        switch(event_id) {
            case RMAKER_EVENT_INIT_DONE:
                ESP_LOGI(TAG, "RainMaker Initialised.");
                break;
            case RMAKER_EVENT_CLAIM_STARTED:
                ESP_LOGI(TAG, "RainMaker Claim Started.");
                break;
            case RMAKER_EVENT_CLAIM_SUCCESSFUL:
                ESP_LOGI(TAG, "RainMaker Claim Successful.");
                break;
            case RMAKER_EVENT_CLAIM_FAILED:
                ESP_LOGE(TAG, "RainMaker Claim Failed.");
                break;
            default:
                ESP_LOGW(TAG, "Unhandled RainMaker Common Event: %"PRId32, event_id);
        }
    } else if (event_base == RMAKER_OTA_EVENT) { // Handle OTA events
        switch(event_id) {
            case RMAKER_OTA_EVENT_STARTING:
                ESP_LOGI(TAG, "Starting OTA. Please wait ...");
                break;
            // Other OTA events like RMAKER_OTA_EVENT_IN_PROGRESS, RMAKER_OTA_EVENT_SUCCESSFUL, RMAKER_OTA_EVENT_FAILED, RMAKER_OTA_EVENT_REJECTED, RMAKER_OTA_EVENT_DELAYED
            default:
                ESP_LOGI(TAG, "OTA Event: %"PRId32, event_id);
                break;
        }
    } else {
        ESP_LOGW(TAG, "Unhandled event base %s with ID %"PRId32, event_base, event_id);
    }
}


void app_main()
{
    /* Initialize NVS. */
    esp_err_t err = nvs_flash_init();
    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        err = nvs_flash_init();
    }
    ESP_ERROR_CHECK(err);

    /* Initialize Wi-Fi stack */
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    /* Register event handlers */
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_PROV_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(RMAKER_COMMON_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(RMAKER_OTA_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));


    /* Initialize ESP RainMaker */
    esp_rmaker_config_t rainmaker_cfg = {
        .enable_time_sync = true, // Automatically sync time using SNTP
    };
    esp_rmaker_node_t *node = esp_rmaker_node_init(&rainmaker_cfg, "ESP RainMaker Light", "Lightbulb");
    if (!node) {
        ESP_LOGE(TAG, "Could not initialise node. Aborting!!!");
        vTaskDelay(5000/portTICK_PERIOD_MS);
        abort();
    }

    /* Create a Light device */
    // Using a standard device type helps the app render a familiar UI
    esp_rmaker_device_t *light_device = esp_rmaker_lightbulb_device_create("SmartLight", NULL, g_power_state);
    if (!light_device) {
        ESP_LOGE(TAG, "Failed to create light device.");
        // Handle error
    }
    
    // Add the device to the node
    esp_rmaker_node_add_device(node, light_device);

    /* Add the standard brightness parameter (ESP_RMAKER_DEF_BRIGHTNESS_NAME) */
    esp_rmaker_param_t *brightness_param = esp_rmaker_brightness_param_create(ESP_RMAKER_DEF_BRIGHTNESS_NAME, g_brightness);
    if (!brightness_param) {
         ESP_LOGE(TAG, "Failed to create brightness parameter.");
    } else {
        esp_rmaker_device_add_param(light_device, brightness_param);
        // You can also set UI type hints if not using standard params
        // esp_rmaker_param_add_ui_type(brightness_param, ESP_RMAKER_UI_SLIDER);
    }
    
    /* Assign the write callback for the device */
    // This single callback will handle writes for all parameters of this device
    esp_rmaker_device_add_cb(light_device, write_callback, NULL);

    /* Enable OTA */
    esp_rmaker_ota_config_t ota_config = {
        .server_cert = ESP_RMAKER_OTA_DEFAULT_SERVER_CERT, // Use default RainMaker OTA server cert
    };
    err = esp_rmaker_ota_enable(&ota_config, OTA_USING_PARAMS); // OTA_USING_PARAMS allows triggering OTA via a parameter
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Failed to enable OTA: %s", esp_err_to_name(err));
    }

    /* Enable scheduling */
    err = esp_rmaker_schedule_enable();
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Failed to enable Schedule: %s", esp_err_to_name(err));
    }
    
    /* Enable System Service to report info like Wi-Fi RSSI, MAC, IP, firmware version */
    esp_rmaker_system_serv_config_t system_serv_config = {
        .flags = SYSTEM_SERV_FLAGS_ALL, // Report all available system info
        .reset_reboot_seconds = 2,      // Seconds to wait before rebooting on reset command
    };
    esp_rmaker_system_service_enable(&system_serv_config);


    /* Start the ESP RainMaker Core task */
    err = esp_rmaker_start();
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Could not start ESP RainMaker!: %s", esp_err_to_name(err));
    }

    // Configure GPIO for LED
    gpio_reset_pin(OUTPUT_GPIO);
    gpio_set_direction(OUTPUT_GPIO, GPIO_MODE_OUTPUT);
    gpio_set_level(OUTPUT_GPIO, g_power_state); // Set initial state

    /* Wi-Fi Provisioning */
    // If you want to use Wi-Fi provisioning (SoftAP or BLE based on menuconfig)
    // The RainMaker SDK can automatically start provisioning if no Wi-Fi credentials are found.
    // You select the provisioning type (SoftAP, BLE) in menuconfig.
    // For SoftAP, the device will create an AP like "PROV_XXXX". Connect to it with the app.
    // For BLE, the app will scan for BLE devices advertising the RainMaker service.
    // To trigger provisioning manually or to use specific schemes:
    wifi_prov_mgr_config_t prov_config = {
        .scheme = wifi_prov_scheme_softap, // or wifi_prov_scheme_ble
        .scheme_event_handler = WIFI_PROV_EVENT_HANDLER_NONE // Let RainMaker handle events
    };
    // Check if device is already provisioned. If not, start provisioning.
    bool provisioned = false;
    err = wifi_prov_mgr_is_provisioned(&provisioned);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Error checking provisioning status: %s", esp_err_to_name(err));
    }

    if (!provisioned) {
        ESP_LOGI(TAG, "Starting Wi-Fi Provisioning");
        // The RainMaker SDK typically starts provisioning if not already provisioned and connected.
        // If you need more control or are not using default RainMaker Wi-Fi handling:
        // ESP_ERROR_CHECK(wifi_prov_mgr_init(prov_config));
        // ESP_ERROR_CHECK(wifi_prov_mgr_start_provisioning(WIFI_PROV_SECURITY_1, NULL, "ESP_Light_Prov", NULL));
        // The RainMaker SDK usually handles this. If you have `esp_rmaker_wifi_init_sta()` or similar,
        // it might internally start provisioning if credentials are not found.
        // For this example, we assume RainMaker's default behavior will trigger provisioning if needed.
        // Or, you can hardcode Wi-Fi credentials for testing:
        /*
        wifi_config_t wifi_config = {
            .sta = {
                .ssid = "YOUR_SSID",
                .password = "YOUR_PASSWORD",
            },
        };
        esp_wifi_set_mode(WIFI_MODE_STA);
        esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
        esp_wifi_connect();
        */
    } else {
        ESP_LOGI(TAG, "Device already provisioned. Connecting to Wi-Fi...");
        // RainMaker SDK will attempt to connect using stored credentials.
    }
    // The esp_rmaker_start() should handle Wi-Fi connection if credentials are known or start provisioning.
}

menu "Example Configuration"
    config EXAMPLE_OUTPUT_GPIO
        int "Output GPIO for Light"
        default 2
        help
            GPIO number to use for controlling the light (e.g., an LED).
endmenu

CONFIG_LOG_DEFAULT_LEVEL_INFO=y
CONFIG_NVS_ENCRYPTION=n # For simplicity in example, enable for production

# ESP RainMaker Configuration
CONFIG_ESP_RMAKER_SELF_CLAIM=n # Set to y for self-claiming during dev, n for app-based claiming
# CONFIG_ESP_RMAKER_ASSISTED_CLAIM=y # If using self_claim=n

# Wi-Fi Provisioning (Choose one)
CONFIG_WIFI_PROV_SCHEME_SOFTAP=y
# CONFIG_WIFI_PROV_SCHEME_BLE=n
CONFIG_WIFI_PROV_SECURITY_VERSION_1=y # For SoftAP provisioning password (if any)
# CONFIG_WIFI_PROV_SEC_MODE_NONE=n
# CONFIG_WIFI_PROV_SEC_MODE_WEP=n
# CONFIG_WIFI_PROV_SEC_MODE_WPA=n
# CONFIG_WIFI_PROV_SEC_MODE_WPA2=y
# CONFIG_WIFI_PROV_SEC_MODE_WPA_WPA2_MIXED=n


# Configure the GPIO for the light
CONFIG_EXAMPLE_OUTPUT_GPIO=2

# Wi-Fi Settings (if hardcoding, not recommended for production)
# CONFIG_ESP_WIFI_SSID="YourSSID"
# CONFIG_ESP_WIFI_PASSWORD="YourPassword"

# Ensure SNTP is enabled (RainMaker usually handles this if enable_time_sync is true)
CONFIG_LWIP_SNTP_ENABLE=y
CONFIG_LWIP_DHCP_MAX_NTP_SERVERS=1
CONFIG_LWIP_SNTP_SERVER_ADDRESS="pool.ntp.org"

# OTA Configuration
CONFIG_ESP_HTTPS_OTA_SEND_CUSTOM_HTTP_HEADER=y # Required by RainMaker OTA
CONFIG_ESP_RMAKER_OTA_ENABLE=y

# System Service
CONFIG_ESP_RMAKER_SYSTEM_SERVICE_ENABLE=y