四博 AI 双目智能音箱技术拆解

四博 AI 双目智能音箱技术拆解：ESP32-S3 如何把语音、双目、触摸、姿态和震动做成完整交互闭环？

现在的 AI 音箱，如果只是"用户说一句，设备回一句"，其实还停留在传统语音设备阶段。

真正有产品竞争力的 AI 硬件，应该不只是会回答问题，而是要具备更自然的多模态交互能力：能听懂用户语音，能用双目表情反馈状态，能感知触摸，能识别摇晃和翻转，还能通过震动马达给用户一个明确反馈。

四博 AI 双目智能音箱方案，核心就是基于 ESP32-S3 主控，把 VB6824 语音前端、0.71 / 1.28 寸双目屏幕、四路触摸感应、三轴姿态传感器、震动马达、Wi-Fi / BLE、小程序和云端 AI 平台组合成一套完整的 AI 交互终端。

它可以做 AI 音箱，也可以做 AI 桌宠、儿童陪伴机、IP 潮玩、品牌客服终端和智能家居语音入口。

一、系统架构：ESP32-S3 负责主控，VB6824 负责语音前端

整机可以分成五个子系统：

1. 主控系统：ESP32-S3R8 / ESP32-S3R2
2. 语音系统：VB6824 + 麦克风 + 喇叭 + 功放
3. 显示系统：0.71 / 1.28 寸双目屏
4. 交互系统：四路触摸 + 三轴姿态 + 震动马达
5. 平台系统：四博小助手小程序 + 云端 AI + MCP + OTA

整体链路可以这样理解：

用户语音 / 触摸 / 摇晃 / 翻转
        ↓
VB6824 / Touch / IMU
        ↓
ESP32-S3 事件队列
        ↓
AI 状态机
        ↓
双目表情 / TTS 播放 / 震动反馈 / 云端通信

推荐软件任务划分：

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        震动马达控制
 ├── audio_task         TTS / 提示音 / 音量管理
 ├── mcp_task           AI 工具调用
 ├── ota_task           固件和素材升级
 └── dispatch_task      全局事件分发

这种结构的好处是，每个模块职责清晰，后续要增加摄像头、RGB 灯、SD 卡、4G 或更多触摸点，都不会破坏主流程。

二、定义统一事件系统

AI 双目设备不建议所有逻辑都写在一个 while 循环里。更合理的方式是：所有输入都转成事件，统一交给状态机处理。

typedef enum {
    APP_EVT_NONE = 0,

    APP_EVT_WIFI_CONNECTED,
    APP_EVT_WIFI_DISCONNECTED,

    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_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_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;

static QueueHandle_t g_app_event_queue;

事件投递函数：

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);
}

主程序初始化：

void app_main(void)
{
    ESP_ERROR_CHECK(nvs_flash_init());

    g_app_event_queue = xQueueCreate(32, sizeof(app_event_t));
    if (!g_app_event_queue) {
        ESP_LOGE("APP", "事件队列创建失败");
        return;
    }

    haptic_app_start();
    eye_app_start();

    wifi_app_start();
    blufi_app_start();

    vb6824_app_start();
    touch_app_start();
    imu_app_start();

    ai_client_start();
    mcp_app_start();
    ota_app_start();

    app_dispatch_start();

    ESP_LOGI("APP", "四博 AI 双目智能音箱启动完成");
}

三、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 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");
        haptic_rhythm_ota();
        break;

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

最终用户看到的是：

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

这就是 AI 音箱从"语音盒子"升级成"有状态、有反馈、有情绪"的关键。

四、四路触摸：本地交互比纯语音更自然

四路触摸建议这样定义：

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

触摸检测示例：

#include "driver/touch_sensor.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，也可以把 touch_pad_read_raw_data() 替换成 I2C 读取触摸状态。

五、震动马达：让交互有"手感"

震动反馈建议定义为：

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

PWM 驱动代码：

#include "driver/ledc.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,
    };
    ESP_ERROR_CHECK(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,
    };
    ESP_ERROR_CHECK(ledc_channel_config(&ch));
}

六、三轴姿态：让设备知道自己被拿起、摇晃、翻转

三轴传感器可以做很多交互：

拿起唤醒
摇一摇切换角色
翻转静音
倾斜控制眼球方向
敲击触发彩蛋
静置自动休眠

姿态检测代码：

#include "driver/i2c.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;
}

IMU 任务：

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));
    }
}

姿态事件处理：

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;
    }
}

七、统一事件分发：把所有交互串起来

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:
                audio_stop_record();
                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_LOW_BATTERY:
                ai_set_state(AI_STATE_LOW_BATTERY);
                break;

            case APP_EVT_OTA_START:
                ai_set_state(AI_STATE_OTA);
                break;

            default:
                break;
            }
        }
    }
}

八、总结：AI 音箱的下一步，是"多模态交互"

四博 AI 双目智能音箱的核心，不只是接入大模型，而是把语音、双目、触摸、姿态、震动、小程序和 AI 平台做成完整闭环。

一句话概括：

四博 AI 双目智能音箱 =
ESP32-S3 多模态主控
+ VB6824 语音前端
+ 0.71 / 1.28 双目屏
+ 四路触摸感应
+ 三轴姿态传感
+ 震动马达
+ 四博小助手小程序
+ 声音克隆 / 知识库 / MCP / OTA

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

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