From ee3224bed2e5838aec024a23aebb01b35eb31082 Mon Sep 17 00:00:00 2001 From: zhiweijian Date: Wed, 1 Nov 2017 16:46:21 +0800 Subject: [PATCH] Component/bt: optimize gatt_server_service_table demo --- .../main/gatts_table_creat_demo.c | 585 ++++++++++++------ .../main/gatts_table_creat_demo.h | 28 +- 2 files changed, 406 insertions(+), 207 deletions(-) diff --git a/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.c b/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.c index facad9fd82..5c46a75ff7 100644 --- a/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.c +++ b/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.c @@ -12,55 +12,102 @@ // See the License for the specific language governing permissions and // limitations under the License. +/**************************************************************************** +* +* This file is for gatt server. It can send adv data, be connected by client. +* It is a Heart Rate PROFILE demo defined by Bluetooth SIG. +* +*****************************************************************************/ -#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 "bt.h" -#include "bta_api.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 "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_bt_main.h" #include "gatts_table_creat_demo.h" +#include "esp_gatt_common_api.h" #define GATTS_TABLE_TAG "GATTS_TABLE_DEMO" -#define HEART_PROFILE_NUM 1 -#define HEART_PROFILE_APP_IDX 0 -#define ESP_HEART_RATE_APP_ID 0x55 -#define SAMPLE_DEVICE_NAME "ESP_HEART_RATE" -#define SAMPLE_MANUFACTURER_DATA_LEN 17 -#define HEART_RATE_SVC_INST_ID 0 +#define PROFILE_NUM 1 +#define PROFILE_APP_IDX 0 +#define ESP_APP_ID 0x55 +#define SAMPLE_DEVICE_NAME "ESP_GATTS_DEMO" +#define SVC_INST_ID 0 -#define GATTS_DEMO_CHAR_VAL_LEN_MAX 0x40 +#define GATTS_DEMO_CHAR_VAL_LEN_MAX 100 +#define PREPARE_BUF_MAX_SIZE 1024 +#define CHAR_DECLARATION_SIZE (sizeof(uint8_t)) -uint8_t char1_str[] ={0x11,0x22,0x33}; +#define ADV_CONFIG_FLAG (1 << 0) +#define SCAN_RSP_CONFIG_FLAG (1 << 1) + +static uint8_t adv_config_done = 0; uint16_t heart_rate_handle_table[HRS_IDX_NB]; -esp_attr_value_t gatts_demo_char1_val = -{ - .attr_max_len = GATTS_DEMO_CHAR_VAL_LEN_MAX, - .attr_len = sizeof(char1_str), - .attr_value = char1_str, +typedef struct { + uint8_t *prepare_buf; + int prepare_len; +} prepare_type_env_t; + +static prepare_type_env_t prepare_write_env; + +#define CONFIG_SET_RAW_ADV_DATA +#ifdef CONFIG_SET_RAW_ADV_DATA +static uint8_t raw_adv_data[] = { + /* flags */ + 0x02, 0x01, 0x06, + /* tx power*/ + 0x02, 0x0a, 0xeb, + /* service uuid */ + 0x03, 0x03, 0xFF, 0x00, + /* device name */ + 0x0f, 0x09, 'E', 'S', 'P', '_', 'G', 'A', 'T', 'T', 'S', '_', 'D','E', 'M', 'O' +}; +static uint8_t raw_scan_rsp_data[] = { + /* flags */ + 0x02, 0x01, 0x06, + /* tx power */ + 0x02, 0x0a, 0xeb, + /* service uuid */ + 0x03, 0x03, 0xFF,0x00 }; - -static uint8_t heart_rate_service_uuid[16] = { +#else +static uint8_t service_uuid[16] = { /* LSB <--------------------------------------------------------------------------------> MSB */ //first uuid, 16bit, [12],[13] is the value - 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x18, 0x0D, 0x00, 0x00, + 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, }; +/* The length of adv data must be less than 31 bytes */ +static esp_ble_adv_data_t adv_data = { + .set_scan_rsp = false, + .include_name = true, + .include_txpower = true, + .min_interval = 0x20, + .max_interval = 0x40, + .appearance = 0x00, + .manufacturer_len = 0, //TEST_MANUFACTURER_DATA_LEN, + .p_manufacturer_data = NULL, //test_manufacturer, + .service_data_len = 0, + .p_service_data = NULL, + .service_uuid_len = sizeof(service_uuid), + .p_service_uuid = service_uuid, + .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT), +}; -static esp_ble_adv_data_t heart_rate_adv_config = { - .set_scan_rsp = false, +// scan response data +static esp_ble_adv_data_t scan_rsp_data = { + .set_scan_rsp = true, .include_name = true, .include_txpower = true, .min_interval = 0x20, @@ -70,20 +117,19 @@ static esp_ble_adv_data_t heart_rate_adv_config = { .p_manufacturer_data = NULL, //&test_manufacturer[0], .service_data_len = 0, .p_service_data = NULL, - .service_uuid_len = sizeof(heart_rate_service_uuid), - .p_service_uuid = heart_rate_service_uuid, + .service_uuid_len = 16, + .p_service_uuid = service_uuid, .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT), }; +#endif /* CONFIG_SET_RAW_ADV_DATA */ -static esp_ble_adv_params_t heart_rate_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, + .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY, }; struct gatts_profile_inst { @@ -101,211 +147,361 @@ struct gatts_profile_inst { esp_bt_uuid_t descr_uuid; }; -static void gatts_profile_event_handler(esp_gatts_cb_event_t event, +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); /* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */ -static struct gatts_profile_inst heart_rate_profile_tab[HEART_PROFILE_NUM] = { - [HEART_PROFILE_APP_IDX] = { +static struct gatts_profile_inst heart_rate_profile_tab[PROFILE_NUM] = { + [PROFILE_APP_IDX] = { .gatts_cb = gatts_profile_event_handler, .gatts_if = ESP_GATT_IF_NONE, /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */ }, - }; -/* - * HTPT PROFILE ATTRIBUTES - **************************************************************************************** - */ +/* Service */ +static const uint16_t GATTS_SERVICE_UUID_TEST = 0x00FF; +static const uint16_t GATTS_CHAR_UUID_TEST_A = 0xFF01; +static const uint16_t GATTS_CHAR_UUID_TEST_B = 0xFF02; +static const uint16_t GATTS_CHAR_UUID_TEST_C = 0xFF03; - -/* - * Heart Rate PROFILE ATTRIBUTES - **************************************************************************************** - */ - -/// Heart Rate Sensor Service -static const uint16_t heart_rate_svc = ESP_GATT_UUID_HEART_RATE_SVC; - -#define CHAR_DECLARATION_SIZE (sizeof(uint8_t)) -static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE; -static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE; +static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE; +static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE; static const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG; -static const uint8_t char_prop_notify = ESP_GATT_CHAR_PROP_BIT_NOTIFY; -static const uint8_t char_prop_read = ESP_GATT_CHAR_PROP_BIT_READ; -static const uint8_t char_prop_read_write = ESP_GATT_CHAR_PROP_BIT_WRITE|ESP_GATT_CHAR_PROP_BIT_READ; - -/// Heart Rate Sensor Service - Heart Rate Measurement Characteristic, notify -static const uint16_t heart_rate_meas_uuid = ESP_GATT_HEART_RATE_MEAS; -static const uint8_t heart_measurement_ccc[2] ={ 0x00, 0x00}; +static const uint8_t char_prop_read = ESP_GATT_CHAR_PROP_BIT_READ; +static const uint8_t char_prop_write = ESP_GATT_CHAR_PROP_BIT_WRITE; +static const uint8_t char_prop_read_write_notify = ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_NOTIFY; +static const uint8_t heart_measurement_ccc[2] = {0x00, 0x00}; +static const uint8_t char_value[4] = {0x11, 0x22, 0x33, 0x44}; -/// Heart Rate Sensor Service -Body Sensor Location characteristic, read -static const uint16_t body_sensor_location_uuid = ESP_GATT_BODY_SENSOR_LOCATION; -static const uint8_t body_sensor_loc_val[1] = {0x00}; - - -/// Heart Rate Sensor Service - Heart Rate Control Point characteristic, write&read -static const uint16_t heart_rate_ctrl_point = ESP_GATT_HEART_RATE_CNTL_POINT; -static const uint8_t heart_ctrl_point[1] = {0x00}; - -/// Full HRS Database Description - Used to add attributes into the database -static const esp_gatts_attr_db_t heart_rate_gatt_db[HRS_IDX_NB] = +/* Full Database Description - Used to add attributes into the database */ +static const esp_gatts_attr_db_t gatt_db[HRS_IDX_NB] = { - // Heart Rate Service Declaration - [HRS_IDX_SVC] = + // Service Declaration + [IDX_SVC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ, - sizeof(uint16_t), sizeof(heart_rate_svc), (uint8_t *)&heart_rate_svc}}, + sizeof(uint16_t), sizeof(GATTS_SERVICE_UUID_TEST), (uint8_t *)&GATTS_SERVICE_UUID_TEST}}, - // Heart Rate Measurement Characteristic Declaration - [HRS_IDX_HR_MEAS_CHAR] = + /* Characteristic Declaration */ + [IDX_CHAR_A] = {{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_notify}}, - - // Heart Rate Measurement Characteristic Value - [HRS_IDX_HR_MEAS_VAL] = - {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&heart_rate_meas_uuid, ESP_GATT_PERM_READ, - HRPS_HT_MEAS_MAX_LEN,0, NULL}}, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, - // Heart Rate Measurement Characteristic - Client Characteristic Configuration Descriptor - [HRS_IDX_HR_MEAS_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(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}}, + /* Characteristic Value */ + [IDX_CHAR_VAL_A] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_A, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, + GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}}, - // Body Sensor Location Characteristic Declaration - [HRS_IDX_BOBY_SENSOR_LOC_CHAR] = + /* Client Characteristic Configuration Descriptor */ + [IDX_CHAR_CFG_A] = + {{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(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}}, + + /* Characteristic Declaration */ + [IDX_CHAR_B] = {{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}}, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read}}, - // Body Sensor Location Characteristic Value - [HRS_IDX_BOBY_SENSOR_LOC_VAL] = - {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&body_sensor_location_uuid, ESP_GATT_PERM_READ, - sizeof(uint8_t), sizeof(body_sensor_loc_val), (uint8_t *)body_sensor_loc_val}}, + /* Characteristic Value */ + [IDX_CHAR_VAL_B] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_B, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, + GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}}, - // Heart Rate Control Point Characteristic Declaration - [HRS_IDX_HR_CTNL_PT_CHAR] = + /* Characteristic Declaration */ + [IDX_CHAR_C] = {{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}}, - - // Heart Rate Control Point Characteristic Value - [HRS_IDX_HR_CTNL_PT_VAL] = - {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&heart_rate_ctrl_point, ESP_GATT_PERM_WRITE|ESP_GATT_PERM_READ, - sizeof(uint8_t), sizeof(heart_ctrl_point), (uint8_t *)heart_ctrl_point}}, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_write}}, + + /* Characteristic Value */ + [IDX_CHAR_VAL_C] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_C, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, + GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}}, + }; - - static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) { - ESP_LOGE(GATTS_TABLE_TAG, "GAP_EVT, event %d\n", event); - switch (event) { - case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT: - esp_ble_gap_start_advertising(&heart_rate_adv_params); - break; - 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_TABLE_TAG, "Advertising start failed\n"); - } - break; - default: - break; + #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_TABLE_TAG, "advertising start failed\n"); + }else{ + ESP_LOGI(GATTS_TABLE_TAG, "advertising start successfully\n"); + } + break; + case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT: + if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS) { + ESP_LOGE(GATTS_TABLE_TAG, "Advertising stop failed\n"); + } + else { + ESP_LOGI(GATTS_TABLE_TAG, "Stop adv successfully\n"); + } + break; + case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT: + ESP_LOGI(GATTS_TABLE_TAG, "update connetion 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; } } -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) +void example_prepare_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param) { - ESP_LOGE(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(&heart_rate_adv_config); + ESP_LOGI(GATTS_TABLE_TAG, "prepare write, handle = %d, value len = %d", param->write.handle, param->write.len); + esp_gatt_status_t status = ESP_GATT_OK; + 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_TABLE_TAG, "%s, Gatt_server prep no mem\n", __func__); + 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; + } + } + /*send response when param->write.need_rsp is true */ + if (param->write.need_rsp){ + esp_gatt_rsp_t *gatt_rsp = (esp_gatt_rsp_t *)malloc(sizeof(esp_gatt_rsp_t)); + if (gatt_rsp != NULL){ + 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_TABLE_TAG, "Send response error\n"); + } + free(gatt_rsp); + }else{ + ESP_LOGE(GATTS_TABLE_TAG, "%s, malloc failed", __func__); + } + } + 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; - ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__); - esp_ble_gatts_create_attr_tab(heart_rate_gatt_db, gatts_if, - HRS_IDX_NB, HEART_RATE_SVC_INST_ID); - break; +} + +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 && prepare_write_env->prepare_buf){ + esp_log_buffer_hex(GATTS_TABLE_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len); + }else{ + ESP_LOGI(GATTS_TABLE_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; +} + +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) +{ + switch (event) { + case ESP_GATTS_REG_EVT:{ + esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME); + if (set_dev_name_ret){ + ESP_LOGE(GATTS_TABLE_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_TABLE_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_TABLE_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_TABLE_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_TABLE_TAG, "config scan response data failed, error code = %x", ret); + } + adv_config_done |= SCAN_RSP_CONFIG_FLAG; + #endif + esp_err_t create_attr_ret = esp_ble_gatts_create_attr_tab(gatt_db, gatts_if, HRS_IDX_NB, SVC_INST_ID); + if (create_attr_ret){ + ESP_LOGE(GATTS_TABLE_TAG, "create attr table failed, error code = %x", create_attr_ret); + } + } + break; case ESP_GATTS_READ_EVT: - - break; - case ESP_GATTS_WRITE_EVT: - break; + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_READ_EVT"); + break; + case ESP_GATTS_WRITE_EVT: + if (!param->write.is_prep){ + ESP_LOGI(GATTS_TABLE_TAG, "GATT_WRITE_EVT, handle = %d, value len = %d, value :", param->write.handle, param->write.len); + esp_log_buffer_hex(GATTS_TABLE_TAG, param->write.value, param->write.len); + if (heart_rate_handle_table[IDX_CHAR_CFG_A] == param->write.handle && param->write.len == 2){ + uint16_t descr_value = param->write.value[1]<<8 | param->write.value[0]; + if (descr_value == 0x0001){ + ESP_LOGI(GATTS_TABLE_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, heart_rate_handle_table[IDX_CHAR_VAL_A], + sizeof(notify_data), notify_data, false); + }else if (descr_value == 0x0002){ + ESP_LOGI(GATTS_TABLE_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, heart_rate_handle_table[IDX_CHAR_VAL_A], + sizeof(indicate_data), indicate_data, true); + } + else if (descr_value == 0x0000){ + ESP_LOGI(GATTS_TABLE_TAG, "notify/indicate disable "); + }else{ + ESP_LOGE(GATTS_TABLE_TAG, "unknown descr value"); + esp_log_buffer_hex(GATTS_TABLE_TAG, param->write.value, param->write.len); + } + + } + /* send response when param->write.need_rsp is true*/ + if (param->write.need_rsp){ + esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL); + } + }else{ + /* handle prepare write */ + example_prepare_write_event_env(gatts_if, &prepare_write_env, param); + } + break; case ESP_GATTS_EXEC_WRITE_EVT: - break; + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_EXEC_WRITE_EVT"); + example_exec_write_event_env(&prepare_write_env, param); + break; case ESP_GATTS_MTU_EVT: - break; - case ESP_GATTS_CONF_EVT: - break; - case ESP_GATTS_UNREG_EVT: - break; - case ESP_GATTS_DELETE_EVT: - break; + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu); + break; + case ESP_GATTS_CONF_EVT: + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_CONF_EVT, status = %d", param->conf.status); + break; case ESP_GATTS_START_EVT: - break; - case ESP_GATTS_STOP_EVT: + ESP_LOGI(GATTS_TABLE_TAG, "SERVICE_START_EVT, status %d, service_handle %d\n", param->start.status, param->start.service_handle); break; case ESP_GATTS_CONNECT_EVT: + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_CONNECT_EVT, conn_id = %d", param->connect.conn_id); + esp_log_buffer_hex(GATTS_TABLE_TAG, param->connect.remote_bda, 6); + 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 + //start sent the update connection parameters to the peer device. + esp_ble_gap_update_conn_params(&conn_params); break; case ESP_GATTS_DISCONNECT_EVT: - 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); + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_DISCONNECT_EVT, reason = %d", param->disconnect.reason); + esp_ble_gap_start_advertising(&adv_params); + break; + case ESP_GATTS_CREAT_ATTR_TAB_EVT:{ + 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 != HRS_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, HRS_IDX_NB); + } + else { + ESP_LOGI(GATTS_TABLE_TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle); + memcpy(heart_rate_handle_table, param->add_attr_tab.handles, sizeof(heart_rate_handle_table)); + esp_ble_gatts_start_service(heart_rate_handle_table[IDX_SVC]); + } + break; } - else if (param->add_attr_tab.num_handle != HRS_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, HRS_IDX_NB); - } - else { - memcpy(heart_rate_handle_table, param->add_attr_tab.handles, sizeof(heart_rate_handle_table)); - esp_ble_gatts_start_service(heart_rate_handle_table[HRS_IDX_SVC]); - } - break; - } - - default: - break; + case ESP_GATTS_STOP_EVT: + 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: + case ESP_GATTS_UNREG_EVT: + case ESP_GATTS_DELETE_EVT: + default: + break; } } -static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, - esp_ble_gatts_cb_param_t *param) +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) { - heart_rate_profile_tab[HEART_PROFILE_APP_IDX].gatts_if = gatts_if; + heart_rate_profile_tab[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, + 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 < HEART_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 == heart_rate_profile_tab[idx].gatts_if) { + for (idx = 0; idx < PROFILE_NUM; idx++) { + /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */ + if (gatts_if == ESP_GATT_IF_NONE || gatts_if == heart_rate_profile_tab[idx].gatts_if) { if (heart_rate_profile_tab[idx].gatts_cb) { heart_rate_profile_tab[idx].gatts_cb(event, gatts_if, param); } @@ -318,7 +514,7 @@ void app_main() { esp_err_t ret; - // Initialize NVS. + /* Initialize NVS. */ ret = nvs_flash_init(); if (ret == ESP_ERR_NVS_NO_FREE_PAGES) { ESP_ERROR_CHECK(nvs_flash_erase()); @@ -351,8 +547,23 @@ void app_main() return; } - esp_ble_gatts_register_callback(gatts_event_handler); - esp_ble_gap_register_callback(gap_event_handler); - esp_ble_gatts_app_register(ESP_HEART_RATE_APP_ID); - return; + ret = esp_ble_gatts_register_callback(gatts_event_handler); + if (ret){ + ESP_LOGE(GATTS_TABLE_TAG, "gatts register error, error code = %x", ret); + return; + } + ret = esp_ble_gap_register_callback(gap_event_handler); + if (ret){ + ESP_LOGE(GATTS_TABLE_TAG, "gap register error, error code = %x", ret); + return; + } + ret = esp_ble_gatts_app_register(ESP_APP_ID); + if (ret){ + ESP_LOGE(GATTS_TABLE_TAG, "gatts app register error, error code = %x", ret); + return; + } + esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500); + if (local_mtu_ret){ + ESP_LOGE(GATTS_TABLE_TAG, "set local MTU failed, error code = %x", local_mtu_ret); + } } diff --git a/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.h b/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.h index c12d1aa59b..cdf2deb8e1 100644 --- a/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.h +++ b/examples/bluetooth/gatt_server_service_table/main/gatts_table_creat_demo.h @@ -17,32 +17,20 @@ #include #include -/* - * DEFINES - **************************************************************************************** - */ - -#define HRPS_HT_MEAS_MAX_LEN (13) - -#define HRPS_MANDATORY_MASK (0x0F) -#define HRPS_BODY_SENSOR_LOC_MASK (0x30) -#define HRPS_HR_CTNL_PT_MASK (0xC0) - ///Attributes State Machine enum { - HRS_IDX_SVC, + IDX_SVC, + IDX_CHAR_A, + IDX_CHAR_VAL_A, + IDX_CHAR_CFG_A, - HRS_IDX_HR_MEAS_CHAR, - HRS_IDX_HR_MEAS_VAL, - HRS_IDX_HR_MEAS_NTF_CFG, + IDX_CHAR_B, + IDX_CHAR_VAL_B, - HRS_IDX_BOBY_SENSOR_LOC_CHAR, - HRS_IDX_BOBY_SENSOR_LOC_VAL, - - HRS_IDX_HR_CTNL_PT_CHAR, - HRS_IDX_HR_CTNL_PT_VAL, + IDX_CHAR_C, + IDX_CHAR_VAL_C, HRS_IDX_NB, };