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

[K10项目分享]行空板k10小智物联——学习状态辅助机（撰写中）

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

[K10项目分享] 行空板k10小智物联——学习状态辅助机（撰写中）

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

【项目背景】
本项目基于行空板 K10 硬件平台，通过修改小智 AI 开源固件，融合 Easy IOT 物联网平台、I2C 超声波传感器（URM09）和 360 舵机，打造一套儿童学习姿态智能看护系统。系统可实现远程唤醒姿态监测、实时距离检测、语音提醒、物联网消息互通等核心功能，帮助家长远程监管孩子的学习状态，及时纠正不良坐姿，同时支持自定义语音交互（如讲故事、播报健康知识）。
【核心功能】
物联网双向通信：小智 AI 与 Easy IOT 平台互发指令，支持远程开启 / 关闭监测、发送语音交互指令（如 “讲个故事”“播报坐姿重要性”）；姿态监测：通过 I2C 超声波传感器实时检测孩子与学习桌的距离，判断是否趴桌学习，触发语音提醒并上报数据至物联网平台；硬件控制：支持通过语音 / 远程指令控制行空板 P0 引脚的 360 舵机（转速 / 方向），扩展互动功能；语音交互：小智 AI 可根据物联网平台指令或本地检测结果，通过自然语言提醒孩子端正坐姿、播报健康知识等。
【硬件清单】
行空板k10小智物联——学习状态辅助机（撰写中）图1
【软件环境】
固件基础：小智 AI 开源代码（xiaozhi-esp32-2.0.5）；开发框架：ESP-IDF（适配 ESP32 的物联网开发框架）；物联网平台：Easy IOT（DFRobot 提供的 MQTT 物联网平台）；传感器库：适配 ESP-IDF 的 URM09 超声波传感器 C++ 库（基于 Arduino 库改写）
【核心技术实现】
1.系统整体架构
行空板k10小智物联——学习状态辅助机（撰写中）图2
2.关键功能实现
(1)Easy IOT MQTT 通信集成
核心修改文件
xiaozhi-esp32-2.0.5/main/boards/common/board.h：新增 MQTT 通信虚函数接口；
  1. // +++ 新增的 Easy IoT 相关接口 +++

  2.     virtual void StartEasyIoTService() {}  // 默认空实现（可选）

  3.     virtual bool IsEasyIoTConnected() const { return false; }  // 默认返回false

  4.     virtual void SendEasyIoTSensorData(int volume) {}  // 示例方法

  5.     virtual void SendEasyIoTStringData(const std::string& data, const std::string& data_type){}
复制代码
xiaozhi-esp32-2.0.5/main/boards/df-k10/df_k10_board.cc：实现 MQTT 客户端初始化、事件处理、消息收发；
  1. #include "mqtt_client.h"

  2. #define IOT_TOPIC "z4ksqL6Ig"          // 设备数据上报主题

  3. #define IOT_TOPIC_control "PufUUHKNR"  // 控制指令接收主题  

  4. #define IOT_TOPIC_talk "6zYbX90Hg"     // 设备对话通信主题
复制代码
在 class Df_K10Board : public WifiBoard 的 private 区域 新增：
  1. private:

  2.     // ... 原有代码 ...

  3.     

  4.     // ===================== 新增MQTT相关成员 =====================

  5.     // MQTT客户端实例句柄，管理MQTT连接

  6.     esp_mqtt_client_handle_t easyiot_mqtt_client_ = nullptr;

  7.     

  8.     // MQTT连接状态标志，true表示已连接

  9.     bool easyiot_connected_ = false;

  10.     

  11.     // MQTT消息回调函数类型定义，用于处理特定主题的消息

  12.     using MqttMessageCallback = std::function<void(const std::string& topic, const std::string& payload)>;

  13.     

  14.     // 主题-回调函数映射表，存储不同主题对应的处理函数

  15.     std::unordered_map<std::string, MqttMessageCallback> topic_callbacks_;

  16.     

  17.     // MQTT事件处理静态函数（适配ESP32事件系统）

  18.     static void MqttEventHandler(void* handler_args, esp_event_base_t base, 

  19.                                  int32_t event_id, void* event_data);

  20.     

  21.     // MQTT事件处理成员函数（实际处理逻辑）

  22.     void HandleMqttEvent(esp_mqtt_event_handle_t event);

  23.     

  24.     // MQTT消息处理核心函数，分发到具体回调

  25.     void ProcessMqttMessage(const std::string& topic, const std::string& payload);

  26.     

  27.     // 订阅指定主题，可设置服务质量等级

  28.     esp_err_t SubscribeToTopic(const std::string& topic, int qos = 0);

  29.     

  30.     // 取消订阅指定主题

  31.     esp_err_t UnsubscribeFromTopic(const std::string& topic);

  32.     

  33.     // ... 其他原有成员 ...
复制代码
在 class Df_K10Board : public WifiBoard 的 public 区域 新增：
  1. public:

  2.     // ... 原有代码 ...

  3.     

  4.     // ===================== 新增MQTT相关公共接口 =====================

  5.     // 启动Easy IoT服务，初始化MQTT客户端并建立连接

  6.     void StartEasyIoTService() override;

  7.     

  8.     // 检查MQTT连接状态

  9.     bool IsEasyIoTConnected() const override;

  10.     

  11.     // 发送传感器数据到MQTT主题

  12.     void SendEasyIoTSensorData(int volume) override;

  13.     

  14.     // 发送字符串数据到MQTT主题，支持数据类型标识

  15.     void SendEasyIoTStringData(const std::string& data, const std::string& data_type) override;

  16.     

  17.     // 注册主题回调函数：为指定主题绑定消息处理函数

  18.     void RegisterTopicCallback(const std::string& topic, MqttMessageCallback callback);

  19.     

  20.     // 移除主题回调函数：取消指定主题的消息处理绑定

  21.     void RemoveTopicCallback(const std::string& topic);

  22.     

  23.     // ... 其他原有方法 ...
复制代码
Df_K10Board 类中 MQTT 相关成员函数的完整实现代码
  1. // ===================== MQTT相关成员函数实现 =====================

  2. 

  3. /**

  4.  * 启动Easy IoT服务

  5.  * 功能：初始化MQTT客户端，配置连接参数，注册事件处理器，并启动连接

  6.  * 注意：只能启动一次，重复调用会警告并返回

  7.  */

  8. void Df_K10Board::StartEasyIoTService() {

  9.     if (easyiot_mqtt_client_ != nullptr) {

  10.         ESP_LOGW(TAG, "Easy IoT service already started");

  11.         return;

  12.     }

  13.     ESP_LOGI(TAG, "Starting Easy IoT service");

  14.     

  15.     // 配置 MQTT 客户端

  16.     esp_mqtt_client_config_t mqtt_cfg = {};

  17.     mqtt_cfg.broker.address.uri = "mqtt://iot.dfrobot.com.cn:1883";  // MQTT服务器地址

  18.     mqtt_cfg.credentials.client_id = "AVNLqL6SR";  // 客户端ID

  19.     mqtt_cfg.credentials.username = "AVNLqL6SR";   // 用户名

  20.     mqtt_cfg.credentials.authentication.password = "04HYqY6IRz";  // 密码

  21.     

  22.     // 配置连接参数

  23.     mqtt_cfg.session.keepalive = 60;  // 60秒心跳包

  24.     mqtt_cfg.session.disable_clean_session = false;  // 清除会话（重新连接时不保留旧消息）

  25.     mqtt_cfg.network.disable_auto_reconnect = false;  // 启用自动重连

  26.     mqtt_cfg.network.reconnect_timeout_ms = 5000;  // 5秒重连间隔

  27.     

  28.     // 初始化MQTT客户端

  29.     easyiot_mqtt_client_ = esp_mqtt_client_init(&mqtt_cfg);

  30.     

  31.     // 注册事件处理函数

  32.     esp_mqtt_client_register_event(easyiot_mqtt_client_, 

  33.         static_cast<esp_mqtt_event_id_t>(ESP_EVENT_ANY_ID),  // 监听所有MQTT事件

  34.         MqttEventHandler,  // 静态事件处理函数

  35.         this);  // 传入当前对象指针作为上下文

  36.     

  37.     // 启动MQTT客户端（开始连接服务器）

  38.     esp_mqtt_client_start(easyiot_mqtt_client_);

  39.     

  40.     // ===================== 注册默认回调函数 =====================

  41.     

  42.     // 1. 控制主题回调：处理LED控制命令

  43.     RegisterTopicCallback(IOT_TOPIC_control, [this](const std::string& topic, const std::string& payload) {

  44.         // 处理LED控制命令

  45.         if (payload == "on") {

  46.             led_strip_->SetAllColor(RGBToColor(0, 255, 0));  // 绿色

  47.             GetDisplay()->ShowNotification("LED ON");

  48.         } else if (payload == "off") {

  49.             led_strip_->SetAllColor(RGBToColor(0, 0, 0));  // 关闭

  50.             GetDisplay()->ShowNotification("LED OFF");

  51.         } else if (payload == "blink") {

  52.             // 闪烁效果

  53.             for (int i = 0; i < 5; i++) {

  54.                 led_strip_->SetAllColor(RGBToColor(255, 255, 0));  // 黄色

  55.                 vTaskDelay(pdMS_TO_TICKS(200));

  56.                 led_strip_->SetAllColor(RGBToColor(0, 0, 0));  // 关闭

  57.                 vTaskDelay(pdMS_TO_TICKS(200));

  58.             }

  59.         }

  60.     });

  61.     

  62.     // 2. 对话主题回调：处理语音交互命令

  63.     RegisterTopicCallback(IOT_TOPIC_talk, [this](const std::string& topic, const std::string& payload) {

  64.         auto& app = Application::GetInstance();

  65.         DeviceState state = app.GetDeviceState();

  66.         

  67.         // 在屏幕上显示收到的消息

  68.         GetDisplay()->ShowNotification(payload);

  69.         

  70.         // 根据设备状态处理消息

  71.         if (state == kDeviceStateListening) {

  72.             // 向服务器发送唤醒词检测

  73.             app.NotifyWakeWord(payload);

  74.         } else if (state == kDeviceStateIdle) {

  75.             // 触发完整的对话

  76.             app.WakeWordInvoke(payload);

  77.         } else if (state == kDeviceStateSpeaking) {

  78.             if (payload == "stop") {

  79.                 // 停止说话命令

  80.                 app.StopSpeaking();

  81.             }

  82.         }

  83.     });

  84. }

  85. 

  86. /**

  87.  * 检查MQTT连接状态

  88.  * 返回值：true表示已连接，false表示未连接

  89.  */

  90. bool Df_K10Board::IsEasyIoTConnected() const {

  91.     return easyiot_connected_;

  92. }

  93. 

  94. /**

  95.  * 发送字符串数据到Easy IoT平台

  96.  * 功能：将字符串数据（如base64编码的图片）以JSON格式发送到指定主题

  97.  * 参数：data - 要发送的数据字符串

  98.  *        data_type - 数据类型标识（如"Information"、"camera_photo"等）

  99.  * 注意：会自动处理数据大小限制，过大数据会被截断

  100.  */

  101. void Df_K10Board::SendEasyIoTStringData(const std::string& data, const std::string& data_type) {

  102.     if (!easyiot_mqtt_client_) {

  103.         ESP_LOGW(TAG, "Easy IoT MQTT client not initialized");

  104.         return;

  105.     }

  106.     

  107.     // MQTT消息大小限制（假设最大为4KB）

  108.     size_t json_overhead = 100;  // JSON格式额外开销

  109.     size_t max_mqtt_payload = 4096;  // 假设MQTT最大payload为4KB

  110.     

  111.     ESP_LOGW(TAG, "Sending data type: %s, data length: %u", data_type.c_str(), data.length());

  112.     

  113.     // 检查数据是否超过MQTT限制

  114.     if (data.length() + json_overhead > max_mqtt_payload) {

  115.         // 数据太大，需要截断

  116.         ESP_LOGW(TAG, "Information data too large (%u bytes), truncating...", data.length());

  117.         

  118.         // 计算最大可发送数据大小

  119.         size_t max_data_size = max_mqtt_payload - json_overhead - 100;  // 留出更多空间

  120.         if (max_data_size > data.length()) {

  121.             max_data_size = data.length();

  122.         }

  123.         

  124.         // 安全地截取子字符串

  125.         std::string truncated_data = data.substr(0, max_data_size);

  126.         

  127.         // 确保数据中不包含null字符（替换为空格）

  128.         for (size_t i = 0; i < truncated_data.length(); i++) {

  129.             if (truncated_data[i] == '\0') {

  130.                 truncated_data[i] = ' ';

  131.             }

  132.         }

  133.         

  134.         // 构建JSON格式的payload

  135.         char payload[max_mqtt_payload];

  136.         int written = snprintf(payload, sizeof(payload), 

  137.                                "{"type":"%s","data":"%s"}",

  138.                                data_type.c_str(), truncated_data.c_str());

  139.         

  140.         if (written < 0 || written >= (int)sizeof(payload)) {

  141.             ESP_LOGE(TAG, "Failed to format JSON payload");

  142.             return;

  143.         }

  144.         

  145.         // 发布消息到主题

  146.         int msg_id = esp_mqtt_client_publish(easyiot_mqtt_client_, 

  147.                                             IOT_TOPIC,  // 设备数据上报主题

  148.                                             payload, 0, 1, 0);

  149.         ESP_LOGI(TAG, "Sent truncated data to Easy IoT, msg_id=%d, payload_size=%d", 

  150.                 msg_id, written);

  151.         return;

  152.     }

  153.     

  154.     // 数据大小合适，直接发送

  155.     char payload[data.length() + json_overhead + 100];

  156.     

  157.     // 清理数据中的null字符

  158.     std::string clean_data = data;

  159.     for (size_t i = 0; i < clean_data.length(); i++) {

  160.         if (clean_data[i] == '\0') {

  161.             clean_data[i] = ' ';

  162.         }

  163.     }

  164.     

  165.     // 根据数据类型构建不同的JSON格式

  166.     int written = 0;

  167.     if (data_type == "Information" || data_type == "camera_photo") {

  168.         // 特殊数据类型包含大小信息

  169.         written = snprintf(payload, sizeof(payload),

  170.                 "{"type":"%s","data":"%s","size":%u}",

  171.                 data_type.c_str(), 

  172.                 clean_data.c_str(), 

  173.                 clean_data.length());

  174.     } else {

  175.         // 普通数据类型

  176.         written = snprintf(payload, sizeof(payload),

  177.                 "{"type":"%s","data":"%s"}",

  178.                 data_type.c_str(), clean_data.c_str());

  179.     }

  180.     

  181.     if (written < 0 || written >= (int)sizeof(payload)) {

  182.         ESP_LOGE(TAG, "Failed to format JSON payload");

  183.         return;

  184.     }

  185.     

  186.     // 发布消息

  187.     int msg_id = esp_mqtt_client_publish(easyiot_mqtt_client_, 

  188.                                         IOT_TOPIC,  // 设备数据上报主题

  189.                                         payload, 0, 1, 0);

  190.     ESP_LOGI(TAG, "Sent string data to Easy IoT, msg_id=%d, payload_size=%d", 

  191.             msg_id, written);

  192. }

  193. 

  194. /**

  195.  * 发送传感器数据到Easy IoT平台

  196.  * 功能：将传感器数据（如音量）以JSON格式发送

  197.  * 参数：volume - 传感器采集的音量值

  198.  */

  199. void Df_K10Board::SendEasyIoTSensorData(int volume) {

  200.     // 构建JSON格式的传感器数据

  201.     char payload[100];

  202.     snprintf(payload, sizeof(payload),

  203.              "{"volume":%d}",

  204.              volume);

  205.     

  206.     // 发布消息到传感器数据主题

  207.     int msg_id = esp_mqtt_client_publish(easyiot_mqtt_client_, 

  208.                                          IOT_TOPIC,  // 设备数据上报主题

  209.                                          payload, 0, 1, 0);

  210.     ESP_LOGI(TAG, "Sent sensor data to Easy IoT, msg_id=%d", msg_id);

  211. }

  212. 

  213. /**

  214.  * 静态MQTT事件处理函数

  215.  * 功能：将ESP32事件系统的MQTT事件转发给成员函数处理

  216.  * 参数：handler_args - 传入的上下文（this指针）

  217.  *        base - 事件基础类型

  218.  *        event_id - 事件ID

  219.  *        event_data - 事件数据

  220.  */

  221. void Df_K10Board::MqttEventHandler(void* handler_args, esp_event_base_t base, 

  222.                                   int32_t event_id, void* event_data) {

  223.     // 将静态上下文转换为对象指针，调用成员函数处理事件

  224.     auto self = static_cast<Df_K10Board*>(handler_args);

  225.     self->HandleMqttEvent(static_cast<esp_mqtt_event_handle_t>(event_data));

  226. }

  227. 

  228. /**

  229.  * 实例MQTT事件处理函数

  230.  * 功能：处理所有MQTT事件，包括连接、断开、订阅、发布、数据接收等

  231.  * 参数：event - MQTT事件句柄

  232.  */

  233. void Df_K10Board::HandleMqttEvent(esp_mqtt_event_handle_t event) {

  234.     switch (event->event_id) {

  235.         case MQTT_EVENT_CONNECTED:

  236.             ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");

  237.             easyiot_connected_ = true;  // 更新连接状态

  238.             

  239.             // 连接成功后自动订阅主题

  240.             SubscribeToTopic(IOT_TOPIC_control);  // 控制主题

  241.             SubscribeToTopic(IOT_TOPIC_talk);     // 对话主题

  242.             

  243.             // 在屏幕上显示连接成功通知

  244.             GetDisplay()->ShowNotification("MQTT Connected");

  245.             break;

  246.             

  247.         case MQTT_EVENT_DISCONNECTED:

  248.             ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");

  249.             easyiot_connected_ = false;  // 更新连接状态

  250.             GetDisplay()->ShowNotification("MQTT Disconnected");

  251.             break;

  252.             

  253.         case MQTT_EVENT_SUBSCRIBED:

  254.             ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);

  255.             break;

  256.             

  257.         case MQTT_EVENT_UNSUBSCRIBED:

  258.             ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);

  259.             break;

  260.             

  261.         case MQTT_EVENT_PUBLISHED:

  262.             ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);

  263.             break;

  264.             

  265.         case MQTT_EVENT_DATA: {

  266.             ESP_LOGI(TAG, "MQTT_EVENT_DATA");

  267.             

  268.             // 提取主题和消息内容

  269.             std::string topic(event->topic, event->topic_len);

  270.             std::string payload(event->data, event->data_len);

  271.             

  272.             ESP_LOGI(TAG, "Received message on topic: %s", topic.c_str());

  273.             ESP_LOGI(TAG, "Payload: %s", payload.c_str());

  274.             

  275.             // 处理接收到的消息

  276.             ProcessMqttMessage(topic, payload);

  277.             break;

  278.         }

  279.             

  280.         case MQTT_EVENT_ERROR:

  281.             ESP_LOGE(TAG, "MQTT_EVENT_ERROR");

  282.             // 处理TCP传输错误

  283.             if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {

  284.                 ESP_LOGE(TAG, "Last error code reported from esp-tls: 0x%x", 

  285.                         event->error_handle->esp_tls_last_esp_err);

  286.                 ESP_LOGE(TAG, "Last tls stack error number: 0x%x", 

  287.                         event->error_handle->esp_tls_stack_err);

  288.             }

  289.             break;

  290.             

  291.         default:

  292.             ESP_LOGI(TAG, "Other event id:%d", event->event_id);

  293.             break;

  294.     }

  295. }

  296. 

  297. /**

  298.  * 处理MQTT消息

  299.  * 功能：根据主题分发消息到对应的回调函数

  300.  * 参数：topic - 消息主题

  301.  *        payload - 消息内容

  302.  */

  303. void Df_K10Board::ProcessMqttMessage(const std::string& topic, const std::string& payload) {

  304.     // 在屏幕上显示简短通知

  305.     GetDisplay()->ShowNotification("MQTT Msg: " + payload.substr(0, 20));

  306.     

  307.     // 查找是否有注册的回调函数

  308.     auto it = topic_callbacks_.find(topic);

  309.     if (it != topic_callbacks_.end()) {

  310.         // 调用注册的回调函数

  311.         it->second(topic, payload);

  312.     } else {

  313.         // 默认消息处理逻辑（无回调注册时使用）

  314.         ESP_LOGW(TAG, "No callback registered for topic: %s", topic.c_str());

  315.         

  316.         // 简单解析控制命令（示例）

  317.         if (topic.find(IOT_TOPIC_control) != std::string::npos) {

  318.             if (payload.find(""led":"on"") != std::string::npos) {

  319.                 led_strip_->SetAllColor(RGBToColor(255, 0, 0));  // 红色

  320.             } else if (payload.find(""led":"off"") != std::string::npos) {

  321.                 led_strip_->SetAllColor(RGBToColor(0, 0, 0));  // 关闭

  322.             }

  323.         }

  324.     }

  325. }

  326. 

  327. /**

  328.  * 注册主题回调函数

  329.  * 功能：为指定主题绑定消息处理函数

  330.  * 参数：topic - 主题名称

  331.  *        callback - 回调函数

  332.  */

  333. void Df_K10Board::RegisterTopicCallback(const std::string& topic, MqttMessageCallback callback) {

  334.     topic_callbacks_[topic] = callback;

  335.     

  336.     // 如果已经连接，立即订阅该主题

  337.     if (easyiot_connected_ && easyiot_mqtt_client_) {

  338.         SubscribeToTopic(topic);

  339.     }

  340. }

  341. 

  342. /**

  343.  * 移除主题回调函数

  344.  * 功能：取消指定主题的回调函数绑定

  345.  * 参数：topic - 主题名称

  346.  */

  347. void Df_K10Board::RemoveTopicCallback(const std::string& topic) {

  348.     topic_callbacks_.erase(topic);

  349. }

  350. 

  351. /**

  352.  * 订阅主题

  353.  * 功能：向MQTT服务器订阅指定主题

  354.  * 参数：topic - 主题名称

  355.  *        qos - 服务质量等级（0-2，默认0）

  356.  * 返回值：ESP_OK成功，ESP_FAIL失败

  357.  */

  358. esp_err_t Df_K10Board::SubscribeToTopic(const std::string& topic, int qos) {

  359.     if (!easyiot_mqtt_client_ || !easyiot_connected_) {

  360.         ESP_LOGW(TAG, "MQTT client not connected, cannot subscribe to topic: %s", topic.c_str());

  361.         return ESP_FAIL;

  362.     }

  363.     

  364.     int msg_id = esp_mqtt_client_subscribe(easyiot_mqtt_client_, topic.c_str(), qos);

  365.     if (msg_id < 0) {

  366.         ESP_LOGE(TAG, "Failed to subscribe to topic: %s", topic.c_str());

  367.         return ESP_FAIL;

  368.     }

  369.     

  370.     ESP_LOGI(TAG, "Subscribed to topic: %s, msg_id: %d", topic.c_str(), msg_id);

  371.     return ESP_OK;

  372. }

  373. 

  374. /**

  375.  * 取消订阅主题

  376.  * 功能：从MQTT服务器取消订阅指定主题

  377.  * 参数：topic - 主题名称

  378.  * 返回值：ESP_OK成功，ESP_FAIL失败

  379.  */

  380. esp_err_t Df_K10Board::UnsubscribeFromTopic(const std::string& topic) {

  381.     if (!easyiot_mqtt_client_ || !easyiot_connected_) {

  382.         return ESP_FAIL;

  383.     }

  384.     

  385.     int msg_id = esp_mqtt_client_unsubscribe(easyiot_mqtt_client_, topic.c_str());

  386.     if (msg_id < 0) {

  387.         ESP_LOGE(TAG, "Failed to unsubscribe from topic: %s", topic.c_str());

  388.         return ESP_FAIL;

  389.     }

  390.     

  391.     ESP_LOGI(TAG, "Unsubscribed from topic: %s, msg_id: %d", topic.c_str(), msg_id);

  392.     return ESP_OK;

  393. }
复制代码
在 mcp_server.cc 文件中新增 MCP 工具函数，用于将信息发送到物联网平台：
  1. // ===================== 新增：发送信息到物联网平台工具 =====================

  2. 

  3. /**

  4.  * 工具名称：self.send_data_to_iot

  5.  * 功能描述：发送信息到物联网平台

  6.  * 适用场景：当需要与物联网平台共享信息或照片时使用此工具

  7.  * 参数说明：

  8.  *   - Information: 要发送的字符串信息，可以是文本信息

  9.  * 调用示例：用户说"分享***信息到物联网"

  10.  */

  11. AddTool("self.send_data_to_iot",

  12.     "发送信息到物联网平台，Information：信息",

  13.     PropertyList({

  14.                 Property("Information", kPropertyTypeString)

  15.             }),

  16.     [camera, &board](const PropertyList& properties) -> ReturnValue {

  17.       // 从参数中提取要发送的信息

  18.       auto Information = properties["Information"].value<std::string>();

  19.       

  20.       // 记录调试信息

  21.       ESP_LOGI("MCP_SERVER", "Sending data to IoT platform, length: %d", Information.length());

  22.       

  23.       // 发送到物联网平台，数据类型为"Information"

  24.       board.SendEasyIoTStringData(std::string(Information), "Information");

  25.       

  26.       // 返回成功

  27.       return true;

  28.     });

复制代码
核心代码逻辑：

  初始化 MQTT 客户端，连接 Easy IOT 平台（地址：mqtt://iot.dfrobot.com.cn:1883）；
  订阅两个核心主题：
    IOT_TOPIC_control：硬件控制指令（如开关灯、舵机控制）；
    IOT_TOPIC_talk：语音交互指令（如 “讲个故事”“播报坐姿重要性”）；
  实现消息回调机制：接收到平台指令后，触发硬件控制或语音交互；
  封装数据上报函数：支持字符串 / 传感器数据（如距离、提醒信息）格式化上报至平台。
【URM09 超声波传感器适配】
核心修改：
  • 将 Arduino 版 URM09 库改写为 ESP-IDF 兼容的 C++ 库（DFRobot_URM09.h/.cc），适配 I2C 主机驱动；
  • 在df_k10_board.cc中集成传感器初始化、数据读取函数：
    • InitializeSensors()：初始化 I2C 总线并挂载传感器，设置自动测量模式（500cm 量程）；
    • GetSensorData()：读取距离 / 温度数据，格式化返回（如 “当前距离为 20 厘米，环境温度为 25.5 摄氏度”）；
  • 在mcp_server.cc注册self.get_distance工具函数，支持小智 AI 调用传感器数据。

URM09-I2C超声波测距传感器库DFRobot_URM09.h文件代码内容
  1. /*!

  2.  * @file DFRobot_URM09.h

  3.  * @brief Basic structure of DFRobot_URM09 class for ESP-IDF

  4.  * @copyright Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)

  5.  * @license The MIT License (MIT)

  6.  * @author ZhixinLiu(zhixin.liu@dfrobot.com)

  7.  * @version V2.0 (ESP-IDF Adaptation)

  8.  * @date 2024-01-01

  9.  * @url https://github.com/DFRobot/DFRobot_URM09

  10.  */

  11. #ifndef __DFRobot_URM09_H__

  12. #define __DFRobot_URM09_H__

  13. 

  14. #include <driver/i2c_master.h>

  15. #include <esp_log.h>

  16. #include <cstdint>

  17. #include <string>

  18. 

  19. // 测量模式定义

  20. #define MEASURE_MODE_AUTOMATIC  0x80

  21. #define MEASURE_MODE_PASSIVE    0x00

  22. 

  23. #define CMD_DISTANCE_MEASURE    0x01

  24. 

  25. // 测量范围定义

  26. #define MEASURE_RANG_500        0x20

  27. #define MEASURE_RANG_300        0x10

  28. #define MEASURE_RANG_150        0x00

  29. 

  30. class DFRobot_URM09 {

  31. public:

  32.     // 寄存器枚举

  33.     typedef enum {

  34.         eSLAVEADDR_INDEX = 0,

  35.         ePID_INDEX,

  36.         eVERSION_INDEX,

  37.         eDIST_H_INDEX,

  38.         eDIST_L_INDEX,

  39.         eTEMP_H_INDEX,

  40.         eTEMP_L_INDEX,

  41.         eCFG_INDEX,

  42.         eCMD_INDEX,

  43.         eREG_NUM

  44.     } eRegister_t;

  45. 

  46.     /**

  47.      * @brief 构造函数

  48.      * @param i2c_bus I2C总线句柄（已在主程序中初始化）

  49.      * @param i2c_addr I2C设备地址（默认为0x11）

  50.      */

  51.     DFRobot_URM09(i2c_master_bus_handle_t i2c_bus, uint8_t i2c_addr = 0x11);

  52.     

  53.     /**

  54.      * @brief 析构函数

  55.      */

  56.     ~DFRobot_URM09();

  57. 

  58.     /**

  59.      * @brief 初始化传感器

  60.      * @return 初始化状态

  61.      */

  62.     bool begin();

  63. 

  64.     /**

  65.      * @brief 设置测量模式和范围

  66.      * @param range 测量范围

  67.      * @param mode 测量模式

  68.      */

  69.     void setModeRange(uint8_t range, uint8_t mode);

  70. 

  71.     /**

  72.      * @brief 发送测量命令（被动模式）

  73.      */

  74.     void measurement();

  75. 

  76.     /**

  77.      * @brief 获取温度值

  78.      * @return 温度值（℃）

  79.      */

  80.     float getTemperature();

  81. 

  82.     /**

  83.      * @brief 获取距离值

  84.      * @return 距离值（cm）

  85.      */

  86.     int16_t getDistance();

  87. 

  88.     /**

  89.      * @brief 扫描I2C设备

  90.      * @return 设备地址，未找到返回-1

  91.      */

  92.     int16_t scanDevice();

  93. 

  94.     /**

  95.      * @brief 获取当前I2C地址

  96.      * @return I2C地址

  97.      */

  98.     uint8_t getI2CAddress();

  99. 

  100.     /**

  101.      * @brief 修改I2C地址

  102.      * @param address 新地址（1-127）

  103.      */

  104.     void modifyI2CAddress(uint8_t address);

  105. 

  106. private:

  107.     // I2C写函数

  108.     esp_err_t i2cWriteRegister(uint8_t reg, uint8_t *data, uint8_t len);

  109.     

  110.     // I2C读函数

  111.     esp_err_t i2cReadRegister(uint8_t reg, uint8_t *data, uint8_t len);

  112. 

  113.     i2c_master_bus_handle_t i2c_bus_;      // I2C总线句柄

  114.     i2c_master_dev_handle_t i2c_dev_;      // I2C设备句柄

  115.     uint8_t i2c_addr_;                     // I2C设备地址

  116.     uint8_t txbuf[10] = {0};               // 发送缓冲区

  117.     const char* TAG = "URM09";             // 日志标签

  118. };

  119. 

  120. #endif // __DFRobot_URM09_H__
复制代码

URM09-I2C超声波测距传感器库文件DFRobot_URM09.cc文件内容
  1. /*!

  2.  * @file DFRobot_URM09.cpp

  3.  * @brief ESP-IDF implementation of DFRobot_URM09 class

  4.  * @copyright Copyright (c) 2010 DFRobot Co.Ltd ([url]http://www.dfrobot.com[/url])

  5.  * @license The MIT License (MIT)

  6.  * @author ZhixinLiu([email]zhixin.liu@dfrobot.com[/email])

  7.  * @version V2.0 (ESP-IDF Adaptation)

  8.  * @date 2024-01-01

  9.  */

  10. #include "DFRobot_URM09.h"

  11. 

  12. // 构造函数 - 注意初始化列表顺序必须与类声明顺序一致

  13. DFRobot_URM09::DFRobot_URM09(i2c_master_bus_handle_t i2c_bus, uint8_t i2c_addr)

  14.     : i2c_bus_(i2c_bus), i2c_dev_(nullptr), i2c_addr_(i2c_addr) {

  15.     // 构造函数体（可为空）

  16. }

  17. 

  18. // 析构函数

  19. DFRobot_URM09::~DFRobot_URM09() {

  20.     if (i2c_dev_) {

  21.         i2c_master_bus_rm_device(i2c_dev_);

  22.     }

  23. }

  24. 

  25. // 初始化传感器

  26. bool DFRobot_URM09::begin() {

  27.     // 配置I2C设备

  28.     i2c_device_config_t dev_cfg = {

  29.         .dev_addr_length = I2C_ADDR_BIT_LEN_7,

  30.         .device_address = i2c_addr_,

  31.         .scl_speed_hz = 100000, // 100kHz

  32.     };

  33.     

  34.     esp_err_t ret = i2c_master_bus_add_device(i2c_bus_, &dev_cfg, &i2c_dev_);

  35.     if (ret != ESP_OK) {

  36.         ESP_LOGE(TAG, "Failed to add I2C device: %s", esp_err_to_name(ret));

  37.         return false;

  38.     }

  39.     

  40.     ESP_LOGI(TAG, "URM09 initialized at address 0x%02X", i2c_addr_);

  41.     return true;

  42. }

  43. 

  44. // 设置测量模式和范围

  45. void DFRobot_URM09::setModeRange(uint8_t range, uint8_t mode) {

  46.     txbuf[0] = (uint8_t)(range | mode);

  47.     i2cWriteRegister(eCFG_INDEX, txbuf, 1);

  48. }

  49. 

  50. // 发送测量命令

  51. void DFRobot_URM09::measurement() {

  52.     txbuf[0] = CMD_DISTANCE_MEASURE;

  53.     i2cWriteRegister(eCMD_INDEX, txbuf, 1);

  54. }

  55. 

  56. // 获取温度

  57. float DFRobot_URM09::getTemperature() {

  58.     uint8_t rxbuf[2] = {0};

  59.     

  60.     if (i2cReadRegister(eTEMP_H_INDEX, rxbuf, 2) != ESP_OK) {

  61.         ESP_LOGE(TAG, "Failed to read temperature");

  62.         return -999.0f;

  63.     }

  64.     

  65.     int16_t temp_raw = ((int16_t)rxbuf[0] << 8) | rxbuf[1];

  66.     return temp_raw / 10.0f;

  67. }

  68. 

  69. // 获取距离

  70. int16_t DFRobot_URM09::getDistance() {

  71.     uint8_t rxbuf[2] = {0};

  72.     

  73.     if (i2cReadRegister(eDIST_H_INDEX, rxbuf, 2) != ESP_OK) {

  74.         ESP_LOGE(TAG, "Failed to read distance");

  75.         return -1;

  76.     }

  77.     

  78.     return ((int16_t)rxbuf[0] << 8) | rxbuf[1];

  79. }

  80. 

  81. // I2C写寄存器

  82. esp_err_t DFRobot_URM09::i2cWriteRegister(uint8_t reg, uint8_t *data, uint8_t len) {

  83.     uint8_t write_buf[10];

  84.     

  85.     if (len > 9) {

  86.         ESP_LOGE(TAG, "Write data too long");

  87.         return ESP_FAIL;

  88.     }

  89.     

  90.     write_buf[0] = reg;

  91.     memcpy(&write_buf[1], data, len);

  92.     

  93.     return i2c_master_transmit(i2c_dev_, write_buf, len + 1, -1);

  94. }

  95. 

  96. // I2C读寄存器

  97. esp_err_t DFRobot_URM09::i2cReadRegister(uint8_t reg, uint8_t *data, uint8_t len) {

  98.     // 先发送寄存器地址

  99.     uint8_t reg_addr = reg;

  100.     esp_err_t ret = i2c_master_transmit(i2c_dev_, ®_addr, 1, -1);

  101.     if (ret != ESP_OK) {

  102.         return ret;

  103.     }

  104.     

  105.     // 然后读取数据

  106.     return i2c_master_receive(i2c_dev_, data, len, -1);

  107. }

  108. 

  109. // 扫描设备

  110. int16_t DFRobot_URM09::scanDevice() {

  111.     // 注意：此函数需要独立I2C操作，可能不适用于已添加到总线的设备

  112.     for (uint8_t address = 1; address < 127; address++) {

  113.         i2c_device_config_t scan_cfg = {

  114.             .dev_addr_length = I2C_ADDR_BIT_LEN_7,

  115.             .device_address = address,

  116.             .scl_speed_hz = 100000,

  117.         };

  118.         

  119.         i2c_master_dev_handle_t scan_dev;

  120.         esp_err_t ret = i2c_master_bus_add_device(i2c_bus_, &scan_cfg, &scan_dev);

  121.         if (ret == ESP_OK) {

  122.             i2c_master_bus_rm_device(scan_dev);

  123.             return address;

  124.         }

  125.     }

  126.     return -1;

  127. }

  128. 

  129. // 获取当前I2C地址

  130. uint8_t DFRobot_URM09::getI2CAddress() {

  131.     uint8_t rxbuf[1] = {0};

  132.     

  133.     if (i2cReadRegister(eSLAVEADDR_INDEX, rxbuf, 1) != ESP_OK) {

  134.         return 0;

  135.     }

  136.     

  137.     return rxbuf[0];

  138. }

  139. 

  140. // 修改I2C地址

  141. void DFRobot_URM09::modifyI2CAddress(uint8_t address) {

  142.     txbuf[0] = address;

  143.     i2cWriteRegister(eSLAVEADDR_INDEX, txbuf, 1);

  144.     i2c_addr_ = address; // 更新内部地址

  145.     

  146.     // 需要重新初始化设备

  147.     if (i2c_dev_) {

  148.         i2c_master_bus_rm_device(i2c_dev_);

  149.         i2c_dev_ = nullptr;

  150.     }

  151.     

  152.     // 重新添加设备

  153.     i2c_device_config_t dev_cfg = {

  154.         .dev_addr_length = I2C_ADDR_BIT_LEN_7,

  155.         .device_address = i2c_addr_,

  156.         .scl_speed_hz = 100000,

  157.     };

  158.     

  159.     i2c_master_bus_add_device(i2c_bus_, &dev_cfg, &i2c_dev_);

  160. }
复制代码
将 DFRobot_URM09.cc 源文件添加到编译系统中,确保 URM09 超声波传感器的驱动代码被编译并链接到最终的可执行文件中。
CMakeLists.txt 文件修改,修改位置：在 CMakeLists.txt 的源文件列表部分
  1. list(APPEND SOURCES "boards/df-k10/DFRobot_URM09.cc")  # 新增：URM09超声波传感器驱动
复制代码
board.h 文件修改,修改位置：在 board.h 的类声明中，在公共接口部分"public:"
  1. // ===================== 在 Board 基类中新增传感器数据获取接口 =====================

  2. // 位置：在 board.h 文件的 Board 类定义中，public: 区域

  3. 

  4. class Board {

  5. public:

  6.     // ... 原有虚函数声明 ...

  7.     

  8.     /**

  9.      * 获取传感器数据的字符串表示

  10.      * 功能：返回当前所有传感器数据的汇总字符串（JSON格式或其他格式）

  11.      * 注意：这是一个虚函数，派生类可以覆盖以提供具体的传感器数据

  12.      * 返回值：传感器数据的字符串表示，默认返回空字符串

  13.      * 使用场景：

  14.      *   1. 用于物联网平台数据上报

  15.      *   2. 用于设备状态监控

  16.      *   3. 用于调试和日志记录

  17.      * 

  18.      * 派生类覆盖示例（在 Df_K10Board 中）：

  19.      *   std::string GetSensorData() override {

  20.      *       // 获取温度、湿度、距离等传感器数据

  21.      *       char buffer[256];

  22.      *       snprintf(buffer, sizeof(buffer),

  23.      *                "{"temperature":%.1f,"humidity":%.1f,"distance":%d}",

  24.      *                temperature_, humidity_, distance_);

  25.      *       return std::string(buffer);

  26.      *   }

  27.      */

  28.     virtual std::string GetSensorData() { return ""; }  // 默认返回空字符串

  29.     

  30.     // ... 其他虚函数声明 ...

  31. };
复制代码
DFRobot URM09 超声波传感器集成代码
在 df_k10_board.cc 文件中新增内容
  1. // ===================== 新增URM09超声波传感器支持 =====================

  2. // 位置：在文件开头的头文件包含部分

  3. #include "DFRobot_URM09.h"  // 新增：URM09超声波传感器驱动

  4. 

  5. // ===================== 在 Df_K10Board 类中新增成员变量 =====================

  6. // 位置：在类定义的私有成员部分

  7. private:

  8.     // ... 其他私有成员 ...

  9.     

  10.     // 超声波传感器相关成员

  11.     DFRobot_URM09* urm09_sensor_;    // URM09传感器实例指针

  12.     int16_t last_distance_cm_;       // 最近一次测量的距离（厘米）

  13.     float last_temperature_c_;       // 最近一次测量的温度（摄氏度）

  14.     

  15.     // 新增初始化函数声明

  16.     void InitializeSensors();        // 初始化所有传感器

  17. 

  18. // ===================== 构造函数修改 =====================

  19. // 位置：在构造函数定义处

  20. Df_K10Board::Df_K10Board()

  21.     : urm09_sensor_(nullptr)       // 在初始化列表中初始化为nullptr

  22.     , last_distance_cm_(0)

  23.     , last_temperature_c_(0.0f)

  24. {

  25.     // 初始化各硬件组件

  26.     InitializeI2c();

  27.     InitializeIoExpander();

  28.     InitializeSpi();

  29.     InitializeIli9341Display();

  30.     InitializeButtons();

  31.     InitializeIot();

  32.     InitializeCamera();

  33.     servo.Initialize();

  34.     servo.InitializeTools();

  35.     

  36.     // 新增传感器初始化

  37.     InitializeSensors();

  38.     

  39.     ESP_LOGI(TAG, "Df_K10Board initialized with URM09 sensor support");

  40. }

  41. 

  42. // ===================== 析构函数实现 =====================

  43. // 位置：在类实现文件的析构函数部分

  44. Df_K10Board::~Df_K10Board() {

  45.     // 清理URM09传感器资源

  46.     if (urm09_sensor_) {

  47.         delete urm09_sensor_;

  48.         urm09_sensor_ = nullptr;

  49.         ESP_LOGI(TAG, "URM09 sensor resources cleaned up");

  50.     }

  51.     

  52.     // 其他资源清理...

  53. }

  54. 

  55. // ===================== 新增传感器初始化函数 =====================

  56. /**

  57.  * 初始化所有传感器

  58.  * 功能：初始化URM09超声波传感器，配置测量模式

  59.  * 注意：需要在I2C总线初始化之后调用

  60.  */

  61. void Df_K10Board::InitializeSensors() {

  62.     ESP_LOGI(TAG, "Initializing sensors...");

  63.     

  64.     // 确保 I2C 总线已初始化

  65.     if (!i2c_bus_) {

  66.         ESP_LOGE(TAG, "I2C bus not initialized before sensor init");

  67.         return;

  68.     }

  69.     

  70.     // 创建URM09传感器实例

  71.     // 参数：I2C总线指针，设备地址（默认为0x11）

  72.     urm09_sensor_ = new DFRobot_URM09(i2c_bus_, 0x11);

  73.     

  74.     if (urm09_sensor_->begin()) {

  75.         // 配置传感器模式：

  76.         // 测量范围：500cm，测量模式：自动

  77.         urm09_sensor_->setModeRange(MEASURE_RANG_500, MEASURE_MODE_AUTOMATIC);

  78.         ESP_LOGI(TAG, "URM09 sensor initialized successfully");

  79.         

  80.         // 读取初始值

  81.         last_distance_cm_ = urm09_sensor_->getDistance();

  82.         last_temperature_c_ = urm09_sensor_->getTemperature();

  83.         ESP_LOGI(TAG, "Initial distance: %d cm, temperature: %.1f C", 

  84.                 last_distance_cm_, last_temperature_c_);

  85.     } else {

  86.         ESP_LOGE(TAG, "Failed to initialize URM09 sensor");

  87.         delete urm09_sensor_;

  88.         urm09_sensor_ = nullptr;

  89.     }

  90. }

  91. 

  92. // ===================== 实现 GetSensorData 函数 =====================

  93. /**

  94.  * 获取传感器数据的字符串表示

  95.  * 功能：读取URM09传感器的距离和温度数据，并格式化为字符串

  96.  * 返回值：包含距离和温度信息的字符串，格式为"当前距离为X厘米，环境温度为Y摄氏度。"

  97.  *        如果传感器未初始化或数据无效，返回相应的错误信息

  98.  * 覆盖：此函数覆盖了基类 Board 中的 GetSensorData() 虚函数

  99.  */

  100. std::string Df_K10Board::GetSensorData() {

  101.     // 检查传感器是否已初始化

  102.     if (!urm09_sensor_) {

  103.         ESP_LOGW(TAG, "URM09 sensor not initialized");

  104.         return "传感器未初始化";

  105.     }

  106.     

  107.     // 读取最新传感器数据

  108.     last_distance_cm_ = urm09_sensor_->getDistance();

  109.     last_temperature_c_ = urm09_sensor_->getTemperature();

  110.     

  111.     ESP_LOGI(TAG, "Sensor reading - Distance: %d cm, Temperature: %.1f C", 

  112.             last_distance_cm_, last_temperature_c_);

  113.     

  114.     // 检查数据有效性

  115.     if (last_distance_cm_ < 0) {

  116.         ESP_LOGW(TAG, "Invalid distance reading: %d cm", last_distance_cm_);

  117.         return "距离数据无效（负值）";

  118.     }

  119.     

  120.     if (last_distance_cm_ > 500) {  // 超出传感器量程

  121.         ESP_LOGW(TAG, "Distance out of range: %d cm", last_distance_cm_);

  122.         return "距离超出量程（超过500厘米）";

  123.     }

  124.     

  125.     // 格式化为中文描述字符串

  126.     char buffer[128];

  127.     snprintf(buffer, sizeof(buffer),

  128.              "当前距离为%d厘米，环境温度为%.1f摄氏度。",

  129.              last_distance_cm_, last_temperature_c_);

  130.     

  131.     return std::string(buffer);

  132. }

复制代码
【360舵机控制】
CMakeLists.txt 文件修改,修改位置：在 CMakeLists.txt 的源文件列表部分
  1. set(SOURCES

  2. "boards/df-k10/servo_controller.cc" # 新增：360舵机驱动

  3.     # ... 其他源文件 ...

  4. )
复制代码
360舵机servo_controller.h库文件内容：
  1. #ifndef __SERVO_CONTROLLER_H__

  2. #define __SERVO_CONTROLLER_H__

  3. 

  4. #include <driver/ledc.h>

  5. #include <driver/gpio.h>

  6. #include <esp_log.h>

  7. #include <freertos/FreeRTOS.h>

  8. #include <freertos/task.h>

  9. #include <freertos/queue.h>

  10. #include <functional>

  11. #include "config.h"

  12. #include "mcp_server.h"

  13. 

  14. class ServoController {

  15. public:

  16.     ServoController(gpio_num_t servo_pin);

  17.     ~ServoController();

  18. 

  19.     // 基本控制方法

  20.     bool Initialize();

  21.     void InitializeTools();  // 初始化MCP工具

  22.     

  23.     // 360度舵机控制方法

  24.     void SetSpeed(int speed);                   // 设置速度 (-100到100)

  25.     void RotateContinuous(int speed);           // 持续旋转

  26.     void RotateForTime(int speed, int duration_ms);  // 旋转指定时间

  27.     void RotateForDegrees(int speed, int degrees);   // 旋转指定角度（估算）

  28.     void Stop();

  29.     void Brake();                               // 刹车（保持当前位置）

  30.     

  31.     // 状态查询

  32.     int GetCurrentSpeed() const { return current_speed_; }

  33.     bool IsMoving() const { return is_moving_; }

  34.     bool IsRotating() const { return is_rotating_; }

  35.     

  36.     // 设置回调函数

  37.     void SetOnMoveCompleteCallback(std::function<void()> callback) {

  38.         on_move_complete_callback_ = callback;

  39.     }

  40. 

  41. private:

  42.     // 硬件相关

  43.     gpio_num_t servo_pin_;

  44.     ledc_channel_t ledc_channel_;

  45.     ledc_timer_t ledc_timer_;

  46.     

  47.     // 状态变量

  48.     int current_speed_;

  49.     bool is_moving_;

  50.     bool is_rotating_;

  51.     bool stop_requested_;

  52.     

  53.     // 校准参数

  54.     float calibration_factor_;      // 校准因子，调整旋转角度与实际角度关系

  55.     float speed_to_angle_per_sec_;  // 速度到角度/秒的映射

  56.     

  57.     // 任务和队列

  58.     TaskHandle_t servo_task_handle_;

  59.     QueueHandle_t command_queue_;

  60.     

  61.     // 回调函数

  62.     std::function<void()> on_move_complete_callback_;

  63.     

  64.     // 命令类型

  65.     enum CommandType {

  66.         CMD_SET_SPEED,          // 设置速度

  67.         CMD_ROTATE_CONTINUOUS,  // 持续旋转

  68.         CMD_ROTATE_TIME,        // 定时旋转

  69.         CMD_ROTATE_DEGREES,     // 旋转指定角度

  70.         CMD_STOP,

  71.         CMD_BRAKE

  72.     };

  73.     

  74.     // 命令结构

  75.     struct ServoCommand {

  76.         CommandType type;

  77.         int param1;  // 速度

  78.         int param2;  // 持续时间(ms)或角度(degrees)

  79.         int param3;  // 备用

  80.     };

  81.     

  82.     // 私有方法

  83.     void WriteSpeed(int speed);

  84.     uint32_t SpeedToCompare(int speed);

  85.     bool IsValidSpeed(int speed) const;

  86.     int ConstrainSpeed(int speed) const;

  87.     

  88.     // 校准方法

  89.     void CalibrateSpeed(int target_speed, int measured_time_ms, int measured_degrees);

  90.     

  91.     // 任务函数

  92.     static void ServoTask(void* parameter);

  93.     void ProcessCommands();

  94.     void ExecuteSetSpeed(int speed);

  95.     void ExecuteRotateContinuous(int speed);

  96.     void ExecuteRotateForTime(int speed, int duration_ms);

  97.     void ExecuteRotateForDegrees(int speed, int degrees);

  98. };

  99. 

  100. #endif // __SERVO_CONTROLLER_H__
复制代码
360舵机库文件servo_controller.cc内容：
  1. #include "servo_controller.h"

  2. #include <esp_log.h>

  3. #include <cmath>

  4. 

  5. #define TAG "ServoController"

  6. 

  7. ServoController::ServoController(gpio_num_t servo_pin)

  8.     : servo_pin_(servo_pin)

  9.     , current_speed_(0)

  10.     , is_moving_(false)

  11.     , is_rotating_(false)

  12.     , stop_requested_(false)

  13.     , calibration_factor_(1.0f)

  14.     , speed_to_angle_per_sec_(6.0f)  // 默认：100速度对应60度/秒

  15.     , servo_task_handle_(nullptr)

  16.     , command_queue_(nullptr)

  17.     , on_move_complete_callback_(nullptr) {

  18.     

  19.     // 根据 GPIO 引脚分配不同的 LEDC 通道

  20.     // 假设最多支持2个舵机

  21.     static int channel_counter = 0;

  22.     switch (channel_counter++) {

  23.         case 0:

  24.             ledc_channel_ = LEDC_CHANNEL_0;

  25.             ledc_timer_ = LEDC_TIMER_0;

  26.             break;

  27.         case 1:

  28.             ledc_channel_ = LEDC_CHANNEL_1;

  29.             ledc_timer_ = LEDC_TIMER_1;

  30.             break;

  31.         default:

  32.             ledc_channel_ = LEDC_CHANNEL_2;

  33.             ledc_timer_ = LEDC_TIMER_2;

  34.             break;

  35.     }

  36.     

  37.     ESP_LOGI(TAG, "创建360度舵机控制器，引脚: %d", servo_pin_);

  38. }

  39. 

  40. ServoController::~ServoController() {

  41.     Stop();

  42.     if (servo_task_handle_ != nullptr) {

  43.         vTaskDelete(servo_task_handle_);

  44.     }

  45.     if (command_queue_ != nullptr) {

  46.         vQueueDelete(command_queue_);

  47.     }

  48. }

  49. 

  50. bool ServoController::Initialize() {

  51.     ESP_LOGI(TAG, "初始化360度舵机控制器，引脚: %d", servo_pin_);

  52.     

  53.     // 配置LEDC定时器 (50Hz，14位分辨率)

  54.     ledc_timer_config_t timer_config = {

  55.         .speed_mode = LEDC_LOW_SPEED_MODE,

  56.         .duty_resolution = LEDC_TIMER_14_BIT,

  57.         .timer_num = ledc_timer_,

  58.         .freq_hz = 50, // 50Hz for servo

  59.         .clk_cfg = LEDC_AUTO_CLK

  60.     };

  61.     

  62.     esp_err_t ret = ledc_timer_config(&timer_config);

  63.     if (ret != ESP_OK) {

  64.         ESP_LOGE(TAG, "LEDC定时器配置失败: %s", esp_err_to_name(ret));

  65.         return false;

  66.     }

  67.     

  68.     // 配置LEDC通道

  69.     ledc_channel_config_t channel_config = {

  70.         .gpio_num = servo_pin_,

  71.         .speed_mode = LEDC_LOW_SPEED_MODE,

  72.         .channel = ledc_channel_,

  73.         .intr_type = LEDC_INTR_DISABLE,

  74.         .timer_sel = ledc_timer_,

  75.         .duty = 0,

  76.         .hpoint = 0

  77.     };

  78.     

  79.     ret = ledc_channel_config(&channel_config);

  80.     if (ret != ESP_OK) {

  81.         ESP_LOGE(TAG, "LEDC通道配置失败: %s", esp_err_to_name(ret));

  82.         return false;

  83.     }

  84.     

  85.     // 创建命令队列

  86.     command_queue_ = xQueueCreate(10, sizeof(ServoCommand));

  87.     if (command_queue_ == nullptr) {

  88.         ESP_LOGE(TAG, "创建命令队列失败");

  89.         return false;

  90.     }

  91.     

  92.     // 创建舵机控制任务

  93.     BaseType_t task_ret = xTaskCreate(

  94.         ServoTask,

  95.         "servo_task",

  96.         4096,

  97.         this,

  98.         5,

  99.         &servo_task_handle_

  100.     );

  101.     

  102.     if (task_ret != pdPASS) {

  103.         ESP_LOGE(TAG, "创建舵机任务失败");

  104.         return false;

  105.     }

  106.     

  107.     // 设置初始速度（停止）

  108.     WriteSpeed(0);

  109.     

  110.     ESP_LOGI(TAG, "360度舵机控制器初始化成功");

  111.     return true;

  112. }

  113. 

  114. void ServoController::InitializeTools() {

  115.     auto& mcp_server = McpServer::GetInstance();

  116.     ESP_LOGI(TAG, "开始注册360度舵机MCP工具...");

  117. 

  118.     // 设置速度

  119.     mcp_server.AddTool("self.servo.set_speed",

  120.                        "设置360度舵机旋转速度。speed: 速度值(-100到100，0=停止，负值=逆时针，正值=顺时针)",

  121.                        PropertyList({Property("speed", kPropertyTypeInteger, 0, -100, 100)}),

  122.                        [this](const PropertyList& properties) -> ReturnValue {

  123.                            int speed = properties["speed"].value<int>();

  124.                            SetSpeed(speed);

  125.                            return "舵机速度设置为 " + std::to_string(speed) + " (0-停止，负-逆时针，正-顺时针)";

  126.                        });

  127. 

  128.     // 持续旋转

  129.     mcp_server.AddTool("self.servo.rotate_continuous",

  130.                        "360度舵机持续旋转。speed: 速度值(-100到100)",

  131.                        PropertyList({Property("speed", kPropertyTypeInteger, 50, -100, 100)}),

  132.                        [this](const PropertyList& properties) -> ReturnValue {

  133.                            int speed = properties["speed"].value<int>();

  134.                            RotateContinuous(speed);

  135.                            return "舵机开始持续旋转，速度: " + std::to_string(speed);

  136.                        });

  137. 

  138.     // 定时旋转

  139.     mcp_server.AddTool("self.servo.rotate_timed",

  140.                        "360度舵机旋转指定时间。speed: 速度值(-100到100); duration_ms: 持续时间(毫秒)",

  141.                        PropertyList({Property("speed", kPropertyTypeInteger, 50, -100, 100),

  142.                                      Property("duration_ms", kPropertyTypeInteger, 1000, 100, 30000)}),

  143.                        [this](const PropertyList& properties) -> ReturnValue {

  144.                            int speed = properties["speed"].value<int>();

  145.                            int duration = properties["duration_ms"].value<int>();

  146.                            RotateForTime(speed, duration);

  147.                            return "舵机旋转 " + std::to_string(duration) + "ms，速度: " + std::to_string(speed);

  148.                        });

  149. 

  150.     // 旋转指定角度（估算）

  151.     mcp_server.AddTool("self.servo.rotate_degrees",

  152.                        "360度舵机旋转指定角度（估算）。speed: 速度值(30-100或-30--100); degrees: 旋转角度",

  153.                        PropertyList({Property("speed", kPropertyTypeInteger, 60, -100, 100),

  154.                                      Property("degrees", kPropertyTypeInteger, 90, 1, 3600)}),

  155.                        [this](const PropertyList& properties) -> ReturnValue {

  156.                            int speed = properties["speed"].value<int>();

  157.                            int degrees = properties["degrees"].value<int>();

  158.                            RotateForDegrees(speed, degrees);

  159.                            return "舵机旋转 " + std::to_string(degrees) + "度，速度: " + std::to_string(speed);

  160.                        });

  161. 

  162.     // 停止舵机

  163.     mcp_server.AddTool("self.servo.stop",

  164.                        "立即停止360度舵机运动",

  165.                        PropertyList(),

  166.                        [this](const PropertyList& properties) -> ReturnValue {

  167.                            Stop();

  168.                            return "舵机已停止";

  169.                        });

  170. 

  171.     // 刹车（保持当前位置）

  172.     mcp_server.AddTool("self.servo.brake",

  173.                        "360度舵机刹车（保持当前位置）",

  174.                        PropertyList(),

  175.                        [this](const PropertyList& properties) -> ReturnValue {

  176.                            Brake();

  177.                            return "舵机已刹车";

  178.                        });

  179. 

  180.     // 获取舵机状态

  181.     mcp_server.AddTool("self.servo.get_status",

  182.                        "获取360度舵机当前状态",

  183.                        PropertyList(),

  184.                        [this](const PropertyList& properties) -> ReturnValue {

  185.                            int speed = GetCurrentSpeed();

  186.                            bool moving = IsMoving();

  187.                            bool rotating = IsRotating();

  188. 

  189.                            std::string status = "{"speed":" + std::to_string(speed) +

  190.                                               ","moving":" + (moving ? "true" : "false") +

  191.                                               ","rotating":" + (rotating ? "true" : "false") + "}";

  192.                            return status;

  193.                        });

  194. 

  195.     // 校准舵机（高级功能）

  196.     mcp_server.AddTool("self.servo.calibrate",

  197.                        "校准360度舵机速度映射。target_speed: 测试速度; measured_time_ms: 测量时间; measured_degrees: 测量角度",

  198.                        PropertyList({Property("target_speed", kPropertyTypeInteger, 100, -100, 100),

  199.                                      Property("measured_time_ms", kPropertyTypeInteger, 1000, 100, 10000),

  200.                                      Property("measured_degrees", kPropertyTypeInteger, 360, 1, 7200)}),

  201.                        [this](const PropertyList& properties) -> ReturnValue {

  202.                            int target_speed = properties["target_speed"].value<int>();

  203.                            int measured_time = properties["measured_time_ms"].value<int>();

  204.                            int measured_degrees = properties["measured_degrees"].value<int>();

  205.                            CalibrateSpeed(target_speed, measured_time, measured_degrees);

  206.                            return "舵机校准完成，新校准因子: " + std::to_string(calibration_factor_);

  207.                        });

  208. 

  209.     ESP_LOGI(TAG, "360度舵机MCP工具注册完成");

  210. }

  211. 

  212. void ServoController::SetSpeed(int speed) {

  213.     if (!IsValidSpeed(speed)) {

  214.         ESP_LOGW(TAG, "无效速度: %d，将限制在有效范围内", speed);

  215.         speed = ConstrainSpeed(speed);

  216.     }

  217.     

  218.     ServoCommand cmd = {CMD_SET_SPEED, speed, 0, 0};

  219.     xQueueSend(command_queue_, &cmd, portMAX_DELAY);

  220. }

  221. 

  222. void ServoController::RotateContinuous(int speed) {

  223.     speed = ConstrainSpeed(speed);

  224.     ServoCommand cmd = {CMD_ROTATE_CONTINUOUS, speed, 0, 0};

  225.     xQueueSend(command_queue_, &cmd, portMAX_DELAY);

  226. }

  227. 

  228. void ServoController::RotateForTime(int speed, int duration_ms) {

  229.     if (duration_ms <= 0) {

  230.         ESP_LOGW(TAG, "持续时间必须大于0");

  231.         return;

  232.     }

  233.     

  234.     speed = ConstrainSpeed(speed);

  235.     ServoCommand cmd = {CMD_ROTATE_TIME, speed, duration_ms, 0};

  236.     xQueueSend(command_queue_, &cmd, portMAX_DELAY);

  237. }

  238. 

  239. void ServoController::RotateForDegrees(int speed, int degrees) {

  240.     if (degrees <= 0) {

  241.         ESP_LOGW(TAG, "旋转角度必须大于0");

  242.         return;

  243.     }

  244.     

  245.     speed = ConstrainSpeed(speed);

  246.     ServoCommand cmd = {CMD_ROTATE_DEGREES, speed, degrees, 0};

  247.     xQueueSend(command_queue_, &cmd, portMAX_DELAY);

  248. }

  249. 

  250. void ServoController::Stop() {

  251.     stop_requested_ = true;

  252.     ServoCommand cmd = {CMD_STOP, 0, 0, 0};

  253.     xQueueSend(command_queue_, &cmd, 0); // 不等待，立即发送停止命令

  254. }

  255. 

  256. void ServoController::Brake() {

  257.     ServoCommand cmd = {CMD_BRAKE, 0, 0, 0};

  258.     xQueueSend(command_queue_, &cmd, portMAX_DELAY);

  259. }

  260. 

  261. void ServoController::WriteSpeed(int speed) {

  262.     speed = ConstrainSpeed(speed);

  263.     uint32_t compare_value = SpeedToCompare(speed);

  264.     ledc_set_duty(LEDC_LOW_SPEED_MODE, ledc_channel_, compare_value);

  265.     ledc_update_duty(LEDC_LOW_SPEED_MODE, ledc_channel_);

  266.     current_speed_ = speed;

  267.     

  268.     ESP_LOGD(TAG, "设置速度: %d, PWM占空比: %lu", speed, compare_value);

  269. }

  270. 

  271. uint32_t ServoController::SpeedToCompare(int speed) {

  272.     // 360度舵机速度控制：

  273.     // 速度范围：-100 到 100

  274.     // 脉冲宽度范围：1.0ms 到 2.0ms

  275.     // -100: 1.0ms (逆时针全速)

  276.     // 0: 1.5ms (停止)

  277.     // 100: 2.0ms (顺时针全速)

  278.     

  279.     // 将速度映射到脉冲宽度

  280.     float pulse_width_ms;

  281.     if (speed == 0) {

  282.         pulse_width_ms = 1.5f;  // 停止

  283.     } else if (speed > 0) {

  284.         // 顺时针：1.5ms 到 2.0ms

  285.         pulse_width_ms = 1.5f + (speed / 100.0f) * 0.5f;

  286.     } else {

  287.         // 逆时针：1.0ms 到 1.5ms

  288.         pulse_width_ms = 1.5f + (speed / 100.0f) * 0.5f;

  289.     }

  290.     

  291.     // 确保在有效范围内

  292.     if (pulse_width_ms < 1.0f) pulse_width_ms = 1.0f;

  293.     if (pulse_width_ms > 2.0f) pulse_width_ms = 2.0f;

  294.     

  295.     float duty_cycle = pulse_width_ms / 20.0f;  // 20ms周期

  296.     uint32_t compare_value = (uint32_t)(duty_cycle * 16383); // 14-bit resolution (2^14 - 1)

  297.     

  298.     return compare_value;

  299. }

  300. 

  301. bool ServoController::IsValidSpeed(int speed) const {

  302.     return speed >= -100 && speed <= 100;

  303. }

  304. 

  305. int ServoController::ConstrainSpeed(int speed) const {

  306.     if (speed < -100) return -100;

  307.     if (speed > 100) return 100;

  308.     return speed;

  309. }

  310. 

  311. void ServoController::CalibrateSpeed(int target_speed, int measured_time_ms, int measured_degrees) {

  312.     // 计算实际的角度/秒

  313.     float actual_degrees_per_sec = (measured_degrees * 1000.0f) / measured_time_ms;

  314.     

  315.     // 计算校准因子

  316.     calibration_factor_ = actual_degrees_per_sec / (abs(target_speed) * speed_to_angle_per_sec_ / 100.0f);

  317.     

  318.     // 更新速度到角度/秒的映射

  319.     speed_to_angle_per_sec_ = (abs(target_speed) * 6.0f * calibration_factor_) / 100.0f;

  320.     

  321.     ESP_LOGI(TAG, "校准完成: 速度=%d, 时间=%dms, 角度=%d度, 校准因子=%.3f",

  322.              target_speed, measured_time_ms, measured_degrees, calibration_factor_);

  323.     ESP_LOGI(TAG, "新的速度-角度映射: %.2f 度/秒 在 100速度", speed_to_angle_per_sec_ * 100);

  324. }

  325. 

  326. void ServoController::ServoTask(void* parameter) {

  327.     ServoController* controller = static_cast<ServoController*>(parameter);

  328.     controller->ProcessCommands();

  329. }

  330. 

  331. void ServoController::ProcessCommands() {

  332.     ServoCommand cmd;

  333.     

  334.     while (true) {

  335.         if (xQueueReceive(command_queue_, &cmd, pdMS_TO_TICKS(100)) == pdTRUE) {

  336.             if (stop_requested_ && cmd.type != CMD_STOP) {

  337.                 continue; // 忽略非停止命令

  338.             }

  339.             

  340.             switch (cmd.type) {

  341.                 case CMD_SET_SPEED:

  342.                     ExecuteSetSpeed(cmd.param1);

  343.                     break;

  344.                     

  345.                 case CMD_ROTATE_CONTINUOUS:

  346.                     ExecuteRotateContinuous(cmd.param1);

  347.                     break;

  348.                     

  349.                 case CMD_ROTATE_TIME:

  350.                     ExecuteRotateForTime(cmd.param1, cmd.param2);

  351.                     break;

  352.                     

  353.                 case CMD_ROTATE_DEGREES:

  354.                     ExecuteRotateForDegrees(cmd.param1, cmd.param2);

  355.                     break;

  356.                     

  357.                 case CMD_STOP:

  358.                     is_moving_ = false;

  359.                     is_rotating_ = false;

  360.                     stop_requested_ = false;

  361.                     WriteSpeed(0);

  362.                     ESP_LOGI(TAG, "舵机停止");

  363.                     break;

  364.                     

  365.                 case CMD_BRAKE:

  366.                     // 刹车：设置速度到0并保持当前位置

  367.                     is_moving_ = false;

  368.                     is_rotating_ = false;

  369.                     WriteSpeed(0);

  370.                     ESP_LOGI(TAG, "舵机刹车");

  371.                     break;

  372.             }

  373.         }

  374.     }

  375. }

  376. 

  377. void ServoController::ExecuteSetSpeed(int speed) {

  378.     ESP_LOGI(TAG, "设置舵机速度: %d", speed);

  379.     is_moving_ = (speed != 0);

  380.     is_rotating_ = false;

  381.     WriteSpeed(speed);

  382. 

  383.     if (on_move_complete_callback_) {

  384.         on_move_complete_callback_();

  385.     }

  386. }

  387. 

  388. void ServoController::ExecuteRotateContinuous(int speed) {

  389.     ESP_LOGI(TAG, "持续旋转，速度: %d", speed);

  390.     is_moving_ = true;

  391.     is_rotating_ = true;

  392.     WriteSpeed(speed);

  393.     

  394.     // 持续旋转直到收到停止命令

  395.     while (!stop_requested_) {

  396.         vTaskDelay(pdMS_TO_TICKS(100));

  397.     }

  398.     

  399.     if (!stop_requested_) {

  400.         WriteSpeed(0);

  401.         is_moving_ = false;

  402.         is_rotating_ = false;

  403.         

  404.         if (on_move_complete_callback_) {

  405.             on_move_complete_callback_();

  406.         }

  407.     }

  408. }

  409. 

  410. void ServoController::ExecuteRotateForTime(int speed, int duration_ms) {

  411.     ESP_LOGI(TAG, "定时旋转，速度: %d，时间: %dms", speed, duration_ms);

  412.     is_moving_ = true;

  413.     is_rotating_ = true;

  414.     WriteSpeed(speed);

  415.     

  416.     // 计算需要等待的tick数

  417.     TickType_t start_tick = xTaskGetTickCount();

  418.     TickType_t delay_ticks = pdMS_TO_TICKS(duration_ms);

  419.     

  420.     // 等待指定时间，但可以提前被停止

  421.     while ((xTaskGetTickCount() - start_tick) < delay_ticks && !stop_requested_) {

  422.         vTaskDelay(pdMS_TO_TICKS(10));

  423.     }

  424.     

  425.     // 停止舵机

  426.     if (!stop_requested_) {

  427.         WriteSpeed(0);

  428.     }

  429.     

  430.     is_moving_ = false;

  431.     is_rotating_ = false;

  432.     

  433.     if (on_move_complete_callback_ && !stop_requested_) {

  434.         on_move_complete_callback_();

  435.     }

  436. }

  437. 

  438. void ServoController::ExecuteRotateForDegrees(int speed, int degrees) {

  439.     ESP_LOGI(TAG, "旋转指定角度，速度: %d，角度: %d度", speed, degrees);

  440.     

  441.     // 计算所需时间（基于校准参数）

  442.     float speed_percentage = abs(speed) / 100.0f;

  443.     float degrees_per_sec = speed_to_angle_per_sec_ * 100 * speed_percentage * calibration_factor_;

  444.     int duration_ms = (int)((degrees / degrees_per_sec) * 1000);

  445.     

  446.     ESP_LOGI(TAG, "预计旋转时间: %dms (%.1f 度/秒)", duration_ms, degrees_per_sec);

  447.     

  448.     is_moving_ = true;

  449.     is_rotating_ = true;

  450.     WriteSpeed(speed);

  451.     

  452.     // 等待计算出的时间

  453.     TickType_t start_tick = xTaskGetTickCount();

  454.     TickType_t delay_ticks = pdMS_TO_TICKS(duration_ms);

  455.     

  456.     while ((xTaskGetTickCount() - start_tick) < delay_ticks && !stop_requested_) {

  457.         vTaskDelay(pdMS_TO_TICKS(10));

  458.     }

  459.     

  460.     // 停止舵机

  461.     if (!stop_requested_) {

  462.         WriteSpeed(0);

  463.     }

  464.     

  465.     is_moving_ = false;

  466.     is_rotating_ = false;

  467.     

  468.     if (on_move_complete_callback_ && !stop_requested_) {

  469.         on_move_complete_callback_();

  470.     }

  471. }
复制代码
df_k10_board.cc文件中新增
  1. #include "servo_controller.h"

  2. // 创建360度舵机控制器

  3. ServoController servo(SERVO_PIN_HORIZONTAL);

  4. class Df_K10Board : public WifiBoard {

  5. private:

  6. Df_K10Board(): urm09_sensor_(nullptr)  // 在初始化列表中初始化为nullptr

  7.     , last_distance_cm_(0)

  8.     , last_temperature_c_(0.0f) {

  9.         // 原初始化各硬件组件

  10.         // 新增：舵机初始化

  11.        servo.Initialize();

  12.        servo.InitializeTools();

  13.      }      

  14. }
复制代码




回复

使用道具 举报

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

本版积分规则

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

硬件清单

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

楼主的其它帖子

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

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

mail