本文正在参与「金石计划 . 分割6万现金大奖」

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

前语

前面一篇文章一文带你知道蓝牙 GATT 协议咱们学习了蓝牙 GATT 相关概念，关于一些根本的专有名词也有了开端的知道，这给咱们了解应用程序打下了概念根底。

本文的前一部分咱们来一步一步剖析 ESP-IDF 中 GATT Server 示例的应用程序架构，经过对程序的剖析，不仅能更好的了解蓝牙 GATT 的根本概念，还能进一步的理解一些上篇文章不曾深化阐明的细节问题。

本文后半部分咱们会经过实践测验现象，进行更加直接的解说，使得咱们更能了解 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 经过手机可以接收到开发板上各种传感器的数据，然后经过手机可以对开发板进行一些操控操作。

接下来的文章咱们的学习测验就会一步一步的朝着这个终究的意图而进行，加油↖(^^)↗！

ESP-IDF 蓝牙开发之 GATT Server 示例详细解析

前语

一、GATT Server 示例

1.1 初始化

1.2 回调函数

gatts_event_handler

gap_event_handler

☆ gatts_profile_a_event_handler ☆

GATT工作流程

esp_ble_gatts_create_service

二、示例测验

2.1 Service 和 UUID

2.2 characteristic

2.3 数据收发

结语

作者信息

ESP-IDF 蓝牙开发之 GATT Server 示例详细解析

前语

一、GATT Server 示例

1.1 初始化

1.2 回调函数

gatts_event_handler

gap_event_handler

☆ gatts_profile_a_event_handler ☆

GATT工作流程

esp_ble_gatts_create_service

二、示例测验

2.1 Service 和 UUID

2.2 characteristic

2.3 数据收发

结语

相关文章

(二十五)MySQL主从实践篇：超详细版读写分离、双主热备架构搭建教学

数组去重的多种方式

SwiftUI100天：使用SwiftUI搭建一个计时器App

即将开幕！XDC 2022 亮点全揭晓！

作者信息