espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-07-30 18:57:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor(bt/bluedroid): Refactor the print for gatt_server and gatt_client example

Browse Source
This commit is contained in:
chenjianhua
2024-08-05 17:31:20 +08:00
committed by BLE BOT
parent 795e2bbae1
commit f4d50858e6
7 changed files with 149 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
components/bt/host/bluedroid/api/esp_bt_main.c
View File

@ -213,3 +213,14 @@ esp_err_t esp_bluedroid_deinit(void)
return ESP_OK; return ESP_OK;
} }
#if defined(CONFIG_EXAMPLE_CI_ID) && defined(CONFIG_EXAMPLE_CI_PIPELINE_ID)
char *esp_bluedroid_get_example_name(void)
{
static char example_name[ESP_BLE_ADV_NAME_LEN_MAX];
memset(example_name, 0, sizeof(example_name));
sprintf(example_name, "BE%02X_%05X_%02X", CONFIG_EXAMPLE_CI_ID & 0xFF,
CONFIG_EXAMPLE_CI_PIPELINE_ID & 0xFFFFF, CONFIG_IDF_FIRMWARE_CHIP_ID & 0xFF);
return example_name;
}
#endif

2
components/bt/host/bluedroid/api/include/api/esp_bt_defs.h
View File

@ -209,6 +209,8 @@ typedef uint8_t esp_ble_key_mask_t; /* the key mask type */
#define ESP_BD_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x" #define ESP_BD_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x"
#define ESP_BD_ADDR_HEX(addr) addr[0], addr[1], addr[2], addr[3], addr[4], addr[5] #define ESP_BD_ADDR_HEX(addr) addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]
#define ESP_BLE_ADV_NAME_LEN_MAX 29
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

5
components/bt/host/bluedroid/api/include/api/esp_bt_main.h
View File

@ -69,6 +69,11 @@ esp_err_t esp_bluedroid_init(void);
*/ */
esp_err_t esp_bluedroid_deinit(void); esp_err_t esp_bluedroid_deinit(void);
#if defined(CONFIG_EXAMPLE_CI_ID) && defined(CONFIG_EXAMPLE_CI_PIPELINE_ID)
// Only for internal used (CI example test)
char *esp_bluedroid_get_example_name(void);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

12
examples/bluetooth/bluedroid/ble/gatt_client/main/Kconfig.projbuild
View File

@ -4,4 +4,16 @@ menu "Example Configuration"
bool "Dump whole adv data and scan response data in example" bool "Dump whole adv data and scan response data in example"
default n default n
config EXAMPLE_CI_ID
int
default 70
help
This config the example id for CI test. Only for internal used.
config EXAMPLE_CI_PIPELINE_ID
int "The pipeline id for CI test"
default 0
help
This config the pipeline id for CI test. Only for internal used.
endmenu endmenu

93
examples/bluetooth/bluedroid/ble/gatt_client/main/gattc_demo.c
View File

@ -38,7 +38,7 @@
#define PROFILE_A_APP_ID 0 #define PROFILE_A_APP_ID 0
#define INVALID_HANDLE 0 #define INVALID_HANDLE 0
static const char remote_device_name[] = "ESP_GATTS_DEMO"; static char remote_device_name[ESP_BLE_ADV_NAME_LEN_MAX] = "ESP_GATTS_DEMO";
static bool connect = false; static bool connect = false;
static bool get_server = false; static bool get_server = false;
static esp_gattc_char_elem_t *char_elem_result = NULL; static esp_gattc_char_elem_t *char_elem_result = NULL;
@ -99,50 +99,46 @@ static void gattc_profile_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
switch (event) { switch (event) {
case ESP_GATTC_REG_EVT: case ESP_GATTC_REG_EVT:
ESP_LOGI(GATTC_TAG, "REG_EVT"); ESP_LOGI(GATTC_TAG, "GATTC application register, status %d, app_id %d", param->reg.status, param->reg.app_id);
esp_err_t scan_ret = esp_ble_gap_set_scan_params(&ble_scan_params); esp_err_t scan_ret = esp_ble_gap_set_scan_params(&ble_scan_params);
if (scan_ret){ if (scan_ret){
ESP_LOGE(GATTC_TAG, "set scan params error, error code = %x", scan_ret); ESP_LOGE(GATTC_TAG, "set scan params error, error code = %x", scan_ret);
} }
break; break;
case ESP_GATTC_CONNECT_EVT:{ case ESP_GATTC_CONNECT_EVT:{
ESP_LOGI(GATTC_TAG, "ESP_GATTC_CONNECT_EVT conn_id %d, if %d", p_data->connect.conn_id, gattc_if); ESP_LOGI(GATTC_TAG, "Connected, conn_id %d, remote "ESP_BD_ADDR_STR"", p_data->connect.conn_id,
ESP_BD_ADDR_HEX(p_data->connect.remote_bda));
gl_profile_tab[PROFILE_A_APP_ID].conn_id = p_data->connect.conn_id; gl_profile_tab[PROFILE_A_APP_ID].conn_id = p_data->connect.conn_id;
memcpy(gl_profile_tab[PROFILE_A_APP_ID].remote_bda, p_data->connect.remote_bda, sizeof(esp_bd_addr_t)); memcpy(gl_profile_tab[PROFILE_A_APP_ID].remote_bda, p_data->connect.remote_bda, sizeof(esp_bd_addr_t));
ESP_LOGI(GATTC_TAG, "REMOTE BDA:");
esp_log_buffer_hex(GATTC_TAG, gl_profile_tab[PROFILE_A_APP_ID].remote_bda, sizeof(esp_bd_addr_t));
esp_err_t mtu_ret = esp_ble_gattc_send_mtu_req (gattc_if, p_data->connect.conn_id); esp_err_t mtu_ret = esp_ble_gattc_send_mtu_req (gattc_if, p_data->connect.conn_id);
if (mtu_ret){ if (mtu_ret){
ESP_LOGE(GATTC_TAG, "config MTU error, error code = %x", mtu_ret); ESP_LOGE(GATTC_TAG, "Config MTU error, error code = %x", mtu_ret);
} }
break; break;
} }
case ESP_GATTC_OPEN_EVT: case ESP_GATTC_OPEN_EVT:
if (param->open.status != ESP_GATT_OK){ if (param->open.status != ESP_GATT_OK){
ESP_LOGE(GATTC_TAG, "open failed, status %d", p_data->open.status); ESP_LOGE(GATTC_TAG, "Open failed, status %d", p_data->open.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "open success"); ESP_LOGI(GATTC_TAG, "Open successfully, mtu %u", p_data->open.mtu);
break; break;
case ESP_GATTC_DIS_SRVC_CMPL_EVT: case ESP_GATTC_DIS_SRVC_CMPL_EVT:
if (param->dis_srvc_cmpl.status != ESP_GATT_OK){ if (param->dis_srvc_cmpl.status != ESP_GATT_OK){
ESP_LOGE(GATTC_TAG, "discover service failed, status %d", param->dis_srvc_cmpl.status); ESP_LOGE(GATTC_TAG, "Service discover failed, status %d", param->dis_srvc_cmpl.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "discover service complete conn_id %d", param->dis_srvc_cmpl.conn_id); ESP_LOGI(GATTC_TAG, "Service discover complete, conn_id %d", param->dis_srvc_cmpl.conn_id);
esp_ble_gattc_search_service(gattc_if, param->dis_srvc_cmpl.conn_id, &remote_filter_service_uuid); esp_ble_gattc_search_service(gattc_if, param->dis_srvc_cmpl.conn_id, &remote_filter_service_uuid);
break; break;
case ESP_GATTC_CFG_MTU_EVT: case ESP_GATTC_CFG_MTU_EVT:
if (param->cfg_mtu.status != ESP_GATT_OK){ ESP_LOGI(GATTC_TAG, "MTU exchange, status %d, MTU %d, conn_id %d", param->cfg_mtu.status, param->cfg_mtu.mtu, param->cfg_mtu.conn_id);
ESP_LOGE(GATTC_TAG,"config mtu failed, error status = %x", param->cfg_mtu.status);
}
ESP_LOGI(GATTC_TAG, "ESP_GATTC_CFG_MTU_EVT, Status %d, MTU %d, conn_id %d", param->cfg_mtu.status, param->cfg_mtu.mtu, param->cfg_mtu.conn_id);
break; break;
case ESP_GATTC_SEARCH_RES_EVT: { case ESP_GATTC_SEARCH_RES_EVT: {
ESP_LOGI(GATTC_TAG, "SEARCH RES: conn_id = %x is primary service %d", p_data->search_res.conn_id, p_data->search_res.is_primary); ESP_LOGI(GATTC_TAG, "Search result, conn_id = %x, is primary service %d", p_data->search_res.conn_id, p_data->search_res.is_primary);
ESP_LOGI(GATTC_TAG, "start handle %d end handle %d current handle value %d", p_data->search_res.start_handle, p_data->search_res.end_handle, p_data->search_res.srvc_id.inst_id); ESP_LOGI(GATTC_TAG, "start handle %d, end handle %d, current handle value %d", p_data->search_res.start_handle, p_data->search_res.end_handle, p_data->search_res.srvc_id.inst_id);
if (p_data->search_res.srvc_id.uuid.len == ESP_UUID_LEN_16 && p_data->search_res.srvc_id.uuid.uuid.uuid16 == REMOTE_SERVICE_UUID) { if (p_data->search_res.srvc_id.uuid.len == ESP_UUID_LEN_16 && p_data->search_res.srvc_id.uuid.uuid.uuid16 == REMOTE_SERVICE_UUID) {
ESP_LOGI(GATTC_TAG, "service found"); ESP_LOGI(GATTC_TAG, "Service found");
get_server = true; get_server = true;
gl_profile_tab[PROFILE_A_APP_ID].service_start_handle = p_data->search_res.start_handle; gl_profile_tab[PROFILE_A_APP_ID].service_start_handle = p_data->search_res.start_handle;
gl_profile_tab[PROFILE_A_APP_ID].service_end_handle = p_data->search_res.end_handle; gl_profile_tab[PROFILE_A_APP_ID].service_end_handle = p_data->search_res.end_handle;
@ -152,7 +148,7 @@ static void gattc_profile_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
} }
case ESP_GATTC_SEARCH_CMPL_EVT: case ESP_GATTC_SEARCH_CMPL_EVT:
if (p_data->search_cmpl.status != ESP_GATT_OK){ if (p_data->search_cmpl.status != ESP_GATT_OK){
ESP_LOGE(GATTC_TAG, "search service failed, error status = %x", p_data->search_cmpl.status); ESP_LOGE(GATTC_TAG, "Service search failed, status %x", p_data->search_cmpl.status);
break; break;
} }
if(p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_REMOTE_DEVICE) { if(p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_REMOTE_DEVICE) {
@ -160,9 +156,9 @@ static void gattc_profile_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
} else if (p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_NVS_FLASH) { } else if (p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_NVS_FLASH) {
ESP_LOGI(GATTC_TAG, "Get service information from flash"); ESP_LOGI(GATTC_TAG, "Get service information from flash");
} else { } else {
ESP_LOGI(GATTC_TAG, "unknown service source"); ESP_LOGI(GATTC_TAG, "Unknown service source");
} }
ESP_LOGI(GATTC_TAG, "ESP_GATTC_SEARCH_CMPL_EVT"); ESP_LOGI(GATTC_TAG, "Service search complete");
if (get_server){ if (get_server){
uint16_t count = 0; uint16_t count = 0;
esp_gatt_status_t status = esp_ble_gattc_get_attr_count( gattc_if, esp_gatt_status_t status = esp_ble_gattc_get_attr_count( gattc_if,
@ -206,10 +202,10 @@ static void gattc_profile_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
} }
break; break;
case ESP_GATTC_REG_FOR_NOTIFY_EVT: { case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
ESP_LOGI(GATTC_TAG, "ESP_GATTC_REG_FOR_NOTIFY_EVT");
if (p_data->reg_for_notify.status != ESP_GATT_OK){ if (p_data->reg_for_notify.status != ESP_GATT_OK){
ESP_LOGE(GATTC_TAG, "REG FOR NOTIFY failed: error status = %d", p_data->reg_for_notify.status); ESP_LOGE(GATTC_TAG, "Notification register failed, status %d", p_data->reg_for_notify.status);
}else{ }else{
ESP_LOGI(GATTC_TAG, "Notification register successfully");
uint16_t count = 0; uint16_t count = 0;
uint16_t notify_en = 1; uint16_t notify_en = 1;
esp_gatt_status_t ret_status = esp_ble_gattc_get_attr_count( gattc_if, esp_gatt_status_t ret_status = esp_ble_gattc_get_attr_count( gattc_if,
@ -264,18 +260,18 @@ static void gattc_profile_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
} }
case ESP_GATTC_NOTIFY_EVT: case ESP_GATTC_NOTIFY_EVT:
if (p_data->notify.is_notify){ if (p_data->notify.is_notify){
ESP_LOGI(GATTC_TAG, "ESP_GATTC_NOTIFY_EVT, receive notify value:"); ESP_LOGI(GATTC_TAG, "Notification received");
}else{ }else{
ESP_LOGI(GATTC_TAG, "ESP_GATTC_NOTIFY_EVT, receive indicate value:"); ESP_LOGI(GATTC_TAG, "Indication received");
} }
esp_log_buffer_hex(GATTC_TAG, p_data->notify.value, p_data->notify.value_len); esp_log_buffer_hex(GATTC_TAG, p_data->notify.value, p_data->notify.value_len);
break; break;
case ESP_GATTC_WRITE_DESCR_EVT: case ESP_GATTC_WRITE_DESCR_EVT:
if (p_data->write.status != ESP_GATT_OK){ if (p_data->write.status != ESP_GATT_OK){
ESP_LOGE(GATTC_TAG, "write descr failed, error status = %x", p_data->write.status); ESP_LOGE(GATTC_TAG, "Descriptor write failed, status %x", p_data->write.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "write descr success "); ESP_LOGI(GATTC_TAG, "Descriptor write successfully");
uint8_t write_char_data[35]; uint8_t write_char_data[35];
for (int i = 0; i < sizeof(write_char_data); ++i) for (int i = 0; i < sizeof(write_char_data); ++i)
{ {
@ -292,21 +288,21 @@ static void gattc_profile_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
case ESP_GATTC_SRVC_CHG_EVT: { case ESP_GATTC_SRVC_CHG_EVT: {
esp_bd_addr_t bda; esp_bd_addr_t bda;
memcpy(bda, p_data->srvc_chg.remote_bda, sizeof(esp_bd_addr_t)); memcpy(bda, p_data->srvc_chg.remote_bda, sizeof(esp_bd_addr_t));
ESP_LOGI(GATTC_TAG, "ESP_GATTC_SRVC_CHG_EVT, bd_addr:"); ESP_LOGI(GATTC_TAG, "Service change from "ESP_BD_ADDR_STR"", ESP_BD_ADDR_HEX(bda));
esp_log_buffer_hex(GATTC_TAG, bda, sizeof(esp_bd_addr_t));
break; break;
} }
case ESP_GATTC_WRITE_CHAR_EVT: case ESP_GATTC_WRITE_CHAR_EVT:
if (p_data->write.status != ESP_GATT_OK){ if (p_data->write.status != ESP_GATT_OK){
ESP_LOGE(GATTC_TAG, "write char failed, error status = %x", p_data->write.status); ESP_LOGE(GATTC_TAG, "Characteristic write failed, status %x)", p_data->write.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "write char success "); ESP_LOGI(GATTC_TAG, "Characteristic write successfully");
break; break;
case ESP_GATTC_DISCONNECT_EVT: case ESP_GATTC_DISCONNECT_EVT:
connect = false; connect = false;
get_server = false; get_server = false;
ESP_LOGI(GATTC_TAG, "ESP_GATTC_DISCONNECT_EVT, reason = %d", p_data->disconnect.reason); ESP_LOGI(GATTC_TAG, "Disconnected, remote "ESP_BD_ADDR_STR", reason 0x%02x",
ESP_BD_ADDR_HEX(p_data->disconnect.remote_bda), p_data->disconnect.reason);
break; break;
default: default:
break; break;
@ -327,24 +323,22 @@ static void esp_gap_cb(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *par
case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT: case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
//scan start complete event to indicate scan start successfully or failed //scan start complete event to indicate scan start successfully or failed
if (param->scan_start_cmpl.status != ESP_BT_STATUS_SUCCESS) { if (param->scan_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
ESP_LOGE(GATTC_TAG, "scan start failed, error status = %x", param->scan_start_cmpl.status); ESP_LOGE(GATTC_TAG, "Scanning start failed, status %x", param->scan_start_cmpl.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "scan start success"); ESP_LOGI(GATTC_TAG, "Scanning start successfully");
break; break;
case ESP_GAP_BLE_SCAN_RESULT_EVT: { case ESP_GAP_BLE_SCAN_RESULT_EVT: {
esp_ble_gap_cb_param_t *scan_result = (esp_ble_gap_cb_param_t *)param; esp_ble_gap_cb_param_t *scan_result = (esp_ble_gap_cb_param_t *)param;
switch (scan_result->scan_rst.search_evt) { switch (scan_result->scan_rst.search_evt) {
case ESP_GAP_SEARCH_INQ_RES_EVT: case ESP_GAP_SEARCH_INQ_RES_EVT:
esp_log_buffer_hex(GATTC_TAG, scan_result->scan_rst.bda, 6);
ESP_LOGI(GATTC_TAG, "searched Adv Data Len %d, Scan Response Len %d", scan_result->scan_rst.adv_data_len, scan_result->scan_rst.scan_rsp_len);
adv_name = esp_ble_resolve_adv_data_by_type(scan_result->scan_rst.ble_adv, adv_name = esp_ble_resolve_adv_data_by_type(scan_result->scan_rst.ble_adv,
scan_result->scan_rst.adv_data_len + scan_result->scan_rst.scan_rsp_len, scan_result->scan_rst.adv_data_len + scan_result->scan_rst.scan_rsp_len,
ESP_BLE_AD_TYPE_NAME_CMPL, ESP_BLE_AD_TYPE_NAME_CMPL,
&adv_name_len); &adv_name_len);
ESP_LOGI(GATTC_TAG, "searched Device Name Len %d", adv_name_len); ESP_LOGI(GATTC_TAG, "Scan result, device "ESP_BD_ADDR_STR", name len %u", ESP_BD_ADDR_HEX(scan_result->scan_rst.bda), adv_name_len);
esp_log_buffer_char(GATTC_TAG, adv_name, adv_name_len); ESP_LOG_BUFFER_CHAR(GATTC_TAG, adv_name, adv_name_len);
#if CONFIG_EXAMPLE_DUMP_ADV_DATA_AND_SCAN_RESP #if CONFIG_EXAMPLE_DUMP_ADV_DATA_AND_SCAN_RESP
if (scan_result->scan_rst.adv_data_len > 0) { if (scan_result->scan_rst.adv_data_len > 0) {
@ -356,14 +350,13 @@ static void esp_gap_cb(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *par
esp_log_buffer_hex(GATTC_TAG, &scan_result->scan_rst.ble_adv[scan_result->scan_rst.adv_data_len], scan_result->scan_rst.scan_rsp_len); esp_log_buffer_hex(GATTC_TAG, &scan_result->scan_rst.ble_adv[scan_result->scan_rst.adv_data_len], scan_result->scan_rst.scan_rsp_len);
} }
#endif #endif
ESP_LOGI(GATTC_TAG, "\n");
if (adv_name != NULL) { if (adv_name != NULL) {
if (strlen(remote_device_name) == adv_name_len && strncmp((char *)adv_name, remote_device_name, adv_name_len) == 0) { if (strlen(remote_device_name) == adv_name_len && strncmp((char *)adv_name, remote_device_name, adv_name_len) == 0) {
ESP_LOGI(GATTC_TAG, "searched device %s\n", remote_device_name); ESP_LOGI(GATTC_TAG, "Device found %s", remote_device_name);
if (connect == false) { if (connect == false) {
connect = true; connect = true;
ESP_LOGI(GATTC_TAG, "connect to the remote device."); ESP_LOGI(GATTC_TAG, "Connect to "ESP_BD_ADDR_STR"", ESP_BD_ADDR_HEX(scan_result->scan_rst.bda));
esp_ble_gap_stop_scanning(); esp_ble_gap_stop_scanning();
esp_ble_gattc_open(gl_profile_tab[PROFILE_A_APP_ID].gattc_if, scan_result->scan_rst.bda, scan_result->scan_rst.ble_addr_type, true); esp_ble_gattc_open(gl_profile_tab[PROFILE_A_APP_ID].gattc_if, scan_result->scan_rst.bda, scan_result->scan_rst.ble_addr_type, true);
} }
@ -380,31 +373,31 @@ static void esp_gap_cb(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *par
case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT: case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
if (param->scan_stop_cmpl.status != ESP_BT_STATUS_SUCCESS){ if (param->scan_stop_cmpl.status != ESP_BT_STATUS_SUCCESS){
ESP_LOGE(GATTC_TAG, "scan stop failed, error status = %x", param->scan_stop_cmpl.status); ESP_LOGE(GATTC_TAG, "Scanning stop failed, status %x", param->scan_stop_cmpl.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "stop scan successfully"); ESP_LOGI(GATTC_TAG, "Scanning stop successfully");
break; break;
case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT: case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS){ if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS){
ESP_LOGE(GATTC_TAG, "adv stop failed, error status = %x", param->adv_stop_cmpl.status); ESP_LOGE(GATTC_TAG, "Advertising stop failed, status %x", param->adv_stop_cmpl.status);
break; break;
} }
ESP_LOGI(GATTC_TAG, "stop adv successfully"); ESP_LOGI(GATTC_TAG, "Advertising stop successfully");
break; break;
case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT: case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
ESP_LOGI(GATTC_TAG, "update connection params status = %d, conn_int = %d, latency = %d, timeout = %d", ESP_LOGI(GATTC_TAG, "Connection params update, status %d, conn_int %d, latency %d, timeout %d",
param->update_conn_params.status, param->update_conn_params.status,
param->update_conn_params.conn_int, param->update_conn_params.conn_int,
param->update_conn_params.latency, param->update_conn_params.latency,
param->update_conn_params.timeout); param->update_conn_params.timeout);
break; break;
case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT: case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
ESP_LOGI(GATTC_TAG, "packet length updated: rx = %d, tx = %d, status = %d", ESP_LOGI(GATTC_TAG, "Packet length update, status %d, rx %d, tx %d",
param->pkt_data_length_cmpl.status,
param->pkt_data_length_cmpl.params.rx_len, param->pkt_data_length_cmpl.params.rx_len,
param->pkt_data_length_cmpl.params.tx_len, param->pkt_data_length_cmpl.params.tx_len);
param->pkt_data_length_cmpl.status);
break; break;
default: default:
break; break;
@ -450,6 +443,10 @@ void app_main(void)
} }
ESP_ERROR_CHECK( ret ); ESP_ERROR_CHECK( ret );
#if CONFIG_EXAMPLE_CI_PIPELINE_ID
memcpy(remote_device_name, esp_bluedroid_get_example_name(), sizeof(remote_device_name));
#endif
ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT)); ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT(); esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();

14
examples/bluetooth/bluedroid/ble/gatt_server/main/Kconfig.projbuild
View File

@ -1,6 +1,6 @@
menu "Example 'GATT SERVER' Config" menu "Example 'GATT SERVER' Config"
config SET_RAW_ADV_DATA config EXAMPLE_SET_RAW_ADV_DATA
bool "Use raw data for advertising packets and scan response data" bool "Use raw data for advertising packets and scan response data"
help help
If this config item is set, raw binary data will be used to generate advertising & scan response data. If this config item is set, raw binary data will be used to generate advertising & scan response data.
@ -11,4 +11,16 @@ menu "Example 'GATT SERVER' Config"
esp_ble_adv_data_t structure. The lower layer will generate the BLE packets. This option has higher esp_ble_adv_data_t structure. The lower layer will generate the BLE packets. This option has higher
overhead at runtime. overhead at runtime.
config EXAMPLE_CI_ID
int
default 70
help
This config the example id for CI test. Only for internal used.
config EXAMPLE_CI_PIPELINE_ID
int "The pipeline id for CI test"
default 0
help
This config the pipeline id for CI test. Only for internal used.
endmenu endmenu

118
examples/bluetooth/bluedroid/ble/gatt_server/main/gatts_demo.c
View File

@ -50,7 +50,8 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
#define GATTS_DESCR_UUID_TEST_B 0x2222 #define GATTS_DESCR_UUID_TEST_B 0x2222
#define GATTS_NUM_HANDLE_TEST_B 4 #define GATTS_NUM_HANDLE_TEST_B 4
#define TEST_DEVICE_NAME "ESP_GATTS_DEMO" static char test_device_name[ESP_BLE_ADV_NAME_LEN_MAX] = "ESP_GATTS_DEMO";
#define TEST_MANUFACTURER_DATA_LEN 17 #define TEST_MANUFACTURER_DATA_LEN 17
#define GATTS_DEMO_CHAR_VAL_LEN_MAX 0x40 #define GATTS_DEMO_CHAR_VAL_LEN_MAX 0x40
@ -72,7 +73,7 @@ static uint8_t adv_config_done = 0;
#define adv_config_flag (1 << 0) #define adv_config_flag (1 << 0)
#define scan_rsp_config_flag (1 << 1) #define scan_rsp_config_flag (1 << 1)
#ifdef CONFIG_SET_RAW_ADV_DATA #ifdef CONFIG_EXAMPLE_SET_RAW_ADV_DATA
static uint8_t raw_adv_data[] = { static uint8_t raw_adv_data[] = {
/* Flags */ /* Flags */
0x02, ESP_BLE_AD_TYPE_FLAG, 0x06, // Length 2, Data Type ESP_BLE_AD_TYPE_FLAG, Data 1 (LE General Discoverable Mode, BR/EDR Not Supported) 0x02, ESP_BLE_AD_TYPE_FLAG, 0x06, // Length 2, Data Type ESP_BLE_AD_TYPE_FLAG, Data 1 (LE General Discoverable Mode, BR/EDR Not Supported)
@ -219,28 +220,30 @@ static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param
case ESP_GAP_BLE_ADV_START_COMPLETE_EVT: case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
//advertising start complete event to indicate advertising start successfully or failed //advertising start complete event to indicate advertising start successfully or failed
if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) { if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
ESP_LOGE(GATTS_TAG, "Advertising start failed\n"); ESP_LOGE(GATTS_TAG, "Advertising start failed, status %d", param->adv_start_cmpl.status);
break;
} }
ESP_LOGI(GATTS_TAG, "Advertising start successfully");
break; break;
case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT: case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS) { if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
ESP_LOGE(GATTS_TAG, "Advertising stop failed\n"); ESP_LOGE(GATTS_TAG, "Advertising stop failed, status %d", param->adv_stop_cmpl.status);
} else { break;
ESP_LOGI(GATTS_TAG, "Stop adv successfully\n");
} }
ESP_LOGI(GATTS_TAG, "Advertising stop successfully");
break; break;
case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT: case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
ESP_LOGI(GATTS_TAG, "update connection params status = %d, conn_int = %d, latency = %d, timeout = %d", ESP_LOGI(GATTS_TAG, "Connection params update, status %d, conn_int %d, latency %d, timeout %d",
param->update_conn_params.status, param->update_conn_params.status,
param->update_conn_params.conn_int, param->update_conn_params.conn_int,
param->update_conn_params.latency, param->update_conn_params.latency,
param->update_conn_params.timeout); param->update_conn_params.timeout);
break; break;
case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT: case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
ESP_LOGI(GATTS_TAG, "packet length updated: rx = %d, tx = %d, status = %d", ESP_LOGI(GATTS_TAG, "Packet length update, status %d, rx %d, tx %d",
param->pkt_data_length_cmpl.status,
param->pkt_data_length_cmpl.params.rx_len, param->pkt_data_length_cmpl.params.rx_len,
param->pkt_data_length_cmpl.params.tx_len, param->pkt_data_length_cmpl.params.tx_len);
param->pkt_data_length_cmpl.status);
break; break;
default: default:
break; break;
@ -294,7 +297,7 @@ void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble
if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC){ if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC){
esp_log_buffer_hex(GATTS_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len); esp_log_buffer_hex(GATTS_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len);
}else{ }else{
ESP_LOGI(GATTS_TAG,"ESP_GATT_PREP_WRITE_CANCEL"); ESP_LOGI(GATTS_TAG,"Prepare write cancel");
} }
if (prepare_write_env->prepare_buf) { if (prepare_write_env->prepare_buf) {
free(prepare_write_env->prepare_buf); free(prepare_write_env->prepare_buf);
@ -306,17 +309,17 @@ void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble
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) { 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) { switch (event) {
case ESP_GATTS_REG_EVT: 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); ESP_LOGI(GATTS_TAG, "GATTS application register, status %d, app_id %d", param->reg.status, param->reg.app_id);
gl_profile_tab[PROFILE_A_APP_ID].service_id.is_primary = true; gl_profile_tab[PROFILE_A_APP_ID].service_id.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.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.len = ESP_UUID_LEN_16;
gl_profile_tab[PROFILE_A_APP_ID].service_id.id.uuid.uuid.uuid16 = GATTS_SERVICE_UUID_TEST_A; 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); esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name(test_device_name);
if (set_dev_name_ret){ if (set_dev_name_ret){
ESP_LOGE(GATTS_TAG, "set device name failed, error code = %x", 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 #ifdef CONFIG_EXAMPLE_SET_RAW_ADV_DATA
esp_err_t raw_adv_ret = esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(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){ if (raw_adv_ret){
ESP_LOGE(GATTS_TAG, "config raw adv data failed, error code = %x ", raw_adv_ret); ESP_LOGE(GATTS_TAG, "config raw adv data failed, error code = %x ", raw_adv_ret);
@ -345,7 +348,7 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
esp_ble_gatts_create_service(gatts_if, &gl_profile_tab[PROFILE_A_APP_ID].service_id, GATTS_NUM_HANDLE_TEST_A); esp_ble_gatts_create_service(gatts_if, &gl_profile_tab[PROFILE_A_APP_ID].service_id, GATTS_NUM_HANDLE_TEST_A);
break; break;
case ESP_GATTS_READ_EVT: { case ESP_GATTS_READ_EVT: {
ESP_LOGI(GATTS_TAG, "GATT_READ_EVT, conn_id %d, trans_id %" PRIu32 ", handle %d\n", param->read.conn_id, param->read.trans_id, param->read.handle); ESP_LOGI(GATTS_TAG, "Characteristic read, conn_id %d, trans_id %" PRIu32 ", handle %d", param->read.conn_id, param->read.trans_id, param->read.handle);
esp_gatt_rsp_t rsp; esp_gatt_rsp_t rsp;
memset(&rsp, 0, sizeof(esp_gatt_rsp_t)); memset(&rsp, 0, sizeof(esp_gatt_rsp_t));
rsp.attr_value.handle = param->read.handle; rsp.attr_value.handle = param->read.handle;
@ -359,15 +362,15 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
break; break;
} }
case ESP_GATTS_WRITE_EVT: { case ESP_GATTS_WRITE_EVT: {
ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, conn_id %d, trans_id %" PRIu32 ", handle %d", param->write.conn_id, param->write.trans_id, param->write.handle); ESP_LOGI(GATTS_TAG, "Characteristic write, conn_id %d, trans_id %" PRIu32 ", handle %d", param->write.conn_id, param->write.trans_id, param->write.handle);
if (!param->write.is_prep){ if (!param->write.is_prep){
ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, value len %d, value :", param->write.len); ESP_LOGI(GATTS_TAG, "value len %d, value ", param->write.len);
esp_log_buffer_hex(GATTS_TAG, param->write.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){ 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]; uint16_t descr_value = param->write.value[1]<<8 | param->write.value[0];
if (descr_value == 0x0001){ if (descr_value == 0x0001){
if (a_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY){ if (a_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY){
ESP_LOGI(GATTS_TAG, "notify enable"); ESP_LOGI(GATTS_TAG, "Notification enable");
uint8_t notify_data[15]; uint8_t notify_data[15];
for (int i = 0; i < sizeof(notify_data); ++i) for (int i = 0; i < sizeof(notify_data); ++i)
{ {
@ -379,7 +382,7 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
} }
}else if (descr_value == 0x0002){ }else if (descr_value == 0x0002){
if (a_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){ if (a_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){
ESP_LOGI(GATTS_TAG, "indicate enable"); ESP_LOGI(GATTS_TAG, "Indication enable");
uint8_t indicate_data[15]; uint8_t indicate_data[15];
for (int i = 0; i < sizeof(indicate_data); ++i) for (int i = 0; i < sizeof(indicate_data); ++i)
{ {
@ -391,10 +394,10 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
} }
} }
else if (descr_value == 0x0000){ else if (descr_value == 0x0000){
ESP_LOGI(GATTS_TAG, "notify/indicate disable "); ESP_LOGI(GATTS_TAG, "Notification/Indication disable");
}else{ }else{
ESP_LOGE(GATTS_TAG, "unknown descr value"); ESP_LOGE(GATTS_TAG, "Unknown descriptor value");
esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len); ESP_LOG_BUFFER_HEX(GATTS_TAG, param->write.value, param->write.len);
} }
} }
@ -403,17 +406,17 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
break; break;
} }
case ESP_GATTS_EXEC_WRITE_EVT: case ESP_GATTS_EXEC_WRITE_EVT:
ESP_LOGI(GATTS_TAG,"ESP_GATTS_EXEC_WRITE_EVT"); ESP_LOGI(GATTS_TAG,"Execute write");
esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL); 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); example_exec_write_event_env(&a_prepare_write_env, param);
break; break;
case ESP_GATTS_MTU_EVT: case ESP_GATTS_MTU_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu); ESP_LOGI(GATTS_TAG, "MTU exchange, conn_id %d, MTU %d", param->mtu.conn_id, param->mtu.mtu);
break; break;
case ESP_GATTS_UNREG_EVT: case ESP_GATTS_UNREG_EVT:
break; break;
case ESP_GATTS_CREATE_EVT: 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); ESP_LOGI(GATTS_TAG, "Service create, status %d, service_handle %d", 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].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.len = ESP_UUID_LEN_16;
gl_profile_tab[PROFILE_A_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_A; gl_profile_tab[PROFILE_A_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_A;
@ -434,7 +437,7 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
uint16_t length = 0; uint16_t length = 0;
const uint8_t *prf_char; const uint8_t *prf_char;
ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, status %d, attr_handle %d, service_handle %d\n", ESP_LOGI(GATTS_TAG, "Characteristic add, status %d, attr_handle %d, service_handle %d",
param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle); 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].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.len = ESP_UUID_LEN_16;
@ -457,13 +460,13 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
} }
case ESP_GATTS_ADD_CHAR_DESCR_EVT: case ESP_GATTS_ADD_CHAR_DESCR_EVT:
gl_profile_tab[PROFILE_A_APP_ID].descr_handle = param->add_char_descr.attr_handle; 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", ESP_LOGI(GATTS_TAG, "Descriptor add, status %d, attr_handle %d, service_handle %d",
param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle); param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle);
break; break;
case ESP_GATTS_DELETE_EVT: case ESP_GATTS_DELETE_EVT:
break; break;
case ESP_GATTS_START_EVT: case ESP_GATTS_START_EVT:
ESP_LOGI(GATTS_TAG, "SERVICE_START_EVT, status %d, service_handle %d\n", ESP_LOGI(GATTS_TAG, "Service start, status %d, service_handle %d",
param->start.status, param->start.service_handle); param->start.status, param->start.service_handle);
break; break;
case ESP_GATTS_STOP_EVT: case ESP_GATTS_STOP_EVT:
@ -476,21 +479,20 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
conn_params.max_int = 0x20; // max_int = 0x20*1.25ms = 40ms conn_params.max_int = 0x20; // max_int = 0x20*1.25ms = 40ms
conn_params.min_int = 0x10; // min_int = 0x10*1.25ms = 20ms conn_params.min_int = 0x10; // min_int = 0x10*1.25ms = 20ms
conn_params.timeout = 400; // timeout = 400*10ms = 4000ms 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:", ESP_LOGI(GATTS_TAG, "Connected, conn_id %u, remote "ESP_BD_ADDR_STR"",
param->connect.conn_id, param->connect.conn_id, ESP_BD_ADDR_HEX(param->connect.remote_bda));
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; gl_profile_tab[PROFILE_A_APP_ID].conn_id = param->connect.conn_id;
//start sent the update connection parameters to the peer device. //start sent the update connection parameters to the peer device.
esp_ble_gap_update_conn_params(&conn_params); esp_ble_gap_update_conn_params(&conn_params);
break; break;
} }
case ESP_GATTS_DISCONNECT_EVT: case ESP_GATTS_DISCONNECT_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_DISCONNECT_EVT, disconnect reason 0x%x", param->disconnect.reason); ESP_LOGI(GATTS_TAG, "Disconnected, remote "ESP_BD_ADDR_STR", reason 0x%02x",
ESP_BD_ADDR_HEX(param->disconnect.remote_bda), param->disconnect.reason);
esp_ble_gap_start_advertising(&adv_params); esp_ble_gap_start_advertising(&adv_params);
break; break;
case ESP_GATTS_CONF_EVT: case ESP_GATTS_CONF_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT, status %d attr_handle %d", param->conf.status, param->conf.handle); ESP_LOGI(GATTS_TAG, "Confirm receive, status %d, attr_handle %d", param->conf.status, param->conf.handle);
if (param->conf.status != ESP_GATT_OK){ if (param->conf.status != ESP_GATT_OK){
esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len); esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len);
} }
@ -508,7 +510,7 @@ static void gatts_profile_a_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) { static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) {
switch (event) { switch (event) {
case ESP_GATTS_REG_EVT: 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); ESP_LOGI(GATTS_TAG, "GATTS application register, status %d, app_id %d", param->reg.status, param->reg.app_id);
gl_profile_tab[PROFILE_B_APP_ID].service_id.is_primary = true; gl_profile_tab[PROFILE_B_APP_ID].service_id.is_primary = true;
gl_profile_tab[PROFILE_B_APP_ID].service_id.id.inst_id = 0x00; gl_profile_tab[PROFILE_B_APP_ID].service_id.id.inst_id = 0x00;
gl_profile_tab[PROFILE_B_APP_ID].service_id.id.uuid.len = ESP_UUID_LEN_16; gl_profile_tab[PROFILE_B_APP_ID].service_id.id.uuid.len = ESP_UUID_LEN_16;
@ -517,7 +519,7 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
esp_ble_gatts_create_service(gatts_if, &gl_profile_tab[PROFILE_B_APP_ID].service_id, GATTS_NUM_HANDLE_TEST_B); esp_ble_gatts_create_service(gatts_if, &gl_profile_tab[PROFILE_B_APP_ID].service_id, GATTS_NUM_HANDLE_TEST_B);
break; break;
case ESP_GATTS_READ_EVT: { case ESP_GATTS_READ_EVT: {
ESP_LOGI(GATTS_TAG, "GATT_READ_EVT, conn_id %d, trans_id %" PRIu32 ", handle %d\n", param->read.conn_id, param->read.trans_id, param->read.handle); ESP_LOGI(GATTS_TAG, "Characteristic read, conn_id %d, trans_id %" PRIu32 ", handle %d", param->read.conn_id, param->read.trans_id, param->read.handle);
esp_gatt_rsp_t rsp; esp_gatt_rsp_t rsp;
memset(&rsp, 0, sizeof(esp_gatt_rsp_t)); memset(&rsp, 0, sizeof(esp_gatt_rsp_t));
rsp.attr_value.handle = param->read.handle; rsp.attr_value.handle = param->read.handle;
@ -531,15 +533,15 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
break; break;
} }
case ESP_GATTS_WRITE_EVT: { case ESP_GATTS_WRITE_EVT: {
ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, conn_id %d, trans_id %" PRIu32 ", handle %d\n", param->write.conn_id, param->write.trans_id, param->write.handle); ESP_LOGI(GATTS_TAG, "Characteristic write, conn_id %d, trans_id %" PRIu32 ", handle %d", param->write.conn_id, param->write.trans_id, param->write.handle);
if (!param->write.is_prep){ if (!param->write.is_prep){
ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, value len %d, value :", param->write.len); ESP_LOGI(GATTS_TAG, "value len %d, value ", param->write.len);
esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len); ESP_LOG_BUFFER_HEX(GATTS_TAG, param->write.value, param->write.len);
if (gl_profile_tab[PROFILE_B_APP_ID].descr_handle == param->write.handle && param->write.len == 2){ if (gl_profile_tab[PROFILE_B_APP_ID].descr_handle == param->write.handle && param->write.len == 2){
uint16_t descr_value= param->write.value[1]<<8 | param->write.value[0]; uint16_t descr_value= param->write.value[1]<<8 | param->write.value[0];
if (descr_value == 0x0001){ if (descr_value == 0x0001){
if (b_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY){ if (b_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY) {
ESP_LOGI(GATTS_TAG, "notify enable"); ESP_LOGI(GATTS_TAG, "Notification enable");
uint8_t notify_data[15]; uint8_t notify_data[15];
for (int i = 0; i < sizeof(notify_data); ++i) for (int i = 0; i < sizeof(notify_data); ++i)
{ {
@ -551,7 +553,7 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
} }
}else if (descr_value == 0x0002){ }else if (descr_value == 0x0002){
if (b_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){ if (b_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){
ESP_LOGI(GATTS_TAG, "indicate enable"); ESP_LOGI(GATTS_TAG, "Indication enable");
uint8_t indicate_data[15]; uint8_t indicate_data[15];
for (int i = 0; i < sizeof(indicate_data); ++i) for (int i = 0; i < sizeof(indicate_data); ++i)
{ {
@ -563,9 +565,9 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
} }
} }
else if (descr_value == 0x0000){ else if (descr_value == 0x0000){
ESP_LOGI(GATTS_TAG, "notify/indicate disable "); ESP_LOGI(GATTS_TAG, "Notification/Indication disable");
}else{ }else{
ESP_LOGE(GATTS_TAG, "unknown value"); ESP_LOGE(GATTS_TAG, "Unknown value");
} }
} }
@ -574,17 +576,17 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
break; break;
} }
case ESP_GATTS_EXEC_WRITE_EVT: case ESP_GATTS_EXEC_WRITE_EVT:
ESP_LOGI(GATTS_TAG,"ESP_GATTS_EXEC_WRITE_EVT"); ESP_LOGI(GATTS_TAG,"Execute write");
esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL); esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
example_exec_write_event_env(&b_prepare_write_env, param); example_exec_write_event_env(&b_prepare_write_env, param);
break; break;
case ESP_GATTS_MTU_EVT: case ESP_GATTS_MTU_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu); ESP_LOGI(GATTS_TAG, "MTU exchange, conn_id %d, MTU %d", param->mtu.conn_id, param->mtu.mtu);
break; break;
case ESP_GATTS_UNREG_EVT: case ESP_GATTS_UNREG_EVT:
break; break;
case ESP_GATTS_CREATE_EVT: 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); ESP_LOGI(GATTS_TAG, "Service create, status %d, service_handle %d", param->create.status, param->create.service_handle);
gl_profile_tab[PROFILE_B_APP_ID].service_handle = param->create.service_handle; gl_profile_tab[PROFILE_B_APP_ID].service_handle = param->create.service_handle;
gl_profile_tab[PROFILE_B_APP_ID].char_uuid.len = ESP_UUID_LEN_16; gl_profile_tab[PROFILE_B_APP_ID].char_uuid.len = ESP_UUID_LEN_16;
gl_profile_tab[PROFILE_B_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_B; gl_profile_tab[PROFILE_B_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_B;
@ -602,7 +604,7 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
case ESP_GATTS_ADD_INCL_SRVC_EVT: case ESP_GATTS_ADD_INCL_SRVC_EVT:
break; break;
case ESP_GATTS_ADD_CHAR_EVT: case ESP_GATTS_ADD_CHAR_EVT:
ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, status %d, attr_handle %d, service_handle %d\n", ESP_LOGI(GATTS_TAG, "Characteristic add, status %d, attr_handle %d, service_handle %d",
param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle); param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle);
gl_profile_tab[PROFILE_B_APP_ID].char_handle = param->add_char.attr_handle; gl_profile_tab[PROFILE_B_APP_ID].char_handle = param->add_char.attr_handle;
@ -614,26 +616,24 @@ static void gatts_profile_b_event_handler(esp_gatts_cb_event_t event, esp_gatt_i
break; break;
case ESP_GATTS_ADD_CHAR_DESCR_EVT: case ESP_GATTS_ADD_CHAR_DESCR_EVT:
gl_profile_tab[PROFILE_B_APP_ID].descr_handle = param->add_char_descr.attr_handle; gl_profile_tab[PROFILE_B_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", ESP_LOGI(GATTS_TAG, "Descriptor add, status %d, attr_handle %d, service_handle %d",
param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle); param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle);
break; break;
case ESP_GATTS_DELETE_EVT: case ESP_GATTS_DELETE_EVT:
break; break;
case ESP_GATTS_START_EVT: case ESP_GATTS_START_EVT:
ESP_LOGI(GATTS_TAG, "SERVICE_START_EVT, status %d, service_handle %d\n", ESP_LOGI(GATTS_TAG, "Service start, status %d, service_handle %d",
param->start.status, param->start.service_handle); param->start.status, param->start.service_handle);
break; break;
case ESP_GATTS_STOP_EVT: case ESP_GATTS_STOP_EVT:
break; break;
case ESP_GATTS_CONNECT_EVT: case ESP_GATTS_CONNECT_EVT:
ESP_LOGI(GATTS_TAG, "CONNECT_EVT, conn_id %d, remote %02x:%02x:%02x:%02x:%02x:%02x:", ESP_LOGI(GATTS_TAG, "Connected, conn_id %d, remote "ESP_BD_ADDR_STR"",
param->connect.conn_id, param->connect.conn_id, ESP_BD_ADDR_HEX(param->connect.remote_bda));
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_B_APP_ID].conn_id = param->connect.conn_id; gl_profile_tab[PROFILE_B_APP_ID].conn_id = param->connect.conn_id;
break; break;
case ESP_GATTS_CONF_EVT: case ESP_GATTS_CONF_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT status %d attr_handle %d", param->conf.status, param->conf.handle); ESP_LOGI(GATTS_TAG, "Confirm receive, status %d, attr_handle %d", param->conf.status, param->conf.handle);
if (param->conf.status != ESP_GATT_OK){ if (param->conf.status != ESP_GATT_OK){
esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len); esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len);
} }
@ -690,6 +690,10 @@ void app_main(void)
} }
ESP_ERROR_CHECK( ret ); ESP_ERROR_CHECK( ret );
#if CONFIG_EXAMPLE_CI_PIPELINE_ID
memcpy(test_device_name, esp_bluedroid_get_example_name(), ESP_BLE_ADV_NAME_LEN_MAX);
#endif
ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT)); ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT(); esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();