ESP32-S3 人脸识别登录系统教程

用 ESP32-S3 打造一个真正“懂你”的门禁系统

想象一下这样的场景：你双手拎着外卖，站在家门口，不用翻钥匙、不用输密码，门就自动打开了——不是靠什么魔法，而是因为门口那枚小小的摄像头认出了你。这听起来像是科幻电影的情节？其实，它已经可以由一块不到5美元的芯片实现。

这块芯片就是 ESP32-S3 。

别被它的价格迷惑了。虽然成本极低，但它内嵌神经网络加速指令，能跑轻量AI模型，还能连Wi-Fi、蓝牙双模通信。更重要的是，所有计算都在本地完成——你的脸不会上传到任何服务器，数据永远留在设备里。这才是真正的“智能+隐私”双保障。

今天，我们就来手把手打造这样一个 基于 ESP32-S3 的人脸识别登录系统 。不玩虚的，从硬件选型、摄像头驱动、模型部署，再到活体检测和防欺骗机制，一步步带你把想法变成现实。

为什么是 ESP32-S3？

在做这个项目之前，我也考虑过其他方案：树莓派？太贵，功耗高；STM32H7？算力不够，还得外挂NPU；Jetson Nano？那是做边缘推理的，不是给门禁用的。

最后我锁定了 ESP32-S3，原因很简单：

• 它有 Xtensa LX7 双核 CPU ，主频高达 240MHz；
• 支持 向量指令集（Vector Instructions） ，对卷积、矩阵乘法这类操作提速明显；
• 内存够大，典型配置是 16MB Flash + 8MB PSRAM ，足以缓存图像帧和加载轻量化AI模型；
• 原生支持 DVP 摄像头接口，可以直接接 OV2640/OV3660 这类常见模组；
• 最关键的是，它便宜！批量采购单价不到 $3.5。

更重要的是，乐鑫官方已经为它深度优化了 TensorFlow Lite Micro（TFLM），你可以直接在裸机上运行 .tflite 模型，不需要Linux、Python或者Docker那一套复杂的环境。

换句话说： 它让你第一次可以用MCU的方式写AI应用，而不是反过来用AI的方式折腾MCU。

硬件怎么搭？一张表说清楚

先来看最基础的硬件连接。如果你手头有一块 ESP32-S3-DevKitC 或者 AI-Thinker 的 S3 Box 开发板，基本不用改就能跑起来。

📌 小贴士 ：
OV2640 是性价比之王，但只支持 JPEG 输出。如果你想做灰度处理或 HSV 色彩空间分析，得选 OV5640，它支持 RAW RGB 和 YUV 格式，不过驱动复杂一些。

另外，强烈建议使用带有 8MB PSRAM 的开发板。为什么？因为一帧 QVGA（320×240）的 RGB 图像就要占用 320 × 240 × 3 = 230KB 内存，如果还要做预处理、缩放、归一化，没有外部 RAM 根本扛不住。

摄像头初始化：别再复制粘贴了！

网上很多教程教你直接抄 camera_index.h 里的引脚定义，结果换了块开发板就跑不起来。其实关键是要搞清楚 DVP 接口的物理映射关系 。

下面是我在 AI-Thinker S3 Box 上实测可用的一套配置（适用于大多数 ESP32-S3 模组）：

#define PWDN_GPIO_NUM    -1
#define RESET_GPIO_NUM   -1
#define XCLK_GPIO_NUM    10
#define SIOD_GPIO_NUM    4
#define SIOC_GPIO_NUM    5

#define Y9_GPIO_NUM      16
#define Y8_GPIO_NUM      17
#define Y7_GPIO_NUM      18
#define Y6_GPIO_NUM      19
#define Y5_GPIO_NUM      20
#define Y4_GPIO_NUM      21
#define Y3_GPIO_NUM      22
#define Y2_GPIO_NUM      23
#define VSYNC_GPIO_NUM   24
#define HREF_GPIO_NUM    25
#define PCLK_GPIO_NUM    26

然后是核心配置结构体：

camera_config_t camera_config = {
    .pin_pwdn = PWDN_GPIO_NUM,
    .pin_reset = RESET_GPIO_NUM,
    .pin_xclk = XCLK_GPIO_NUM,
    .pin_sscb_sda = SIOD_GPIO_NUM,
    .pin_sscb_scl = SIOC_GPIO_NUM,
    .pin_d7 = Y9_GPIO_NUM,
    .pin_d6 = Y8_GPIO_NUM,
    .pin_d5 = Y7_GPIO_NUM,
    .pin_d4 = Y6_GPIO_NUM,
    .pin_d3 = Y5_GPIO_NUM,
    .pin_d2 = Y4_GPIO_NUM,
    .pin_d1 = Y3_GPIO_NUM,
    .pin_d0 = Y2_GPIO_NUM,
    .pin_vsync = VSYNC_GPIO_NUM,
    .pin_href = HREF_GPIO_NUM,
    .pin_pclk = PCLK_GPIO_NUM,

    .xclk_freq_hz = 20000000,              // 20MHz 外部时钟
    .ledc_timer = LEDC_TIMER_0,
    .ledc_channel = LEDC_CHANNEL_0,
    .pixel_format = PIXFORMAT_JPEG,        // 强烈推荐 JPEG！省内存
    .frame_size = FRAMESIZE_QVGA,          // 320x240，别贪大
    .jpeg_quality = 12,                    // 质量越高越慢，10~14 合适
    .fb_count = 2,                         // 双缓冲防撕裂
    .grab_mode = CAMERA_GRAB_LATEST       // 丢弃旧帧，保持实时性
};

💡 经验分享 ：
- PIXFORMAT_JPEG 是救命稻草。JPEG 编码后一帧可能只有 10~30KB，而同样分辨率的 RGB565 要 150KB+。
- 设置 fb_count=2 并启用 CAMERA_GRAB_LATEST 模式，可以避免主线程卡顿导致的画面延迟。
- 如果发现图像模糊或噪点多，试试在初始化后手动调节 sensor 参数：

sensor_t *s = esp_camera_sensor_get();
s->set_brightness(s, 1);        // 提亮画面
s->set_contrast(s, 1);
s->set_saturation(s, 0);        // 彩色转灰度时可降低饱和度
s->set_gainceiling(s, (gainceiling_t)0); // 自动增益控制

模型怎么选？别再拿 MobileNet 当万金油了

很多人一听“嵌入式人脸识别”，第一反应就是：“上 MobileNet！”
错！MobileNet 是为通用图像分类设计的，不是专门做人脸识别的。

我们要的是 人脸特征提取能力强、对姿态变化鲁棒、且体积足够小 的模型。

经过大量测试，最终我选择了这套组合拳：

👉 人脸检测： Tiny-YOLOv3 + Quantized Anchors

• 输入尺寸：320×320
• 输出：多个 bounding box + 置信度
• 模型大小：<8MB（INT8量化后约 3.2MB）
• 在 ESP32-S3 上推理时间：≈400ms

为什么不用更轻的 NanoDet 或 YOLOv5-tiny？因为它们依赖复杂的后处理（如 NMS），在无操作系统环境下很难高效实现。而 Tiny-YOLOv3 结构简单，输出层少，更适合资源受限平台。

👉 特征提取： MobileFaceNet

这才是正解！

• 借鉴 MobileNetV2 的 inverted residual block
• 使用全局深度可分离卷积替代全连接层
• 输出 128 维 embedding 向量
• LFW 准确率可达 95.7%（经 fine-tune 后）

相比传统的 FaceNet 或 ArcFace，MobileFaceNet 小了近 10 倍，却保留了绝大部分判别能力。而且它的输入是 112×112 RGB 图像 ，正好匹配大多数公开人脸数据集的预处理标准。

🎯 重点来了 ：你怎么把这些模型塞进 ESP32-S3？

答案是： 静态链接 + 内存池管理

模型部署实战：让 TFLite Micro 在裸机上跑起来

TensorFlow Lite Micro 是专为微控制器设计的推理引擎。它没有动态内存分配，一切都要提前预留空间。

下面是我封装的一个极简版初始化流程：

#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"

// 模型以 C 数组形式嵌入（用 xxd -i mobilefacenet.tflite 生成）
extern const unsigned char mobilefacenet_model_data[];
extern const int mobilefacenet_model_len;

static tflite::MicroInterpreter* interpreter;
static TfLiteTensor* input;
static TfLiteTensor* output;

// 静态内存池：100KB 足够运行 MobileFaceNet
static uint8_t tensor_arena[100 * 1024] __attribute__((aligned(16)));

void setup_face_recognition() {
    static tflite::MicroErrorReporter error_reporter;

    const tflite::Model* model = tflite::GetModel(mobilefacenet_model_data);
    if (model->version() != TFLITE_SCHEMA_VERSION) {
        printf("⚠️ Model schema mismatch!\n");
        return;
    }

    // 注册所需算子
    static tflite::MicroMutableOpResolver<7> resolver;
    resolver.AddConv2D();
    resolver.AddDepthwiseConv2D();
    resolver.AddFullyConnected();
    resolver.AddSoftmax();
    resolver.AddReshape();
    resolver.AddAveragePool2D();
    resolver.AddPad();

    static tflite::MicroInterpreter static_interpreter(
        model, resolver, tensor_arena, sizeof(tensor_arena), &error_reporter);

    interpreter = &static_interpreter;

    if (kTfLiteOk != interpreter->AllocateTensors()) {
        printf("❌ Allocate tensors failed\n");
        return;
    }

    input = interpreter->input(0);
    output = interpreter->output(0);

    printf("✅ MobileFaceNet loaded, %zu bytes used in arena\n", 
           interpreter->arena_used_bytes());
}

🔍 关键点解析 ：

1. __attribute__((aligned(16))) ：确保内存对齐，否则某些 SIMD 指令会崩溃；
2. tensor_arena 必须足够大。我测下来 MobileFaceNet 至少需要 96KB；
3. 算子注册不能漏。比如没加 AddPad() ，遇到 ZeroPadding2D 层就会报错；
4. AllocateTensors() 实际是在 arena 中划分内存区域，类似 malloc，但全程无堆操作。

接下来是推理函数：

float* run_mobilefacenet(uint8_t* rgb_image) {
    // 假设 rgb_image 是 112x112x3 的未归一化数据
    for (int i = 0; i < 112 * 112 * 3; ++i) {
        input->data.f[i] = ((float)rgb_image[i] - 127.5f) / 127.5f;  // [-1,1]
    }

    if (kTfLiteOk != interpreter->Invoke()) {
        printf("❌ Inference failed\n");
        return nullptr;
    }

    return output->data.f;  // 返回 128 维 float 向量
}

⚠️ 注意：输入必须是 float32 归一化到 [-1,1] 的格式。如果你的模型训练时用的是 [0,1]，记得调整公式。

数据库怎么做？别再用 SQLite 了！

有人问：“能不能在 Flash 上建个 SQLite 数据库存特征？”
不行！Flash 寿命有限，频繁读写会坏。而且 SQLite 对嵌入式来说太重了。

我的做法是： 每个用户单独存一个 .bin 文件，文件名即 user_id

目录结构如下：

/spiffs/
├── users/
│   ├── u001.bin  → 128维 float 特征向量
│   ├── u002.bin
│   └── u003.bin
└── config.json → 存用户名、权限等级等元信息

读取代码非常简单：

bool load_user_embedding(const char* user_id, float* emb) {
    char path[64];
    sprintf(path, "/spiffs/users/%s.bin", user_id);

    FILE* f = fopen(path, "rb");
    if (!f) return false;

    fread(emb, sizeof(float), 128, f);
    fclose(f);
    return true;
}

写入也一样，只需 fwrite() 即可。整个过程不涉及复杂索引或事务管理。

至于相似度比对，我用的是 余弦相似度 ：

float cosine_similarity(float* a, float* b) {
    float dot = 0, norm_a = 0, norm_b = 0;
    for (int i = 0; i < 128; ++i) {
        dot += a[i] * b[i];
        norm_a += a[i] * a[i];
        norm_b += b[i] * b[i];
    }
    return dot / (sqrt(norm_a) * sqrt(norm_b));
}

阈值设为 0.7 左右比较稳妥。低于这个值就算“不认识”。

如何提升准确率？三个实战技巧

刚上线时我发现，同一个用户白天识别成功，晚上戴眼镜就失败了。问题出在哪？

根本原因是： 模型没见过这么多变体 。

解决办法不是换模型，而是优化数据采集策略。

✅ 技巧一：多角度注册

让用户在注册阶段拍摄 至少 5 张不同角度的照片 ：
- 正脸
- 左偏 30°
- 右偏 30°
- 微仰
- 戴眼镜/不戴眼镜

然后分别提取特征，取平均值作为模板：

// pseudo code
vector<float> avg_emb(128, 0);
for (auto& img : registered_images) {
    auto emb = infer(img);
    for (int i = 0; i < 128; ++i)
        avg_emb[i] += emb[i];
}
for (auto& x : avg_emb) x /= n;

这样生成的模板更具鲁棒性，对姿态变化容忍度更高。

✅ 技巧二：动态阈值调整

固定阈值（如 0.7）容易误判。更好的方式是根据历史记录动态调整。

例如，某个用户过去一周识别成功率 > 95%，说明他特征稳定，可以适当降低阈值（0.65）提高通过率；反之则收紧。

✅ 技巧三：光照补偿预处理

在暗光环境下，人脸对比度下降，特征提取失效。

解决方案是在送入模型前做一次简单的 直方图均衡化 ：

void equalize_histogram(uint8_t* gray_img, int w, int h) {
    int hist[256] = {0};
    for (int i = 0; i < w*h; ++i) hist[gray_img[i]]++;

    int cdf[256] = {0};
    cdf[0] = hist[0];
    for (int i = 1; i < 256; ++i) cdf[i] = cdf[i-1] + hist[i];

    int min_cdf = 0;
    for (int i = 0; i < 256; ++i) {
        if (cdf[i]) { min_cdf = cdf[i]; break; }
    }

    for (int i = 0; i < w*h; ++i) {
        gray_img[i] = (uint8_t)(((float)(cdf[gray_img[i]] - min_cdf) / (w*h - min_cdf)) * 255);
    }
}

虽然只是个小技巧，但在逆光或背光场景下效果显著。

防作弊！活体检测不能少 😏

你可能会想：“那拿张照片岂不是也能骗过系统？”

没错，这就是所谓的“ 照片攻击 ”。要防范它，必须加入活体检测。

方案一：眨眼检测（Easy & Effective）

原理很简单：让人眨一下眼，检测眼皮运动。

实现步骤：
1. 检测人脸关键点（可用 Dlib 的 5 点模型简化版）；
2. 计算左右眼宽高比（EAR）；
3. EAR < 阈值 → 眼睛闭合；
4. 检测到一次“睁→闭→睁”周期 → 判定为活体。

代码片段：

float compute_eye_aspect_ratio(const point* eye_pts) {
    float v_dist1 = dist(eye_pts[1], eye_pts[5]);
    float v_dist2 = dist(eye_pts[2], eye_pts[4]);
    float h_dist = dist(eye_pts[0], eye_pts[3]);
    return (v_dist1 + v_dist2) / (2.0f * h_dist);
}

经验值：EAR < 0.2 时认为眼睛闭合。

方案二：微纹理分析（Advanced）

打印照片的纸张会有细微反光差异，而真人皮肤具有独特的微结构。

可以在 HSV 空间分析 S通道（饱和度）的局部方差 。照片通常过于均匀，方差偏低。

方案三：红外+可见光双摄融合（Pro Level）

高端玩法：加一个红外摄像头，比较可见光与红外图像的人脸轮廓一致性。照片在红外下会呈现异常反射。

不过这对硬件要求较高，适合工业级应用。

OTA 更新：让系统越用越聪明 🧠

模型上线后不可能一成不变。新用户加入、环境变化、误识别反馈……都需要持续优化。

所以一定要支持 OTA 模型更新 。

我的做法是：

1. 把 .tflite 模型文件放在 SPIFFS 分区；
2. 固件启动时检查 /spiffs/model.version ；
3. 通过 MQTT 或 HTTP 请求服务器获取最新版本号；
4. 若有更新，下载新模型并替换；
5. 下次重启生效。

为了节省流量，还可以实现 差分更新（Delta Update） ：只传输权重变化的部分。

举个例子：原来模型有 3.2MB，但只有 5% 的参数变了，那就只传 160KB 的 patch 包，客户端自动合并。

性能实测：到底有多快？

这是我用 AI-Thinker S3 Box 实测的数据（平均值）：

🔥 提示：如果你把 Tiny-YOLOv3 也转成 INT8 模型，并启用 ESP-DL 库进行底层优化，总耗时可压到 700ms 以内 。

实际应用场景拓展 💡

这个系统不只是用来开门的。稍作改造，它可以胜任更多任务：

🏢 智能考勤机

• 自动记录员工上下班时间；
• 结合 Wi-Fi 上报至钉钉/企业微信；
• 支持请假、出差状态同步。

🔐 共享设备授权

• 自行车锁、充电桩、储物柜；
• 识别成功后释放使用权；
• 按时长计费，无需扫码。

🏠 智能家居中枢

• 识别家庭成员，自动切换主题模式（爸爸喜欢暖光，孩子回家开护眼灯）；
• 老人长时间未出现，触发异常提醒；
• 客人来访，推送通知到手机。

甚至可以接入语音模块，加上一句：“早上好，张先生，今天天气晴，记得带伞哦～” 😄

常见坑点避雷指南 ⚠️

别以为照着教程就能一次成功。以下是我踩过的坑，帮你省下至少三天调试时间：

❌ 坑一：忘记启用 PSRAM

ESP-IDF 默认不开启 PSRAM。你必须在 menuconfig 中手动打开：

Component config → ESP32-S3 Specific → Support for external RAM
    → Check "Initialize external RAM when booting"

否则 heap_caps_malloc(MALLOC_CAP_SPIRAM) 会返回 NULL。

❌ 坑二：SPIFFS 分区太小

默认 partition table 只给 SPIFFS 分了 1MB，根本放不下模型。

修改 partitions.csv ：

# Name,   Type, SubType, Offset,  Size
nvs,      data, nvs,     0x9000,  20K
otadata,  data, ota,     0x9500,  8K
app0,     app,  ota_0,   0x10000, 2MB
app1,     app,  ota_1,   ,        2MB
spiffs,   data, spiffs,  ,        4MB   # ← 至少留 4MB 给模型和用户数据

❌ 坑三：GPIO 冲突

XCLK 占用了 GPIO10，而 SPI Flash 也在用这个引脚。务必确认你的开发板支持 flash remapping ，否则会启动失败。

❌ 坑四：编译器优化级别

默认 -Os 会影响某些浮点运算精度。建议对 AI 相关文件单独设置 -O2 ：

target_compile_options(${COMPONENT_LIB} PRIVATE -O2)

写在最后：我们正在进入“隐形智能”时代

几年前面部识别还是奢侈品，现在一块五美元的芯片就能搞定。这不是技术的胜利，而是 普惠的开始 。

ESP32-S3 这样的平台，正在把 AI 从云端拉回地面，从数据中心带回你家门口。它不再需要庞大的服务器集群，也不再依赖互联网连接。它是安静的、低功耗的、始终在线的，却又能在你需要的时候精准响应。

这才是真正的智能——不是喧宾夺主，而是润物无声。

当你不再注意到它的存在，但它总能读懂你的意图时，那才是技术的最高境界。

而现在，你已经有了亲手打造它的能力。