搞定蓝牙——第四章（GATT协议）

已于 2023-10-27 21:28:08 修改
阅读量2.8k 收藏 14
点赞数 8
文章标签： 单片机 ESP32 蓝牙
于 2023-10-26 22:56:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyh80227/article/details/134066466
版权

搞定蓝牙——第四章（GATT协议）

  • 文章下面用的英文表示：
    server和client：服务端和客户端
    char.：characteristic缩写，特征
    Attribute:属性
    ATT:Attribute Protocol缩写

原理介绍

GATT是蓝牙协议栈的一种协议，它定义了ble设备数据通讯的方法（设备角色、数据格式、服务发现、安全加密等等），也就是说两个ble设备是通讯的规范就是GATT协议。GAP也是一种协议，但是它是规范通讯之前的广播、连接等。

层次结构

GATT的层次结构是这样的。
在这里插入图片描述在这里插入图片描述
一个Profile包含多个server（与server和client中的server不是一个意思），一个server包含多个char.，profile只是一个定义，表示某个功能，例如测心率、测血氧等，server是一个服务，也表示某个功能，不传递实际的数据。char.是一个特征，可以理解为数据存放的地方。char.里面包含了属性、值和描述符，属性定义了访问权限，值就是一个要传递的数据，描述符描述了这个数据、例如单位。所以只有server和char.是实际运行的组件。

server和client端

Server端和client端，这个也是GATT定义的，一般server端提供服务，要传输的数据也在服务里面，client读取server的服务，也就是获取数据。有的服务可以接收client的数据，例如通知和指示。

Attribute

因为GATT是一种通讯规范，那通讯的数据是怎么样的呢？你想哈，好多地方都用到了蓝牙技术，但是应用场景差异有些很大，所以，这种数据格式必须能满足所有这些应用场景。于是，SIG（蓝牙技术联盟）就定义了一个统一的数据格式，称为Attribute（属性），也是ble传输最小单元了，每次最少发一个数据就是一个Attribute。
Attribute的结构是怎么样的呢。看图。
在这里插入图片描述
一个Attribute有四种类型的数据，一个一个展开说明。
Handle：因为ble发送数据都是一个一个Attribute发送的，所以需要加一个表示符来表示这个Attribute，可以看作为这个Attribute的名字，这个handle就是这个东西。
Type：表示Attribute的类型，使用16bit的UUID来表示，例如0x2800表示这个一个server声明的Attribute，更多看下图。
在这里插入图片描述
Value：表示这个Attribute的值，这个值有两种情况，如果从上面的Type中发现这是一个server声明的Attribute或者是char.声明的Attribute，那么这是一个UUID,这个可以自己定义，也可以用通用的，如果是其他，那么就是一个数据，例如心率、血氧。
Permissions：权限，也就是运行client对于这个Attribute的Value操作权限，因为server声明和char.声明是UUDI，所以该值为只读。

Ble是按照Attribute的格式来定义一个一个的数据的，在server端需要配置这一些Attribute，也就是Attribute表，这个表必须包含server声明、char.声明和char.值。
例如看看ESP32中的Attribute表，对于应用而言，维护这张表非常重要
在这里插入图片描述

ESP32部分

结构

参考官方手册蓝牙技术说明，链接：
https://www.espressif.com/sites/default/files/documentation/esp32_bluetooth_architecture_cn.pdf
有一张层次结构图
在这里插入图片描述

如下图所示，用户只关心USER APP和USER TASK这两部分，从图中可以看出GATT和GAP两部分是和USER APP有交互的，这就是通过两个回调函数来实现的，我们关系回调函数的实现就行了，至于回调函数什么时候被调用，那就是ESP底层写好的库实现的了。
在这里插入图片描述

初始化

直接看官方demo，打开路径，
在这里插入图片描述
拉到最底下找到app_main函数，看到初始化内容

esp_err_t ret;
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();

    // 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();
    }
    ESP_ERROR_CHECK( ret );

    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret) {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    ESP_LOGI(GATTS_TABLE_TAG, "%s init bluetooth\n", __func__);
    ret = esp_bluedroid_init();
    if (ret) {
        ESP_LOGE(GATTS_TABLE_TAG, "%s init bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }
    ret = esp_bluedroid_enable();
    if (ret) {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

这里初始化nvs_flash、然后释放经典蓝牙内容（当前学习ble，不使用经典蓝牙）、然后初始蓝牙控制器、使能蓝牙控制器、初始化bluedroid、使能bluedroid。

esp_ble_gatts_register_callback(gatts_event_handler);
esp_ble_gap_register_callback(gap_event_handler);

注册两个回调函数，GAP和GATT服务端回调函数

esp_ble_gatts_app_register(ESP_SPP_APP_ID);

注册APP，这里可以注册多个APP
最后开启任务

spp_task_init();

所以，ble的控制都是在上面注册的两个回调函数里的。

两个回调函数

这个是GAP的回调函数

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
    esp_err_t err;
    ESP_LOGE(GATTS_TABLE_TAG, "GAP_EVT, event %d\n", event);

    switch (event) {
    case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
        esp_ble_gap_start_advertising(&spp_adv_params);
        break;
    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
        //advertising start complete event to indicate advertising start successfully or failed
        if((err = param->adv_start_cmpl.status) != ESP_BT_STATUS_SUCCESS) {
            ESP_LOGE(GATTS_TABLE_TAG, "Advertising start failed: %s\n", esp_err_to_name(err));
        }
        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)
{
    ESP_LOGI(GATTS_TABLE_TAG, "EVT %d, gatts if %d\n", event, gatts_if);

    /* 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) {
            spp_profile_tab[SPP_PROFILE_APP_IDX].gatts_if = gatts_if;
        } else {
            ESP_LOGI(GATTS_TABLE_TAG, "Reg app failed, app_id %04x, status %d\n",param->reg.app_id, param->reg.status);
            return;
        }
    }

    do {
        int idx;
        for (idx = 0; idx < SPP_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 == spp_profile_tab[idx].gatts_if) {
                if (spp_profile_tab[idx].gatts_cb) {
                    spp_profile_tab[idx].gatts_cb(event, gatts_if, param);
                }
            }
        }
    } while (0);
}

GATTS回调函数有两部分，if (event == ESP_GATTS_REG_EVT){…} 和do {…}while(0)。
在main注册会使用了esp_ble_gatts_app_register(ESP_SPP_APP_ID);会进入第一个if语句，修改profile表的gatts_if（这个是一个标识，表示这个是APP，注册不同APP会产生不同gatts_if），然后进入do {…}while(0)，进行实际的操作，也就是执行gatts_cb的函数。

static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
{
    esp_ble_gatts_cb_param_t *p_data = (esp_ble_gatts_cb_param_t *) param;
    uint8_t res = 0xff;

    ESP_LOGI(GATTS_TABLE_TAG, "event = %x\n",event);
    switch (event) {
        case ESP_GATTS_REG_EVT:
            ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
            esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME);

            ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
            esp_ble_gap_config_adv_data_raw((uint8_t *)spp_adv_data, sizeof(spp_adv_data));

            ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
            esp_ble_gatts_create_attr_tab(spp_gatt_db, gatts_if, SPP_IDX_NB, SPP_SVC_INST_ID);
        break;
        case ESP_GATTS_READ_EVT:
            res = find_char_and_desr_index(p_data->read.handle);
            if(res == SPP_IDX_SPP_STATUS_VAL){
                //TODO:client read the status characteristic
            }
         break;
        case ESP_GATTS_WRITE_EVT: {
            res = find_char_and_desr_index(p_data->write.handle);
            if(p_data->write.is_prep == false){
                ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_WRITE_EVT : handle = %d\n", res);
                if(res == SPP_IDX_SPP_COMMAND_VAL){
                    uint8_t * spp_cmd_buff = NULL;
                    spp_cmd_buff = (uint8_t *)malloc((spp_mtu_size - 3) * sizeof(uint8_t));
                    if(spp_cmd_buff == NULL){
                        ESP_LOGE(GATTS_TABLE_TAG, "%s malloc failed\n", __func__);
                        break;
                    }
                    memset(spp_cmd_buff,0x0,(spp_mtu_size - 3));
                    memcpy(spp_cmd_buff,p_data->write.value,p_data->write.len);
                    xQueueSend(cmd_cmd_queue,&spp_cmd_buff,10/portTICK_PERIOD_MS);
                }else if(res == SPP_IDX_SPP_DATA_NTF_CFG){
                    if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00)){
                        enable_data_ntf = true;
                    }else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00)){
                        enable_data_ntf = false;
                    }
                }
#ifdef SUPPORT_HEARTBEAT
                else if(res == SPP_IDX_SPP_HEARTBEAT_CFG){
                    if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00)){
                        enable_heart_ntf = true;
                    }else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00)){
                        enable_heart_ntf = false;
                    }
                }else if(res == SPP_IDX_SPP_HEARTBEAT_VAL){
                    if((p_data->write.len == sizeof(heartbeat_s))&&(memcmp(heartbeat_s,p_data->write.value,sizeof(heartbeat_s)) == 0)){
                        heartbeat_count_num = 0;
                    }
                }
#endif
                else if(res == SPP_IDX_SPP_DATA_RECV_VAL){
#ifdef SPP_DEBUG_MODE
                    esp_log_buffer_char(GATTS_TABLE_TAG,(char *)(p_data->write.value),p_data->write.len);
#else
                    uart_write_bytes(UART_NUM_0, (char *)(p_data->write.value), p_data->write.len);
#endif
                }else{
                    //TODO:
                }
            }else if((p_data->write.is_prep == true)&&(res == SPP_IDX_SPP_DATA_RECV_VAL)){
                ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_PREP_WRITE_EVT : handle = %d\n", res);
                store_wr_buffer(p_data);
            }
            break;
        }
        case ESP_GATTS_EXEC_WRITE_EVT:{
            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_EXEC_WRITE_EVT\n");
            if(p_data->exec_write.exec_write_flag){
                print_write_buffer();
                free_write_buffer();
            }
            break;
        }
        case ESP_GATTS_MTU_EVT:
            spp_mtu_size = p_data->mtu.mtu;
            break;
        case ESP_GATTS_CONF_EVT:
            break;
        case ESP_GATTS_UNREG_EVT:
            break;
        case ESP_GATTS_DELETE_EVT:
            break;
        case ESP_GATTS_START_EVT:
            break;
        case ESP_GATTS_STOP_EVT:
            break;
        case ESP_GATTS_CONNECT_EVT:
            spp_conn_id = p_data->connect.conn_id;
            spp_gatts_if = gatts_if;
            is_connected = true;
            memcpy(&spp_remote_bda,&p_data->connect.remote_bda,sizeof(esp_bd_addr_t));
#ifdef SUPPORT_HEARTBEAT
            uint16_t cmd = 0;
            xQueueSend(cmd_heartbeat_queue,&cmd,10/portTICK_PERIOD_MS);
#endif
            break;
        case ESP_GATTS_DISCONNECT_EVT:
            is_connected = false;
            enable_data_ntf = false;
#ifdef SUPPORT_HEARTBEAT
            enable_heart_ntf = false;
            heartbeat_count_num = 0;
#endif
            esp_ble_gap_start_advertising(&spp_adv_params);
            break;
        case ESP_GATTS_OPEN_EVT:
            break;
        case ESP_GATTS_CANCEL_OPEN_EVT:
            break;
        case ESP_GATTS_CLOSE_EVT:
            break;
        case ESP_GATTS_LISTEN_EVT:
            break;
        case ESP_GATTS_CONGEST_EVT:
            break;
        case ESP_GATTS_CREAT_ATTR_TAB_EVT:{
            ESP_LOGI(GATTS_TABLE_TAG, "The number handle =%x\n",param->add_attr_tab.num_handle);
            if (param->add_attr_tab.status != ESP_GATT_OK){
                ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table failed, error code=0x%x", param->add_attr_tab.status);
            }
            else if (param->add_attr_tab.num_handle != SPP_IDX_NB){
                ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table abnormally, num_handle (%d) doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, SPP_IDX_NB);
            }
            else {
                memcpy(spp_handle_table, param->add_attr_tab.handles, sizeof(spp_handle_table));
                esp_ble_gatts_start_service(spp_handle_table[SPP_IDX_SVC]);
            }
            break;
        }
        default:
            break;
    }
}

注册完成以后，所有的GATTS回调函数都在这个函数执行。首先，注册APP会进入这个函数执行case ESP_GATTS_REG_EVT:… ，在里面设置ble名字、设置广播数据(会进入GAP回调)、创建属性表(很重要，会进入GATTS回调)。创建属性表完成后会进入这个函数的case ESP_GATTS_CREAT_ATTR_TAB_EVT:…，这里打印一些内容后开始启动服务（属性表已经在程序上面定义的时候写好了）。
设置广播数据会进入GAP回调。在GAP回调函数中进入case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:…，开启广播，开启广播完成会进入这个函数的case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:…。至此，等待客户端ble来扫描、连接，然后客户端会读取属性表，所有的数据通讯就是通过这个属性表来完成的。

属性表

属性表在程序中定义。

static const esp_gatts_attr_db_t spp_gatt_db[SPP_IDX_NB] =
{
    //SPP -  Service Declaration
    [SPP_IDX_SVC]                       =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
    sizeof(spp_service_uuid), sizeof(spp_service_uuid), (uint8_t *)&spp_service_uuid}},

    //SPP -  data receive characteristic Declaration
    [SPP_IDX_SPP_DATA_RECV_CHAR]            =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},

    //SPP -  data receive characteristic Value
    [SPP_IDX_SPP_DATA_RECV_VAL]                 =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_receive_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    SPP_DATA_MAX_LEN,sizeof(spp_data_receive_val), (uint8_t *)spp_data_receive_val}},

    //SPP -  data notify characteristic Declaration
    [SPP_IDX_SPP_DATA_NOTIFY_CHAR]  =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},

    //SPP -  data notify characteristic Value
    [SPP_IDX_SPP_DATA_NTY_VAL]   =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_notify_uuid, ESP_GATT_PERM_READ,
    SPP_DATA_MAX_LEN, sizeof(spp_data_notify_val), (uint8_t *)spp_data_notify_val}},

    //SPP -  data notify characteristic - Client Characteristic Configuration Descriptor
    [SPP_IDX_SPP_DATA_NTF_CFG]         =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    sizeof(uint16_t),sizeof(spp_data_notify_ccc), (uint8_t *)spp_data_notify_ccc}},

    //SPP -  command characteristic Declaration
    [SPP_IDX_SPP_COMMAND_CHAR]            =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},

    //SPP -  command characteristic Value
    [SPP_IDX_SPP_COMMAND_VAL]                 =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_command_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    SPP_CMD_MAX_LEN,sizeof(spp_command_val), (uint8_t *)spp_command_val}},

    //SPP -  status characteristic Declaration
    [SPP_IDX_SPP_STATUS_CHAR]            =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},

    //SPP -  status characteristic Value
    [SPP_IDX_SPP_STATUS_VAL]                 =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_status_uuid, ESP_GATT_PERM_READ,
    SPP_STATUS_MAX_LEN,sizeof(spp_status_val), (uint8_t *)spp_status_val}},

    //SPP -  status characteristic - Client Characteristic Configuration Descriptor
    [SPP_IDX_SPP_STATUS_CFG]         =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    sizeof(uint16_t),sizeof(spp_status_ccc), (uint8_t *)spp_status_ccc}},

#ifdef SUPPORT_HEARTBEAT
    //SPP -  Heart beat characteristic Declaration
    [SPP_IDX_SPP_HEARTBEAT_CHAR]  =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}},

    //SPP -  Heart beat characteristic Value
    [SPP_IDX_SPP_HEARTBEAT_VAL]   =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_heart_beat_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    sizeof(spp_heart_beat_val), sizeof(spp_heart_beat_val), (uint8_t *)spp_heart_beat_val}},

    //SPP -  Heart beat characteristic - Client Characteristic Configuration Descriptor
    [SPP_IDX_SPP_HEARTBEAT_CFG]         =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    sizeof(uint16_t),sizeof(spp_data_notify_ccc), (uint8_t *)spp_heart_beat_ccc}},
#endif
};

查看esp_gatts_attr_db_t的结构，

typedef struct
{
    esp_attr_control_t      attr_control;                   /*!< The attribute control type */
    esp_attr_desc_t         att_desc;                       /*!< The attribute type */
} esp_gatts_attr_db_t;

由两部分组成，第一部分

typedef struct
{
#define ESP_GATT_RSP_BY_APP             0
#define ESP_GATT_AUTO_RSP               1
    /**
     * @brief if auto_rsp set to ESP_GATT_RSP_BY_APP, means the response of Write/Read operation will by replied by application.
              if auto_rsp set to ESP_GATT_AUTO_RSP, means the response of Write/Read operation will be replied by GATT stack automatically.
     */
    uint8_t auto_rsp;
} esp_attr_control_t;

只有一个数据，前面两个define表示了这个数据可以使用的值，ble服务器与客户端通讯，客户端对于服务器数据的读写是需要服务端回复的，这个回复可以由ESP底层完成、也可以由用户自己写程序完成，为了方便，demo使用了ESP库完成，选择ESP_GATT_AUTO_RSP
第二部分

typedef struct
 {
     uint16_t uuid_length;              /*!< UUID length */
     uint8_t  *uuid_p;                  /*!< UUID value */
     uint16_t perm;                     /*!< Attribute permission */
     uint16_t max_length;               /*!< Maximum length of the element*/
     uint16_t length;                   /*!< Current length of the element*/
     uint8_t  *value;                   /*!< Element value array*/
 } esp_attr_desc_t;

UUDI长度（demo使用16位）、UUDI数据、属性权限、数据最大长度、数据当前长度、数据。数据最大长度和数据当前长度区分：数据最大长度指示这个Attribute可以写入的数据最大的长度，数据当前长度指示Attribute当前只需要写入这么多个数据，两者可以不同的。
直接看属性表

//SPP -  Service Declaration
    [SPP_IDX_SVC]                       =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
    sizeof(spp_service_uuid), sizeof(spp_service_uuid), (uint8_t *)&spp_service_uuid}},

    //SPP -  data receive characteristic Declaration
    [SPP_IDX_SPP_DATA_RECV_CHAR]            =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},

    //SPP -  data receive characteristic Value
    [SPP_IDX_SPP_DATA_RECV_VAL]                 =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_receive_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    SPP_DATA_MAX_LEN,sizeof(spp_data_receive_val), (uint8_t *)spp_data_receive_val}},

    //SPP -  data notify characteristic Declaration
    [SPP_IDX_SPP_DATA_NOTIFY_CHAR]  =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
    CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},

    //SPP -  data notify characteristic Value
    [SPP_IDX_SPP_DATA_NTY_VAL]   =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_notify_uuid, ESP_GATT_PERM_READ,
    SPP_DATA_MAX_LEN, sizeof(spp_data_notify_val), (uint8_t *)spp_data_notify_val}},

    //SPP -  data notify characteristic - Client Characteristic Configuration Descriptor
    [SPP_IDX_SPP_DATA_NTF_CFG]         =
    {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
    sizeof(uint16_t),sizeof(spp_data_notify_ccc), (uint8_t *)spp_data_notify_ccc}},

根据前面的内容，server和char.是实体的，所以需要声明和定义它们，这个属性表就是这么一个作用，由于第一个参数是选择了ESP库自动回复，所以直接看第二个参数。
数组第一个元素是server的声明、第二个元素是数据接收char.声明、第三个元素是数据接收char.值定义、第四个是notify类的char.声明、第五个是notify类的char.值定义、第六个是客户端char.配置描述。
Server的声明是必须有的，它的UUID配置为primary_service_uuid，这个值为0x2800，查看下图，表明这个Attribute是一个服务声明
在这里插入图片描述
它的权限是只读，因为UUID都是固定的，所以只读。
它的值使用了自定义的UUID，只是一个标识。
Char.声明也是必须有的，其他和server声明类似，其中这里的值是ESP_GATT_CHAR_PROP_BIT_WRITE_NR|ESP_GATT_CHAR_PROP_BIT_READ，表示这个char.值是可以读写的，其中WRITE_NR表示无响应写操作,可以连续高效地接收客户端的数据
Char.数据定义也是必须有的，这里的值就是真正要传输的数据了。可以通过esp_ble_gatts_set_attr_value()函数来写这个属性表，当客户端来读取Attribute的时候就可以获取到这个值了。
Notify的Attribute和前面的类似，这个是一个通知，服务器可以通过这个Attribute发送一个通知，客户端就能马上收到通知就能获取数据（和上面修改属性表的方式发送数据相比，这种方式客户端能触发一个事件，不需要客户端主动读取属性表），还有一种类似的方式是指示。通知和指示的Attribute还必须配置一个Client Characteristic Configuration Descriptor(简称CCC)的Attribute，这里配置的值表示客户端是否能主动接收通知和指示，例如，在心率服务中，有一个称为心率测量的特征。 GATT 客户端（例如您的手机）可以使用该特征的 CCCD 来接收有关该特征的更新。因此，它通过在 CCCD 中启用所述特征的指示或通知来订阅心率测量特征。这意味着 GATT 服务器（很可能是心率传感器设备）会将这些测量结果推送到您的手机，而您的手机无需轮询这些测量结果。默认为0x00，0x00。这个Attribute可以通过客户端配置，所以必须可读可写。

蜗牛快跑丫
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【蓝牙协议栈】【BLE】【GATT】通用属性协议（超详细）
金陵岂是池中物的博客
02-05 3793
1. GATT概念1.1 GATT定义GATT：通用属性协议，它是低功耗蓝牙BLE设备之间进行通信的协议。GATT定义了一种多层的数据结构，已连接的低功耗蓝牙设备用它来进行通信，其定义的多层数据结构简要概括起来就是服务（service）可以包含多个特征（），每个特征包含属性（properties）和值（value），还可以包含多个描述（descriptor➢GATT基于ATT协议（属性协议）来承载的，属性协议主要用来发现、读写、通知和指示属性。➢GATT。
蓝牙协议分析包含物理层，链路层，ATT,GATT等协议分析
03-23
蓝牙协议分析包含物理层，链路层，ATT,GATT等协议分析
蓝牙 - GATT介绍
最新发布
guoqx的专栏
07-11 1044
接下来是 UUID 或属性类型。例如，SIG 采用的电池服务包含一个名为 "电池电量 "的特征，但它还包含其他非特征属性，这些属性有助于重组服务中的数据，如服务声明和包含定义等。GAP定义了服务及其特征的格式，以及用于与这些属性接口的程序，如服务发现、特征读取、特征写入、通知和指示，其作用与属性协议 ATT 相同。其中的例子包括用户描述、用于订阅通知和指示的字段，以及定义值的呈现方式（如值的格式和单位）的字段。服务中的属性有不同的类型，它们可以是持有值的特性，也可以是帮助构建服务中数据结构的非特性类型。
关于蓝牙协议中GATT、特性、属性解释
qq_26226375的博客
03-12 1万+
在蓝牙的学习中，一上来就要面对一大堆的专业名词。首先就是服务是什么？特性是什么？属性是什么？刚开始的时候查了很多资料都还是没有搞懂。这次就结合代码，尽量用最通俗易懂的方式将这些东西解释并记录下来，也希望能帮助到别人。（如果有不对的，也希望有大神能指出来） 通用属性配置文件（Generic Attribute Profile）GATT GATT主要定义了。服务器server和客户端client。而其他的服务、特性、属性都是在这个协议下的各种角色。他们的关系如下： 属性（Attribute） .
蓝牙----蓝牙协议栈GATT层
qq_43306777的博客
01-19 1666
通用属性配置文件（GATT），用来进行两个连接设备的数据通信，其中数据以特征值的方式传输与存储。GATT 层区分为 Server 和 Client。客户端读取和写入存储在服务端的特征值Server：(从机)该设备包含由 GATT 客户端读取或写入的 characteristic。Client：(主机)从 GATT 服务器读取或写入数据的蓝牙设备。
ESP32-C3 学习测试 蓝牙 篇（三、认识蓝牙 GATT 协议）
不浮夸，不将就，认真对待学知识的我们
05-26 7295
磨刀不误砍柴工，本文了解一些基本的蓝牙协议基础知识
蓝牙GATT协议文档--TI--BLE stack
12-24
蓝牙GATT协议描述文件，中文版，帮助你更好的理解蓝牙GATT协议，翻译自TI
蓝牙GATT协议
yzpbright的博客
03-16 4312
原文：Introduction to Bluetooth Low Energy ，作为 BLE 的入门时介绍是非常合适的。 现在低功耗蓝牙连接都是建立在 GATT (Generic Attribute Profile) 协议之上。GATT 是一个在蓝牙连接之上的发送和接收很短的数据段的通用规范，这些很短的数据段被称为属性（Attribute）。 GAP 详细介绍 GATT 之前，需要了解 GAP（Generic Access Profile），它在用来控制设备连接和广播。GAP 使你的设备被其他设备可见，并
GATT协议
夜影轩的专栏
05-05 4498
1.主要用于寻找和配置服务端的属性，其实就是寻找、配置和读写servcice端的各种attribute，使其按需要的方式工作。 它有两个角色：Server和Client，一个实际的例子： 2.概述 GATT使用Attribute Protocol来传输data: Opcode表示该PDU的类型，包括command, request, respon
安卓蓝牙GATT协议介绍
suwen8100的博客
06-20 3759
蓝牙GATT协议
蓝牙GATT协议介绍
热门推荐
Zzt的博客
11-09 1万+
原文：https://blog.csdn.net/u013378580/article/details/52891462  版权声明：本文为博主原创文章，转载请附上博文链接！ 在这之前我们得先了解一下一些专业词汇： 1、PROFILE profile可以理解为一种规范，一个标准的通信协议，它存在于从机中。蓝牙组织规定了一些标准的profile，例如 HID OVER GATT ，防丢器 ，心率计...
蓝牙通信协议
09-22
蓝牙协议:介绍蓝牙通信原理，已经蓝牙协议结构。
基于蓝牙的通信协议
08-12
基于android的蓝牙通信协议，很好用的
gatt.rar_BLUE_gatt_蓝牙协议gatt
09-24
标题中的“gatt.rar_BLUE_gatt_蓝牙协议gatt”暗示了这个压缩包与蓝牙（Bluetooth）技术有关，特别是GATT（Generic Attribute Profile）协议。GATT是蓝牙低功耗（Bluetooth Low Energy, BLE）的核心部分，用于设备间...
Android 蓝牙 BLE gatt协议扫描（scan）数据流程图（java-framework），将Android 源码使用
04-30
Android 蓝牙 BLE gatt协议扫描（scan）数据流程图（java-framework），将Android 源码使用流程图的形式画了出来，使Android 蓝牙开发者更清楚数据收发走向，代码流程更加形象生动，能够很快的熟悉Android 蓝牙源码...
【Bluetooth蓝牙开发】九、BLE协议之GATT
Donge's Blog
09-14 3210
1、开篇词 2、蓝牙开发入门 3、蓝牙协议栈总览 4、蓝牙协议栈——物理层 5、蓝牙协议栈——链路层 6、蓝牙协议栈——传输层 7、蓝牙协议栈——L2CAP协议 8、蓝牙协议栈——ATT协议 9、蓝牙协议栈——GATT协议 10、蓝牙通信流程分析 11、蓝牙协议栈——Bluez交叉编译 12、蓝牙调试工具汇总
蓝牙协议系列之（六） GATT
一个IT人的技术成长历程。
10-30 205
ATT之所以称作“protocol”，是因为它还比较抽象，仅仅定义了一套机制，允许client和server通过Attribute的形式共享信息。而具体共享哪些信息，ATT并不关心，这是GATT（Generic Attribute Profile）的主场。GATT相对ATT只多了一个‘G‘，但含义却大不同，因为GATT是一个profile（更准确的说是profile framework）。
蓝牙协议之GATT学习笔记
qq_40993639的博客
08-28 3167
学习 蓝牙协议栈的GATT
蓝牙bluetooth基础知识介绍+实战调试
a2591748032的博客
01-14 3726
蓝牙bluetooth基础知识介绍+实战调试
esp32蓝牙GATT协议介绍
04-04
ESP32是一款集成了Wi-Fi和蓝牙功能的微控制器，它支持蓝牙经典模式和低功耗蓝牙模式。在低功耗蓝牙模式下，ESP32支持GATT协议。 GATT（通用属性配置文件）协议是蓝牙低功耗设备之间通信的核心协议。它定义了一种通用的基于属性的协议，用于在低功耗蓝牙设备之间传输数据。GATT协议使得低功耗蓝牙设备之间的通信更加高效和可靠。 在ESP32上，GATT协议的实现需要使用BLE设备模块。BLE设备模块是ESP32开发板上的一个软件模块，它提供了与蓝牙低功耗设备通信所需的所有功能。通过使用BLE设备模块，ESP32可以充当GATT服务器或GATT客户端。 作为GATT服务器，ESP32可以提供属性服务和属性特征，供GATT客户端读取或写入数据。作为GATT客户端，ESP32可以扫描周围的低功耗蓝牙设备并连接到它们，然后读取或写入它们提供的属性服务和属性特征。 总之，ESP32的支持GATT协议为低功耗蓝牙设备之间的通信提供了更加高效和可靠的方式，使得开发低功耗蓝牙设备更加容易和便捷。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值