【花雕动手做】嵌入式 AI Agent 实战：MimiClaw ESP32-S3 接入飞书，远程控制板载 RGB 全彩灯效

// ====================== WS2812 驱动配置 ======================
#include "driver/led_strip.h"  // 引入官方 led_strip 组件

#define WS2812_GPIO 48        // 板载 WS2812 连接的 GPIO 引脚
static led_strip_handle_t s_led_strip = NULL;  // LED 驱动句柄

// WS2812 初始化函数
static esp_err_t ws2812_init(void)
{
    if (s_led_strip != NULL) return ESP_OK;  // 避免重复初始化

    // LED 灯带配置
    led_strip_config_t strip_cfg = {
        .strip_gpio_num = WS2812_GPIO,    // 连接的 GPIO 引脚
        .max_leds = 1,                    // 灯珠数量（板载为 1 个）
        .led_model = LED_MODEL_WS2812,    // 灯珠型号为 WS2812
        .color_component_format = LED_STRIP_COLOR_COMPONENT_FMT_GRB,  // WS2812 颜色格式为 GRB
    };

    // RMT 外设配置（驱动 WS2812 需用到 RMT 外设）
    led_strip_rmt_config_t rmt_cfg = {
        .clk_src = RMT_CLK_SRC_DEFAULT,   // 默认时钟源
        .resolution_hz = 10 * 1000 * 1000,// 分辨率 10MHz
        .flags.with_dma = false,          // 无需 DMA（单灯珠无需高速传输）
    };

    // 创建 RMT 驱动的 LED 设备
    led_strip_new_rmt_device(&strip_cfg, &rmt_cfg, &s_led_strip);
    led_strip_clear(s_led_strip);  // 初始化后熄灭彩灯
    return ESP_OK;
}

// WS2812 颜色设置函数（r: 红色, g: 绿色, b: 蓝色，取值 0-255）
static esp_err_t ws2812_set(uint8_t r, uint8_t g, uint8_t b)
{
    ws2812_init();  // 确保驱动已初始化
    led_strip_set_pixel(s_led_strip, 0, r, g, b);  // 设置第 0 个灯珠颜色
    led_strip_refresh(s_led_strip);  // 刷新显示，使颜色生效
    return ESP_OK;
}

// 颜色控制工具执行函数（red 红灯）
static esp_err_t tool_red_execute(const char *in, char *out, size_t len) {
    ws2812_set(255, 0, 0);  // 红色：R=255, G=0, B=0
    snprintf(out, len, "Red ON");  // 工具执行结果反馈
    return ESP_OK;
}

// 颜色控制工具执行函数（green 绿灯）
static esp_err_t tool_green_execute(const char *in, char *out, size_t len) {
    ws2812_set(0, 255, 0);  // 绿色：R=0, G=255, B=0
    snprintf(out, len, "Green ON");
    return ESP_OK;
}

// 颜色控制工具执行函数（blue 蓝灯）
static esp_err_t tool_blue_execute(const char *in, char *out, size_t len) {
    ws2812_set(0, 0, 255);  // 蓝色：R=0, G=0, B=255
    snprintf(out, len, "Blue ON");
    return ESP_OK;
}

// 颜色控制工具执行函数（yellow 暖黄灯）
static esp_err_t tool_yellow_execute(const char *in, char *out, size_t len) {
    ws2812_set(255, 150, 0);  // 暖黄色：R=255, G=150, B=0（避免纯黄刺眼）
    snprintf(out, len, "Yellow ON");
    return ESP_OK;
}

// 颜色控制工具执行函数（off 熄灭）
static esp_err_t tool_off_execute(const char *in, char *out, size_t len) {
    ws2812_set(0, 0, 0);  // 熄灭：R=0, G=0, B=0
    snprintf(out, len, "Light OFF");
    return ESP_OK;
}

// 注册 RGB 颜色控制工具（同名简单工具，提高 LLM 调用成功率）
mimi_tool_t red_tool = {
    .name = "red",
    .description = "Turn on the red LED immediately. Use when user says 'red'.",
    .input_schema_json = "{\"type\":\"object\",\"properties\":{},\"required\":[]}",  // 无输入参数
    .execute = tool_red_execute,  // 绑定执行函数
};
register_tool(&red_tool);  // 注册工具

mimi_tool_t green_tool = {
    .name = "green",
    .description = "Turn on the green LED immediately. Use when user says 'green'.",
    .input_schema_json = "{\"type\":\"object\",\"properties\":{},\"required\":[]}",
    .execute = tool_green_execute,
};
register_tool(&green_tool);

mimi_tool_t blue_tool = {
    .name = "blue",
    .description = "Turn on the blue LED immediately. Use when user says 'blue'.",
    .input_schema_json = "{\"type\":\"object\",\"properties\":{},\"required\":[]}",
    .execute = tool_blue_execute,
};
register_tool(&blue_tool);

mimi_tool_t yellow_tool = {
    .name = "yellow",
    .description = "Turn on the yellow LED immediately. Use when user says 'yellow'.",
    .input_schema_json = "{\"type\":\"object\",\"properties\":{},\"required\":[]}",
    .execute = tool_yellow_execute,
};
register_tool(&yellow_tool);

mimi_tool_t off_tool = {
    .name = "off",
    .description = "Turn off the LED immediately. Use when user says 'off'.",
    .input_schema_json = "{\"type\":\"object\",\"properties\":{},\"required\":[]}",
    .execute = tool_off_execute,
};
register_tool(&off_tool);

// 颜色指令预处理函数：匹配颜色词，直接执行工具，跳过 LLM
static bool try_direct_color_command(const char *content, char *output, size_t output_size)
{
    // 去除消息前后空白字符（避免用户输入空格导致匹配失败）
    while (*content == ' ' || *content == '\t' || *content == '\n') content++;
    const char *end = content + strlen(content);
    while (end > content && (*(end-1) == ' ' || *(end-1) == '\t' || *(end-1) == '\n')) end--;
    size_t len = end - content;

    // 精确匹配颜色词，触发对应工具
    if (len == 3 && strncasecmp(content, "red", 3) == 0) {
        tool_registry_execute("red", "{}", output, output_size);
        return true;
    }
    if (len == 5 && strncasecmp(content, "green", 5) == 0) {
        tool_registry_execute("green", "{}", output, output_size);
        return true;
    }
    if (len == 4 && strncasecmp(content, "blue", 4) == 0) {
        tool_registry_execute("blue", "{}", output, output_size);
        return true;
    }
    if (len == 6 && strncasecmp(content, "yellow", 6) == 0) {
        tool_registry_execute("yellow", "{}", output, output_size);
        return true;
    }
    if (len == 3 && strncasecmp(content, "off", 3) == 0) {
        tool_registry_execute("off", "{}", output, output_size);
        return true;
    }

    return false;  // 不匹配颜色词，走正常 LLM 流程
}

// 在 agent_loop_task 函数的消息处理开头，添加预处理调用
void agent_loop_task(void *arg)
{
    // ... 原有代码省略 ...

    while (1) {
        mimi_msg_t msg;
        if (message_bus_pop_inbound(&msg, portMAX_DELAY) != ESP_OK) continue;

        // 新增：颜色指令预处理，匹配则直接执行工具
        char direct_response[128];
        if (try_direct_color_command(msg.content, direct_response, sizeof(direct_response))) {
            ESP_LOGI(TAG, "Direct color command matched, executing tool and responding");
            // 直接回复工具执行结果，跳过 LLM 调用
            mimi_msg_t out = {0};
            strncpy(out.channel, msg.channel, sizeof(out.channel)-1);
            strncpy(out.chat_id, msg.chat_id, sizeof(out.chat_id)-1);
            out.content = strdup(direct_response);
            message_bus_push_outbound(&out);
            free(msg.content);
            continue;
        }

        // ... 原有 LLM 调用、消息处理逻辑不变 ...
    }
}

# 清除之前的编译缓存（可选，避免旧代码影响）
idf.py fullclean

# 编译固件
idf.py build

# 烧录固件并打开串口监视器（替换 COM7 为实际串口号）
idf.py -p COM7 flash monitor

# 配置 WiFi（替换为你的 WiFi 名称和密码）
mimi> set_wifi 你的SSID 你的WiFi密码

# 查看 WiFi 连接状态，确认获取 IP 地址（显示 connected 即为成功）
mimi> wifi_status

# 配置 LLM API Key（以 DeepSeek 为例，替换为你的 API Key）
mimi> set_api_key sk-xxxxxxx

# 配置 LLM 模型和提供商（DeepSeek 模型需指定 provider 为 openai 兼容模式）
mimi> set_model deepseek-chat
mimi> set_model_provider openai

# 配置飞书凭证（替换为之前保存的 App ID 和 App Secret）
mimi> set_feishu_creds 你的AppID 你的AppSecret

# 重启 MimiClaw，使配置生效
mimi> restart

I (138484) feishu: Message from ou_1f6ce18f5c5d222d9fa9a1719b359ee2: red
I (138484) agent: Processing message from feishu:ou_1f6ce18f5c5d222d9fa9a1719b359ee2
I (138484) tools: Executing tool: red
I (138484) tools: WS2812 initialized on GPIO 48
I (138484) tools: Tool red returned: OK
I (138484) agent: Direct color command matched, executing tool and responding
I (139414) feishu: Got tenant access token (expires in 5323s)
I (140744) feishu: Sent to ou_1f6ce18f5c5d222d9fa9a1719b359ee2 (10 bytes)
I (140744) mimi: Feishu send success for ou_1f6ce18f5c5d222d9fa9a1719b359ee2 (10 bytes)