四博 AI 双目方案技术拆解：用 ESP32-S3 做一个有眼神、有触感、有姿态感知的 AI 交互终端

四博 AI 双目方案技术拆解：用 ESP32-S3 做一个有眼神、有触感、有姿态感知的 AI 交互终端

AI 硬件真正的门槛，不只是"能不能接入大模型"，而是设备有没有完整的交互闭环。

四博 AI 双目方案的思路，是用 ESP32-S3 主控 + VB6824 语音前端 + 0.71 / 1.28 寸双目光屏 + 四路触控 + 三轴姿态传感器 + 震动马达 + 四博小助手小程序，构建一个可以"听、说、看、摸、感知动作、反馈状态"的多模态 AI 终端。

根据四博资料，AI-S3 双目方案采用 ESP32S3R8 + 16M Flash + VB6824，并支持小智、豆包、ChatGPT 等主流大模型接入；开发宝典中也包含 AI-S3 双目、VB6824、配网、OTA、MCP 等开发内容。

---

一、整体架构：把 AI 设备做成事件驱动系统

这类设备不建议写成一个大循环，而应该拆成多个 FreeRTOS 任务，通过事件队列统一调度。

app_main
 ├── wifi_task          // Wi-Fi连接、重连、联网状态
 ├── blufi_task         // 四博小助手BLE配网
 ├── vb6824_task        // 唤醒、打断、录音事件
 ├── ai_ws_task         // WebSocket / MQTT AI通信
 ├── eye_task           // 双目动画刷新
 ├── touch_task         // 四路触控扫描
 ├── imu_task           // 三轴姿态检测
 ├── haptic_task        // 震动马达控制
 ├── mcp_task           // AI工具调用
 ├── ota_task           // 固件和素材升级
 └── app_dispatch_task  // 全局事件分发

设备内部所有模块都围绕事件运行：

语音唤醒 → APP_EVT_WAKE_WORD
顶部触摸 → APP_EVT_TOUCH_TOP
摇晃设备 → APP_EVT_IMU_SHAKE
AI开始回复 → APP_EVT_AI_SPEAKING
网络断开 → APP_EVT_WIFI_DISCONNECTED
OTA升级 → APP_EVT_OTA_START

这样做的好处是：语音、双目、触控、马达、姿态传感器都能统一联动，后续增加功能也不会破坏主流程。

---

二、定义全局事件系统

先定义一个统一事件类型。

#pragma once

#include <stdint.h>
#include <stdbool.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"

typedef enum {
    APP_EVT_NONE = 0,

    APP_EVT_WIFI_CONNECTED,
    APP_EVT_WIFI_DISCONNECTED,

    APP_EVT_BLUFI_START,
    APP_EVT_BLUFI_DONE,

    APP_EVT_WAKE_WORD,
    APP_EVT_VOICE_INTERRUPT,
    APP_EVT_RECORD_START,
    APP_EVT_RECORD_STOP,

    APP_EVT_TOUCH_TOP,
    APP_EVT_TOUCH_LEFT,
    APP_EVT_TOUCH_RIGHT,
    APP_EVT_TOUCH_BACK,

    APP_EVT_IMU_PICKUP,
    APP_EVT_IMU_SHAKE,
    APP_EVT_IMU_FLIP,
    APP_EVT_IMU_TILT_LEFT,
    APP_EVT_IMU_TILT_RIGHT,

    APP_EVT_AI_LISTENING,
    APP_EVT_AI_THINKING,
    APP_EVT_AI_SPEAKING,
    APP_EVT_AI_FINISHED,
    APP_EVT_AI_ERROR,

    APP_EVT_MCP_TOOL_CALL,
    APP_EVT_LOW_BATTERY,
    APP_EVT_OTA_START,
    APP_EVT_OTA_DONE,
} app_event_id_t;

typedef struct {
    app_event_id_t id;
    int param1;
    int param2;
    char payload[256];
} app_event_t;

extern QueueHandle_t g_app_event_queue;

void app_post_event(app_event_id_t id, int p1, int p2, const char *payload);

事件发送函数：

#include "app_event.h"
#include <string.h>

QueueHandle_t g_app_event_queue = NULL;

void app_post_event(app_event_id_t id, int p1, int p2, const char *payload)
{
    if (!g_app_event_queue) {
        return;
    }

    app_event_t evt = {
        .id = id,
        .param1 = p1,
        .param2 = p2,
    };

    if (payload) {
        strncpy(evt.payload, payload, sizeof(evt.payload) - 1);
    }

    xQueueSend(g_app_event_queue, &evt, 0);
}

---

三、AI 状态机：让双目、语音、震动统一联动

AI 双目设备最好用状态机描述设备状态。

typedef enum {
    AI_STATE_BOOT = 0,
    AI_STATE_IDLE,
    AI_STATE_WAKEUP,
    AI_STATE_LISTENING,
    AI_STATE_THINKING,
    AI_STATE_SPEAKING,
    AI_STATE_TOUCH_FEEDBACK,
    AI_STATE_SHAKE_FEEDBACK,
    AI_STATE_SLEEP,
    AI_STATE_NETWORK_ERROR,
    AI_STATE_LOW_BATTERY,
    AI_STATE_OTA,
} ai_state_t;

static ai_state_t g_ai_state = AI_STATE_BOOT;

状态切换函数：

void eye_play_anim(const char *name);
void audio_play_prompt(const char *name);
void audio_start_record(void);
void audio_stop_record(void);
void audio_stop_tts(void);
void haptic_short(void);
void haptic_double(void);
void haptic_long(void);

void ai_set_state(ai_state_t state)
{
    g_ai_state = state;

    switch (state) {
    case AI_STATE_BOOT:
        eye_play_anim("boot");
        audio_play_prompt("boot.wav");
        break;

    case AI_STATE_IDLE:
        eye_play_anim("idle_blink");
        break;

    case AI_STATE_WAKEUP:
        eye_play_anim("wake");
        haptic_double();
        audio_play_prompt("ding.wav");
        break;

    case AI_STATE_LISTENING:
        eye_play_anim("listening");
        audio_start_record();
        break;

    case AI_STATE_THINKING:
        eye_play_anim("thinking");
        break;

    case AI_STATE_SPEAKING:
        eye_play_anim("speaking");
        break;

    case AI_STATE_TOUCH_FEEDBACK:
        eye_play_anim("happy");
        haptic_short();
        break;

    case AI_STATE_SHAKE_FEEDBACK:
        eye_play_anim("surprised");
        haptic_double();
        break;

    case AI_STATE_SLEEP:
        eye_play_anim("sleep");
        audio_stop_tts();
        break;

    case AI_STATE_NETWORK_ERROR:
        eye_play_anim("net_error");
        haptic_long();
        audio_play_prompt("network_error.wav");
        break;

    case AI_STATE_LOW_BATTERY:
        eye_play_anim("low_battery");
        haptic_long();
        audio_play_prompt("low_battery.wav");
        break;

    case AI_STATE_OTA:
        eye_play_anim("ota");
        break;

    default:
        eye_play_anim("idle_blink");
        break;
    }
}

这样用户每一次操作都有明确反馈：

唤醒成功：双目睁眼 + 双短震 + 提示音
AI聆听：眼睛聚焦 + 开始录音
AI思考：眼球转动 / loading动画
AI回复：说话表情 + TTS播放
触摸顶部：开心表情 + 短震
摇晃设备：惊讶表情 + 双震
翻转设备：睡眠表情 + 停止播放
网络异常：困惑表情 + 长震 + 提示音

---

四、四路触控：本地交互入口

四路触控建议定义为：

触控位置	功能
顶部	唤醒 / 暂停 / 继续
左侧	上一个角色 / 上一首
右侧	下一个角色 / 下一首
背部	配网 / 静音 / 长按恢复出厂

如果用 ESP32-S3 的 Touch Pad，可以这样写：

#include "driver/touch_sensor.h"
#include "esp_log.h"
#include "app_event.h"

#define TOUCH_THRESHOLD_PERCENT 70

typedef struct {
    touch_pad_t pad;
    uint32_t baseline;
    app_event_id_t evt;
    const char *name;
} touch_key_t;

static touch_key_t s_touch_keys[] = {
    {TOUCH_PAD_NUM1, 0, APP_EVT_TOUCH_TOP,   "TOP"},
    {TOUCH_PAD_NUM2, 0, APP_EVT_TOUCH_LEFT,  "LEFT"},
    {TOUCH_PAD_NUM3, 0, APP_EVT_TOUCH_RIGHT, "RIGHT"},
    {TOUCH_PAD_NUM4, 0, APP_EVT_TOUCH_BACK,  "BACK"},
};

static void touch_calibrate(void)
{
    for (int i = 0; i < 4; i++) {
        uint32_t sum = 0;

        for (int j = 0; j < 20; j++) {
            uint32_t raw = 0;
            touch_pad_read_raw_data(s_touch_keys[i].pad, &raw);
            sum += raw;
            vTaskDelay(pdMS_TO_TICKS(10));
        }

        s_touch_keys[i].baseline = sum / 20;

        ESP_LOGI("TOUCH", "%s baseline=%lu",
                 s_touch_keys[i].name,
                 s_touch_keys[i].baseline);
    }
}

static void touch_task(void *arg)
{
    while (1) {
        for (int i = 0; i < 4; i++) {
            uint32_t raw = 0;
            touch_pad_read_raw_data(s_touch_keys[i].pad, &raw);

            uint32_t threshold =
                s_touch_keys[i].baseline * TOUCH_THRESHOLD_PERCENT / 100;

            if (raw < threshold) {
                ESP_LOGI("TOUCH", "%s touched raw=%lu",
                         s_touch_keys[i].name, raw);

                app_post_event(s_touch_keys[i].evt, raw, 0, NULL);

                vTaskDelay(pdMS_TO_TICKS(250));
            }
        }

        vTaskDelay(pdMS_TO_TICKS(30));
    }
}

void touch_app_start(void)
{
    ESP_ERROR_CHECK(touch_pad_init());

    for (int i = 0; i < 4; i++) {
        ESP_ERROR_CHECK(touch_pad_config(s_touch_keys[i].pad));
    }

    vTaskDelay(pdMS_TO_TICKS(300));
    touch_calibrate();

    xTaskCreate(touch_task, "touch_task", 4096, NULL, 5, NULL);
}

如果实际硬件用外置触控 IC，比如 I2C 触控芯片，只需要把 touch_pad_read_raw_data() 替换成 I2C 读取触控状态即可。

---

五、震动马达：把"触摸"变成"有反馈"

震动马达建议用 LEDC PWM 控制。

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

#define MOTOR_GPIO          15
#define MOTOR_LEDC_MODE     LEDC_LOW_SPEED_MODE
#define MOTOR_TIMER         LEDC_TIMER_0
#define MOTOR_CHANNEL       LEDC_CHANNEL_0
#define MOTOR_FREQ_HZ       2000
#define MOTOR_DUTY_MAX      8191

static void motor_set(uint32_t duty)
{
    ledc_set_duty(MOTOR_LEDC_MODE, MOTOR_CHANNEL, duty);
    ledc_update_duty(MOTOR_LEDC_MODE, MOTOR_CHANNEL);
}

void haptic_short(void)
{
    motor_set(MOTOR_DUTY_MAX * 60 / 100);
    vTaskDelay(pdMS_TO_TICKS(60));
    motor_set(0);
}

void haptic_double(void)
{
    for (int i = 0; i < 2; i++) {
        motor_set(MOTOR_DUTY_MAX * 70 / 100);
        vTaskDelay(pdMS_TO_TICKS(50));
        motor_set(0);
        vTaskDelay(pdMS_TO_TICKS(80));
    }
}

void haptic_long(void)
{
    motor_set(MOTOR_DUTY_MAX * 80 / 100);
    vTaskDelay(pdMS_TO_TICKS(300));
    motor_set(0);
}

void haptic_rhythm_ota(void)
{
    for (int i = 0; i < 3; i++) {
        motor_set(MOTOR_DUTY_MAX * 50 / 100);
        vTaskDelay(pdMS_TO_TICKS(80));
        motor_set(0);
        vTaskDelay(pdMS_TO_TICKS(120));
    }
}

void haptic_app_start(void)
{
    ledc_timer_config_t timer = {
        .speed_mode = MOTOR_LEDC_MODE,
        .timer_num = MOTOR_TIMER,
        .duty_resolution = LEDC_TIMER_13_BIT,
        .freq_hz = MOTOR_FREQ_HZ,
        .clk_cfg = LEDC_AUTO_CLK,
    };
    ledc_timer_config(&timer);

    ledc_channel_config_t ch = {
        .gpio_num = MOTOR_GPIO,
        .speed_mode = MOTOR_LEDC_MODE,
        .channel = MOTOR_CHANNEL,
        .timer_sel = MOTOR_TIMER,
        .duty = 0,
        .hpoint = 0,
    };
    ledc_channel_config(&ch);
}

建议震动语义：

短震：触摸确认
双震：唤醒成功 / 角色切换
长震：网络异常 / 低电量
节奏震：OTA升级 / 配网模式

---

六、三轴姿态：拿起、摇晃、翻转都能变成输入

三轴传感器可以实现拿起唤醒、摇一摇切换角色、翻转静音、倾斜眼球跟随。

#include "driver/i2c.h"
#include "esp_log.h"
#include "app_event.h"
#include <math.h>

#define I2C_PORT        I2C_NUM_0
#define I2C_SDA_GPIO    8
#define I2C_SCL_GPIO    9
#define I2C_FREQ_HZ     400000

#define IMU_ADDR        0x68
#define IMU_REG_ACCEL_X 0x3B

typedef struct {
    int16_t x;
    int16_t y;
    int16_t z;
} accel_data_t;

static esp_err_t imu_read_accel(accel_data_t *acc)
{
    uint8_t reg = IMU_REG_ACCEL_X;
    uint8_t buf[6] = {0};

    esp_err_t ret = i2c_master_write_read_device(
        I2C_PORT,
        IMU_ADDR,
        &reg,
        1,
        buf,
        sizeof(buf),
        pdMS_TO_TICKS(50)
    );

    if (ret != ESP_OK) {
        return ret;
    }

    acc->x = (int16_t)((buf[0] << 8) | buf[1]);
    acc->y = (int16_t)((buf[2] << 8) | buf[3]);
    acc->z = (int16_t)((buf[4] << 8) | buf[5]);

    return ESP_OK;
}

static bool imu_detect_shake(accel_data_t now, accel_data_t last)
{
    int dx = abs(now.x - last.x);
    int dy = abs(now.y - last.y);
    int dz = abs(now.z - last.z);

    return (dx + dy + dz) > 18000;
}

static bool imu_detect_flip(accel_data_t now)
{
    return now.z < -12000;
}

static bool imu_detect_tilt_left(accel_data_t now)
{
    return now.x < -10000;
}

static bool imu_detect_tilt_right(accel_data_t now)
{
    return now.x > 10000;
}

static void imu_task(void *arg)
{
    accel_data_t last = {0};

    while (1) {
        accel_data_t now;

        if (imu_read_accel(&now) == ESP_OK) {
            if (imu_detect_shake(now, last)) {
                app_post_event(APP_EVT_IMU_SHAKE, now.x, now.y, NULL);
            }

            if (imu_detect_flip(now)) {
                app_post_event(APP_EVT_IMU_FLIP, now.x, now.z, NULL);
            }

            if (imu_detect_tilt_left(now)) {
                app_post_event(APP_EVT_IMU_TILT_LEFT, now.x, 0, NULL);
            }

            if (imu_detect_tilt_right(now)) {
                app_post_event(APP_EVT_IMU_TILT_RIGHT, now.x, 0, NULL);
            }

            last = now;
        }

        vTaskDelay(pdMS_TO_TICKS(80));
    }
}

void imu_app_start(void)
{
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_SDA_GPIO,
        .scl_io_num = I2C_SCL_GPIO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = I2C_FREQ_HZ,
    };

    i2c_param_config(I2C_PORT, &conf);
    i2c_driver_install(I2C_PORT, I2C_MODE_MASTER, 0, 0, 0);

    xTaskCreate(imu_task, "imu_task", 4096, NULL, 5, NULL);
}

姿态联动建议：

static void handle_imu_event(app_event_t *evt)
{
    switch (evt->id) {
    case APP_EVT_IMU_SHAKE:
        ai_set_state(AI_STATE_SHAKE_FEEDBACK);
        role_switch_random();
        break;

    case APP_EVT_IMU_FLIP:
        ai_set_state(AI_STATE_SLEEP);
        audio_stop_tts();
        break;

    case APP_EVT_IMU_TILT_LEFT:
        eye_set_gaze(-30, 0);
        break;

    case APP_EVT_IMU_TILT_RIGHT:
        eye_set_gaze(30, 0);
        break;

    default:
        break;
    }
}

---

七、VB6824 事件解析：唤醒和打断独立处理

VB6824 可以通过 UART 向 ESP32-S3 上报事件。

协议示例：

0xA5 0x01 0x00 0x5A    唤醒成功
0xA5 0x02 0x00 0x5A    用户打断
0xA5 0x03 0x00 0x5A    开始录音
0xA5 0x04 0x00 0x5A    停止录音

解析代码：

#include "driver/uart.h"
#include "app_event.h"

#define VB_UART_NUM      UART_NUM_1
#define VB_UART_TX       17
#define VB_UART_RX       18
#define VB_UART_BAUD     115200

#define VB_HEAD          0xA5
#define VB_TAIL          0x5A

#define VB_CMD_WAKEUP    0x01
#define VB_CMD_INTERRUPT 0x02
#define VB_CMD_REC_START 0x03
#define VB_CMD_REC_STOP  0x04

static void vb6824_parse_frame(uint8_t *buf, int len)
{
    if (len < 4) {
        return;
    }

    if (buf[0] != VB_HEAD || buf[3] != VB_TAIL) {
        return;
    }

    switch (buf[1]) {
    case VB_CMD_WAKEUP:
        app_post_event(APP_EVT_WAKE_WORD, 0, 0, NULL);
        break;

    case VB_CMD_INTERRUPT:
        app_post_event(APP_EVT_VOICE_INTERRUPT, 0, 0, NULL);
        break;

    case VB_CMD_REC_START:
        app_post_event(APP_EVT_RECORD_START, 0, 0, NULL);
        break;

    case VB_CMD_REC_STOP:
        app_post_event(APP_EVT_RECORD_STOP, 0, 0, NULL);
        break;

    default:
        break;
    }
}

static void vb6824_uart_task(void *arg)
{
    uint8_t rx[64];

    while (1) {
        int len = uart_read_bytes(
            VB_UART_NUM,
            rx,
            sizeof(rx),
            pdMS_TO_TICKS(100)
        );

        if (len > 0) {
            vb6824_parse_frame(rx, len);
        }
    }
}

void vb6824_app_start(void)
{
    uart_config_t cfg = {
        .baud_rate = VB_UART_BAUD,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
    };

    uart_driver_install(VB_UART_NUM, 2048, 0, 0, NULL, 0);
    uart_param_config(VB_UART_NUM, &cfg);
    uart_set_pin(VB_UART_NUM, VB_UART_TX, VB_UART_RX,
                 UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);

    xTaskCreate(vb6824_uart_task, "vb6824_uart", 4096, NULL, 6, NULL);
}

---

八、统一事件分发：把所有模块串起来

static void app_dispatch_task(void *arg)
{
    app_event_t evt;

    while (1) {
        if (xQueueReceive(g_app_event_queue, &evt, portMAX_DELAY)) {
            switch (evt.id) {
            case APP_EVT_WIFI_CONNECTED:
                ai_set_state(AI_STATE_IDLE);
                break;

            case APP_EVT_WIFI_DISCONNECTED:
                ai_set_state(AI_STATE_NETWORK_ERROR);
                break;

            case APP_EVT_WAKE_WORD:
                ai_set_state(AI_STATE_WAKEUP);
                ai_set_state(AI_STATE_LISTENING);
                break;

            case APP_EVT_VOICE_INTERRUPT:
                audio_stop_tts();
                ai_set_state(AI_STATE_LISTENING);
                break;

            case APP_EVT_RECORD_START:
                ai_set_state(AI_STATE_LISTENING);
                break;

            case APP_EVT_RECORD_STOP:
                ai_set_state(AI_STATE_THINKING);
                break;

            case APP_EVT_TOUCH_TOP:
                ai_set_state(AI_STATE_TOUCH_FEEDBACK);
                app_post_event(APP_EVT_WAKE_WORD, 0, 0, NULL);
                break;

            case APP_EVT_TOUCH_LEFT:
                role_switch_prev();
                eye_play_anim("prev_role");
                haptic_short();
                break;

            case APP_EVT_TOUCH_RIGHT:
                role_switch_next();
                eye_play_anim("next_role");
                haptic_short();
                break;

            case APP_EVT_TOUCH_BACK:
                eye_play_anim("config");
                haptic_double();
                blufi_start_config();
                break;

            case APP_EVT_IMU_SHAKE:
            case APP_EVT_IMU_FLIP:
            case APP_EVT_IMU_TILT_LEFT:
            case APP_EVT_IMU_TILT_RIGHT:
                handle_imu_event(&evt);
                break;

            case APP_EVT_AI_THINKING:
                ai_set_state(AI_STATE_THINKING);
                break;

            case APP_EVT_AI_SPEAKING:
                ai_set_state(AI_STATE_SPEAKING);
                break;

            case APP_EVT_AI_ERROR:
                ai_set_state(AI_STATE_NETWORK_ERROR);
                break;

            case APP_EVT_OTA_START:
                ai_set_state(AI_STATE_OTA);
                haptic_rhythm_ota();
                break;

            default:
                break;
            }
        }
    }
}

---

九、AI 云端返回 JSON 后，设备如何联动双目

云端返回结构化消息：

{
  "type": "tts",
  "state": "start",
  "emotion": "happy",
  "text": "你好，我在。"
}

设备解析：

#include "cJSON.h"

static void ai_handle_json(const char *json)
{
    cJSON *root = cJSON_Parse(json);
    if (!root) {
        return;
    }

    cJSON *type = cJSON_GetObjectItem(root, "type");
    cJSON *state = cJSON_GetObjectItem(root, "state");
    cJSON *emotion = cJSON_GetObjectItem(root, "emotion");

    if (cJSON_IsString(type)) {
        if (strcmp(type->valuestring, "stt") == 0) {
            app_post_event(APP_EVT_AI_THINKING, 0, 0, NULL);
        }

        if (strcmp(type->valuestring, "llm") == 0) {
            app_post_event(APP_EVT_AI_THINKING, 0, 0, NULL);
        }

        if (strcmp(type->valuestring, "tts") == 0) {
            if (state && cJSON_IsString(state)) {
                if (strcmp(state->valuestring, "start") == 0) {
                    app_post_event(APP_EVT_AI_SPEAKING, 0, 0, NULL);
                } else if (strcmp(state->valuestring, "stop") == 0) {
                    app_post_event(APP_EVT_AI_FINISHED, 0, 0, NULL);
                }
            }
        }
    }

    if (cJSON_IsString(emotion)) {
        if (strcmp(emotion->valuestring, "happy") == 0) {
            eye_play_anim("happy");
        } else if (strcmp(emotion->valuestring, "thinking") == 0) {
            eye_play_anim("thinking");
        } else if (strcmp(emotion->valuestring, "sad") == 0) {
            eye_play_anim("sad");
        } else if (strcmp(emotion->valuestring, "surprised") == 0) {
            eye_play_anim("surprised");
        } else {
            eye_play_anim("speaking");
        }
    }

    cJSON_Delete(root);
}

这就是 AI 双目方案的关键：云端 AI 不只是返回文字，设备端还可以根据 emotion 字段切换双目表情。

---

十、MCP 工具：让 AI 能控制硬件

四博小助手适配 MCP 后，可以让 AI 大模型直接调用设备能力。

例如定义一个"切换眼睛主题"的工具：

{
  "name": "self.eye.set_theme",
  "description": "切换四博AI双目的眼睛主题",
  "parameters": {
    "type": "object",
    "properties": {
      "theme": {
        "type": "string",
        "enum": ["默认", "海洋", "爱心", "梦境", "彩虹", "机甲", "花仙子"]
      }
    },
    "required": ["theme"]
  }
}

设备侧处理：

void mcp_set_eye_theme(const char *theme)
{
    if (strcmp(theme, "海洋") == 0) {
        eye_load_theme("ocean");
    } else if (strcmp(theme, "爱心") == 0) {
        eye_load_theme("heart");
    } else if (strcmp(theme, "梦境") == 0) {
        eye_load_theme("dream");
    } else if (strcmp(theme, "彩虹") == 0) {
        eye_load_theme("rainbow");
    } else if (strcmp(theme, "机甲") == 0) {
        eye_load_theme("mecha");
    } else if (strcmp(theme, "花仙子") == 0) {
        eye_load_theme("flower");
    } else {
        eye_load_theme("default");
    }

    haptic_short();
}

再定义一个表情工具：

{
  "name": "self.eye.set_expression",
  "description": "设置四博AI双目的表情状态",
  "parameters": {
    "type": "object",
    "properties": {
      "expression": {
        "type": "string",
        "enum": ["开心", "思考", "惊讶", "困惑", "睡觉", "待机"]
      }
    },
    "required": ["expression"]
  }
}

void mcp_set_eye_expression(const char *expression)
{
    if (strcmp(expression, "开心") == 0) {
        eye_play_anim("happy");
        haptic_short();
    } else if (strcmp(expression, "思考") == 0) {
        eye_play_anim("thinking");
    } else if (strcmp(expression, "惊讶") == 0) {
        eye_play_anim("surprised");
        haptic_double();
    } else if (strcmp(expression, "困惑") == 0) {
        eye_play_anim("confused");
    } else if (strcmp(expression, "睡觉") == 0) {
        eye_play_anim("sleep");
    } else {
        eye_play_anim("idle_blink");
    }
}

用户可以直接说：

把眼睛换成爱心主题。
切换成睡觉表情。
进入配网模式。
音量调低一点。

大模型就可以通过工具调用真正控制硬件。

---

十一、总结

四博 AI 双目方案的核心价值，是把多个交互模块统一成一个完整的 AI 硬件平台：

ESP32-S3：联网、UI、状态机、AI通信
VB6824：唤醒、AEC、打断、语音前端
双目光屏：表情显示、状态可视化
四路触控：本地输入
三轴传感器：动作感知
震动马达：触觉反馈
四博小助手：配网、声音克隆、知识库、MCP、OTA

它可以做 AI 音箱、AI 桌宠、AI 学习伙伴、IP 潮玩、品牌智能客服和智能家居入口。

未来的 AI 硬件，不会只是一个会回答问题的喇叭，而是一个有眼神、有触感、有动作感知、有专属声音和专属知识库的智能伙伴。

四博 AI 双目方案，正是面向这个方向的一套高集成、高性价比、可量产的技术平台。