了解了蓝牙 GATT 相关概念，趁热打铁，分析一下官方示例 GATT Server 的应用程序架构。

前言

上一篇文章我们学习了 蓝牙 GATT 相关概念，对于一些基本的专有名词也有了初步的认识，这给我们理解应用程序打下了概念基础 。

本文我们就来分析一下官方示例 GATT Server 的应用程序架构，通过对程序的分析，不仅能更好的理解蓝牙 GATT 的基本概念，还能进一步的明白一些上篇文章不曾深入说明的细节问题。

ESP32-C3学习 蓝牙 篇系列博文连接：
测试使用的开发板：
自己画一块ESP32-C3 的开发板（第一次使用立创EDA）（PCB到手）
测试使用的开发环境：
ESP32-C3 VScode开发环境搭建（基于乐鑫官方ESP-IDF——Windows和Ubuntu双环境）
蓝牙篇系列相关博文：
ESP32-C3 学习测试 蓝牙 篇（一、认识 ESP-IDF 的蓝牙框架、简单的了解蓝牙协议栈）
(第二篇为手机和开发板了解示例文章，很简单的没有技术含量的记录文章，后期补上)
ESP32-C3 学习测试 蓝牙 篇（三、一文带你认识蓝牙 GATT 协议 ）

一、GATT Server 示例分析

作为一个单独的应用程序，GATT Server 代码量也算是多的了，我们根据应用程序运行流程从 app_main 开始。

1.1 初始化

1、NVS 初始化，在使用 wifi 的时候我们也需要初始化 NVS ，用来存储一些比较信息：

// Initialize NVS.
    ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
   
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }

2、释放一下 ESP_BT_MODE_CLASSIC_BT，就是释放经典蓝牙资源，保证设备不工作在经典蓝牙下面：

 ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

3、按照默认配置BT_CONTROLLER_INIT_CONFIG_DEFAULT，初始化 蓝牙控制器：

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;
    }

4、使能蓝牙控制器，工作在 BLE mode:

//如果想要动态改变蓝牙模式不能直接调用该函数，先disable关闭蓝牙再使用该API来改变蓝牙模式
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;
    }

5、初始化蓝牙主机，使能蓝牙主机：

//蓝牙栈 `bluedroid stack` 包括了BT和 BLE 使用的基本的define和API
ret = esp_bluedroid_init();
    if (ret) {
   
        ESP_LOGE(GATTS_TAG, "%s init bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }
    ret = esp_bluedroid_enable();
    if (ret) {
   
        ESP_LOGE(GATTS_TAG, "%s enable bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

6、注册 GATT 回调函数，回调函数具体内容会在下文说明：

ret = esp_ble_gatts_register_callback(gatts_event_handler);
    if (ret){
   
        ESP_LOGE(GATTS_TAG, "gatts register error, error code = %x", ret);
        return;
    }

7、注册 GAP 回调函数，在前面的文章我们说过：蓝牙是通过GAP建立通信的，所以在这个回调函数中定义了在广播期间蓝牙设备的一些操作：

ret = esp_ble_gap_register_callback(gap_event_handler);
    if (ret){
   
        ESP_LOGE(GATTS_TAG, "gap register error, error code = %x", ret);
        return;
    }

8、 注册 service ：

/*
当调用esp_ble_gatts_app_register()注册一个应用程序Profile(Application Profile)，
将触发ESP_GATTS_REG_EVT事件，
除了可以完成对应profile的gatts_if的注册,
还可以调用esp_bel_create_attr_tab()来创建profile Attributes 表
或创建一个服务esp_ble_gatts_create_service()                         
*/
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;
    }
    ret = esp_ble_gatts_app_register(PROFILE_B_APP_ID);
    if (ret){
   
        ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
        return;
    }

9、设置 mtu ，mtu 相关说明如下：

MTU: MAXIMUM TRANSMISSION UNIT
最大传输单元，
指在一个PDU 能够传输的最大数据量(多少字节可以一次性传输到对方)。

PDU：Protocol Data Unit 
协议数据单元,
在一个传输单元中的有效传输数据。

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);
    }

1.2 回调函数

在示例中有好几个回调函数，我们依次来看：

gatts_event_handler

先来看第一个回调函数gatts_event_handler：

/*
参数说明：
event: 
esp_gatts_cb_event_t 枚举类型，表示调用该回调函数时的事件(或蓝牙的状态)

gatts_if: 
esp_gatt_if_t (uint8_t) 这是GATT访问接口类型，
通常在GATT客户端上不同的应用程序用不同的gatt_if(不同的Application profile对应不同的gatts_if) ，
调用esp_ble_gatts_app_register()时，
注册Application profile 就会有一个gatts_if。

param: esp_ble_gatts_cb_param_t 指向回调函数的参数，是个联合体类型，
不同的事件类型采用联合体内不同的成员结构体。
*/
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 
    判断是否是 GATT 的注册事件
    */
    if (event == ESP_GATTS_REG_EVT) {
   
         /* 
         确定底层GATT运行成功
         触发ESP_GATTS_REG_EVT时，完成对每个profile 的gatts_if 的注册
         */
        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 
     * 如果gatts_if == 某个Profile的gatts_if时，调用对应profile的回调函数处理事情。
     */
    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);
}

这个函数的主要作用：导入 GATT 的 profiles。

这个函数注册完成之后，就会在ble 协议任务函数中运行，将程序前面定义的 profiles 导入：

在这两个 profiles 中，每一个都有自己对于的回调函数：gatts_profile_a_event_handler 和 gatts_profile_b_event_handler， 这也是我们本示例的关键函数，下面我们会来分析。

.

gap_event_handler

第二个，GAP事件回调函数gap_event_handler，

我们在上一篇文章分析过，GAP 定义了在广播期间蓝牙设备的一些操作，蓝牙是通过GAP建立通信的（说明看代码注释，了解 GAP 各个事件的含义）：

/*
其中开始广播 adv_params 的参数定义为：
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,
};
*/
static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
   
    switch (event) {
   
#ifdef CONFIG_SET_RAW_ADV_DATA
    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;
#else
    case ESP_GAP_BLE_ADV_DATA_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_SET_COMPLETE_EVT://广播扫描相应设置完成标志
        adv_config_done &= (~scan_rsp_config_flag);
        if (adv_config_done == 0){
   
            esp_ble_gap_start_advertising(&adv_params);
        }
        break;
#endif
    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT: //开始广播事件标志
        //advertising start complete event to indicate advertising start successfully or failed
        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;
    }
}

说明：GAP 的回调函数有很多，通过枚举esp_gap_ble_cb_event_t可查看。这里我们只说明上面回调函数使用到的。

.

☆ gatts_profile_a_event_handler ☆

本示例的核心部分， GATT回调函数gatts_profile_a_event_handler，

理解了他将让自己在以后蓝牙 GATT 的开发中更加得心应手（说明看代码注释，了解 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) {
   
    /*
    展示了一个Service的创建
    GATT注册事件，添加 service的基本信息，设置BLE名称
    */
    case ESP_GATTS_REG_EVT:
        ESP_LOGI(GATTS_TAG, "REGISTER_APP_EVT, status %d, app_id %d\n", 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_16;
        gl_profile_tab[PROFILE_A_APP_ID].service_id.id.uuid.uuid.uuid16 = GATTS_SERVICE_UUID_TEST_A;

        esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name(TEST_DEVICE_NAME);
        if (set_dev_name_ret){
   
            ESP_LOGE(GATTS_TAG, "set device name failed, error code = %x", set_dev_name_ret);
        }
#ifdef CONFIG_SET_RAW_ADV_DATA 
        esp_err_t raw_adv_ret = esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(raw_adv_data));
        if (raw_adv_ret){
   
            ESP_LOGE(GATTS_TAG, "config raw adv data failed, error code = %x ", raw_adv_ret);
        }
        adv_config_done |= adv_config_flag;
        esp_err_t raw_scan_ret = esp_ble_gap_config_scan_rsp_data_raw(raw_scan_rsp_data, sizeof(raw_scan_rsp_data));
        if (raw_scan_ret){
   
            ESP_LOGE(GATTS_TAG, "config raw scan rsp data failed, error code = %x", raw_scan_ret);
        }
        adv_config_done |= scan_rsp_config_flag;
#else
        //config adv data
        esp_err_t ret = esp_ble_gap_config_adv_data(&adv_data);
        if (ret){
   
            ESP_LOGE(GATTS_TAG, "config adv data failed, error code = %x", ret);
        }
        adv_config_done |= adv_config_flag;
        //config scan response data
        ret = esp_ble_gap_config_adv_data(&scan_rsp_data);
        if (ret){
   
            ESP_LOGE(GATTS_TAG, "config scan response data failed, error code = %x", ret);
        }
        adv_config_done |= scan_rsp_config_flag;

#endif
        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_READ_EVT: {
    //GATT读取事件，手机读取开发板的数据
        ESP_LOGI(GATTS_TAG, "GATT_READ_EVT, conn_id %d, trans_id %d, handle %d\n", param->read.conn_id, param->read.trans_id, param->read.handle);
        esp_gatt_rsp_t rsp;
        memset(&rsp, 0, sizeof(esp_gatt_rsp_t));
        rsp.attr_value.handle = param->read.handle;
        rsp.attr_value.len = 4;
        rsp.attr_value.value[0] = 0xde;
        rsp.attr_value.value[1] = 0xed;
        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_WRITE_EVT: {
    //GATT写事件，手机给开发板的发送数据，不需要回复
        ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, conn_id %d, trans_id %d, handle %d", param->write.conn_id, param->write.trans_id, param->write.handle);
        if (!param->write.is_prep){
   
            ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, value len %d, value :", param->write.len);
            esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len);
            if (gl_profile_tab[PROFILE_A_APP_ID].descr_handle == param->write.handle && param->write.len == 2){
   
                uint16_t descr_value = param->write.value[1]<<8 | param->write.value[0];
                if (descr_value == 0x0001){
   
                    if (a_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY){
   
                        ESP_LOGI(GATTS_TAG, "notify enable");
                        uint8_t notify_data[15];
                        for (int i = 0; i < sizeof(notify_data); ++i)
                        {
   
                            notify_data[i] = i%0xff;
                        }
                        //the size of notify_data[] need less than MTU size
                        esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, gl_profile_tab[PROFILE_A_APP_ID].char_handle,
                                                sizeof(notify_data), notify_data, false);
                    }
                }else if (descr_value == 0x0002){
   
                    if (a_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){
   
                        ESP_LOGI(GATTS_TAG, "indicate enable");
                        uint8_t indicate_data[15];
                        for (int i = 0; i < sizeof(indicate_data); ++i)
                        {
   
                            indicate_data[i] = i%0xff;
                        }
                        //the size of indicate_data[] need less than MTU size
                        esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, gl_profile_tab[PROFILE_A_APP_ID].char_handle,
                                                sizeof(indicate_data), indicate_data, true);
                    }
                }
                else if (descr_value == 0x0000){
   
                    ESP_LOGI(GATTS_TAG, "notify/indicate disable ");
                }else{
   
                    ESP_LOGE(GATTS_TAG, "unknown descr value");
                    esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len);
                }

            }
        }
        example_write_event_env(gatts_if, &a_prepare_write_env, param);
        break;
    }
    case ESP_GATTS_EXEC_WRITE_EVT: //GATT写事件，手机给开发板的发送数据，需要回复
        ESP_LOGI(GATTS_TAG,"ESP_GATTS_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_MTU_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
        break;
    case ESP_GATTS_UNREG_EVT:
        break;
    //创建 GATT事件,基本参数的设置，将Characteristic加到service中，完成触发下面事件
    case ESP_GATTS_CREATE_EVT: 
        ESP_LOGI(GATTS_TAG, "CREATE_SERVICE_EVT, status %d,  service_handle %d\n", param->create.status, param->create.service_handle);
        gl_profile_tab[PROFILE_A_APP_ID].service_handle = param->create.service_handle;
        gl_profile_tab[PROFILE_A_APP_ID].char_uuid.len = ESP_UUID_LEN_16;
        gl_profile_tab[PROFILE_A_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_A;

        esp_ble_gatts_start_service(gl_profile_tab[PROFILE_A_APP_ID].service_handle);
        a_property = ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
        esp_err_t add_char_ret = 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 | ESP_GATT_PERM_WRITE,
                                                        a_property,
                                                        &gatts_demo_char1_val, NULL);
        if (add_char_ret){
   
            ESP_LOGE(GATTS_TAG, "add char failed, error code =%x",add_char_ret);
        }
        break;
    case ESP_GATTS_ADD_INCL_SRVC_EVT:
        break;
    //添加Characteristic事件，添加Characteristic的Descriptor，完成触发下面事件
    case ESP_GATTS_ADD_CHAR_EVT: {
    
        uint16_t length = 0;
        const uint8_t *prf_char;

        ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, status %d,  attr_handle %d, service_handle %d\n",
                param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle);
        gl_profile_tab[PROFILE_A_APP_ID].char_handle = param->add_char.attr_handle;
        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_err_t get_attr_ret = esp_ble_gatts_get_attr_value(param->add_char.attr_handle,  &length, &prf_char);
        if (get_attr_ret == ESP_FAIL){
   
            ESP_LOGE(GATTS_TAG, "ILLEGAL HANDLE");
        }

        ESP_LOGI(GATTS_TAG, "the gatts demo char length = %x\n", length);
        for(int i = 0; i < length; i++){
   
            ESP_LOGI(GATTS_TAG, "prf_char[%x] =%x\n",i,prf_char[i]);
        }
        esp_err_t add_descr_ret = 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);
        if (add_descr_ret){
   
            ESP_LOGE(GATTS_TAG, "add char descr failed, error code =%x", add_descr_ret);
        }
        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, status %d, attr_handle %d, service_handle %d\n",
                 param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle);
        break;
    case ESP_GATTS_DELETE_EVT:
        break;
    case ESP_GATTS_START_EVT:
        ESP_LOGI(GATTS_TAG, "SERVICE_START_EVT, status %d, service_handle %d\n",
                 param->start.status, param->start.service_handle);
        break;
    case ESP_GATTS_STOP_EVT:
        break;
    case ESP_GATTS_CONNECT_EVT: {
    // GATT 连接事件
        esp_ble_conn_update_params_t conn_params = {
   0};
        memcpy(conn_params.bda, param->connect.remote_bda, sizeof(esp_bd_addr_t));
        /* For the IOS system, please reference the apple official documents about the ble connection parameters restrictions. */
        conn_params.latency = 0;
        conn_params.max_int = 0x20;    // max_int = 0x20*1.25ms = 40ms
        conn_params.min_int = 0x10;    // min_int = 0x10*1.25ms = 20ms
        conn_params.timeout = 400;    // timeout = 400*10ms = 4000ms
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONNECT_EVT, conn_id %d, remote %02x:%02x:%02x:%02x:%02x:%02x:",
                 param->connect.conn_id,
                 param->connect.remote_bda[0], param->connect.remote_bda[1], param->connect.remote_bda[2],
                 param->connect.remote_bda[3], param->connect.remote_bda[4], param->connect.remote_bda[5]);
        gl_profile_tab[PROFILE_A_APP_ID].conn_id = param->connect.conn_id;
        //start sent the update connection parameters to the peer device.
        esp_ble_gap_update_conn_params(&conn_params);
        break;
    }
    case ESP_GATTS_DISCONNECT_EVT://断开连接事件
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_DISCONNECT_EVT, disconnect reason 0x%x", param->disconnect.reason);
        esp_ble_gap_start_advertising(&adv_params);
        break;
    case ESP_GATTS_CONF_EVT: //GATT配置事件
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT, status %d attr_handle %d", param->conf.status, param->conf.handle);
        if (param->conf.status != ESP_GATT_OK){
   
            esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len);
        }
        break;
    case ESP_GATTS_OPEN_EVT:
    case ESP_GATTS_CANCEL_OPEN_EVT:
    case ESP_GATTS_CLOSE_EVT:
    case ESP_GATTS_LISTEN_EVT:
    case ESP_GATTS_CONGEST_EVT:
    default:
        break;
    }
}

除了上面代码中事件的简单注释，还有一些需要说明的地方：

1、 在ESP_GATTS_CREATE_EVT事件中调用了函数：

esp_err_t esp_ble_gatts_start_service(uint16_t service_handle)

该函数的作用是启动 GATT 服务。

再然后调用函数：

esp_err_t esp_ble_gatts_add_char(uint16_t service_handle,  esp_bt_uuid_t  *char_uuid,
                                 esp_gatt_perm_t perm, esp_gatt_char_prop_t property, esp_attr_value_t *char_val,
                                 esp_attr_control_t *control)

来添加特性(特征的UUID， 特征值描述符属性权限， 特征属性、特征值、属性响应控制字节)。

上面的一系列操作会触发ESP_GATTS_START_EVT和ESP_GATTS_ADD_CHAR_EVT事件

2、上面事件中有2个写事件： ESP_GATTS_WRITE_EVT 和 ESP_GATTS_EXEC_WRITE_EVT
其中ESP_GATTS_EXEC_WRITE_EVT 事件在接收到写数据之后需要为 Client 回复数据 ，前者不需要。

.

GATT事件流程

在没有连接之前：注册->创建->启动->添加特征->添加特征描述：

ESP_GATTS_REG_EVT—>
ESP_GATTS_CREATE_EVT—>
ESP_GATTS_START_EVT—>
ESP_GATTS_ADD_CHAR_EVT—>
ESP_GATTS_ADD_CHAR_DESCR_EVT

流程说明：

在 Demo 的ESP_GATTS_REG_EVT事件中，调用esp_ble_gap_set_device_name(char *)来设置蓝牙设备名字；调用esp_ble_gap_config_adv_data()来配置广播数据；

最后调用esp_ble_gatts_create_service()指定 gatts_if 和 service_id 来创建服务<实际调用 btc_transfer_context() 来完成服务的创建和调用回调函数>。

服务创建完成就会触发回调函数向profile报告状态和服务ID。Service_id对于后面添加included serivces 和 characteristics 和 descriptor 都要用到。触发ESP_GATTS_CREATE_EVT事件

在Demo的ESP_GATTS_CREATE_EVT中调用esp_ble_gatts_start_service(uint16_t service_handle)来启动服务；

再调用 esp_ble_gatts_add_char() 来添加特性(特征的UUID， 特征值描述符属性权限， 特征属性、特征值、属性响应控制字节)。

触发ESP_GATTS_START_EVT和ESP_GATTS_ADD_CHAR_EVT事件，在ESP_GATTS_ADD_CHAR_EVT事件中，获取特征值调用esp_err_tesp_ble_gatts_add_char_descr()来添加特征描述符。

在连接之后：

CONNECT_EVT—>
ESP_GATTS_MTU_EVT—>
GATT_WRITE_EVT—>
ESP_GATTS_CONF_EVT—>
GATT_READ_EVT

esp_ble_gatts_create_service

在提一个函数，在上面介绍的回调函数时间中说到 ESP_GATTS_REG_EVT 最后回调用 esp_ble_gatts_create_service 来创建服务：

创建一个service。当一个service创建成功后，ESP_CREATE_SERVICE_EVT事件触发回调函数被调用，该回调函数报告了 profile 的 stauts 和 service ID。当要添加 include service 和 characteristics//descriptors 入服务 service，Service ID 在回调函数中用到。

/*
gatts_if：GATT 服务器访问接口

service_id: 服务UUID相关信息

num_handle:
该服务所需的句柄数 service、characteristic declaration、 characteristic value、characteristic description 的句柄数总和。
Demo中用的是4（1+3），如果有两个特征，则为7（1+3+3）.
*/
esp_err_t esp_ble_gatts_create_service(esp_gatt_if_t gatts_if,
                                       esp_gatt_srvc_id_t *service_id, uint16_t num_handle)
{
   
    btc_msg_t msg;
    btc_ble_gatts_args_t arg;

    ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);

    msg.sig = BTC_SIG_API_CALL;
    msg.pid = BTC_PID_GATTS;
    msg.act = BTC_GATTS_ACT_CREATE_SERVICE;
    arg.create_srvc.gatts_if = gatts_if;
    arg.create_srvc.num_handle = num_handle;
    memcpy(&arg.create_srvc.service_id, service_id, sizeof(esp_gatt_srvc_id_t));

    return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gatts_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
}

二、示例测试

根据上面的代码分析和上一篇文章的内容，我们可以尝试一下对示例进行一定的测试修改。

当然目前来说，还是怎么简单怎么来。

2.1 Service 和 UUID

Service 个数，我们示例中是使用了注册了2个 Service ，首先说明一下上一篇文章中，我们说到示例连接后能够获取到的 Service 为4个，实际上前面2个是固有的，后面2个才是我们程序中注册的：

我们通过程序中定义的 UUID 也能够看出来：

在程序中其设置的位置如下：

正好讲到 UUID ，可以发现 characteristic 的UUID 也和定义的一样：

在程序中其设置的位置如下：

2.2 characteristic

characteristic 的创建位置在程序中对应的位置如下：

更多的一些说明需要等熟悉了以后再来更新。

2.3 数据收发

我们的蓝牙应用的最终目的还是数据的交互，数据收发，我们前面说了好几篇文章都没有切实的体会到数据的收发，现在终于要开始测试了。

与蓝牙设备的数据交互，可以认为就是对 Characteristci 进行读写即可达到与其通信的目的。

示例中在使用 esp_ble_gatts_add_char 函数添加 Characteristci 时就定义了可读可写属性：

我们下面就来通过手机与开发板进行数据的读写测试:

读数据：

我们通过手机端进行如下操作：

上图中，我们读取到了来自 Server 的数据，在程序中对应的实现部分为：

所以可以想象，如果我们把传感器的数据放在这些 value 中，那么设备读取数据，是不是就可以读取到传感器的数据了。

另外说明：在 Client 端有一个按钮：接收通知数据，对其进行操作有如下 LOG：

这里的原因暂时不理解，等后期明白了会更新说明。

写数据：

除了读数据，我们通过手机端也可以对设备进行写数据（当然前提是这个 characteristic 添加的时候支持写）：

对于写数据，在程序中对应的实现部分为：

和发送类似，这里我们可以添加一些相关的代码，收到 Client 发送的特定指令，进行特定的操作，简单的比如切换LED，采集一次数据等。

结语

本文经过对示例程序的分析说明，然后通过对比手机端读取到的信息，进行了简单的数据读写测试，了解了程序的设计框架，也算是入门了 ESP-IDF 的蓝牙 GATT 开发。

当然我们还只停留在理论分析阶段，实际上到现在我们都不曾真正的动手修改添加过程序代码。对于我计划的以应用为目的来说，至少也需要使用蓝牙 BLE 通过手机能够接收到开发板上各种传感器的数据，然后通过手机可以对开发板进行一些控制操作。

接下来的文章我们的学习测试就会一步一步的朝着这个最终的目的而进行，加油↖(^ω^)↗！