ESP32手势识别部署实现文档

ESP32手势识别部署实现文档

项目结构设计

本项目实现了在ESP32上部署量化后的手势识别模型。项目采用ESP-IDF框架进行开发，整体架构包括模型加载、数据预处理、推理执行和结果处理等核心模块。

分区表配置

系统分区表（partitions.csv）的设计充分考虑了模型部署的需求：

1
2
3
4
5
# Name,   Type, SubType,  Offset,   Size,  Flags
nvs,      data, nvs,      0x9000,   24K,
phy_init, data, phy,      0xf000,   4K,
factory,  app,  factory,  0x10000,  4000K,
model,    data, spiffs,   ,         256K,
CSV

特别注意以下几点：

  • factory分区分配4MB，保证应用程序有足够空间
  • 专门划分model分区（256KB）用于存储量化后的模型
  • nvs分区用于存储系统配置信息
  • phy_init分区用于无线校准数据

构建系统配置

项目的CMakeLists.txt配置体现了模块化的设计思想：

1
2
3
4
5
6
7
set(srcs app_main.cpp)
set(requires esp-dl)

idf_component_register(SRCS ${srcs}
                     REQUIRES ${requires}
                     INCLUDE_DIRS "../model"
                     WHOLE_ARCHIVE)
CMAKE

构建系统的关键设计：

  1. 使用esp-dl组件提供深度学习支持
  2. 将模型目录添加到包含路径
  3. 使用WHOLE_ARCHIVE确保所有符号都被链接

模型打包流程

构建系统中包含了自动化的模型打包流程：

1
2
3
4
5
6
7
8
9
10
set(MVMODEL_EXE ${PROJECT_DIR}/pack_model.py)
idf_build_get_property(build_dir BUILD_DIR)
set(image_file ${build_dir}/espdl_models/models.espdl)

add_custom_command(
    OUTPUT ${image_file}
    COMMAND python ${MVMODEL_EXE} --model_path=${MODEL_FILE_PATH} 
    --out_file=${image_file}
    DEPENDS ${MODEL_FILE_PATH}
    VERBATIM)
CMAKE

这个过程可以自动完成：

  • 模型文件的打包
  • 分区大小的验证
  • 模型的烧录准备

图像预处理实现

预处理工具开发

为了简化部署过程，开发了专门的图像预处理工具：

1
2
3
4
5
6
7
def process_image(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    resized = cv2.resize(gray, (96, 96))
    normalized = resized.astype('float32') / 255.0
    quantized = (normalized * 128).astype(np.int8)
    return quantized
PYTHON

预处理步骤包括：

  1. 图像加载和灰度转换
  2. 尺寸调整到96x96
  3. 归一化处理
  4. 量化到int8范围

头文件生成

预处理数据通过生成C++头文件的方式集成到项目中：

1
2
3
4
5
6
7
8
9
10
11
12
def generate_header(data, output_path):
    with open(output_path, 'w') as f:
        f.write("#pragma once\n\n")
        f.write("const int8_t test_image_data[9216] = {\n    ")
        data_str = [str(x) for x in data.flatten()]
        chunk_size = 12
        for i in range(0, len(data_str), chunk_size):
            chunk = data_str[i:i + chunk_size]
            f.write(", ".join(chunk))
            if i + chunk_size < len(data_str):
                f.write(",\n    ")
        f.write("};\n")
PYTHON

这种设计的优势：

  • 预处理数据直接编译到固件中
  • 避免运行时的预处理开销
  • 确保数据格式的一致性

推理实现

核心推理模块

推理实现的核心代码展示了整个工作流程：

1
2
3
4
5
6
7
8
9
10
11
class TensorBase* prepare_input_tensor() {
    TensorBase* input_tensor = new TensorBase(
        {1, 1, 96, 96},           
        test_image_data,          
        -7,                       
        dl::DATA_TYPE_INT8,       
        false,                    
        MALLOC_CAP_SPIRAM        
    );
    return input_tensor;
}
CPP

推理过程的关键考虑：

  1. 使用SPIRAM存储张量数据
  2. 采用int8量化数据类型
  3. 设置合适的量化参数（指数）

后处理实现

结果处理部分实现了softmax计算和置信度输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void print_confidences(TensorBase* output_tensor) {
    int8_t* output_data = static_cast<int8_t*>(
        output_tensor->get_element_ptr()
    );
    float scale = std::pow(2, output_tensor->exponent);

    // Softmax计算
    float max_val = -INFINITY;
    for (int i = 0; i < NUM_CLASSES; i++) {
        float val = output_data[i] * scale;
        if (val > max_val) max_val = val;
    }

    float sum = 0;
    std::vector<float> confidences(NUM_CLASSES);
    for (int i = 0; i < NUM_CLASSES; i++) {
        float val = std::exp((output_data[i] * scale) - max_val);
        confidences[i] = val;
        sum += val;
    }
}
CPP

后处理的重点：

  • 正确的反量化处理
  • 数值稳定性考虑
  • 内存使用优化

性能优化

内存管理

代码中实现了严格的内存管理策略：

1
2
3
4
5
6
7
size_t free_mem_before = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
ESP_LOGI(TAG, "Free memory before inference: %u bytes", free_mem_before);

// 运行推理...

size_t free_mem_after = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
ESP_LOGI(TAG, "Free memory after inference: %u bytes", free_mem_after);
CPP

内存优化措施：

  1. 使用SPIRAM存储大型数据
  2. 及时释放不用的资源
  3. 监控内存使用情况

时间性能优化

系统实现了详细的时间性能监控：

1
2
3
4
5
6
7
8
9
10
int64_t start_time = esp_timer_get_time();
// 模型加载...
int64_t load_time = esp_timer_get_time();
ESP_LOGI(TAG, "Model loaded in %lld ms", (load_time - start_time) / 1000);

int64_t inference_start = esp_timer_get_time();
// 执行推理...
int64_t inference_end = esp_timer_get_time();
ESP_LOGI(TAG, "Inference time: %lld ms", 
         (inference_end - inference_start) / 1000);
CPP

性能优化重点：

  1. 模型加载时间优化
  2. 推理执行时间监控
  3. 系统响应时间分析

部署建议

内存配置

  1. SPIRAM配置

    • 启用SPIRAM支持
    • 配置适当的时钟频率
    • 考虑内存对齐要求

  2. 堆内存管理

    • 设置合理的堆大小
    • 监控内存碎片
    • 实现内存泄漏检测

性能调优

  1. 时钟配置

    • CPU频率选择
    • SPIRAM时钟配置
    • 外设时钟优化

  2. 中断处理

    • 最小化中断处理时间
    • 合理的中断优先级设置
    • 避免长时间禁用中断

可靠性保障

  1. 看门狗配置

    • 设置合理的超时时间
    • 实现任务监控
    • 正确的复位处理

  2. 错误处理

    • 完善的错误检查
    • 日志记录机制
    • 故障恢复策略
fyp
ESP32手势识别部署实现文档
https://blakehansen130.github.io/2024/11/29/esp32-deployment-docs/
发布于
2024年11月29日
许可协议