ESP32(九) BLE GATTS

移动设备可发现ESP的BLE并且连接通讯

• 首先在sdkconfig中打开BT
• 然后在ESPIDF的GATTS例程修改，实现了一个服务，两个特征值，一个值用于发送，一个用于接收
• 理解代码之前先理解蓝牙，具体参考本博客低功耗蓝牙BLE文章

#include "dh_p1_blu_task.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <cJSON.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_bt.h"

#include "esp_gap_ble_api.h"
#include "esp_gatts_api.h"
#include "esp_bt_defs.h"
#include "esp_bt_main.h"
#include "esp_gatt_common_api.h"

#include "sdkconfig.h"
#include "dh_wifi_sta.h"
#include "dh_meter_data.h"
#include "dh_file.h"

#define GATTS_TAG "GATTS"

/*
 * [ycp]:
 * 一个自定义蓝牙广播数据
 * 一个服务，附带两个特征值
 * 使用 Raw 格式
 */

#define GATTS_NUM_HANDLE_TEST_A     7//(3+3+1就是2个特征值，一个特征值就是3+1)
#define PREPARE_BUF_MAX_SIZE 1024

static esp_gatt_char_prop_t rx_property = 0;
static esp_gatt_char_prop_t tx_property = 0;

static bool bluetooth_initialized = false;
static uint8_t adv_config_done = 0;
static bool ble_is_connected = false;
#define adv_config_flag      (1 << 0)
#define scan_rsp_config_flag (1 << 1)
#define CONFIG_SET_RAW_ADV_DATA
#define PROFILE_NUM 1
#define PROFILE_A_APP_ID 0


/*
 * [ycp]:
 * AK 广播参数
 */
static uint8_t raw_adv_data[] = {
        //长度 类型
        0x12, 0xFF,
        //数据
        // 厂商ID（2字节，0xFFFF）
        0xFF, 0xFF,
        // 广播信息版本（1字节，0x02）
        0x02,
        // MAC地址（6字节，大端）
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 实际需替换为设备MAC
        // 绑定状态（1字节，0x00：未绑定，0x01：已绑定，0x02：配对状态）
        0x00,
        // 设备型号（2字节，大端，参考设备型号表）
        0x00, 0x00,
        // 产品代码（4字节，大端）
        0x00, 0x00, 0x00, 0x00,
        // 能力类型（1字节，bitmap）
        0x00
};
static uint8_t raw_scan_rsp_data[] = {
        0x0f, 0x09, 0x45, 0x53, 0x50, 0x5f, 0x47, 0x41, 0x54, 0x54, 0x53, 0x5f, 0x44,
        0x45, 0x4d, 0x4f
};

static esp_bt_uuid_t anker_rx_uuid = {
        .len = ESP_UUID_LEN_128,
        .uuid = {
                .uuid128 = {0x25, 0x20, 0x56, 0x7C, 0x05, 0xCF, 0x6E, 0xB4, 0xC5, 0x41, 0x02, 0x03, 0x02, 0x00, 0x85,
                            0x8C}  // 对应设备RX UUID
        }
};
static esp_bt_uuid_t anker_tx_uuid = {
        .len = ESP_UUID_LEN_128,
        .uuid = {
                .uuid128 = {0x25, 0x20, 0x56, 0x7C, 0x05, 0xCF, 0x6E, 0xB4, 0xC5, 0x41, 0x02, 0x03, 0x03, 0x00, 0x85,
                            0x8C}  // 对应设备TX UUID
        }
};
static esp_bt_uuid_t anker_service_uuid = {
        .len = ESP_UUID_LEN_128,
        .uuid = {
                .uuid128 = {0x25, 0x20, 0x56, 0x7C, 0x05, 0xCF, 0x6E, 0xB4, 0xC5, 0x41, 0x02, 0x03, 0x01, 0x00, 0x85,
                            0x8C}  // 对应图片中的Service uuid
        }
};

static esp_ble_adv_params_t adv_params = {
        .adv_int_min        = 0x20,
        .adv_int_max        = 0x40,
        .adv_type           = ADV_TYPE_IND,
        .own_addr_type      = BLE_ADDR_TYPE_PUBLIC,
        //.peer_addr            =
        //.peer_addr_type       =
        .channel_map        = ADV_CHNL_ALL,
        .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
};

struct gatts_profile_inst {
    esp_gatts_cb_t gatts_cb;
    uint16_t gatts_if;
    uint16_t app_id;
    uint16_t conn_id;
    uint16_t service_handle;
    esp_gatt_srvc_id_t service_id;
    uint16_t rx_char_handle;
    uint16_t tx_char_handle;
    esp_bt_uuid_t char_uuid;
    esp_gatt_perm_t perm;
    esp_gatt_char_prop_t property;
    uint16_t descr_handle;
    esp_bt_uuid_t descr_uuid;
};

typedef struct {
    uint8_t *prepare_buf;
    int prepare_len;
} prepare_type_env_t;


static void
gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);

void
example_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param);

void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param);

esp_err_t ntwcfg_data_parse(char* data,uint8_t len);

// GATT 配置文件，一个文件关联一个服务
static struct gatts_profile_inst gl_profile_tab[PROFILE_NUM] = {
        [PROFILE_A_APP_ID] = {
                .gatts_cb = gatts_profile_a_event_handler,
                .gatts_if = ESP_GATT_IF_NONE,       /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
        },
};


static prepare_type_env_t a_prepare_write_env;


// 连接过程回调
static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
    switch (event) {
        case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
            adv_config_done &= (~adv_config_flag);
            if (adv_config_done == 0) {
                esp_ble_gap_start_advertising(&adv_params);
            }
            break;
        case ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT:
            adv_config_done &= (~scan_rsp_config_flag);
            if (adv_config_done == 0) {
                esp_ble_gap_start_advertising(&adv_params);
            }
            break;
        case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
            if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
                ESP_LOGE(GATTS_TAG, "Advertising start failed\n");
            }
            break;
        case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
            if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS) {
                ESP_LOGE(GATTS_TAG, "Advertising stop failed\n");
            } else {
                ESP_LOGI(GATTS_TAG, "Stop adv successfully\n");
            }
            break;
        case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
            ESP_LOGI(GATTS_TAG,
                     "update connection params status = %d, min_int = %d, max_int = %d,conn_int = %d,latency = %d, timeout = %d",
                     param->update_conn_params.status,
                     param->update_conn_params.min_int,
                     param->update_conn_params.max_int,
                     param->update_conn_params.conn_int,
                     param->update_conn_params.latency,
                     param->update_conn_params.timeout);
            break;
        default:
            break;
    }
}


// 处理写请求，一般不需要改
void example_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env,
                             esp_ble_gatts_cb_param_t *param) {
    esp_gatt_status_t status = ESP_GATT_OK;
    if (param->write.need_rsp) {
        if (param->write.is_prep) {
            if (prepare_write_env->prepare_buf == NULL) {
                prepare_write_env->prepare_buf = (uint8_t *) malloc(PREPARE_BUF_MAX_SIZE * sizeof(uint8_t));
                prepare_write_env->prepare_len = 0;
                if (prepare_write_env->prepare_buf == NULL) {
                    ESP_LOGE(GATTS_TAG, "Gatt_server prep no mem\n");
                    status = ESP_GATT_NO_RESOURCES;
                }
            } else {
                if (param->write.offset > PREPARE_BUF_MAX_SIZE) {
                    status = ESP_GATT_INVALID_OFFSET;
                } else if ((param->write.offset + param->write.len) > PREPARE_BUF_MAX_SIZE) {
                    status = ESP_GATT_INVALID_ATTR_LEN;
                }
            }

            esp_gatt_rsp_t *gatt_rsp = (esp_gatt_rsp_t *) malloc(sizeof(esp_gatt_rsp_t));
            gatt_rsp->attr_value.len = param->write.len;
            gatt_rsp->attr_value.handle = param->write.handle;
            gatt_rsp->attr_value.offset = param->write.offset;
            gatt_rsp->attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE;
            memcpy(gatt_rsp->attr_value.value, param->write.value, param->write.len);
            esp_err_t response_err = esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id,
                                                                 status, gatt_rsp);
            if (response_err != ESP_OK) {
                ESP_LOGE(GATTS_TAG, "Send response error\n");
            }
            free(gatt_rsp);
            if (status != ESP_GATT_OK) {
                return;
            }
            memcpy(prepare_write_env->prepare_buf + param->write.offset,
                   param->write.value,
                   param->write.len);
            prepare_write_env->prepare_len += param->write.len;

        } else {
            esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, NULL);
        }
    }
}

// 处理写请求，一般不需要改
void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param) {
    if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
                esp_log_buffer_hex(GATTS_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len);
    } else {
        ESP_LOGI(GATTS_TAG, "ESP_GATT_PREP_WRITE_CANCEL");
    }
    if (prepare_write_env->prepare_buf) {
        free(prepare_write_env->prepare_buf);
        prepare_write_env->prepare_buf = NULL;
    }
    prepare_write_env->prepare_len = 0;
}


// GATT 通信回调，需要自定义
static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event,
                                          esp_gatt_if_t gatts_if,
                                          esp_ble_gatts_cb_param_t *param) {
    switch (event) {
        case ESP_GATTS_REG_EVT: {
            ESP_LOGI(GATTS_TAG, "REGISTER_APP_EVT, status %d, app_id %d", param->reg.status, param->reg.app_id);
            gl_profile_tab[PROFILE_A_APP_ID].service_id.is_primary = true;
            gl_profile_tab[PROFILE_A_APP_ID].service_id.id.inst_id = 0x00;
            gl_profile_tab[PROFILE_A_APP_ID].service_id.id.uuid.len = ESP_UUID_LEN_128;
            gl_profile_tab[PROFILE_A_APP_ID].service_id.id.uuid.uuid = anker_service_uuid.uuid;

            esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(raw_adv_data));
            adv_config_done |= adv_config_flag;
            esp_ble_gap_config_scan_rsp_data_raw(raw_scan_rsp_data, sizeof(raw_scan_rsp_data));
            adv_config_done |= scan_rsp_config_flag;

            // 只创建服务，不添加特征
            esp_ble_gatts_create_service(gatts_if,
                                         &gl_profile_tab[PROFILE_A_APP_ID].service_id,
                                         GATTS_NUM_HANDLE_TEST_A);
            break;
        }

        case ESP_GATTS_CREATE_EVT: {
            ESP_LOGI(GATTS_TAG, "CREATE_SERVICE_EVT, status %d, handle %d",
                     param->create.status, param->create.service_handle);

            gl_profile_tab[PROFILE_A_APP_ID].service_handle = param->create.service_handle;
            esp_ble_gatts_start_service(param->create.service_handle);

            // 添加 RX 特征值（写无响应）
            gl_profile_tab[PROFILE_A_APP_ID].char_uuid = anker_rx_uuid;
            rx_property = ESP_GATT_CHAR_PROP_BIT_WRITE_NR;
            esp_ble_gatts_add_char(param->create.service_handle,
                                   &gl_profile_tab[PROFILE_A_APP_ID].char_uuid,
                                   ESP_GATT_PERM_WRITE,
                                   rx_property,
                                   NULL, NULL);
            break;
        }

        case ESP_GATTS_ADD_CHAR_EVT: {
            ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, attr_handle %d", param->add_char.attr_handle);

            const esp_bt_uuid_t *added_uuid = &param->add_char.char_uuid;

            // 判断添加的是 RX，接着添加 TX
            if (memcmp(added_uuid->uuid.uuid128, anker_rx_uuid.uuid.uuid128, 16) == 0) {
                gl_profile_tab[PROFILE_A_APP_ID].rx_char_handle = param->add_char.attr_handle;//

                // 添加 TX 特征值（notify）
                gl_profile_tab[PROFILE_A_APP_ID].char_uuid = anker_tx_uuid;
                tx_property = ESP_GATT_CHAR_PROP_BIT_NOTIFY;
                esp_ble_gatts_add_char(gl_profile_tab[PROFILE_A_APP_ID].service_handle,
                                       &gl_profile_tab[PROFILE_A_APP_ID].char_uuid,
                                       ESP_GATT_PERM_READ,
                                       tx_property,
                                       NULL, NULL);
            } else if (memcmp(added_uuid->uuid.uuid128, anker_tx_uuid.uuid.uuid128, 16) == 0) {
                gl_profile_tab[PROFILE_A_APP_ID].tx_char_handle = param->add_char.attr_handle;//

                // 添加 CCCD 描述符（用于客户端打开 notify）
                gl_profile_tab[PROFILE_A_APP_ID].descr_uuid.len = ESP_UUID_LEN_16;
                gl_profile_tab[PROFILE_A_APP_ID].descr_uuid.uuid.uuid16 = ESP_GATT_UUID_CHAR_CLIENT_CONFIG;

                esp_ble_gatts_add_char_descr(gl_profile_tab[PROFILE_A_APP_ID].service_handle,
                                             &gl_profile_tab[PROFILE_A_APP_ID].descr_uuid,
                                             ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
                                             NULL, NULL);
            }
            break;
        }

        case ESP_GATTS_ADD_CHAR_DESCR_EVT:
            gl_profile_tab[PROFILE_A_APP_ID].descr_handle = param->add_char_descr.attr_handle;
            ESP_LOGI(GATTS_TAG, "ADD_DESCR_EVT, handle %d", param->add_char_descr.attr_handle);
            break;

        case ESP_GATTS_CONNECT_EVT:
            ESP_LOGI(GATTS_TAG, "CONNECT_EVT, conn_id %d", param->connect.conn_id);
            gl_profile_tab[PROFILE_A_APP_ID].conn_id = param->connect.conn_id;
            ble_is_connected = true;
            break;

        case ESP_GATTS_DISCONNECT_EVT:
            ESP_LOGI(GATTS_TAG, "DISCONNECT_EVT, reason = 0x%x", param->disconnect.reason);
            esp_ble_gap_start_advertising(&adv_params);
            ble_is_connected = false;
            break;

        case ESP_GATTS_WRITE_EVT: {
            ESP_LOGI(GATTS_TAG, "WRITE_EVT, handle: %d, len: %d", param->write.handle, param->write.len);
            esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len);

            ESP_LOGI(GATTS_TAG, "%s\r\n",param->write.value);
            char ntwcfg_data[250];
            if (param->write.len < 245) {
                sprintf(ntwcfg_data,"%s",param->write.value);
            }
            // 解析 json
            ntwcfg_data_parse(ntwcfg_data,sizeof(ntwcfg_data));

            // 处理是否是写入 notify 配置
            if (param->write.handle == gl_profile_tab[PROFILE_A_APP_ID].descr_handle && param->write.len == 2) {
                uint16_t descr_val = param->write.value[1] << 8 | param->write.value[0];
                if (descr_val == 0x0001) {
                    ESP_LOGI(GATTS_TAG, "Notify enabled by client\r\n");
                } else if (descr_val == 0x0000) {
                    ESP_LOGI(GATTS_TAG, "Notify disabled by client\r\n");
                }
            }

            // 如果是写入 RX 特征值，主动通过 TX 通知回应，测试用
#if 0
            ESP_LOGI(GATTS_TAG, "%d\r\n", gl_profile_tab[PROFILE_A_APP_ID].rx_char_handle);
            if (param->write.handle == gl_profile_tab[PROFILE_A_APP_ID].rx_char_handle &&
                (rx_property & ESP_GATT_CHAR_PROP_BIT_WRITE_NR)) {

                ESP_LOGI(GATTS_TAG, "RX Write -> Sending Notify back");

                uint8_t notify_data[20];
                int notify_len = snprintf((char *) notify_data, sizeof(notify_data),
                                          "Echo len %d", param->write.len);

                esp_err_t err = esp_ble_gatts_send_indicate(
                        gatts_if,
                        gl_profile_tab[PROFILE_A_APP_ID].conn_id,
                        gl_profile_tab[PROFILE_A_APP_ID].tx_char_handle,
                        notify_len,
                        notify_data,
                        false
                );

                if (err != ESP_OK) {
                    ESP_LOGE(GATTS_TAG, "Notify failed: %s", esp_err_to_name(err));
                }

            }
#endif
            example_write_event_env(gatts_if, &a_prepare_write_env, param);
            break;
        }

        case ESP_GATTS_EXEC_WRITE_EVT:
            ESP_LOGI(GATTS_TAG, "EXEC_WRITE_EVT");
            esp_ble_gatts_send_response(gatts_if,
                                        param->write.conn_id,
                                        param->write.trans_id,
                                        ESP_GATT_OK, NULL);
            example_exec_write_event_env(&a_prepare_write_env, param);
            break;

        case ESP_GATTS_READ_EVT: {
            ESP_LOGI(GATTS_TAG, "READ_EVT");
            esp_gatt_rsp_t rsp = {0};
            rsp.attr_value.handle = param->read.handle;
            rsp.attr_value.len = 4;
            rsp.attr_value.value[0] = 0xDE;
            rsp.attr_value.value[1] = 0xAD;
            rsp.attr_value.value[2] = 0xBE;
            rsp.attr_value.value[3] = 0xEF;
            esp_ble_gatts_send_response(gatts_if,
                                        param->read.conn_id,
                                        param->read.trans_id,
                                        ESP_GATT_OK, &rsp);
            break;
        }

        case ESP_GATTS_MTU_EVT:
            ESP_LOGI(GATTS_TAG, "MTU_EVT, MTU = %d", param->mtu.mtu);
            break;

        default:
            break;
    }
}

// 注册 GATT 事件回调，注册的动作具体发生实际在这里
static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) {
    /* If event is register event, store the gatts_if for each profile */
    if (event == ESP_GATTS_REG_EVT) {
        if (param->reg.status == ESP_GATT_OK) {
            gl_profile_tab[param->reg.app_id].gatts_if = gatts_if;
        } else {
            ESP_LOGI(GATTS_TAG, "Reg app failed, app_id %04x, status %d\n",
                     param->reg.app_id,
                     param->reg.status);
            return;
        }
    }

    /* If the gatts_if equal to profile A, call profile A cb handler,
     * so here call each profile's callback */
    do {
        int idx;
        for (idx = 0; idx < PROFILE_NUM; idx++) {
            if (gatts_if == ESP_GATT_IF_NONE ||
                /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
                gatts_if == gl_profile_tab[idx].gatts_if) {
                if (gl_profile_tab[idx].gatts_cb) {
                    gl_profile_tab[idx].gatts_cb(event, gatts_if, param);
                }
            }
        }
    } while (0);
}

bool esp_ble_is_connected() {
    return ble_is_connected;
}

bool dh_p1_blu_send_result(bool result) {
    ESP_LOGI(GATTS_TAG, "RX Write -> Sending Notify back");

    if (esp_ble_is_connected()) {
        static uint16_t count = 0;
        uint8_t notify_data[20];
        esp_err_t err = ESP_OK;
        int len = snprintf((char *) notify_data, sizeof(notify_data), result==true?"Connect OK":"Connect False", count++);

        err = esp_ble_gatts_send_indicate(
                gl_profile_tab[PROFILE_A_APP_ID].gatts_if,
                gl_profile_tab[PROFILE_A_APP_ID].conn_id,
                gl_profile_tab[PROFILE_A_APP_ID].tx_char_handle,  // 注意：应是 TX 的 handle
                len,
                notify_data,
                false
        );
        if (err == ESP_OK) {
            return true;
        } else {
            ESP_LOGI(GATTS_TAG, "Send error\r\n");
            return false;
        }
    } else {
        ESP_LOGI(GATTS_TAG, "Blue Not connected\r\n");
        return false;
    }

}

esp_err_t ntwcfg_data_parse(char* data, uint8_t len){
    cJSON* pRoot = cJSON_Parse(data);
    if(pRoot == NULL) {
        ESP_LOGI(GATTS_TAG,"[JSON] Parse failed.");
        return ESP_FAIL;
    }

    cJSON* cjson_ssid = cJSON_GetObjectItem(pRoot, "ssid");
    cJSON* cjson_pwd  = cJSON_GetObjectItem(pRoot, "passwd");

    if (cjson_ssid && cJSON_IsString(cjson_ssid) &&
        cjson_pwd  && cJSON_IsString(cjson_pwd)) {

        ESP_LOGI(GATTS_TAG, "[JSON] ssid: %s", cjson_ssid->valuestring);
        ESP_LOGI(GATTS_TAG, "[JSON] pwd : %s", cjson_pwd->valuestring);

        // todo 赋值 配网
        {
            // 复制SSID，SSID最长31位
            size_t ssid_len = strlen(cjson_ssid->valuestring);
            if (ssid_len < sizeof(gs_meter_info.m_ssid)) {
                strncpy(gs_meter_info.m_ssid, cjson_ssid->valuestring, ssid_len);
                gs_meter_info.m_ssid[ssid_len] = '\0';
            }

            // 复制密码,最长63
            size_t pwd_len = strlen(cjson_pwd->valuestring);
            if (pwd_len < sizeof(gs_meter_info.m_passwd)) {
                strncpy(gs_meter_info.m_passwd, cjson_pwd->valuestring, pwd_len);
                gs_meter_info.m_ssid[pwd_len] = '\0';
            }
        }
        cJSON_Delete(pRoot);
        dh_write_wifiCfg();
        dh_p1_wifi_connect();
        return ESP_OK;
    } else {
        ESP_LOGW(GATTS_TAG, "[JSON] Missing or invalid 'ssid' or 'passwd'");
        cJSON_Delete(pRoot);
        return ESP_FAIL;
    }
}


void dh_p1_blu_task_init(void) {
    esp_err_t ret;

    if (bluetooth_initialized) {
        ESP_LOGI(GATTS_TAG, "BLE is initialized. Skip deinit.");
        return;
    }

    // 释放经典蓝牙
    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

    // 初始默认蓝牙控制器，硬件层
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }
    // 启动 BLE 蓝牙控制器，硬件层
    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    // 初始化 Bluedroid 协议栈（BLE 协议逻辑层）
    ret = esp_bluedroid_init();
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s init bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }
    // 使能 Bluedroid 协议栈（BLE 协议逻辑层）
    ret = esp_bluedroid_enable();
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s enable bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    // GATT 负责设备之间实际数据传输
    ret = esp_ble_gatts_register_callback(gatts_event_handler);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "gatts register error, error code = %x", ret);
        return;
    }
    // GAP 负责设备发现和连接
    ret = esp_ble_gap_register_callback(gap_event_handler);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "gap register error, error code = %x", ret);
        return;
    }
    // 注册 GATT 服务，并分配一个ID
    ret = esp_ble_gatts_app_register(PROFILE_A_APP_ID);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
        return;
    }
    // BLE 数据传输中单次最多能发/收多少字节
    esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
    if (local_mtu_ret) {
        ESP_LOGE(GATTS_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
    }

    bluetooth_initialized = true;  // 设置标志
}


void dh_p1_blu_deinit(void) {
    if (!bluetooth_initialized) {
        ESP_LOGI(GATTS_TAG, "BLE not initialized. Skip deinit.");
        return;
    }

    ESP_LOGI(GATTS_TAG, "Deinitializing BLE...");

    esp_ble_gap_stop_advertising();
    esp_ble_gatts_app_unregister(PROFILE_A_APP_ID);

    esp_bluedroid_disable();
    esp_bluedroid_deinit();

    esp_bt_controller_disable();
    esp_bt_controller_deinit();

    bluetooth_initialized = false;

    ESP_LOGI(GATTS_TAG, "BLE deinitialized.");
}