FreeRTOS 内存管理

ESP32 内存布局

ESP32 有多种类型的内存：

// 不同类型的内存区域
DRAM (Data RAM)     - 约320KB，用于变量和堆
IRAM (Instruction RAM) - 约128KB，用于代码
RTC Fast Memory     - 8KB，RTC和深度睡眠时保持
RTC Slow Memory     - 8KB，超低功耗存储
Flash Memory        - 外部，存储程序代码
PSRAM (可选)        - 外部，可扩展到8MB

FreeRTOS 内存管理方案

FreeRTOS 提供了5种内存管理方案，ESP-IDF 主要使用：

1. 动态内存分配 (类似 Go 的 new)

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

// 分配内存
void* ptr = pvPortMalloc(1024);  // 分配1KB
if (ptr == NULL) {
    // 内存分配失败处理
    ESP_LOGE(TAG, "Memory allocation failed!");
    return;
}

// 使用内存
memset(ptr, 0, 1024);

// 必须手动释放！（和Go不同）
vPortFree(ptr);
ptr = NULL;  // 防止野指针

2. ESP-IDF 的内存管理函数

#include "esp_heap_caps.h"

// 分配普通内存
void* ptr1 = malloc(1024);

// 分配DMA可用内存
void* dma_buf = heap_caps_malloc(1024, MALLOC_CAP_DMA);

// 分配PSRAM内存（如果有的话）
void* psram_buf = heap_caps_malloc(1024, MALLOC_CAP_SPIRAM);

// 记得释放
free(ptr1);
free(dma_buf);
free(psram_buf);

任务栈内存管理

每个 FreeRTOS 任务都有自己的栈：

// 创建任务时指定栈大小
xTaskCreate(
    my_task,           // 任务函数
    "MyTask",          // 任务名
    4096,              // 栈大小（字节）- 这很重要！
    NULL,              // 参数
    5,                 // 优先级
    NULL               // 任务句柄
);

void my_task(void* parameter) {
    // 栈上分配（自动管理，任务结束时释放）
    char buffer[256];  // 在栈上分配256字节
    
    // 堆上分配（需要手动管理）
    char* heap_buf = malloc(1024);
    
    // 使用...
    
    free(heap_buf);  // 必须释放
    
    vTaskDelete(NULL);  // 删除任务（栈内存自动释放）
}

内存监控和调试

#include "esp_heap_caps.h"

void print_memory_info() {
    // 获取堆内存信息
    size_t free_heap = esp_get_free_heap_size();
    size_t min_free = esp_get_minimum_free_heap_size();
    
    printf("Free heap: %d bytes\n", free_heap);
    printf("Min free heap: %d bytes\n", min_free);
    
    // 获取任务栈使用情况
    UBaseType_t stack_remaining = uxTaskGetStackHighWaterMark(NULL);
    printf("Stack remaining: %d words\n", stack_remaining);
}

常见内存问题和最佳实践

1. 内存泄漏预防

// ❌ 错误：忘记释放
void bad_function() {
    char* buf = malloc(1024);
    // 忘记 free(buf); - 内存泄漏！
}

// ✅ 正确：总是配对分配和释放
void good_function() {
    char* buf = malloc(1024);
    if (buf == NULL) return;  // 检查分配是否成功
    
    // 使用 buf...
    
    free(buf);  // 总是释放
    buf = NULL; // 防止误用
}

2. 栈溢出预防

// ❌ 危险：大数组在栈上
void dangerous_task(void* param) {
    char huge_array[8192];  // 可能导致栈溢出！
}

// ✅ 安全：大内存用堆
void safe_task(void* param) {
    char* large_buf = malloc(8192);
    if (large_buf == NULL) {
        ESP_LOGE(TAG, "Failed to allocate memory");
        vTaskDelete(NULL);
        return;
    }
    
    // 使用 large_buf...
    
    free(large_buf);
    vTaskDelete(NULL);
}

3. 内存池模式（推荐用于频繁分配）

// 预分配内存池
#define POOL_SIZE 10
#define BUF_SIZE 1024

typedef struct {
    char data[BUF_SIZE];
    bool in_use;
} buffer_t;

buffer_t buffer_pool[POOL_SIZE];

buffer_t* get_buffer() {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (!buffer_pool[i].in_use) {
            buffer_pool[i].in_use = true;
            return &buffer_pool[i];
        }
    }
    return NULL;  // 池子满了
}

void return_buffer(buffer_t* buf) {
    if (buf) {
        buf->in_use = false;
    }
}

配置文件调优

在 sdkconfig 或 menuconfig 中：

# 堆内存配置
CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1536

# 内存调试
CONFIG_HEAP_POISONING_COMPREHENSIVE=y  # 检测内存损坏
CONFIG_HEAP_TRACING=y                  # 内存追踪

与 Go 的主要区别

Go	ESP32 + FreeRTOS
自动垃圾回收	手动内存管理
make([]byte, 1024)	malloc(1024) + free()
栈自动增长	固定栈大小
内存安全	需要手动检查边界
无内存泄漏担心	必须配对分配/释放

实用建议

1. 总是检查分配是否成功
2. 每个 malloc 都要有对应的 free
3. 合理设置任务栈大小
4. 使用内存调试工具
5. 考虑使用静态分配替代动态分配
6. 定期监控内存使用情况

这样的内存管理虽然比 Go 复杂，但给了你更多的控制权，这在资源受限的嵌入式环境中是必要的。