设为首页收藏本站
首页 > 论坛 > 行空板

[M10项目]行空板k10小智与掌控板MCP：语音控制硬件，追踪红外点！

云天 | 中级技神 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2026-3-1 13:38:13 [显示全部楼层]
13浏览
0回复
0收藏
查看: 13|回复: 0

[M10项目] 行空板k10小智与掌控板MCP：语音控制硬件，追踪红外点！

[复制链接]
本帖最后由 云天 于 2026-3-1 15:21 编辑

用行空板K10当你的AI助手，用掌控板作为智能执行终端，通过MCP协议实现语音控制LED、读取传感器、追踪红外点，打造一个可扩展的智能硬件控制系统。

【项目引言】

       行空板K10和掌控板是创客学习和作品中的两大明星设备。一个拥有强大的屏幕和AI算力，可以运行完整的AI语音助手；另一个小巧灵活，拥有丰富的板载传感器和扩展接口。如果能将两者结合起来，让行空板K10成为你的“大脑”，用语音指挥掌控板完成各种任务，那该多酷！

       本文将带你实现这样一个系统：行空板K10刷入小智AI固件，作为语音交互终端；掌控板运行MCP（模型上下文协议）服务器，注册各种硬件控制工具。当你对行空板说出指令时，小智AI通过WiFi调用掌控板上的MCP工具，实现对LED灯、传感器、甚至红外摄像头的实时控制。项目还扩展了红外定位摄像头模块，展示了系统的强大扩展能力。

【硬件清单】

       行空板K10 × 1（已刷小智AI固件）
       掌控板 × 1
       IO扩展板 × 1（用于连接掌控板，方便插接外部传感器）
       红外定位摄像头模块（DFRobot SEN0158）× 1
       杜邦线若干
       USB数据线（用于供电和程序上传）
行空板k10小智与掌控板MCP：语音控制硬件，追踪红外点！图3

       注：掌控板板载资源包括：WS2812 RGB灯带（3颗）、光线传感器（P4）、声音传感器（P10）、0.96英寸OLED显示屏（128×64，I2C接口）。这些直接可用，无需额外连接。

【实现原理】
       整个系统基于 “小智AI平台” 和 “MCP协议” 实现。
       行空板K10：刷入小智AI固件后，它成为一台反文旁虫立的语音助手。在手机上用小智AI App扫码绑定，即可通过WiFi接入云端。当我们对它说话时，语音会被识别并发送到小智AI云端进行处理。
       掌控板：运行我们编写的Arduino程序，作为 “MCP服务器”。程序向小智AI平台注册了多个“工具”（例如“打开LED”、“读取光线传感器”、“获取红外点”）。每个工具对应一个函数，可以被远程调用。
       MCP协议：行空板K10与小智AI云端通信，云端根据用户意图，选择合适的工具，通过WebSocket向掌控板发送JSON-RPC请求。掌控板解析请求、执行函数、返回结果。整个过程无缝衔接。
       这样一来，我们实现了“语音 → 云端理解 → 调用硬件”的完整闭环。
行空板k10小智与掌控板MCP：语音控制硬件，追踪红外点！图1

【 掌控板端代码解析】

       掌控板端程序是整个项目的核心。我们使用Arduino IDE开发，依赖以下库：
       WebSocketMCP：用于实现MCP服务器
       Adafruit_NeoPixel：控制WS2812灯带
       U8g2：驱动OLED显示屏
      ArduinoJson：解析和处理JSON数据

       1. MCP服务器初始化与工具注册

       在 `setup()` 中，我们初始化WiFi、OLED、传感器，然后启动MCP客户端（这里实际上是服务器模式，但库命名为client，我们沿用其API）：
  1. mcpClient.begin(MCP_ENDPOINT, onMcpConnectionChange);
复制代码

       `MCP_ENDPOINT` 是你在小智AI平台申请到的专属接入点地址，包含了你的用户和智能体信息。连接成功后，会调用 `registerMcpTools()` 注册所有工具。

       每个工具注册时需提供名称、描述、输入参数JSON schema和一个回调函数。以LED控制工具为例：
  1. mcpClient.registerTool(

  2. 

  3.   "led_blink",

  4. 

  5.   "控制 WS2812 灯带 (on/off/blink/flow)",

  6. 

  7.   "{"properties":{"state":{"title":"LED状态","type":"string","enum":["on","off","blink","flow"]}},"required":["state"],"title":"ledControlArguments","type":"object"}",

  8. 

  9.   [](const String& args) -> WebSocketMCP::ToolResponse {

  10. 

  11.     // 解析参数，执行控制逻辑，返回结果

  12. 

  13.   }

  14. 

  15. );
复制代码
      类似的，我们注册了 `light_sensor`、`sound_sensor` 和 `ir_camera` 工具。

       2. 非阻塞LED状态机

       为了在LED闪烁或流水灯时不影响MCP通信和OLED刷新，我们设计了状态机。在 `loop()` 中定期调用 `handleLedStateMachine()`，根据当前模式（`LED_MODE_ON`、`LED_MODE_BLINK`、`LED_MODE_FLOW`）逐步更新灯带，避免使用 `delay()`。

  1. void handleLedStateMachine() {

  2. // 仅在MCP控制激活且未超时时执行

  3. switch (currentLedMode) {

  4. case LED_MODE_BLINK:

  5. // 每200ms翻转一次，计数5次后结束

  6. break;

  7. case LED_MODE_FLOW:

  8. // 每300ms点亮下一个灯珠，循环3次

  9. break;

  10. // ...

  11. }

  12. }
复制代码

       3. OLED实时信息显示

        OLED分四行显示：WiFi状态、IP地址、MCP连接状态、最新MCP消息（支持滚动）。当收到工具调用结果时，`onMcpOutput` 会被触发（实际在库中未用，我们改为在工具回调中直接更新显示），但这里我们简化设计：每次工具执行后，将返回的摘要信息赋值给 `mcpMessage`，并开启滚动标志。

       4. 红外定位摄像头读取

       SEN0158红外摄像头通过I2C接口连接。我们编写了 `initIRCamera()` 和 `readIRCamera()` 函数，完全参照官方示例代码。在 `ir_camera` 工具的回调中，调用 `readIRCamera()` 读取四个点的坐标，打包成JSON返回：
  1. {

  2. "success": true,

  3. "points": [

  4. {"x": 123, "y": 456},

  5. {"x": 1023, "y": 1023},

  6. // ...

  7. ]

  8. }
复制代码
      无效点坐标为 `(1023, 1023)`，可根据需要过滤。
行空板k10小智与掌控板MCP：语音控制硬件，追踪红外点！图2


红外源(使用红外发射二极管串联 220Ω 电阻，5V供电)

【行空板K10端配置】

       行空板K10端相对简单，主要是刷入小智AI固件并进行配置。

       1. 刷写固件：从小智AI官网下载适用于行空板K10的固件，用balenaEtcher等工具写入TF卡，插入行空板并启动。
       2. 配网与绑定：启动后，行空板屏幕会显示二维码。用手机上的小智AI App扫描，按照提示连接WiFi并完成绑定。
       3. 创建智能体：在App或网页控制台中，创建一个新的智能体（或修改已有角色）。在“MCP接入点”设置中，填入你掌控板代码中的那个长串 `MCP_ENDPOINT` 地址。
       4. 保存并同步：保存设置，行空板会自动同步最新配置。

       现在，当你对着行空板说“打开LED”时，云端会识别意图，并通过MCP调用掌控板的 `led_blink` 工具，传入参数 `{"state":"on"}`。
【使用演示】

       下面是一些你可以尝试的语音指令，以及掌控板的反应：

语音指令
掌控板行为
OLED显示反馈
“打开LED”灯带亮起白光Tool: led_blink state=on
“流水灯”灯带依次点亮蓝色光，循环一次Tool: led_blink state=flow
“光线值多少”读取光线传感器，返回数值Light: 356
“检测红外点”读取红外摄像头，返回四个点坐标显示第一个有效点坐标（如有）
“关灯”灯带熄灭Tool: led_blink state=off

       你还可以组合指令，例如：“如果光线值小于100，打开LED”。这需要云端具备逻辑判断能力，小智AI的智能体可以通过“工作流”功能实现，本文暂不展开。

【项目扩展：红外定位摄像头的应用】

       加入红外定位摄像头后，项目的玩法大大增加：

       红外目标追踪：用940nm红外遥控器或自制红外信标，在摄像头前移动，掌控板可实时获取其坐标。你可以将这些坐标发送给行空板，在屏幕上绘制轨迹。
       互动游戏：结合投影或大屏幕，制作一个“红外射击游戏”，玩家用红外枪瞄准屏幕上的目标，摄像头检测到红外点位置，判断是否命中。
       机器人导航：在机器人身上安装红外LED，用多个摄像头实现室内定位。

       由于摄像头支持最多4个点，你甚至可以同时追踪多个目标，实现更复杂的交互。

【演示视频】

【项目总结】

       本文展示了如何将行空板K10与掌控板结合，通过小智AI平台和MCP协议，实现语音控制硬件、读取传感器、显示信息，并扩展红外定位摄像头。这个方案不仅让两块常用创客板各展所长，还为未来的智能硬件项目提供了一个可复用的架构：用AI语音作为人机交互入口，用MCP作为设备控制桥梁，硬件端可以无限扩展。

       你可以在此基础上添加更多传感器（如温湿度、PM2.5）、执行器（电机、舵机），甚至让多个掌控板同时在线，打造一个全屋智能语音控制系统。期待你的创意！

【附：完整代码】
  1. /*

  2.   掌控板 MCP 客户端 + WS2812 灯带 + OLED 显示屏+IO扩展展+红外定位摄像头模块

  3.   功能：

  4.   - 连接 WiFi

  5.   - 连接 WebSocket MCP 服务器

  6.   - 通过 WS2812 灯带指示连接状态（红色快闪：WiFi未连；绿色慢闪：WiFi已连但MCP未连；蓝色常亮：全部连接）

  7.   - OLED 显示当前 WiFi 状态、IP 地址、MCP 状态

  8.   - OLED 第四行滚动显示最新的 MCP 消息

  9.   - 通过串口发送命令给 MCP 服务器

  10.   - 注册 MCP 工具：

  11.       * LED 控制（led_blink）

  12.       * 系统信息（system-info）

  13.       * 光线传感器（light_sensor）——直接读取 P4 (GPIO36)

  14.       * 声音传感器（sound_sensor）——直接读取 P10 (GPIO26)

  15.       *红外定位摄像头模块（Positioning IR Camera）-i2c（SCL 22，SDA 23）

  16.   - 解决 MCP 工具与状态指示灯的冲突（MCP 工具控制期间暂停状态指示，超时后恢复）

  17. */

  18. 

  19. #include <Arduino.h>

  20. #include <WiFi.h>

  21. #include <WebSocketMCP.h>          // 请确保已安装此库

  22. #include <Adafruit_NeoPixel.h>     // WS2812 库

  23. #include <U8g2lib.h>               // OLED 库

  24. #include <Wire.h>

  25. 

  26. /********** 配置项 ***********/

  27. // WiFi 设置

  28. const char* WIFI_SSID = "**********";

  29. const char* WIFI_PASS = "**********";

  30. 

  31. // WebSocket MCP 服务器地址（请替换为你的有效 token）

  32. const char* MCP_ENDPOINT = "wss://api.xiaozhi.me/mcp/?token=你自己的token";

  33. 

  34. // 调试串口

  35. #define DEBUG_SERIAL Serial

  36. #define DEBUG_BAUD_RATE 115200

  37. 

  38. /********** 硬件引脚定义 ***********/

  39. // WS2812 灯带（掌控板上通常接在 GPIO17，三个灯珠）

  40. #define WS2812_PIN    17

  41. #define NUM_PIXELS    3

  42. Adafruit_NeoPixel pixels(NUM_PIXELS, WS2812_PIN, NEO_GRB + NEO_KHZ800);

  43. 

  44. // OLED 显示屏（掌控板固定 I2C 引脚：SCL=22, SDA=23）

  45. #define OLED_SCL      22

  46. #define OLED_SDA      23

  47. // 使用硬件 I2C，驱动为 SH1106（若实际为 SSD1306 可修改构造函数）

  48. U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, OLED_SCL, OLED_SDA);

  49. 

  50. // 传感器引脚定义

  51. #define LIGHT_SENSOR_PIN   39   // 光线传感器接 P4 (GPIO36, ADC1_CH3)

  52. #define SOUND_SENSOR_PIN   36   // 声音传感器接 P10 (GPIO26, ADC2_CH0)

  53. // 新增：数字激光接近传感器接 P2 (GPIO35)

  54. #define PROXIMITY_SENSOR_PIN 35

  55. // 红外定位摄像头模块 (SEN0158) 相关定义

  56. #define IRCAM_I2C_ADDR  0x58      // I2C 设备地址 (0xB0 右移一位)

  57. #define IRCAM_DATA_LEN   16        // 一次读取的数据长度

  58. byte irCamData[IRCAM_DATA_LEN];    // 存储原始数据的缓冲区

  59. 

  60. // 存储最多4个点的坐标，无效点坐标通常为 1023,1023

  61. int irX[4] = {1023, 1023, 1023, 1023};

  62. int irY[4] = {1023, 1023, 1023, 1023};

  63. /********** 全局变量 ***********/

  64. WebSocketMCP mcpClient;          // MCP 客户端对象

  65. // LED 模式枚举

  66. enum LedMode {

  67.   LED_MODE_IDLE,       // 空闲，由系统状态指示灯控制

  68.   LED_MODE_ON,         // 常亮（白色）

  69.   LED_MODE_OFF,        // 熄灭

  70.   LED_MODE_BLINK,      // 闪烁（白色，5次）

  71.   LED_MODE_FLOW        // 流水灯（蓝色，单次）

  72. };

  73. // LED 状态机变量

  74. LedMode currentLedMode = LED_MODE_IDLE;   // 当前模式

  75. int flowIndex = 0;                         // 流水灯当前索引

  76. unsigned long lastLedStep = 0;              // 上次步骤时间

  77. bool blinkState = false;                     // 闪烁当前亮灭状态

  78. int blinkCount = 0;                           // 闪烁已进行次数

  79. const int blinkTotal = 5;                     // 闪烁总次数

  80. const int flowDelay = 300;                     // 流水灯步进间隔（毫秒）

  81. const int blinkDelay = 200;                     // 闪烁间隔（毫秒）

  82. // 连接状态

  83. bool wifiConnected = false;

  84. bool mcpConnected  = false;

  85. 

  86. // MCP 工具主动控制 LED 的标志（用于解决冲突）

  87. bool mcpLedActive = false;       // 当前是否由 MCP 工具控制 LED

  88. unsigned long mcpLedTimeout = 0; // 控制模式的超时时间（毫秒）

  89. 

  90. // OLED 上次显示的状态（用于避免频繁刷新）

  91. String lastWifiStatus = "";

  92. String lastMCPStatus  = "";

  93. String lastIP         = "";

  94. 

  95. // MCP 消息滚动相关

  96. String mcpMessage = "";                // 最新 MCP 消息

  97. int scrollOffset = 0;                   // 滚动偏移（像素）

  98. unsigned long lastScrollTime = 0;       // 上次滚动时间

  99. const int scrollInterval = 300;          // 滚动间隔（毫秒）

  100. bool isScrolling = false;                // 是否正在滚动

  101. int messageWidth = 0;                    // 消息总像素宽度

  102. 

  103. /********** 函数声明 ***********/

  104. void setupWifi();

  105. void onMcpOutput(const String &message);

  106. void onMcpError(const String &error);

  107. void onMcpConnectionChange(bool connected);

  108. void registerMcpTools();

  109. void processSerialCommands();

  110. void updateOLED();                // 更新 OLED 显示

  111. void handleLEDs();                // 处理 WS2812 状态指示（考虑 MCP 覆盖）

  112. void printHelp();

  113. void printStatus();

  114. 

  115. /********** setup() ***********/

  116. void setup() {

  117.   DEBUG_SERIAL.begin(DEBUG_BAUD_RATE);

  118.   DEBUG_SERIAL.println("\n\n======== 掌控板 MCP 客户端启动 ========");

  119. 

  120.   // 初始化 WS2812 灯带

  121.   pixels.begin();

  122.   pixels.clear();

  123.   pixels.show();

  124. 

  125.   // 初始化 OLED 显示屏

  126.   Wire.begin(OLED_SDA, OLED_SCL);   // 启动 I2C 总线

  127.   u8g2.begin();

  128.   u8g2.enableUTF8Print();            // 启用 UTF-8 打印（如需显示中文）

  129.   u8g2.setFont(u8g2_font_wqy16_t_gb2312b); // 使用中文字体（需库支持，若没有可换英文字体）

  130.   u8g2.clearBuffer();

  131.   u8g2.setCursor(0, 15);

  132.   u8g2.print("系统初始化...");

  133.   u8g2.sendBuffer();

  134.   initIRCamera();                    // <--- 新增：初始化红外摄像头

  135.   // 连接 WiFi

  136.   setupWifi();

  137. 

  138.   // 初始化 MCP 客户端

  139.   if (mcpClient.begin(MCP_ENDPOINT, onMcpConnectionChange)) {

  140.     DEBUG_SERIAL.println("[MCP] 客户端初始化成功，正在连接服务器...");

  141.   } else {

  142.     DEBUG_SERIAL.println("[MCP] 客户端初始化失败！");

  143.   }

  144. 

  145.   // 显示帮助信息

  146.   DEBUG_SERIAL.println("\n使用说明：");

  147.   DEBUG_SERIAL.println("- 通过串口输入命令并回车发送给 MCP 服务器");

  148.   DEBUG_SERIAL.println("- 输入 help 查看可用命令");

  149.   DEBUG_SERIAL.println();

  150. 

  151.   // 短暂显示启动信息后，进入主循环

  152.   delay(1000);

  153. }

  154. 

  155. /********** loop() ***********/

  156. void loop() {

  157.   mcpClient.loop();

  158.   processSerialCommands();

  159. 

  160.   // 处理 LED 状态机（非阻塞效果）

  161.   handleLedStateMachine();

  162. 

  163.   // 更新 WS2812 状态指示灯（仅在非 MCP 控制时生效）

  164.   handleLEDs();

  165. 

  166.   // 滚动更新：如果正在滚动且达到时间间隔，增加偏移并刷新显示

  167.   if (isScrolling && (millis() - lastScrollTime > scrollInterval)) {

  168.     lastScrollTime = millis();

  169.     scrollOffset += 2;  // 每次滚动2像素，可根据需要调整速度

  170.     if (scrollOffset > messageWidth) {

  171.       scrollOffset = 0; // 循环滚动

  172.     }

  173.     // 强制刷新 OLED（因为状态未变，但 isScrolling 为 true，updateOLED 会重绘）

  174.     updateOLED();

  175.   }

  176. 

  177.   // 更新 OLED 显示（当状态变化或需要滚动时，updateOLED 内部判断）

  178.   updateOLED();

  179. 

  180.   // 小延时，避免过度占用 CPU

  181.   delay(10);

  182. }

  183. /**

  184.  * 初始化红外定位摄像头

  185.  * 参考 SEN0158 Wiki 示例代码

  186.  */

  187. void initIRCamera() {

  188.   DEBUG_SERIAL.println("[IR Camera] 正在初始化...");

  189.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  190.   Wire.write(0x30); Wire.write(0x01); delay(10);

  191.   Wire.endTransmission();

  192.   

  193.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  194.   Wire.write(0x30); Wire.write(0x08); delay(10);

  195.   Wire.endTransmission();

  196.   

  197.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  198.   Wire.write(0x06); Wire.write(0x90); delay(10);

  199.   Wire.endTransmission();

  200.   

  201.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  202.   Wire.write(0x08); Wire.write(0xC0); delay(10);

  203.   Wire.endTransmission();

  204.   

  205.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  206.   Wire.write(0x1A); Wire.write(0x40); delay(10);

  207.   Wire.endTransmission();

  208.   

  209.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  210.   Wire.write(0x33); Wire.write(0x33); delay(10);

  211.   Wire.endTransmission();

  212.   

  213.   delay(100);

  214.   DEBUG_SERIAL.println("[IR Camera] 初始化完成");

  215. }

  216. /**

  217.  * 读取红外摄像头数据并解析出最多4个点的坐标

  218.  * 返回 true 表示读取成功（即使没有检测到点），false 表示 I2C 通信失败

  219.  */

  220. bool readIRCamera() {

  221.   // 请求读取数据

  222.   Wire.beginTransmission(IRCAM_I2C_ADDR);

  223.   Wire.write(0x36);

  224.   if (Wire.endTransmission() != 0) {

  225.     return false; // I2C 通信错误

  226.   }

  227. 

  228.   // 请求 16 字节数据

  229.   uint8_t bytesReceived = Wire.requestFrom(IRCAM_I2C_ADDR, IRCAM_DATA_LEN);

  230.   if (bytesReceived < IRCAM_DATA_LEN) {

  231.     return false; // 数据长度不足

  232.   }

  233. 

  234.   // 读取原始数据到缓冲区

  235.   for (int i = 0; i < IRCAM_DATA_LEN; i++) {

  236.     irCamData[i] = Wire.read();

  237.   }

  238. 

  239.   // --- 解析坐标 (完全按照示例代码的逻辑) ---

  240.   int s;

  241.   // 点 0

  242.   irX[0] = irCamData[1];

  243.   irY[0] = irCamData[2];

  244.   s = irCamData[3];

  245.   irX[0] += (s & 0x30) << 4;

  246.   irY[0] += (s & 0xC0) << 2;

  247. 

  248.   // 点 1

  249.   irX[1] = irCamData[4];

  250.   irY[1] = irCamData[5];

  251.   s = irCamData[6];

  252.   irX[1] += (s & 0x30) << 4;

  253.   irY[1] += (s & 0xC0) << 2;

  254. 

  255.   // 点 2

  256.   irX[2] = irCamData[7];

  257.   irY[2] = irCamData[8];

  258.   s = irCamData[9];

  259.   irX[2] += (s & 0x30) << 4;

  260.   irY[2] += (s & 0xC0) << 2;

  261. 

  262.   // 点 3

  263.   irX[3] = irCamData[10];

  264.   irY[3] = irCamData[11];

  265.   s = irCamData[12];

  266.   irX[3] += (s & 0x30) << 4;

  267.   irY[3] += (s & 0xC0) << 2;

  268. 

  269.   return true;

  270. }

  271. /********** WiFi 连接 ***********/

  272. void setupWifi() {

  273.   DEBUG_SERIAL.print("[WiFi] 正在连接 ");

  274.   DEBUG_SERIAL.println(WIFI_SSID);

  275. 

  276.   WiFi.mode(WIFI_STA);

  277.   WiFi.begin(WIFI_SSID, WIFI_PASS);

  278. 

  279.   int attempts = 0;

  280.   while (WiFi.status() != WL_CONNECTED && attempts < 40) { // 最多等待 20 秒

  281.     delay(500);

  282.     DEBUG_SERIAL.print(".");

  283.     attempts++;

  284.   }

  285. 

  286.   if (WiFi.status() == WL_CONNECTED) {

  287.     wifiConnected = true;

  288.     DEBUG_SERIAL.println("\n[WiFi] 连接成功！");

  289.     DEBUG_SERIAL.print("[WiFi] IP 地址: ");

  290.     DEBUG_SERIAL.println(WiFi.localIP());

  291.   } else {

  292.     wifiConnected = false;

  293.     DEBUG_SERIAL.println("\n[WiFi] 连接失败！将继续尝试...");

  294.   }

  295. }

  296. 

  297. /********** MCP 回调函数 ***********/

  298. void onMcpOutput(const String &message) {

  299.   DEBUG_SERIAL.print("[MCP 输出] ");

  300.   DEBUG_SERIAL.println(message);

  301.   // 更新消息并重置滚动

  302.   mcpMessage = message;

  303.   scrollOffset = 0;

  304.   lastScrollTime = millis();

  305.   // 计算消息宽度

  306.   messageWidth = u8g2.getUTF8Width(mcpMessage.c_str());

  307.   isScrolling = (messageWidth > 128);  // 如果宽度超过屏幕宽度则滚动

  308.   // 强制刷新显示

  309.   updateOLED();

  310. }

  311. 

  312. void onMcpError(const String &error) {

  313.   DEBUG_SERIAL.print("[MCP 错误] ");

  314.   DEBUG_SERIAL.println(error);

  315. }

  316. 

  317. void onMcpConnectionChange(bool connected) {

  318.   mcpConnected = connected;

  319.   if (connected) {

  320.     DEBUG_SERIAL.println("[MCP] 已连接到服务器");

  321.     registerMcpTools();   // 连接成功后注册工具

  322.   } else {

  323.     DEBUG_SERIAL.println("[MCP] 与服务器断开连接");

  324.   }

  325. }

  326. 

  327. /********** 注册 MCP 工具（注意检查此函数的闭合括号）***********/

  328. void registerMcpTools() {

  329.   DEBUG_SERIAL.println("[MCP] 正在注册工具...");

  330. 

  331.   // 1. LED 控制工具（解决与状态指示的冲突）

  332.   // 1. LED 控制工具（已增加 "flow" 流水灯模式）

  333. mcpClient.registerTool(

  334.   "led_blink",

  335.   "控制 WS2812 灯带 (on/off/blink/flow)",

  336.   "{"properties":{"state":{"title":"LED状态","type":"string","enum":["on","off","blink","flow"]}},"required":["state"],"title":"ledControlArguments","type":"object"}",

  337.   [](const String& args) -> WebSocketMCP::ToolResponse {

  338.     DynamicJsonDocument doc(256);

  339.     DeserializationError error = deserializeJson(doc, args);

  340.     if (error) {

  341.       return WebSocketMCP::ToolResponse("{"success":false,"error":"无效的参数格式"}", true);

  342.     }

  343. 

  344.     String state = doc["state"].as<String>();

  345.     DEBUG_SERIAL.println("[工具] LED 控制: " + state);

  346. 

  347.     // 激活 MCP 控制模式，设置超时（30秒）

  348.     mcpLedActive = true;

  349.     mcpLedTimeout = millis() + 30000;

  350. 

  351.     // 根据命令设置状态机模式

  352.     if (state == "on") {

  353.       currentLedMode = LED_MODE_ON;

  354.       pixels.fill(pixels.Color(255, 255, 255));

  355.       pixels.show();

  356.     } else if (state == "off") {

  357.       currentLedMode = LED_MODE_OFF;

  358.       pixels.clear();

  359.       pixels.show();

  360.     } else if (state == "blink") {

  361.       currentLedMode = LED_MODE_BLINK;

  362.       blinkState = false;

  363.       blinkCount = 0;

  364.       lastLedStep = millis();

  365.       // 立即熄灭（准备开始闪烁）

  366.       pixels.clear();

  367.       pixels.show();

  368.     } else if (state == "flow") {

  369.       currentLedMode = LED_MODE_FLOW;

  370.       flowIndex = 0;

  371.       lastLedStep = millis();

  372.       // 立即开始第一步（点亮第一个灯）

  373.       pixels.clear();

  374.       pixels.setPixelColor(0, pixels.Color(0, 0, 255));

  375.       pixels.show();

  376.     }

  377. 

  378.     String resultJson = "{"success":true,"state":"" + state + ""}";

  379.     return WebSocketMCP::ToolResponse(resultJson);

  380.   }

  381. );

  382.   DEBUG_SERIAL.println("[MCP] LED 控制工具已注册");

  383. 

  384.   // 2. 系统信息工具

  385.   mcpClient.registerTool(

  386.     "system-info",

  387.     "获取掌控板系统信息",

  388.     "{"properties":{},"title":"systemInfoArguments","type":"object"}",

  389.     [](const String& args) -> WebSocketMCP::ToolResponse {

  390.       String chipModel = ESP.getChipModel();

  391.       uint32_t chipId = ESP.getEfuseMac() & 0xFFFFFFFF;

  392.       uint32_t freeHeap = ESP.getFreeHeap() / 1024;

  393.       String ip = WiFi.localIP().toString();

  394. 

  395.       String resultJson = "{"success":true,"model":"" + chipModel +

  396.                           "","chipId":"" + String(chipId, HEX) +

  397.                           "","freeHeap":" + String(freeHeap) +

  398.                           ","wifiStatus":"" + (WiFi.status() == WL_CONNECTED ? "connected" : "disconnected") +

  399.                           "","ipAddress":"" + ip + ""}";

  400.       return WebSocketMCP::ToolResponse(resultJson);

  401.     }

  402.   );

  403.   DEBUG_SERIAL.println("[MCP] 系统信息工具已注册");

  404. 

  405.   // 3. 光线传感器工具（直接读取引脚）

  406.   mcpClient.registerTool(

  407.     "light_sensor",

  408.     "读取光线传感器原始值（P4, GPIO39）",

  409.     "{"properties":{},"title":"lightSensorArguments","type":"object"}",

  410.     [](const String& args) -> WebSocketMCP::ToolResponse {

  411.       int value = analogRead(LIGHT_SENSOR_PIN);

  412.       String resultJson = "{"success":true,"value":" + String(value) + "}";

  413.       // 在 OLED 上显示结果摘要

  414.     mcpMessage = "光线传感器: " + String(value) ;

  415.     scrollOffset = 0;

  416.     lastScrollTime = millis();

  417.     messageWidth = u8g2.getUTF8Width(mcpMessage.c_str());

  418.     isScrolling = (messageWidth > 128);

  419.     updateOLED();  // 立即刷新显示

  420.       return WebSocketMCP::ToolResponse(resultJson);

  421.     }

  422.   );

  423.   DEBUG_SERIAL.println("[MCP] 光线传感器工具已注册");

  424. 

  425.   // 4. 声音传感器工具（直接读取引脚）

  426.   mcpClient.registerTool(

  427.     "sound_sensor",

  428.     "读取声音传感器原始值（P10, GPIO36）",

  429.     "{"properties":{},"title":"soundSensorArguments","type":"object"}",

  430.     [](const String& args) -> WebSocketMCP::ToolResponse {

  431.       int value = analogRead(SOUND_SENSOR_PIN);

  432.       String resultJson = "{"success":true,"value":" + String(value) + "}";

  433.       // 在 OLED 上显示结果摘要

  434.     mcpMessage = "获取的声音传感器的原始值: " + String(value) ;

  435.     scrollOffset = 0;

  436.     lastScrollTime = millis();

  437.     messageWidth = u8g2.getUTF8Width(mcpMessage.c_str());

  438.     isScrolling = (messageWidth > 128);

  439.     updateOLED();  // 立即刷新显示

  440.       return WebSocketMCP::ToolResponse(resultJson);

  441.     }

  442.   );

  443.   

  444.   DEBUG_SERIAL.println("[MCP] 声音传感器工具已注册");

  445. // 5. 红外定位摄像头工具

  446. mcpClient.registerTool(

  447.   "ir_camera",

  448.   "读取红外定位摄像头数据 (最多4个点, 无效点坐标为1023)",

  449.   "{"properties":{},"title":"irCameraArguments","type":"object"}",

  450.   [](const String& args) -> WebSocketMCP::ToolResponse {

  451.     DynamicJsonDocument doc(1024); // 稍大的缓冲区用于存放4个点

  452. 

  453.     if (readIRCamera()) {

  454.       // 构建包含所有点的 JSON 数组

  455.       JsonArray points = doc.createNestedArray("points");

  456.       for (int i = 0; i < 4; i++) {

  457.         JsonObject point = points.createNestedObject();

  458.         point["x"] = irX[i];

  459.         point["y"] = irY[i];

  460.       }

  461.       doc["success"] = true;

  462.     } else {

  463.       doc["success"] = false;

  464.       doc["error"] = "I2C 读取失败";

  465.     }

  466. 

  467.     String resultJson;

  468.     serializeJson(doc, resultJson);

  469.     return WebSocketMCP::ToolResponse(resultJson, !doc["success"].as<bool>());

  470.   }

  471. );

  472. DEBUG_SERIAL.println("[MCP] 红外定位摄像头工具已注册");

  473. 

  474.   DEBUG_SERIAL.println("[MCP] 工具注册完成，共 " + String(mcpClient.getToolCount()) + " 个工具");

  475. } // <--- 确保这里有一个闭合大括号，与开头的 void registerMcpTools() { 匹配

  476. 

  477. /********** 处理串口命令 ***********/

  478. #define MAX_INPUT_LENGTH 1024

  479. char inputBuffer[MAX_INPUT_LENGTH];

  480. int inputBufferIndex = 0;

  481. 

  482. void processSerialCommands() {

  483.   while (DEBUG_SERIAL.available() > 0) {

  484.     char inChar = (char)DEBUG_SERIAL.read();

  485. 

  486.     if (inChar == '\n' || inChar == '\r') {

  487.       if (inputBufferIndex > 0) {

  488.         inputBuffer[inputBufferIndex] = '\0';

  489.         String command = String(inputBuffer);

  490.         command.trim();

  491. 

  492.         if (command.length() > 0) {

  493.           if (command == "help") {

  494.             printHelp();

  495.           } else if (command == "status") {

  496.             printStatus();

  497.           } else if (command == "reconnect") {

  498.             DEBUG_SERIAL.println("正在重新连接 MCP 服务器...");

  499.             mcpClient.disconnect();

  500.           } else if (command == "tools") {

  501.             DEBUG_SERIAL.println("已注册工具数量: " + String(mcpClient.getToolCount()));

  502.           } else {

  503.             if (mcpClient.isConnected()) {

  504.               mcpClient.sendMessage(command);

  505.               DEBUG_SERIAL.println("[发送] " + command);

  506.             } else {

  507.               DEBUG_SERIAL.println("未连接到 MCP 服务器，无法发送命令");

  508.             }

  509.           }

  510.         }

  511.         inputBufferIndex = 0;

  512.       }

  513.     } else if (inChar == '\b' || inChar == 127) {

  514.       if (inputBufferIndex > 0) {

  515.         inputBufferIndex--;

  516.         DEBUG_SERIAL.print("\b \b");

  517.       }

  518.     } else if (inputBufferIndex < MAX_INPUT_LENGTH - 1) {

  519.       inputBuffer[inputBufferIndex++] = inChar;

  520.       DEBUG_SERIAL.print(inChar);

  521.     }

  522.   }

  523. }

  524. 

  525. void printHelp() {

  526.   DEBUG_SERIAL.println("可用命令：");

  527.   DEBUG_SERIAL.println("  help     - 显示此帮助");

  528.   DEBUG_SERIAL.println("  status   - 显示当前连接状态");

  529.   DEBUG_SERIAL.println("  reconnect- 重新连接 MCP 服务器");

  530.   DEBUG_SERIAL.println("  tools    - 查看已注册工具");

  531.   DEBUG_SERIAL.println("  其他内容将直接发送到 MCP 服务器");

  532. }

  533. 

  534. void printStatus() {

  535.   DEBUG_SERIAL.println("当前状态：");

  536.   DEBUG_SERIAL.print("  WiFi: ");

  537.   DEBUG_SERIAL.println(wifiConnected ? "已连接" : "未连接");

  538.   if (wifiConnected) {

  539.     DEBUG_SERIAL.print("  IP 地址: ");

  540.     DEBUG_SERIAL.println(WiFi.localIP());

  541.     DEBUG_SERIAL.print("  信号强度: ");

  542.     DEBUG_SERIAL.println(WiFi.RSSI());

  543.   }

  544.   DEBUG_SERIAL.print("  MCP 服务器: ");

  545.   DEBUG_SERIAL.println(mcpConnected ? "已连接" : "未连接");

  546. }

  547. 

  548. /********** OLED 显示更新（支持滚动消息）***********/

  549. void updateOLED() {

  550.   static String lastWifiStatus = "";

  551.   static String lastMCPStatus = "";

  552.   static String lastIP = "";

  553.   static String lastMessage = "";

  554. 

  555.   String currentWifiStatus = wifiConnected ? "已连接" : "未连接";

  556.   String currentMCPStatus = mcpConnected ? "已连接" : "未连接";

  557.   String currentIP = wifiConnected ? WiFi.localIP().toString() : "0.0.0.0";

  558. 

  559.   bool stateChanged = (currentWifiStatus != lastWifiStatus) ||

  560.                       (currentMCPStatus != lastMCPStatus) ||

  561.                       (currentIP != lastIP) ||

  562.                       (mcpMessage != lastMessage); // 消息内容变化

  563. 

  564.   // 如果正在滚动或状态变化，则重绘

  565.   if (stateChanged || isScrolling) {

  566.     u8g2.clearBuffer();

  567. 

  568.     // 绘制前三行

  569.     u8g2.setCursor(0, 15);

  570.     u8g2.print("WiFi: " + currentWifiStatus);

  571.     u8g2.setCursor(0, 30);

  572.     u8g2.print("IP: " + currentIP);

  573.     u8g2.setCursor(0, 45);

  574.     u8g2.print("MCP: " + currentMCPStatus);

  575. 

  576.     // 绘制第四行（消息滚动）

  577.     if (mcpMessage.length() > 0) {

  578.       // 设置裁剪窗口，限定在第四行区域（y从53到63，根据字体高度调整）

  579.       u8g2.setClipWindow(0, 45, 127, 63);

  580.       u8g2.setCursor(0 - scrollOffset, 60);

  581.       u8g2.print(mcpMessage);

  582.       u8g2.setClipWindow(0, 0, 127, 63); // 恢复全屏裁剪

  583.     }

  584. 

  585.     u8g2.sendBuffer();

  586. 

  587.     lastWifiStatus = currentWifiStatus;

  588.     lastMCPStatus = currentMCPStatus;

  589.     lastIP = currentIP;

  590.     lastMessage = mcpMessage;

  591.   }

  592. }

  593. /**

  594.  * LED 状态机处理函数

  595.  * 在 loop 中定期调用，根据当前模式执行非阻塞操作

  596.  */

  597. void handleLedStateMachine() {

  598.   // 仅当 MCP 控制模式激活且未超时时，才处理状态机

  599.   if (!mcpLedActive || millis() >= mcpLedTimeout) {

  600.     // 如果超时，恢复空闲模式，交给 handleLEDs 处理

  601.     if (currentLedMode != LED_MODE_IDLE) {

  602.       currentLedMode = LED_MODE_IDLE;

  603.       // 强制熄灭，让 handleLEDs 接管

  604.       pixels.clear();

  605.       pixels.show();

  606.     }

  607.     return;

  608.   }

  609. 

  610.   unsigned long now = millis();

  611. 

  612.   switch (currentLedMode) {

  613.     case LED_MODE_ON:

  614.     case LED_MODE_OFF:

  615.       // 常亮/常灭模式无需额外处理，已在工具回调中设置

  616.       break;

  617. 

  618.     case LED_MODE_BLINK:

  619.       if (now - lastLedStep >= blinkDelay) {

  620.         lastLedStep = now;

  621.         if (!blinkState) {

  622.           // 点亮

  623.           pixels.fill(pixels.Color(255, 255, 255));

  624.           blinkState = true;

  625.         } else {

  626.           // 熄灭

  627.           pixels.clear();

  628.           blinkState = false;

  629.           blinkCount++;

  630.         }

  631.         pixels.show();

  632. 

  633.         // 如果闪烁次数完成，退出 MCP 控制模式（可选：让超时自然结束，或立即返回空闲）

  634.         if (blinkCount >= blinkTotal) {

  635.           // 闪烁完成，可以立即结束 MCP 控制，恢复状态指示

  636.           mcpLedActive = false;

  637.           currentLedMode = LED_MODE_IDLE;

  638.           // 确保灯灭，让 handleLEDs 接管

  639.           pixels.clear();

  640.           pixels.show();

  641.         }

  642.       }

  643.       break;

  644. 

  645.     case LED_MODE_FLOW:

  646.       if (now - lastLedStep >= flowDelay) {

  647.         lastLedStep = now;

  648.         // 移动到下一个灯珠

  649.         flowIndex++;

  650.         if (flowIndex < NUM_PIXELS) {

  651.           pixels.clear();

  652.           pixels.setPixelColor(flowIndex, pixels.Color(0, 0, 255));

  653.           pixels.show();

  654.         } else {

  655.           // 流水结束，退出 MCP 控制模式

  656.           mcpLedActive = false;

  657.           currentLedMode = LED_MODE_IDLE;

  658.           pixels.clear();

  659.           pixels.show();

  660.         }

  661.       }

  662.       break;

  663. 

  664.     case LED_MODE_IDLE:

  665.     default:

  666.       break;

  667.   }

  668. }

  669. /********** WS2812 灯带状态指示（考虑 MCP 工具覆盖）***********/

  670. void handleLEDs() {

  671.   // 如果处于 MCP 工具控制模式且未超时，则跳过状态指示，交由状态机处理

  672.   if (mcpLedActive && millis() < mcpLedTimeout) {

  673.     return;  // 状态机已在别处运行

  674.   }

  675. 

  676.   // 确保 MCP 控制标志被清除（超时后）

  677.   mcpLedActive = false;

  678.   currentLedMode = LED_MODE_IDLE;  // 确保模式复位

  679.   static unsigned long lastUpdate = 0;

  680.   static bool ledState = false;

  681.   uint32_t targetColor = 0;

  682.   unsigned long interval = 0;

  683. 

  684.   if (!wifiConnected) {

  685.     targetColor = pixels.Color(255, 0, 0); // 红色

  686.     interval = 100;                         // 快速闪烁

  687.   } else if (!mcpConnected) {

  688.     targetColor = pixels.Color(0, 255, 0); // 绿色

  689.     interval = 500;                         // 慢速闪烁

  690.   } else {

  691.     targetColor = pixels.Color(0, 0, 255); // 蓝色

  692.     interval = 0;                            // 常亮

  693.   }

  694. 

  695.   if (interval == 0) {

  696.     // 常亮

  697.     pixels.fill(targetColor);

  698.     pixels.show();

  699.   } else {

  700.     // 非阻塞闪烁

  701.     if (millis() - lastUpdate > interval) {

  702.       lastUpdate = millis();

  703.       ledState = !ledState;

  704.       if (ledState) {

  705.         pixels.fill(targetColor);

  706.       } else {

  707.         pixels.clear();

  708.       }

  709.       pixels.show();

  710.     }

  711.   }

  712. }
复制代码


【参考资料】

       行空板K10产品页：https://www.dfrobot.com.cn/goods-4014.html
       DFRobot SEN0158红外定位摄像头wiki：https://wiki.dfrobot.com.cn/_SKU_SEN0158_Positioning_IR_Camera
       小智AI官网：https://xiaozhi.me
       掌控板官网：https://www.mpython.cn
       如果你有任何问题或改进建议，欢迎在评论区留言交流！



回复

使用道具 举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

为本项目制作心愿单
购买心愿单
心愿单 编辑
[[wsData.name]]

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主
勋章墙
活跃会员 宣传大使 牛X认证 创客造 编辑选择奖 志“童”道合 编辑选择奖 编辑选择奖 编辑选择奖 编辑选择奖

楼主的其它帖子

background 创造力兑换 background 心愿单 background 创客导航
上海智位机器人股份有限公司 沪ICP备09038501号-4 备案 沪公网安备31011502402448

© 2013-2026 Comsenz Inc. Powered by Discuz! X3.4 Licensed

mail