ESP-ADF外设子系统深度解析：esp_peripherals组件架构与核心设计（核心API详解之单个外设管理）

单个外设管理API

esp_periph_create

功能描述：创建一个新的外设实例。

函数原型：

/*** @brief      创建一个新的外设实例* * @details    分配内存并初始化一个新的外设结构。这个函数仅创建外设的基本结构，*             不会设置外设的功能函数。要完成外设的创建，还需要调用 esp_periph_set_function 设置*             外设的初始化、运行和销毁函数，然后调用 esp_periph_start 将外设添加到外设集合中。* * @param[in]  periph_id  外设 ID，可以是预定义的 ID 或通过 esp_periph_alloc_periph_id 分配的 ID* @param[in]  tag        外设标签，用于调试和识别外设，如果为 NULL，将使用默认标签 "periph"* * @return     成功：返回外设句柄*             失败：返回 NULL（内存分配失败时）*/
esp_periph_handle_t esp_periph_create(int periph_id, const char *tag)
{esp_periph_handle_t new_entry = audio_calloc(1, sizeof(struct esp_periph));AUDIO_MEM_CHECK(TAG, new_entry, return NULL);if (tag) {new_entry->tag = audio_strdup(tag);} else {new_entry->tag = audio_strdup("periph");}AUDIO_MEM_CHECK(TAG, new_entry->tag, {audio_free(new_entry);return NULL;})new_entry->state = PERIPH_STATE_INIT;new_entry->periph_id = periph_id;return new_entry;
}

参数说明：

• periph_id：外设 ID，可以是预定义的 ID 或通过 esp_periph_alloc_periph_id 分配的 ID
• tag：外设标签，用于调试和识别外设，如果为 NULL，将使用默认标签 “periph”

返回值：

• 成功：返回外设句柄
• 失败：返回 NULL（内存分配失败时）

调用示例：

// 创建外设集合
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);// 使用预定义 ID 创建外设
esp_periph_handle_t gpio_periph = esp_periph_create(PERIPH_ID_GPIO, "gpio");
if (gpio_periph == NULL) {ESP_LOGE(TAG, "Failed to create GPIO peripheral");return;
}// 设置外设函数
esp_periph_set_function(gpio_periph, gpio_init_func, gpio_run_func, gpio_destroy_func);// 启动外设
esp_periph_start(set, gpio_periph);// 或者创建自定义外设
int custom_id;
esp_periph_alloc_periph_id(set, &custom_id);
esp_periph_handle_t custom_periph = esp_periph_create(custom_id, "my_custom_periph");

创建外设时序图：

这个时序图展示了esp_periph_create函数的执行流程，以及完整的外设创建过程，包括创建外设、设置外设函数和启动外设的步骤。

注意：esp_periph_create函数只是创建外设的第一步，完整的外设创建过程还需要设置外设函数和启动外设。外设创建后的初始状态为PERIPH_STATE_INIT，需要通过esp_periph_start函数将外设添加到外设集合中并启动。

esp_periph_set_function

功能描述：设置外设的功能函数，包括初始化、运行和销毁函数。

函数原型：

/*** @brief      设置外设的功能函数* * @details    为外设设置初始化、运行和销毁函数。这些函数定义了外设的行为和生命周期。*             初始化函数在外设启动时调用，运行函数在收到事件时调用，销毁函数在外设停止时调用。*             这些函数应该在调用 esp_periph_start 之前设置。* * @param[in]  periph   外设句柄，通过 esp_periph_create 获得* @param[in]  init     初始化函数，在外设启动时调用* @param[in]  run      运行函数，在收到事件时调用* @param[in]  destroy  销毁函数，在外设停止时调用* * @return     成功：ESP_OK*/
esp_err_t esp_periph_set_function(esp_periph_handle_t periph,esp_periph_func init,esp_periph_run_func run,esp_periph_func destroy)
{periph->init = init;periph->run = run;periph->destroy = destroy;return ESP_OK;
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得
• init：初始化函数，在外设启动时调用
• run：运行函数，在收到事件时调用
• destroy：销毁函数，在外设停止时调用

返回值：

• 成功：返回ESP_OK

函数类型定义：

// 初始化和销毁函数类型
typedef esp_err_t (*esp_periph_func)(esp_periph_handle_t periph);// 运行函数类型
typedef esp_err_t (*esp_periph_run_func)(esp_periph_handle_t periph, audio_event_iface_msg_t *msg);

调用示例：

// 创建外设
esp_periph_handle_t gpio_periph = esp_periph_create(PERIPH_ID_GPIO, "gpio");// 定义外设函数
esp_err_t gpio_init(esp_periph_handle_t periph) {// 初始化 GPIO 外设的代码ESP_LOGI(TAG, "GPIO peripheral initialized");return ESP_OK;
}esp_err_t gpio_run(esp_periph_handle_t periph, audio_event_iface_msg_t *msg) {// 处理 GPIO 事件的代码if (msg->cmd == GPIO_EVENT_BUTTON_PRESSED) {ESP_LOGI(TAG, "Button pressed");}return ESP_OK;
}esp_err_t gpio_destroy(esp_periph_handle_t periph) {// 清理 GPIO 外设资源的代码ESP_LOGI(TAG, "GPIO peripheral destroyed");return ESP_OK;
}// 设置外设函数
esp_periph_set_function(gpio_periph, gpio_init, gpio_run, gpio_destroy);// 启动外设
esp_periph_start(set, gpio_periph);

设置外设函数时序图：

这个时序图展示了esp_periph_set_function函数的执行流程，以及外设函数在外设生命周期中的调用时机。

注意：外设函数定义了外设的行为和生命周期。初始化函数应该设置外设的初始状态和资源，运行函数应该处理外设的事件，销毁函数应该清理外设的资源。这三个函数都是可选的，可以设置为 NULL，但对于大多数外设，至少应该提供初始化和运行函数。

esp_periph_start

功能描述：启动外设并将其添加到外设集合中。

函数原型：

/*** @brief      启动外设并将其添加到外设集合中* * @details    将外设添加到外设集合的链表中，并注册外设的事件处理函数。*             如果外设集合处于非运行状态且配置了任务栈，则创建并启动外设任务。*             如果外设已经存在于外设集合中，则只是启用该外设。* * @param[in]  periph_set_handle  外设集合句柄* @param[in]  periph             要启动的外设句柄* * @return     成功：ESP_OK*             失败：ESP_FAIL（当外设集合无效或创建任务失败时）*/
esp_err_t esp_periph_start(esp_periph_set_handle_t periph_set_handle, esp_periph_handle_t periph)
{if (periph_set_handle == NULL) {AUDIO_ERROR(TAG, "Peripherals have not been initialized");return ESP_FAIL;}if (esp_periph_set_get_by_id(periph_set_handle, periph->periph_id) != NULL) {ESP_LOGI(TAG, "This peripheral has been added");periph->disabled = false;} else {esp_periph_register_on_events(periph, &periph_set_handle->event_handle);STAILQ_INSERT_TAIL(&periph_set_handle->periph_list, periph, entries);}if (periph_set_handle->run == false && periph_set_handle->task_stack > 0) {periph_set_handle->run = true;if (audio_thread_create(&periph_set_handle->audio_thread,"esp_periph",esp_periph_task,periph_set_handle,periph_set_handle->task_stack,periph_set_handle->task_prio,periph_set_handle->ext_stack,periph_set_handle->task_core) != ESP_OK) {ESP_LOGE(TAG, "Create [%s] task failed", periph->tag);return ESP_FAIL;}}return ESP_OK;
}

参数说明：

• periph_set_handle：外设集合句柄，通过 esp_periph_set_init 获得
• periph：要启动的外设句柄，通过 esp_periph_create 获得

返回值：

• 成功：返回ESP_OK
• 失败：返回ESP_FAIL（当外设集合无效或创建任务失败时）

调用示例：

// 创建外设集合
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);// 创建外设
esp_periph_handle_t button = periph_button_init(&button_cfg);
if (button == NULL) {ESP_LOGE(TAG, "Failed to create button peripheral");return;
}// 启动外设
esp_err_t ret = esp_periph_start(set, button);
if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to start button peripheral");return;
}// 创建并启动另一个外设
esp_periph_handle_t sdcard = periph_sdcard_init(&sdcard_cfg);
esp_periph_start(set, sdcard);

启动外设时序图：

这个时序图展示了esp_periph_start函数的执行流程，包括如何检查外设是否已存在、添加外设到链表以及创建外设任务的过程。

注意：esp_periph_start函数是外设创建过程的最后一步，它将外设添加到外设集合中并启动外设任务。如果外设集合使用任务模式（task_stack > 0），则会创建一个任务来处理外设事件；如果使用无任务模式（task_stack = 0），则需要手动调用esp_periph_set_list_init和esp_periph_set_list_run函数。

esp_periph_stop

功能描述：停止外设的运行。

函数原型：

/*** @brief      停止外设的运行* * @details    通过将外设的 disabled 标志设置为 true 来停止外设的运行。*             这不会从外设集合中移除外设，也不会调用外设的销毁函数，*             只是禁用外设使其不再处理事件。* * @param[in]  periph  要停止的外设句柄* * @return     成功：ESP_OK*/
esp_err_t esp_periph_stop(esp_periph_handle_t periph)
{if (periph) {periph->disabled = true;return ESP_OK;}return ESP_OK;
}

参数说明：

• periph：要停止的外设句柄，通过 esp_periph_create 获得

返回值：

• 成功：返回ESP_OK

调用示例：

// 创建并启动外设
esp_periph_handle_t button = periph_button_init(&button_cfg);
esp_periph_start(set, button);// 使用外设...// 当不再需要按钮外设时停止它
esp_periph_stop(button);// 如果需要再次启用外设，可以再次调用 esp_periph_start
// esp_periph_start(set, button);// 如果需要完全移除外设，可以调用 esp_periph_remove_from_set
// esp_periph_remove_from_set(set, button);

停止外设时序图：

这个时序图展示了esp_periph_stop函数的执行流程，以及外设任务如何处理被禁用的外设。

注意：esp_periph_stop函数只是通过设置外设的 disabled 标志来禁用外设，它不会从外设集合中移除外设，也不会调用外设的销毁函数。如果需要完全移除外设，应该使用esp_periph_remove_from_set函数。如果需要再次启用外设，可以再次调用esp_periph_start函数。

esp_periph_set_data

功能描述：设置外设的用户数据。

函数原型：

/*** @brief      设置外设的用户数据* * @details    将用户指定的数据指针关联到外设上。这个函数允许开发者将任意类型的数据*             与外设关联，便于在外设的回调函数中访问这些数据。* * @param[in]  periph  外设句柄* @param[in]  data    要设置的用户数据指针* * @return     成功：ESP_OK*/
esp_err_t esp_periph_set_data(esp_periph_handle_t periph, void *data)
{periph->periph_data = data;return ESP_OK;
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得
• data：要设置的用户数据指针，可以是任意类型的数据

返回值：

• 成功：返回ESP_OK

调用示例：

// 创建外设
esp_periph_handle_t button = periph_button_init(&button_cfg);// 创建用户数据结构
typedef struct {int button_press_count;bool long_press_detected;void *user_context;
} button_user_data_t;button_user_data_t *user_data = calloc(1, sizeof(button_user_data_t));
if (user_data == NULL) {ESP_LOGE(TAG, "Failed to allocate memory for button user data");return;
}// 初始化用户数据
user_data->button_press_count = 0;
user_data->long_press_detected = false;
user_data->user_context = some_context;// 将用户数据关联到外设
esp_periph_set_data(button, user_data);// 启动外设
esp_periph_start(set, button);// 在外设的运行函数中可以访问用户数据
esp_err_t button_run(esp_periph_handle_t periph, audio_event_iface_msg_t *msg) {button_user_data_t *user_data = (button_user_data_t *)esp_periph_get_data(periph);if (msg->cmd == BUTTON_PRESSED) {user_data->button_press_count++;ESP_LOGI(TAG, "Button pressed %d times", user_data->button_press_count);}return ESP_OK;
}

设置外设数据时序图：

这个时序图展示了esp_periph_set_data函数的执行流程，以及如何在外设的运行函数中访问这些数据。

注意：esp_periph_set_data函数允许开发者将任意类型的数据与外设关联，这在实现复杂的外设行为时非常有用。开发者负责管理这些数据的生命周期，包括在不再需要时释放内存。

esp_periph_get_data

功能描述：获取外设的用户数据。

函数原型：

/*** @brief      获取外设的用户数据* * @details    返回之前通过 esp_periph_set_data 函数设置的用户数据指针。*             这个函数允许开发者在外设的回调函数中访问与外设关联的数据。* * @param[in]  periph  外设句柄* * @return     外设的用户数据指针，如果未设置则返回 NULL*/
void *esp_periph_get_data(esp_periph_handle_t periph)
{return periph->periph_data;
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得

返回值：

• 外设的用户数据指针，如果未设置则返回 NULL

调用示例：

// 在外设的运行函数中获取并使用用户数据
esp_err_t button_run(esp_periph_handle_t periph, audio_event_iface_msg_t *msg) {// 获取用户数据button_user_data_t *user_data = (button_user_data_t *)esp_periph_get_data(periph);if (user_data == NULL) {ESP_LOGE(TAG, "No user data associated with this peripheral");return ESP_FAIL;}// 使用用户数据if (msg->cmd == BUTTON_PRESSED) {user_data->button_press_count++;ESP_LOGI(TAG, "Button pressed %d times", user_data->button_press_count);// 检查是否达到特定条件if (user_data->button_press_count >= 10) {ESP_LOGI(TAG, "Button press count reached threshold");// 执行特定操作...}}return ESP_OK;
}

获取外设数据时序图：

这个时序图展示了esp_periph_get_data函数的执行流程，以及如何在外设的运行函数中获取并使用用户数据。

注意：esp_periph_get_data函数返回的是void*类型的指针，需要开发者自己进行类型转换才能正确使用。在使用前应该始终检查返回值是否为 NULL，以避免空指针引用错误。

esp_periph_get_state

功能描述：获取外设的当前状态。

函数原型：

/*** @brief      获取外设的当前状态* * @details    返回外设的当前状态，可以是初始化、运行中、错误或停止状态。*             这个函数允许开发者检查外设的当前状态，以便进行相应的处理。* * @param[in]  periph  外设句柄* * @return     外设的当前状态（esp_periph_state_t类型）*/
esp_periph_state_t esp_periph_get_state(esp_periph_handle_t periph)
{return periph->state;
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得

返回值：

• 外设的当前状态（esp_periph_state_t类型），可能的值包括：
  • PERIPH_STATE_INIT：外设处于初始化状态
  • PERIPH_STATE_RUNNING：外设处于运行状态
  • PERIPH_STATE_ERROR：外设处于错误状态
  • PERIPH_STATE_STOPPED：外设处于停止状态

调用示例：

// 创建并启动外设
esp_periph_handle_t button = periph_button_init(&button_cfg);
esp_periph_start(set, button);// 检查外设状态
esp_periph_state_t state = esp_periph_get_state(button);
switch (state) {case PERIPH_STATE_INIT:ESP_LOGI(TAG, "Button peripheral is in initialization state");break;case PERIPH_STATE_RUNNING:ESP_LOGI(TAG, "Button peripheral is running");break;case PERIPH_STATE_ERROR:ESP_LOGE(TAG, "Button peripheral encountered an error");// 处理错误情况...break;case PERIPH_STATE_STOPPED:ESP_LOGI(TAG, "Button peripheral is stopped");break;default:ESP_LOGE(TAG, "Unknown peripheral state: %d", state);break;
}// 在外设的运行函数中也可以检查状态
esp_err_t button_run(esp_periph_handle_t periph, audio_event_iface_msg_t *msg) {if (esp_periph_get_state(periph) != PERIPH_STATE_RUNNING) {ESP_LOGW(TAG, "Button peripheral is not in running state");return ESP_FAIL;}// 正常处理事件...return ESP_OK;
}

获取外设状态时序图：

这个时序图展示了esp_periph_get_state函数的执行流程，以及应用程序如何根据外设状态进行相应处理。

注意：外设状态是由外设子系统内部管理的，开发者不应直接修改外设的状态。外设初始创建时处于PERIPH_STATE_INIT状态，在初始化函数成功执行后变为PERIPH_STATE_RUNNING状态，如果初始化失败则变为PERIPH_STATE_ERROR状态。

esp_periph_get_id

功能描述：获取外设的 ID。

函数原型：

/*** @brief      获取外设的 ID* * @details    返回外设的唯一标识 ID。每个外设都有一个唯一的 ID，可以是预定义的 ID*             或通过 esp_periph_alloc_periph_id 分配的自定义 ID。* * @param[in]  periph  外设句柄* * @return     外设的 ID（esp_periph_id_t 类型）*/
esp_periph_id_t esp_periph_get_id(esp_periph_handle_t periph)
{return periph->periph_id;
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得

返回值：

• 外设的 ID（esp_periph_id_t 类型）

调用示例：

// 创建外设
esp_periph_handle_t button = periph_button_init(&button_cfg);
esp_periph_start(set, button);// 获取外设 ID
esp_periph_id_t id = esp_periph_get_id(button);
ESP_LOGI(TAG, "Button peripheral ID: %d", id);// 使用 ID 从外设集合中获取外设
esp_periph_handle_t found_periph = esp_periph_set_get_by_id(set, id);
if (found_periph != NULL) {ESP_LOGI(TAG, "Found peripheral with ID %d", id);
}

获取外设 ID 时序图：

这个时序图展示了esp_periph_get_id函数的执行流程，以及如何使用获取到的 ID 来查找外设。

注意：外设 ID 是外设的唯一标识，用于在外设集合中查找和识别外设。预定义的外设 ID 定义在 esp_peripherals.h 文件中，而自定义外设 ID 可以通过 esp_periph_alloc_periph_id 函数分配。

esp_periph_set_id

功能描述：设置外设的 ID。

函数原型：

/*** @brief      设置外设的 ID* * @details    修改外设的唯一标识 ID。这个函数允许开发者在运行时更改外设的 ID，*             但应谨慎使用，因为这可能导致 ID 冲突或外设无法通过 ID 被正确识别。* * @param[in]  periph     外设句柄* @param[in]  periph_id  要设置的新 ID* * @return     成功：ESP_OK*/
esp_err_t esp_periph_set_id(esp_periph_handle_t periph, esp_periph_id_t periph_id)
{periph->periph_id = periph_id;return ESP_OK;
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得
• periph_id：要设置的新 ID，可以是预定义的 ID 或通过 esp_periph_alloc_periph_id 分配的 ID

返回值：

• 成功：返回ESP_OK

调用示例：

// 创建外设
esp_periph_handle_t custom_periph = esp_periph_create(PERIPH_ID_UNKNOWN, "custom");// 分配新的 ID
int new_id;
esp_periph_alloc_periph_id(set, &new_id);// 设置外设 ID
esp_periph_set_id(custom_periph, new_id);
ESP_LOGI(TAG, "Custom peripheral ID set to: %d", new_id);// 启动外设
esp_periph_start(set, custom_periph);// 现在可以使用新 ID 查找外设
esp_periph_handle_t found_periph = esp_periph_set_get_by_id(set, new_id);

设置外设 ID 时序图：

这个时序图展示了esp_periph_set_id函数的执行流程，以及如何分配新 ID 并将其设置给外设。

注意：尽管esp_periph_set_id函数允许开发者更改外设的 ID，但应谨慎使用。更改已添加到外设集合中的外设的 ID 可能会导致无法通过 ID 找到该外设。建议在外设添加到外设集合之前设置其 ID。

esp_periph_init

功能描述：手动初始化外设。

函数原型：

/*** @brief      手动初始化外设* * @details    直接调用外设的初始化函数。这个函数通常不需要直接调用，*             因为外设的初始化通常在 esp_periph_start 函数中自动完成。*             只有在特殊情况下，如需要手动控制外设初始化时机时，才需要调用此函数。* * @param[in]  periph  外设句柄* * @return     成功：返回外设初始化函数的返回值*             失败：如果外设没有初始化函数，可能会导致程序崩溃*/
esp_err_t esp_periph_init(esp_periph_handle_t periph)
{return periph->init(periph);
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得

返回值：

• 成功：返回外设初始化函数的返回值，通常是 ESP_OK
• 失败：如果外设初始化失败，返回错误代码，如 ESP_FAIL

调用示例：

// 创建外设
esp_periph_handle_t button = periph_button_init(&button_cfg);// 设置外设函数
esp_periph_set_function(button, button_init, button_run, button_destroy);// 手动初始化外设
esp_err_t ret = esp_periph_init(button);
if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to initialize button peripheral");return;
}// 注意：通常不需要手动初始化，因为 esp_periph_start 会自动完成初始化
// esp_periph_start(set, button);

手动初始化外设时序图：

这个时序图展示了esp_periph_init函数的执行流程，以及如何直接调用外设的初始化函数。

注意：esp_periph_init函数直接调用外设的初始化函数，没有进行空指针检查。因此，在调用此函数前，应确保外设的初始化函数已经设置，否则可能导致程序崩溃。通常情况下，应使用esp_periph_start函数来启动外设，该函数会安全地处理外设的初始化。

esp_periph_run

功能描述：手动运行外设的运行函数。

函数原型：

/*** @brief      手动运行外设的运行函数* * @details    直接调用外设的运行函数，传入 NULL 消息。这个函数通常不需要直接调用，*             因为外设的运行函数通常在外设任务中或通过 esp_periph_set_list_run 函数自动调用。*             只有在特殊情况下，如需要手动触发外设处理时，才需要调用此函数。* * @param[in]  periph  外设句柄* * @return     成功：返回外设运行函数的返回值*             失败：如果外设没有运行函数，可能会导致程序崩溃*/
esp_err_t esp_periph_run(esp_periph_handle_t periph)
{return periph->run(periph, NULL);
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得

返回值：

• 成功：返回外设运行函数的返回值，通常是 ESP_OK
• 失败：如果外设运行失败，返回错误代码，如 ESP_FAIL

调用示例：

// 创建外设
esp_periph_handle_t button = periph_button_init(&button_cfg);// 设置外设函数
esp_periph_set_function(button, button_init, button_run, button_destroy);// 手动初始化外设
esp_periph_init(button);// 手动运行外设
esp_err_t ret = esp_periph_run(button);
if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to run button peripheral");return;
}// 注意：通常不需要手动运行外设，因为外设任务或 esp_periph_set_list_run 会自动调用运行函数

手动运行外设时序图：

这个时序图展示了esp_periph_run函数的执行流程，以及如何直接调用外设的运行函数。

注意：esp_periph_run函数直接调用外设的运行函数，没有进行空指针检查。因此，在调用此函数前，应确保外设的运行函数已经设置，否则可能导致程序崩溃。与正常的外设运行函数调用不同，这里传入的消息参数为 NULL，这意味着外设可能无法正常处理事件。

esp_periph_destroy

功能描述：手动销毁外设。

函数原型：

/*** @brief      手动销毁外设* * @details    直接调用外设的销毁函数。这个函数通常不需要直接调用，*             因为外设的销毁通常在 esp_periph_set_destroy 或 esp_periph_set_list_destroy 函数中自动完成。*             只有在特殊情况下，如需要手动控制外设销毁时机时，才需要调用此函数。* * @param[in]  periph  外设句柄* * @return     成功：返回外设销毁函数的返回值*             失败：如果外设没有销毁函数，可能会导致程序崩溃*/
esp_err_t esp_periph_destroy(esp_periph_handle_t periph)
{return periph->destroy(periph);
}

参数说明：

• periph：外设句柄，通过 esp_periph_create 获得

返回值：

• 成功：返回外设销毁函数的返回值，通常是 ESP_OK
• 失败：如果外设销毁失败，返回错误代码，如 ESP_FAIL

调用示例：

// 创建外设
esp_periph_handle_t button = periph_button_init(&button_cfg);// 设置外设函数
esp_periph_set_function(button, button_init, button_run, button_destroy);// 使用外设...// 先从外设集合中移除外设
esp_periph_remove_from_set(set, button);// 手动销毁外设
esp_err_t ret = esp_periph_destroy(button);
if (ret != ESP_OK) {ESP_LOGE(TAG, "Failed to destroy button peripheral");return;
}// 释放外设内存
// free(button);  // 注意：外设的内存释放取决于具体实现// 注意：通常不需要手动销毁外设，因为 esp_periph_set_destroy 会自动完成销毁

手动销毁外设时序图：

这个时序图展示了esp_periph_destroy函数的执行流程，以及如何直接调用外设的销毁函数。

注意：esp_periph_destroy函数直接调用外设的销毁函数，没有进行空指针检查。因此，在调用此函数前，应确保外设的销毁函数已经设置，否则可能导致程序崩溃。这个函数只负责调用外设的销毁函数，不会释放外设本身的内存。如果需要完全释放外设资源，还需要手动释放外设的内存。