ESP-IDF JSON处理：数据序列化与反序列化

ESP-IDF JSON处理：数据序列化与反序列化

【免费下载链接】esp-idf Espressif IoT Development Framework. Official development framework for Espressif SoCs. 项目地址: https://gitcode.com/GitHub_Trending/es/esp-idf

引言：为什么嵌入式系统需要JSON处理？

在物联网（IoT）和嵌入式系统开发中，JSON（JavaScript Object Notation）已成为数据交换的事实标准。ESP-IDF作为乐鑫（Espressif）芯片的官方开发框架，提供了强大的JSON处理能力，让开发者能够轻松实现设备与云端、设备与设备之间的结构化数据通信。

你是否遇到过这些痛点？

• 设备配置信息需要持久化存储
• MQTT消息需要结构化格式
• HTTP API接口需要JSON数据交换
• 设备状态需要序列化传输

本文将深入解析ESP-IDF中的JSON处理机制，通过实际代码示例和最佳实践，帮助你掌握数据序列化与反序列化的核心技术。

ESP-IDF JSON组件架构

cJSON库核心特性

ESP-IDF集成了轻量级的cJSON库，这是一个单文件C语言JSON解析器，具有以下特点：

// cJSON数据结构
typedef struct cJSON {
    struct cJSON *next, *prev;  // 双向链表指针
    struct cJSON *child;        // 子节点指针
    int type;                   // 节点类型
    char *valuestring;          // 字符串值
    int valueint;               // 整数值  
    double valuedouble;         // 双精度值
    char *string;               // 键名
} cJSON;

支持的数据类型

数据类型	cJSON常量	说明
空值	cJSON_NULL	表示null值
布尔真	cJSON_True	true值
布尔假	cJSON_False	false值
数字	cJSON_Number	整数或浮点数
字符串	cJSON_String	字符串值
数组	cJSON_Array	JSON数组
对象	cJSON_Object	JSON对象

基础JSON操作实战

1. JSON字符串解析（反序列化）

#include "cJSON.h"

void parse_json_example() {
    const char *json_string = "{\"device\":{\"name\":\"ESP32\",\"version\":1.0,\"active\":true}}";
    
    // 解析JSON字符串
    cJSON *root = cJSON_Parse(json_string);
    if (root == NULL) {
        const char *error_ptr = cJSON_GetErrorPtr();
        if (error_ptr != NULL) {
            ESP_LOGE("JSON", "Error before: %s", error_ptr);
        }
        return;
    }
    
    // 提取设备信息
    cJSON *device = cJSON_GetObjectItem(root, "device");
    cJSON *name = cJSON_GetObjectItem(device, "name");
    cJSON *version = cJSON_GetObjectItem(device, "version");
    cJSON *active = cJSON_GetObjectItem(device, "active");
    
    ESP_LOGI("JSON", "Device: %s, Version: %.1f, Active: %s",
             name->valuestring,
             version->valuedouble,
             cJSON_IsTrue(active) ? "true" : "false");
    
    // 释放内存
    cJSON_Delete(root);
}

2. JSON对象构建（序列化）

cJSON* create_device_json(const char *name, double version, bool active) {
    cJSON *root = cJSON_CreateObject();
    cJSON *device = cJSON_CreateObject();
    
    cJSON_AddItemToObject(root, "device", device);
    cJSON_AddStringToObject(device, "name", name);
    cJSON_AddNumberToObject(device, "version", version);
    
    if (active) {
        cJSON_AddTrueToObject(device, "active");
    } else {
        cJSON_AddFalseToObject(device, "active");
    }
    
    return root;
}

void serialize_json_example() {
    cJSON *root = create_device_json("ESP32-C3", 2.1, true);
    
    // 生成JSON字符串
    char *json_str = cJSON_Print(root);
    ESP_LOGI("JSON", "Serialized JSON: %s", json_str);
    
    // 释放资源
    free(json_str);
    cJSON_Delete(root);
}

高级JSON处理技巧

1. 数组操作

void json_array_example() {
    cJSON *root = cJSON_CreateObject();
    cJSON *sensors = cJSON_CreateArray();
    
    cJSON_AddItemToObject(root, "sensors", sensors);
    
    // 添加传感器数据
    for (int i = 0; i < 3; i++) {
        cJSON *sensor = cJSON_CreateObject();
        cJSON_AddNumberToObject(sensor, "id", i);
        cJSON_AddNumberToObject(sensor, "value", 25.5 + i);
        cJSON_AddItemToArray(sensors, sensor);
    }
    
    char *json_str = cJSON_Print(root);
    ESP_LOGI("JSON", "Sensor array: %s", json_str);
    
    free(json_str);
    cJSON_Delete(root);
}

2. 嵌套对象处理

void nested_json_example() {
    cJSON *root = cJSON_CreateObject();
    
    // 创建网络配置对象
    cJSON *network = cJSON_CreateObject();
    cJSON_AddStringToObject(network, "ssid", "MyWiFi");
    cJSON_AddStringToObject(network, "password", "secret123");
    cJSON_AddNumberToObject(network, "channel", 6);
    
    // 创建MQTT配置对象
    cJSON *mqtt = cJSON_CreateObject();
    cJSON_AddStringToObject(mqtt, "broker", "mqtt.broker.com");
    cJSON_AddNumberToObject(mqtt, "port", 1883);
    cJSON_AddTrueToObject(mqtt, "retain");
    
    // 添加到根对象
    cJSON_AddItemToObject(root, "network", network);
    cJSON_AddItemToObject(root, "mqtt", mqtt);
    
    char *config_str = cJSON_Print(root);
    ESP_LOGI("JSON", "Device config: %s", config_str);
    
    free(config_str);
    cJSON_Delete(root);
}

实战应用场景

场景1：设备配置管理

// 保存配置到NVS
esp_err_t save_config_to_nvs(cJSON *config) {
    char *config_str = cJSON_PrintUnformatted(config);
    if (config_str == NULL) {
        return ESP_FAIL;
    }
    
    nvs_handle_t handle;
    ESP_ERROR_CHECK(nvs_open("storage", NVS_READWRITE, &handle));
    ESP_ERROR_CHECK(nvs_set_str(handle, "device_config", config_str));
    ESP_ERROR_CHECK(nvs_commit(handle));
    nvs_close(handle);
    
    free(config_str);
    return ESP_OK;
}

// 从NVS加载配置
cJSON* load_config_from_nvs() {
    nvs_handle_t handle;
    size_t required_size;
    
    ESP_ERROR_CHECK(nvs_open("storage", NVS_READONLY, &handle));
    ESP_ERROR_CHECK(nvs_get_str(handle, "device_config", NULL, &required_size));
    
    char *config_str = malloc(required_size);
    ESP_ERROR_CHECK(nvs_get_str(handle, "device_config", config_str, &required_size));
    nvs_close(handle);
    
    cJSON *config = cJSON_Parse(config_str);
    free(config_str);
    
    return config;
}

场景2：MQTT消息处理

void mqtt_json_message_handler(const char *topic, const char *payload) {
    cJSON *root = cJSON_Parse(payload);
    if (root == NULL) {
        ESP_LOGE("MQTT", "Invalid JSON message");
        return;
    }
    
    // 处理不同类型的消息
    cJSON *type = cJSON_GetObjectItem(root, "type");
    if (type && cJSON_IsString(type)) {
        if (strcmp(type->valuestring, "control") == 0) {
            handle_control_message(root);
        } else if (strcmp(type->valuestring, "config") == 0) {
            handle_config_message(root);
        } else if (strcmp(type->valuestring, "status") == 0) {
            handle_status_message(root);
        }
    }
    
    cJSON_Delete(root);
}

性能优化与最佳实践

内存管理策略

错误处理模式

cJSON* safe_json_parse(const char *json_str) {
    cJSON *root = cJSON_Parse(json_str);
    if (root == NULL) {
        const char *error_ptr = cJSON_GetErrorPtr();
        if (error_ptr != NULL) {
            ESP_LOGE("JSON", "Parse error before: %s", error_ptr);
        }
        return NULL;
    }
    return root;
}

char* safe_json_print(cJSON *item) {
    if (item == NULL) {
        return NULL;
    }
    char *str = cJSON_Print(item);
    if (str == NULL) {
        ESP_LOGE("JSON", "Failed to print JSON");
    }
    return str;
}

常见问题与解决方案

问题1：内存泄漏

症状：解析大量JSON数据后内存不足 解决方案：

void process_json_safely(const char *json_str) {
    cJSON *root = cJSON_Parse(json_str);
    if (root) {
        // 处理数据
        process_data(root);
        
        // 必须释放内存
        cJSON_Delete(root);
    }
}

问题2：数据类型混淆

症状：错误地访问了错误的数据类型字段 解决方案：

double get_json_number_safe(cJSON *obj, const char *key, double default_val) {
    cJSON *item = cJSON_GetObjectItem(obj, key);
    if (item && cJSON_IsNumber(item)) {
        return item->valuedouble;
    }
    return default_val;
}

const char* get_json_string_safe(cJSON *obj, const char *key, const char *default_val) {
    cJSON *item = cJSON_GetObjectItem(obj, key);
    if (item && cJSON_IsString(item) && item->valuestring != NULL) {
        return item->valuestring;
    }
    return default_val;
}

总结与展望

通过本文的学习，你应该已经掌握了ESP-IDF中JSON处理的核心技术。JSON作为现代物联网通信的标准格式，在设备配置、状态上报、远程控制等场景中发挥着重要作用。

关键要点回顾：

• cJSON提供了轻量级且高效的JSON解析和生成能力
• 正确的内存管理是避免内存泄漏的关键
• 类型安全的访问函数可以提高代码健壮性
• JSON与NVS结合可以实现设备配置的持久化存储

随着ESP-IDF的不断发展，JSON处理能力也在持续增强。建议在实际项目中多实践这些技术，并根据具体需求选择合适的数据序列化方案。

下一步学习建议：

• 探索Protocol Buffers等二进制序列化方案
• 学习JSON Schema进行数据验证
• 研究JSON在WebSocket通信中的应用

掌握JSON处理技术，将为你的物联网开发之路打下坚实基础！

【免费下载链接】esp-idf Espressif IoT Development Framework. Official development framework for Espressif SoCs. 项目地址: https://gitcode.com/GitHub_Trending/es/esp-idf