Chapter 122: ThingsBoard IoT Platform Integration

# Create a directory for ThingsBoard data
mkdir -p ~/.mytb-data && sudo chown -R 799:799 ~/.mytb-data
mkdir -p ~/.mytb-logs && sudo chown -R 799:799 ~/.mytb-logs

# Run ThingsBoard CE (Community Edition)
docker run -it -p 9090:9090 -p 1883:1883 -p 7070:7070 -p 5683:5683/udp \
-v ~/.mytb-data:/data \
-v ~/.mytb-logs:/var/log/thingsboard \
--name mytb --restart always \
thingsboard/tb-postgres

#include <stdio.h>
#include <string.h>
#include <cJSON.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "mqtt_client.h"
#include "driver/gpio.h"

// Configuration - Set these via menuconfig
#define WIFI_SSID CONFIG_WIFI_SSID
#define WIFI_PASS CONFIG_WIFI_PASSWORD
#define TB_BROKER_URI CONFIG_TB_BROKER_URI // e.g., "mqtt://localhost" or "mqtt://mqtt.thingsboard.cloud"
#define TB_ACCESS_TOKEN CONFIG_TB_ACCESS_TOKEN // The device access token from ThingsBoard
#define FIRMWARE_VERSION "v1.0.1" // Example firmware version
#define LED_GPIO CONFIG_LED_GPIO

static const char *TAG = "THINGSBOARD_EXAMPLE";
static EventGroupHandle_t wifi_event_group;
const int WIFI_CONNECTED_BIT = BIT0;
static esp_mqtt_client_handle_t mqtt_client_handle = NULL;
static bool g_led_state = false;

static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) {
    // (Identical to previous chapters - connect, handle disconnect, got_ip)
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        ESP_LOGI(TAG, "Disconnected from Wi-Fi. Retrying...");
        esp_wifi_connect();
        xEventGroupClearBits(wifi_event_group, WIFI_CONNECTED_BIT);
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "Got IP address: " IPSTR, IP2STR(&event->ip_info.ip));
        xEventGroupSetBits(wifi_event_group, WIFI_CONNECTED_BIT);
        if (mqtt_client_handle) {
            esp_mqtt_client_start(mqtt_client_handle);
        }
    }
}

void wifi_init_sta(void) {
    // (Identical to previous chapters)
    wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_netif_init()); ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta(); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    esp_event_handler_instance_t instance_any_id, instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL, &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL, &instance_got_ip));
    wifi_config_t wifi_config = { .sta = { .ssid = WIFI_SSID, .password = WIFI_PASS, .threshold.authmode = WIFI_AUTH_WPA2_PSK, }, };
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start()); ESP_LOGI(TAG, "wifi_init_sta finished.");
    xEventGroupWaitBits(wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
    ESP_LOGI(TAG, "Connected to AP SSID:%s", WIFI_SSID);
}

static void send_attributes(void) {
    if (!mqtt_client_handle || !(xEventGroupGetBits(wifi_event_group) & WIFI_CONNECTED_BIT)) return;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddStringToObject(root, "firmware_version", FIRMWARE_VERSION);
    cJSON_AddStringToObject(root, "serial_number", "SN-00123ABC"); // Example
    
    char *json_payload = cJSON_PrintUnformatted(root);
    if (json_payload) {
        esp_mqtt_client_publish(mqtt_client_handle, "v1/devices/me/attributes", json_payload, 0, 1, 0);
        ESP_LOGI(TAG, "Sent attributes: %s", json_payload);
        free(json_payload);
    }
    cJSON_Delete(root);
}

static void mqtt_event_handler_cb(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
    esp_mqtt_event_handle_t event = event_data;
    char rpc_response_topic[128];
    char rpc_request_id_str[16] = {0}; // To store RPC request ID from topic

    switch ((esp_mqtt_event_id_t)event_id) {
        case MQTT_EVENT_CONNECTED:
            ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED to %s", TB_BROKER_URI);
            // Subscribe to RPC requests for this device
            esp_mqtt_client_subscribe(mqtt_client_handle, "v1/devices/me/rpc/request/+", 1);
            ESP_LOGI(TAG, "Subscribed to RPC requests: v1/devices/me/rpc/request/+");
            // Subscribe to attribute updates from server (optional)
            esp_mqtt_client_subscribe(mqtt_client_handle, "v1/devices/me/attributes", 1);
            ESP_LOGI(TAG, "Subscribed to attribute updates: v1/devices/me/attributes");

            // Send client-side attributes on connect
            send_attributes();
            break;
        case MQTT_EVENT_DISCONNECTED:
            ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
            break;
        case MQTT_EVENT_SUBSCRIBED:
            ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
            break;
        case MQTT_EVENT_DATA:
            ESP_LOGI(TAG, "MQTT_EVENT_DATA from topic: %.*s", event->topic_len, event->topic);
            ESP_LOGD(TAG, "Data: %.*s", event->data_len, event->data);

            // Check if it's an RPC request topic: v1/devices/me/rpc/request/{request_id}
            if (strncmp(event->topic, "v1/devices/me/rpc/request/", strlen("v1/devices/me/rpc/request/")) == 0) {
                // Extract request_id from the topic
                // Topic format: v1/devices/me/rpc/request/{request_id}
                // event->topic_len, event->topic
                const char *rpc_topic_prefix = "v1/devices/me/rpc/request/";
                int prefix_len = strlen(rpc_topic_prefix);
                if (event->topic_len > prefix_len) {
                    int id_len = event->topic_len - prefix_len;
                    if (id_len < sizeof(rpc_request_id_str)) {
                         strncpy(rpc_request_id_str, event->topic + prefix_len, id_len);
                         rpc_request_id_str[id_len] = '\0'; // Null terminate
                         ESP_LOGI(TAG, "RPC Request ID: %s", rpc_request_id_str);
                    }
                }


                char *data_str = malloc(event->data_len + 1);
                if (!data_str) break;
                memcpy(data_str, event->data, event->data_len);
                data_str[event->data_len] = '\0';

                cJSON *json_rpc = cJSON_Parse(data_str);
                free(data_str);

                if (json_rpc) {
                    cJSON *method = cJSON_GetObjectItem(json_rpc, "method");
                    cJSON *params = cJSON_GetObjectItem(json_rpc, "params");

                    if (method && cJSON_IsString(method)) {
                        ESP_LOGI(TAG, "RPC Method: %s", method->valuestring);
                        if (strcmp(method->valuestring, "setLedState") == 0) {
                            if (params && cJSON_IsObject(params)) {
                                cJSON *value_item = cJSON_GetObjectItem(params, "value");
                                if (value_item && cJSON_IsBool(value_item)) {
                                    g_led_state = cJSON_IsTrue(value_item);
                                    gpio_set_level(LED_GPIO, g_led_state);
                                    ESP_LOGI(TAG, "LED state set to: %s", g_led_state ? "ON" : "OFF");
                                    
                                    // Send RPC response (optional for one-way, good for two-way)
                                    if (strlen(rpc_request_id_str) > 0) {
                                        snprintf(rpc_response_topic, sizeof(rpc_response_topic), "v1/devices/me/rpc/response/%s", rpc_request_id_str);
                                        char *response_payload = "{\"status\":\"success\"}"; // Example response
                                        esp_mqtt_client_publish(mqtt_client_handle, rpc_response_topic, response_payload, 0, 1, 0);
                                        ESP_LOGI(TAG, "Sent RPC response to %s", rpc_response_topic);
                                    }
                                    // Report new LED state as telemetry or attribute if desired
                                    cJSON *telemetry_payload = cJSON_CreateObject();
                                    cJSON_AddBoolToObject(telemetry_payload, "led_on_rpc", g_led_state);
                                    char *telemetry_str = cJSON_PrintUnformatted(telemetry_payload);
                                    if (telemetry_str) {
                                        esp_mqtt_client_publish(mqtt_client_handle, "v1/devices/me/telemetry", telemetry_str, 0, 0, 0);
                                        free(telemetry_str);
                                    }
                                    cJSON_Delete(telemetry_payload);
                                }
                            }
                        }
                    }
                    cJSON_Delete(json_rpc);
                }
            } else if (strncmp(event->topic, "v1/devices/me/attributes", event->topic_len) == 0) {
                 ESP_LOGI(TAG, "Received attribute update from server: %.*s", event->data_len, event->data);
                 // Parse and handle server-side or shared attribute updates here
                 // e.g., if server sets a "targetTemperature" or "telemetryUploadInterval"
            }
            break;
        case MQTT_EVENT_ERROR:
            ESP_LOGE(TAG, "MQTT_EVENT_ERROR type %d", event->error_handle->error_type);
            break;
        default:
            ESP_LOGI(TAG, "Other MQTT event id:%d", event->event_id);
            break;
    }
}

static void mqtt_app_start(void) {
    const esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.uri = TB_BROKER_URI,
        .credentials.username = TB_ACCESS_TOKEN, // Access token is the username
        // .credentials.client_id = "ESP32Client-ThingsBoard", // Optional, can be any unique string
        // For TLS with ThingsBoard Cloud or self-hosted with TLS:
        // .broker.verification.crt_bundle_attach = esp_crt_bundle_attach, // Use ESP-IDF cert bundle
    };

    mqtt_client_handle = esp_mqtt_client_init(&mqtt_cfg);
    esp_mqtt_client_register_event(mqtt_client_handle, ESP_EVENT_ANY_ID, mqtt_event_handler_cb, NULL);
    // MQTT client start is handled by Wi-Fi event handler
}

void app_main(void) {
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    gpio_reset_pin(LED_GPIO);
    gpio_set_direction(LED_GPIO, GPIO_MODE_OUTPUT);
    gpio_set_level(LED_GPIO, g_led_state);

    wifi_init_sta();
    mqtt_app_start();

    int msg_count = 0;
    while (1) {
        if (mqtt_client_handle && (xEventGroupGetBits(wifi_event_group) & WIFI_CONNECTED_BIT)) {
            cJSON *root = cJSON_CreateObject();
            float temperature = 20.0 + ((float)esp_random() / (float)UINT32_MAX) * 15.0; // Simulated
            float humidity = 40.0 + ((float)esp_random() / (float)UINT32_MAX) * 30.0;   // Simulated
            
            cJSON_AddNumberToObject(root, "temperature", temperature);
            cJSON_AddNumberToObject(root, "humidity", humidity);
            cJSON_AddNumberToObject(root, "messageId", msg_count++);
            cJSON_AddBoolToObject(root, "led_state_telemetry", g_led_state);


            char *json_payload = cJSON_PrintUnformatted(root);
            if (json_payload) {
                esp_mqtt_client_publish(mqtt_client_handle, "v1/devices/me/telemetry", json_payload, 0, 0, 0);
                ESP_LOGI(TAG, "Sent telemetry: %s", json_payload);
                free(json_payload);
            }
            cJSON_Delete(root);
        }
        vTaskDelay(pdMS_TO_TICKS(10000)); // Send telemetry every 10 seconds
    }
}

menu "ThingsBoard Example Configuration"
    config WIFI_SSID
        string "Wi-Fi SSID"
        default "YourSSID"

    config WIFI_PASSWORD
        string "Wi-Fi Password"
        default "YourPassword"
    
    config TB_BROKER_URI
        string "ThingsBoard MQTT Broker URI"
        default "mqtt://localhost" # For local Docker: mqtt://<your-pc-ip> if ESP32 is on same LAN
                                  # For TB Cloud: mqtt://mqtt.thingsboard.cloud
        help
            URI of the ThingsBoard MQTT broker.
            For non-TLS: mqtt://host
            For TLS: mqtts://host (port 8883 usually)

    config TB_ACCESS_TOKEN
        string "ThingsBoard Device Access Token"
        default "YOUR_DEVICE_ACCESS_TOKEN"
        help
            The access token for your device created in ThingsBoard.

    config LED_GPIO
        int "LED GPIO Pin"
        default 2
        help
            GPIO pin connected to an LED for RPC testing.
endmenu