API tools faq
paste
Guest User

gatts_demo.c

a guest
Mar 22nd, 2018
326
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 32.88 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.    This example code is in the Public Domain (or CC0 licensed, at your option.)
  3.  
  4.    Unless required by applicable law or agreed to in writing, this
  5.    software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
  6.    CONDITIONS OF ANY KIND, either express or implied.
  7. */
  8.  
  9. /****************************************************************************
  10. *
  11. * This file is for gatt server. It can send adv data, be connected by client.
  12. * Run the gatt_client demo, the client demo will automatically connect to the gatt_server demo.
  13. * Client demo will enable gatt_server's notify after connection. Then two devices will exchange
  14. * data.
  15. *
  16. ****************************************************************************/
  17.  
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include "freertos/FreeRTOS.h"
  23. #include "freertos/task.h"
  24. #include "freertos/event_groups.h"
  25. #include "esp_system.h"
  26. #include "esp_log.h"
  27. #include "nvs_flash.h"
  28. #include "esp_bt.h"
  29.  
  30. #include "esp_gap_ble_api.h"
  31. #include "esp_gatts_api.h"
  32. #include "esp_bt_defs.h"
  33. #include "esp_bt_main.h"
  34. #include "esp_bt_main.h"
  35. #include "esp_gatt_common_api.h"
  36.  
  37. #include "sdkconfig.h"
  38.  
  39. #define GATTS_TAG "GATTS_DEMO"
  40.  
  41. ///Declare the static function
  42. 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);
  43. 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);
  44.  
  45. #define GATTS_SERVICE_UUID_TEST_A   0x00FF
  46. #define GATTS_CHAR_UUID_TEST_A      0xFF01
  47. #define GATTS_DESCR_UUID_TEST_A     0x3333
  48. #define GATTS_NUM_HANDLE_TEST_A     4
  49.  
  50. #define GATTS_SERVICE_UUID_TEST_B   0x00EE
  51. #define GATTS_CHAR_UUID_TEST_B      0xEE01
  52. #define GATTS_DESCR_UUID_TEST_B     0x2222
  53. #define GATTS_NUM_HANDLE_TEST_B     4
  54.  
  55. #define TEST_DEVICE_NAME            "ESP_GATTS_DEMO"
  56. #define TEST_MANUFACTURER_DATA_LEN  17
  57.  
  58. #define GATTS_DEMO_CHAR_VAL_LEN_MAX 0x40
  59.  
  60. #define PREPARE_BUF_MAX_SIZE 1024
  61.  
  62. uint8_t char1_str[] = {0x11,0x22,0x33};
  63. esp_gatt_char_prop_t a_property = 0;
  64. esp_gatt_char_prop_t b_property = 0;
  65.  
  66. esp_attr_value_t gatts_demo_char1_val =
  67. {
  68.     .attr_max_len = GATTS_DEMO_CHAR_VAL_LEN_MAX,
  69.     .attr_len     = sizeof(char1_str),
  70.     .attr_value   = char1_str,
  71. };
  72.  
  73. static uint8_t adv_config_done = 0;
  74. #define adv_config_flag      (1 << 0)
  75. #define scan_rsp_config_flag (1 << 1)
  76.  
  77. #ifdef CONFIG_SET_RAW_ADV_DATA
  78. static uint8_t raw_adv_data[] = {
  79.         0x02, 0x01, 0x06,
  80.         0x02, 0x0a, 0xeb, 0x03, 0x03, 0xab, 0xcd
  81. };
  82. static uint8_t raw_scan_rsp_data[] = {
  83.         0x0f, 0x09, 0x45, 0x53, 0x50, 0x5f, 0x47, 0x41, 0x54, 0x54, 0x53, 0x5f, 0x44,
  84.         0x45, 0x4d, 0x4f
  85. };
  86. #else
  87.  
  88. static uint8_t adv_service_uuid128[32] = {
  89.     /* LSB <--------------------------------------------------------------------------------> MSB */
  90.     //first uuid, 16bit, [12],[13] is the value
  91.     0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0xEE, 0x00, 0x00, 0x00,
  92.     //second uuid, 32bit, [12], [13], [14], [15] is the value
  93.     0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
  94. };
  95.  
  96. // The length of adv data must be less than 31 bytes
  97. //static uint8_t test_manufacturer[TEST_MANUFACTURER_DATA_LEN] =  {0x12, 0x23, 0x45, 0x56};
  98. //adv data
  99. static esp_ble_adv_data_t adv_data = {
  100.     .set_scan_rsp = false,
  101.     .include_name = true,
  102.     .include_txpower = true,
  103.     .min_interval = 0x20,
  104.     .max_interval = 0x40,
  105.     .appearance = 0x00,
  106.     .manufacturer_len = 0, //TEST_MANUFACTURER_DATA_LEN,
  107.     .p_manufacturer_data =  NULL, //&test_manufacturer[0],
  108.     .service_data_len = 0,
  109.     .p_service_data = NULL,
  110.     .service_uuid_len = 32,
  111.     .p_service_uuid = adv_service_uuid128,
  112.     .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
  113. };
  114. // scan response data
  115. static esp_ble_adv_data_t scan_rsp_data = {
  116.     .set_scan_rsp = true,
  117.     .include_name = true,
  118.     .include_txpower = true,
  119.     .min_interval = 0x20,
  120.     .max_interval = 0x40,
  121.     .appearance = 0x00,
  122.     .manufacturer_len = 0, //TEST_MANUFACTURER_DATA_LEN,
  123.     .p_manufacturer_data =  NULL, //&test_manufacturer[0],
  124.     .service_data_len = 0,
  125.     .p_service_data = NULL,
  126.     .service_uuid_len = 32,
  127.     .p_service_uuid = adv_service_uuid128,
  128.     .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
  129. };
  130.  
  131. #endif /* CONFIG_SET_RAW_ADV_DATA */
  132.  
  133. static esp_ble_adv_params_t adv_params = {
  134.     .adv_int_min        = 0x20,
  135.     .adv_int_max        = 0x40,
  136.     .adv_type           = ADV_TYPE_IND,
  137.     .own_addr_type      = BLE_ADDR_TYPE_PUBLIC,
  138.     //.peer_addr            =
  139.     //.peer_addr_type       =
  140.     .channel_map        = ADV_CHNL_ALL,
  141.     .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
  142. };
  143.  
  144. #define PROFILE_NUM 2
  145. #define PROFILE_A_APP_ID 0
  146. #define PROFILE_B_APP_ID 1
  147.  
  148. struct gatts_profile_inst {
  149.     esp_gatts_cb_t gatts_cb;
  150.     uint16_t gatts_if;
  151.     uint16_t app_id;
  152.     uint16_t conn_id;
  153.     uint16_t service_handle;
  154.     esp_gatt_srvc_id_t service_id;
  155.     uint16_t char_handle;
  156.     esp_bt_uuid_t char_uuid;
  157.     esp_gatt_perm_t perm;
  158.     esp_gatt_char_prop_t property;
  159.     uint16_t descr_handle;
  160.     esp_bt_uuid_t descr_uuid;
  161. };
  162.  
  163. /* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */
  164. static struct gatts_profile_inst gl_profile_tab[PROFILE_NUM] = {
  165.     [PROFILE_A_APP_ID] = {
  166.         .gatts_cb = gatts_profile_a_event_handler,
  167.         .gatts_if = ESP_GATT_IF_NONE,       /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
  168.     },
  169.     [PROFILE_B_APP_ID] = {
  170.         .gatts_cb = gatts_profile_b_event_handler,                   /* This demo does not implement, similar as profile A */
  171.         .gatts_if = ESP_GATT_IF_NONE,       /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
  172.     },
  173. };
  174.  
  175. typedef struct {
  176.     uint8_t                 *prepare_buf;
  177.     int                     prepare_len;
  178. } prepare_type_env_t;
  179.  
  180. static prepare_type_env_t a_prepare_write_env;
  181. static prepare_type_env_t b_prepare_write_env;
  182.  
  183. void example_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param);
  184. void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param);
  185.  
  186. static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
  187. {
  188.     switch (event) {
  189. #ifdef CONFIG_SET_RAW_ADV_DATA
  190.     case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
  191.         adv_config_done &= (~adv_config_flag);
  192.         if (adv_config_done==0){
  193.             esp_ble_gap_start_advertising(&adv_params);
  194.         }
  195.         break;
  196.     case ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT:
  197.         adv_config_done &= (~scan_rsp_config_flag);
  198.         if (adv_config_done==0){
  199.             esp_ble_gap_start_advertising(&adv_params);
  200.         }
  201.         break;
  202. #else
  203.     case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
  204.         adv_config_done &= (~adv_config_flag);
  205.         if (adv_config_done == 0){
  206.             esp_ble_gap_start_advertising(&adv_params);
  207.         }
  208.         break;
  209.     case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
  210.         adv_config_done &= (~scan_rsp_config_flag);
  211.         if (adv_config_done == 0){
  212.             esp_ble_gap_start_advertising(&adv_params);
  213.         }
  214.         break;
  215. #endif
  216.     case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
  217.         //advertising start complete event to indicate advertising start successfully or failed
  218.         if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
  219.             ESP_LOGE(GATTS_TAG, "Advertising start failed\n");
  220.         } else { // AY add
  221.             ESP_LOGI(GATTS_TAG, "----------Advertising start successfully");
  222.         } // ~AY ADD
  223.         break;
  224.     case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
  225.         if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS) {
  226.             ESP_LOGE(GATTS_TAG, "Advertising stop failed\n");
  227.         }
  228.         else {
  229.             ESP_LOGI(GATTS_TAG, "Stop adv successfully\n");
  230.         }
  231.         break;
  232.     case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
  233.          ESP_LOGI(GATTS_TAG, "update connection params status = %d, min_int = %d, max_int = %d,conn_int = %d,latency = %d, timeout = %d",
  234.                   param->update_conn_params.status,
  235.                   param->update_conn_params.min_int,
  236.                   param->update_conn_params.max_int,
  237.                   param->update_conn_params.conn_int,
  238.                   param->update_conn_params.latency,
  239.                   param->update_conn_params.timeout);
  240.         break;
  241.     default:
  242.         break;
  243.     }
  244. }
  245.  
  246. void example_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param){
  247.     esp_gatt_status_t status = ESP_GATT_OK;
  248.     if (param->write.need_rsp){
  249.         if (param->write.is_prep){
  250.             if (prepare_write_env->prepare_buf == NULL) {
  251.                 prepare_write_env->prepare_buf = (uint8_t *)malloc(PREPARE_BUF_MAX_SIZE*sizeof(uint8_t));
  252.                 prepare_write_env->prepare_len = 0;
  253.                 if (prepare_write_env->prepare_buf == NULL) {
  254.                     ESP_LOGE(GATTS_TAG, "Gatt_server prep no mem\n");
  255.                     status = ESP_GATT_NO_RESOURCES;
  256.                 }
  257.             } else {
  258.                 if(param->write.offset > PREPARE_BUF_MAX_SIZE) {
  259.                     status = ESP_GATT_INVALID_OFFSET;
  260.                 } else if ((param->write.offset + param->write.len) > PREPARE_BUF_MAX_SIZE) {
  261.                     status = ESP_GATT_INVALID_ATTR_LEN;
  262.                 }
  263.             }
  264.  
  265.             esp_gatt_rsp_t *gatt_rsp = (esp_gatt_rsp_t *)malloc(sizeof(esp_gatt_rsp_t));
  266.             gatt_rsp->attr_value.len = param->write.len;
  267.             gatt_rsp->attr_value.handle = param->write.handle;
  268.             gatt_rsp->attr_value.offset = param->write.offset;
  269.             gatt_rsp->attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE;
  270.             memcpy(gatt_rsp->attr_value.value, param->write.value, param->write.len);
  271.             esp_err_t response_err = esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, gatt_rsp);
  272.             if (response_err != ESP_OK){
  273.                ESP_LOGE(GATTS_TAG, "Send response error\n");
  274.             }
  275.             free(gatt_rsp);
  276.             if (status != ESP_GATT_OK){
  277.                 return;
  278.             }
  279.             memcpy(prepare_write_env->prepare_buf + param->write.offset,
  280.                    param->write.value,
  281.                    param->write.len);
  282.             prepare_write_env->prepare_len += param->write.len;
  283.  
  284.         }else{
  285.             esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, NULL);
  286.         }
  287.     }
  288. }
  289.  
  290. void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param){
  291.     if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC){
  292.         esp_log_buffer_hex(GATTS_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len);
  293.     }else{
  294.         ESP_LOGI(GATTS_TAG,"ESP_GATT_PREP_WRITE_CANCEL");
  295.     }
  296.     if (prepare_write_env->prepare_buf) {
  297.         free(prepare_write_env->prepare_buf);
  298.         prepare_write_env->prepare_buf = NULL;
  299.     }
  300.     prepare_write_env->prepare_len = 0;
  301. }
  302.  
  303. 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) {
  304.     switch (event) {
  305.     case ESP_GATTS_REG_EVT:
  306.         ESP_LOGI(GATTS_TAG, "REGISTER_APP_EVT, status %d, app_id %d\n", param->reg.status, param->reg.app_id);
  307.         gl_profile_tab[PROFILE_A_APP_ID].service_id.is_primary = true;
  308.         gl_profile_tab[PROFILE_A_APP_ID].service_id.id.inst_id = 0x00;
  309.         gl_profile_tab[PROFILE_A_APP_ID].service_id.id.uuid.len = ESP_UUID_LEN_16;
  310.         gl_profile_tab[PROFILE_A_APP_ID].service_id.id.uuid.uuid.uuid16 = GATTS_SERVICE_UUID_TEST_A;
  311.  
  312.         esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name(TEST_DEVICE_NAME);
  313.         if (set_dev_name_ret){
  314.             ESP_LOGE(GATTS_TAG, "set device name failed, error code = %x", set_dev_name_ret);
  315.         }
  316. #ifdef CONFIG_SET_RAW_ADV_DATA
  317.         esp_err_t raw_adv_ret = esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(raw_adv_data));
  318.         if (raw_adv_ret){
  319.             ESP_LOGE(GATTS_TAG, "config raw adv data failed, error code = %x ", raw_adv_ret);
  320.         }
  321.         adv_config_done |= adv_config_flag;
  322.         esp_err_t raw_scan_ret = esp_ble_gap_config_scan_rsp_data_raw(raw_scan_rsp_data, sizeof(raw_scan_rsp_data));
  323.         if (raw_scan_ret){
  324.             ESP_LOGE(GATTS_TAG, "config raw scan rsp data failed, error code = %x", raw_scan_ret);
  325.         }
  326.         adv_config_done |= scan_rsp_config_flag;
  327. #else
  328.         //config adv data
  329.         esp_err_t ret = esp_ble_gap_config_adv_data(&adv_data);
  330.         if (ret){
  331.             ESP_LOGE(GATTS_TAG, "config adv data failed, error code = %x", ret);
  332.         }
  333.         adv_config_done |= adv_config_flag;
  334.         //config scan response data
  335.         ret = esp_ble_gap_config_adv_data(&scan_rsp_data);
  336.         if (ret){
  337.             ESP_LOGE(GATTS_TAG, "config scan response data failed, error code = %x", ret);
  338.         }
  339.         adv_config_done |= scan_rsp_config_flag;
  340.  
  341. #endif
  342.         esp_ble_gatts_create_service(gatts_if, &gl_profile_tab[PROFILE_A_APP_ID].service_id, GATTS_NUM_HANDLE_TEST_A);
  343.         break;
  344.     case ESP_GATTS_READ_EVT: {
  345.         ESP_LOGI(GATTS_TAG, "GATT_READ_EVT, conn_id %d, trans_id %d, handle %d\n", param->read.conn_id, param->read.trans_id, param->read.handle);
  346.         esp_gatt_rsp_t rsp;
  347.         memset(&rsp, 0, sizeof(esp_gatt_rsp_t));
  348.         rsp.attr_value.handle = param->read.handle;
  349.         rsp.attr_value.len = 4;
  350.         rsp.attr_value.value[0] = 0xde;
  351.         rsp.attr_value.value[1] = 0xed;
  352.         rsp.attr_value.value[2] = 0xbe;
  353.         rsp.attr_value.value[3] = 0xef;
  354.         esp_ble_gatts_send_response(gatts_if, param->read.conn_id, param->read.trans_id,
  355.                                     ESP_GATT_OK, &rsp);
  356.         break;
  357.     }
  358.     case ESP_GATTS_WRITE_EVT: {
  359.         ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, conn_id %d, trans_id %d, handle %d", param->write.conn_id, param->write.trans_id, param->write.handle);
  360.         if (!param->write.is_prep){
  361.             ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, value len %d, value :", param->write.len);
  362.             esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len);
  363.             if (gl_profile_tab[PROFILE_A_APP_ID].descr_handle == param->write.handle && param->write.len == 2){
  364.                 uint16_t descr_value = param->write.value[1]<<8 | param->write.value[0];
  365.                 if (descr_value == 0x0001){
  366.                     if (a_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY){
  367.                         ESP_LOGI(GATTS_TAG, "notify enable");
  368.                         uint8_t notify_data[15];
  369.                         for (int i = 0; i < sizeof(notify_data); ++i)
  370.                         {
  371.                             notify_data[i] = i%0xff;
  372.                         }
  373.                         //the size of notify_data[] need less than MTU size
  374.                         esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, gl_profile_tab[PROFILE_A_APP_ID].char_handle,
  375.                                                 sizeof(notify_data), notify_data, false);
  376.                     }
  377.                 }else if (descr_value == 0x0002){
  378.                     if (a_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){
  379.                         ESP_LOGI(GATTS_TAG, "indicate enable");
  380.                         uint8_t indicate_data[15];
  381.                         for (int i = 0; i < sizeof(indicate_data); ++i)
  382.                         {
  383.                             indicate_data[i] = i%0xff;
  384.                         }
  385.                         //the size of indicate_data[] need less than MTU size
  386.                         esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, gl_profile_tab[PROFILE_A_APP_ID].char_handle,
  387.                                                 sizeof(indicate_data), indicate_data, true);
  388.                     }
  389.                 }
  390.                 else if (descr_value == 0x0000){
  391.                     ESP_LOGI(GATTS_TAG, "notify/indicate disable ");
  392.                 }else{
  393.                     ESP_LOGE(GATTS_TAG, "unknown descr value");
  394.                     esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len);
  395.                 }
  396.  
  397.             }
  398.         }
  399.         example_write_event_env(gatts_if, &a_prepare_write_env, param);
  400.         break;
  401.     }
  402.     case ESP_GATTS_EXEC_WRITE_EVT:
  403.         ESP_LOGI(GATTS_TAG,"ESP_GATTS_EXEC_WRITE_EVT");
  404.         esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
  405.         example_exec_write_event_env(&a_prepare_write_env, param);
  406.         break;
  407.     case ESP_GATTS_MTU_EVT:
  408.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
  409.         break;
  410.     case ESP_GATTS_UNREG_EVT:
  411.         break;
  412.     case ESP_GATTS_CREATE_EVT:
  413.         ESP_LOGI(GATTS_TAG, "CREATE_SERVICE_EVT, status %d,  service_handle %d\n", param->create.status, param->create.service_handle);
  414.         gl_profile_tab[PROFILE_A_APP_ID].service_handle = param->create.service_handle;
  415.         gl_profile_tab[PROFILE_A_APP_ID].char_uuid.len = ESP_UUID_LEN_16;
  416.         gl_profile_tab[PROFILE_A_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_A;
  417.  
  418.         esp_ble_gatts_start_service(gl_profile_tab[PROFILE_A_APP_ID].service_handle);
  419.         a_property = ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
  420.         esp_err_t add_char_ret = esp_ble_gatts_add_char(gl_profile_tab[PROFILE_A_APP_ID].service_handle, &gl_profile_tab[PROFILE_A_APP_ID].char_uuid,
  421.                                                         ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
  422.                                                         a_property,
  423.                                                         &gatts_demo_char1_val, NULL);
  424.         if (add_char_ret){
  425.             ESP_LOGE(GATTS_TAG, "add char failed, error code =%x",add_char_ret);
  426.         }
  427.         break;
  428.     case ESP_GATTS_ADD_INCL_SRVC_EVT:
  429.         break;
  430.     case ESP_GATTS_ADD_CHAR_EVT: {
  431.         uint16_t length = 0;
  432.         const uint8_t *prf_char;
  433.  
  434.         ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, status %d,  attr_handle %d, service_handle %d\n",
  435.                 param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle);
  436.         gl_profile_tab[PROFILE_A_APP_ID].char_handle = param->add_char.attr_handle;
  437.         gl_profile_tab[PROFILE_A_APP_ID].descr_uuid.len = ESP_UUID_LEN_16;
  438.         gl_profile_tab[PROFILE_A_APP_ID].descr_uuid.uuid.uuid16 = ESP_GATT_UUID_CHAR_CLIENT_CONFIG;
  439.         esp_err_t get_attr_ret = esp_ble_gatts_get_attr_value(param->add_char.attr_handle,  &length, &prf_char);
  440.         if (get_attr_ret == ESP_FAIL){
  441.             ESP_LOGE(GATTS_TAG, "ILLEGAL HANDLE");
  442.         }
  443.  
  444.         ESP_LOGI(GATTS_TAG, "the gatts demo char length = %x\n", length);
  445.         for(int i = 0; i < length; i++){
  446.             ESP_LOGI(GATTS_TAG, "prf_char[%x] =%x\n",i,prf_char[i]);
  447.         }
  448.         esp_err_t add_descr_ret = esp_ble_gatts_add_char_descr(gl_profile_tab[PROFILE_A_APP_ID].service_handle, &gl_profile_tab[PROFILE_A_APP_ID].descr_uuid,
  449.                                                                 ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, NULL, NULL);
  450.         if (add_descr_ret){
  451.             ESP_LOGE(GATTS_TAG, "add char descr failed, error code =%x", add_descr_ret);
  452.         }
  453.         break;
  454.     }
  455.     case ESP_GATTS_ADD_CHAR_DESCR_EVT:
  456.         gl_profile_tab[PROFILE_A_APP_ID].descr_handle = param->add_char_descr.attr_handle;
  457.         ESP_LOGI(GATTS_TAG, "ADD_DESCR_EVT, status %d, attr_handle %d, service_handle %d\n",
  458.                  param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle);
  459.         break;
  460.     case ESP_GATTS_DELETE_EVT:
  461.         break;
  462.     case ESP_GATTS_START_EVT:
  463.         ESP_LOGI(GATTS_TAG, "SERVICE_START_EVT, status %d, service_handle %d\n",
  464.                  param->start.status, param->start.service_handle);
  465.         break;
  466.     case ESP_GATTS_STOP_EVT:
  467.         break;
  468.     case ESP_GATTS_CONNECT_EVT: {
  469.         esp_ble_conn_update_params_t conn_params = {0};
  470.         memcpy(conn_params.bda, param->connect.remote_bda, sizeof(esp_bd_addr_t));
  471.         /* For the IOS system, please reference the apple official documents about the ble connection parameters restrictions. */
  472.         conn_params.latency = 0;
  473.         conn_params.max_int = 0x20;    // max_int = 0x20*1.25ms = 40ms
  474.         conn_params.min_int = 0x10;    // min_int = 0x10*1.25ms = 20ms
  475.         conn_params.timeout = 400;    // timeout = 400*10ms = 4000ms
  476.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONNECT_EVT, conn_id %d, remote %02x:%02x:%02x:%02x:%02x:%02x:",
  477.                  param->connect.conn_id,
  478.                  param->connect.remote_bda[0], param->connect.remote_bda[1], param->connect.remote_bda[2],
  479.                  param->connect.remote_bda[3], param->connect.remote_bda[4], param->connect.remote_bda[5]);
  480.         gl_profile_tab[PROFILE_A_APP_ID].conn_id = param->connect.conn_id;
  481.         //start sent the update connection parameters to the peer device.
  482.         esp_ble_gap_update_conn_params(&conn_params);
  483.  
  484.         // ADD
  485.         esp_ble_gap_start_advertising(&adv_params); // advertise once again
  486.         ESP_LOGI(GATTS_TAG, "----------Advertising once again");
  487.         // ~ADD
  488.         break;
  489.     }
  490.     case ESP_GATTS_DISCONNECT_EVT:
  491.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_DISCONNECT_EVT, reason %d", param->disconnect.reason);
  492.         esp_ble_gap_start_advertising(&adv_params);
  493.         break;
  494.     case ESP_GATTS_CONF_EVT:
  495.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT, status %d", param->conf.status);
  496.         if (param->conf.status != ESP_GATT_OK){
  497.             esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len);
  498.         }
  499.         break;
  500.     case ESP_GATTS_OPEN_EVT:
  501.     case ESP_GATTS_CANCEL_OPEN_EVT:
  502.     case ESP_GATTS_CLOSE_EVT:
  503.     case ESP_GATTS_LISTEN_EVT:
  504.     case ESP_GATTS_CONGEST_EVT:
  505.     default:
  506.         break;
  507.     }
  508. }
  509.  
  510. 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) {
  511.     switch (event) {
  512.     case ESP_GATTS_REG_EVT:
  513.         ESP_LOGI(GATTS_TAG, "REGISTER_APP_EVT, status %d, app_id %d\n", param->reg.status, param->reg.app_id);
  514.         gl_profile_tab[PROFILE_B_APP_ID].service_id.is_primary = true;
  515.         gl_profile_tab[PROFILE_B_APP_ID].service_id.id.inst_id = 0x00;
  516.         gl_profile_tab[PROFILE_B_APP_ID].service_id.id.uuid.len = ESP_UUID_LEN_16;
  517.         gl_profile_tab[PROFILE_B_APP_ID].service_id.id.uuid.uuid.uuid16 = GATTS_SERVICE_UUID_TEST_B;
  518.  
  519.         esp_ble_gatts_create_service(gatts_if, &gl_profile_tab[PROFILE_B_APP_ID].service_id, GATTS_NUM_HANDLE_TEST_B);
  520.         break;
  521.     case ESP_GATTS_READ_EVT: {
  522.         ESP_LOGI(GATTS_TAG, "GATT_READ_EVT, conn_id %d, trans_id %d, handle %d\n", param->read.conn_id, param->read.trans_id, param->read.handle);
  523.         esp_gatt_rsp_t rsp;
  524.         memset(&rsp, 0, sizeof(esp_gatt_rsp_t));
  525.         rsp.attr_value.handle = param->read.handle;
  526.         rsp.attr_value.len = 4;
  527.         rsp.attr_value.value[0] = 0xde;
  528.         rsp.attr_value.value[1] = 0xed;
  529.         rsp.attr_value.value[2] = 0xbe;
  530.         rsp.attr_value.value[3] = 0xef;
  531.         esp_ble_gatts_send_response(gatts_if, param->read.conn_id, param->read.trans_id,
  532.                                     ESP_GATT_OK, &rsp);
  533.         break;
  534.     }
  535.     case ESP_GATTS_WRITE_EVT: {
  536.         ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, conn_id %d, trans_id %d, handle %d\n", param->write.conn_id, param->write.trans_id, param->write.handle);
  537.         if (!param->write.is_prep){
  538.             ESP_LOGI(GATTS_TAG, "GATT_WRITE_EVT, value len %d, value :", param->write.len);
  539.             esp_log_buffer_hex(GATTS_TAG, param->write.value, param->write.len);
  540.             if (gl_profile_tab[PROFILE_B_APP_ID].descr_handle == param->write.handle && param->write.len == 2){
  541.                 uint16_t descr_value= param->write.value[1]<<8 | param->write.value[0];
  542.                 if (descr_value == 0x0001){
  543.                     if (b_property & ESP_GATT_CHAR_PROP_BIT_NOTIFY){
  544.                         ESP_LOGI(GATTS_TAG, "notify enable");
  545.                         uint8_t notify_data[15];
  546.                         for (int i = 0; i < sizeof(notify_data); ++i)
  547.                         {
  548.                             notify_data[i] = i%0xff;
  549.                         }
  550.                         //the size of notify_data[] need less than MTU size
  551.                         esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, gl_profile_tab[PROFILE_B_APP_ID].char_handle,
  552.                                                 sizeof(notify_data), notify_data, false);
  553.                     }
  554.                 }else if (descr_value == 0x0002){
  555.                     if (b_property & ESP_GATT_CHAR_PROP_BIT_INDICATE){
  556.                         ESP_LOGI(GATTS_TAG, "indicate enable");
  557.                         uint8_t indicate_data[15];
  558.                         for (int i = 0; i < sizeof(indicate_data); ++i)
  559.                         {
  560.                             indicate_data[i] = i%0xff;
  561.                         }
  562.                         //the size of indicate_data[] need less than MTU size
  563.                         esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, gl_profile_tab[PROFILE_B_APP_ID].char_handle,
  564.                                                 sizeof(indicate_data), indicate_data, true);
  565.                     }
  566.                 }
  567.                 else if (descr_value == 0x0000){
  568.                     ESP_LOGI(GATTS_TAG, "notify/indicate disable ");
  569.                 }else{
  570.                     ESP_LOGE(GATTS_TAG, "unknown value");
  571.                 }
  572.  
  573.             }
  574.         }
  575.         example_write_event_env(gatts_if, &b_prepare_write_env, param);
  576.         break;
  577.     }
  578.     case ESP_GATTS_EXEC_WRITE_EVT:
  579.         ESP_LOGI(GATTS_TAG,"ESP_GATTS_EXEC_WRITE_EVT");
  580.         esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
  581.         example_exec_write_event_env(&b_prepare_write_env, param);
  582.         break;
  583.     case ESP_GATTS_MTU_EVT:
  584.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
  585.         break;
  586.     case ESP_GATTS_UNREG_EVT:
  587.         break;
  588.     case ESP_GATTS_CREATE_EVT:
  589.         ESP_LOGI(GATTS_TAG, "CREATE_SERVICE_EVT, status %d,  service_handle %d\n", param->create.status, param->create.service_handle);
  590.         gl_profile_tab[PROFILE_B_APP_ID].service_handle = param->create.service_handle;
  591.         gl_profile_tab[PROFILE_B_APP_ID].char_uuid.len = ESP_UUID_LEN_16;
  592.         gl_profile_tab[PROFILE_B_APP_ID].char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_TEST_B;
  593.  
  594.         esp_ble_gatts_start_service(gl_profile_tab[PROFILE_B_APP_ID].service_handle);
  595.         b_property = ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
  596.         esp_err_t add_char_ret =esp_ble_gatts_add_char( gl_profile_tab[PROFILE_B_APP_ID].service_handle, &gl_profile_tab[PROFILE_B_APP_ID].char_uuid,
  597.                                                         ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
  598.                                                         b_property,
  599.                                                         NULL, NULL);
  600.         if (add_char_ret){
  601.             ESP_LOGE(GATTS_TAG, "add char failed, error code =%x",add_char_ret);
  602.         }
  603.         break;
  604.     case ESP_GATTS_ADD_INCL_SRVC_EVT:
  605.         break;
  606.     case ESP_GATTS_ADD_CHAR_EVT:
  607.         ESP_LOGI(GATTS_TAG, "ADD_CHAR_EVT, status %d,  attr_handle %d, service_handle %d\n",
  608.                  param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle);
  609.  
  610.         gl_profile_tab[PROFILE_B_APP_ID].char_handle = param->add_char.attr_handle;
  611.         gl_profile_tab[PROFILE_B_APP_ID].descr_uuid.len = ESP_UUID_LEN_16;
  612.         gl_profile_tab[PROFILE_B_APP_ID].descr_uuid.uuid.uuid16 = ESP_GATT_UUID_CHAR_CLIENT_CONFIG;
  613.         esp_ble_gatts_add_char_descr(gl_profile_tab[PROFILE_B_APP_ID].service_handle, &gl_profile_tab[PROFILE_B_APP_ID].descr_uuid,
  614.                                      ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
  615.                                      NULL, NULL);
  616.         break;
  617.     case ESP_GATTS_ADD_CHAR_DESCR_EVT:
  618.         gl_profile_tab[PROFILE_B_APP_ID].descr_handle = param->add_char_descr.attr_handle;
  619.         ESP_LOGI(GATTS_TAG, "ADD_DESCR_EVT, status %d, attr_handle %d, service_handle %d\n",
  620.                  param->add_char_descr.status, param->add_char_descr.attr_handle, param->add_char_descr.service_handle);
  621.         break;
  622.     case ESP_GATTS_DELETE_EVT:
  623.         break;
  624.     case ESP_GATTS_START_EVT:
  625.         ESP_LOGI(GATTS_TAG, "SERVICE_START_EVT, status %d, service_handle %d\n",
  626.                  param->start.status, param->start.service_handle);
  627.         break;
  628.     case ESP_GATTS_STOP_EVT:
  629.         break;
  630.     case ESP_GATTS_CONNECT_EVT:
  631.         ESP_LOGI(GATTS_TAG, "CONNECT_EVT, conn_id %d, remote %02x:%02x:%02x:%02x:%02x:%02x:",
  632.                  param->connect.conn_id,
  633.                  param->connect.remote_bda[0], param->connect.remote_bda[1], param->connect.remote_bda[2],
  634.                  param->connect.remote_bda[3], param->connect.remote_bda[4], param->connect.remote_bda[5]);
  635.         gl_profile_tab[PROFILE_B_APP_ID].conn_id = param->connect.conn_id;
  636.         break;
  637.     case ESP_GATTS_CONF_EVT:
  638.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT status %d", param->conf.status);
  639.         if (param->conf.status != ESP_GATT_OK){
  640.             esp_log_buffer_hex(GATTS_TAG, param->conf.value, param->conf.len);
  641.         }
  642.     break;
  643.     case ESP_GATTS_DISCONNECT_EVT:
  644.     case ESP_GATTS_OPEN_EVT:
  645.     case ESP_GATTS_CANCEL_OPEN_EVT:
  646.     case ESP_GATTS_CLOSE_EVT:
  647.     case ESP_GATTS_LISTEN_EVT:
  648.     case ESP_GATTS_CONGEST_EVT:
  649.     default:
  650.         break;
  651.     }
  652. }
  653.  
  654. static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
  655. {
  656.     /* If event is register event, store the gatts_if for each profile */
  657.     if (event == ESP_GATTS_REG_EVT) {
  658.         if (param->reg.status == ESP_GATT_OK) {
  659.             gl_profile_tab[param->reg.app_id].gatts_if = gatts_if;
  660.         } else {
  661.             ESP_LOGI(GATTS_TAG, "Reg app failed, app_id %04x, status %d\n",
  662.                     param->reg.app_id,
  663.                     param->reg.status);
  664.             return;
  665.         }
  666.     }
  667.  
  668.     /* If the gatts_if equal to profile A, call profile A cb handler,
  669.      * so here call each profile's callback */
  670.     do {
  671.         int idx;
  672.         for (idx = 0; idx < PROFILE_NUM; idx++) {
  673.             if (gatts_if == ESP_GATT_IF_NONE || /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
  674.                     gatts_if == gl_profile_tab[idx].gatts_if) {
  675.                 if (gl_profile_tab[idx].gatts_cb) {
  676.                     gl_profile_tab[idx].gatts_cb(event, gatts_if, param);
  677.                 }
  678.             }
  679.         }
  680.     } while (0);
  681. }
  682.  
  683. void app_main()
  684. {
  685.     esp_err_t ret;
  686.  
  687.     // Initialize NVS.
  688.     ret = nvs_flash_init();
  689.     if (ret == ESP_ERR_NVS_NO_FREE_PAGES) {
  690.         ESP_ERROR_CHECK(nvs_flash_erase());
  691.         ret = nvs_flash_init();
  692.     }
  693.     ESP_ERROR_CHECK( ret );
  694.  
  695.     ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
  696.  
  697.     esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
  698.     ret = esp_bt_controller_init(&bt_cfg);
  699.     if (ret) {
  700.         ESP_LOGE(GATTS_TAG, "%s initialize controller failed\n", __func__);
  701.         return;
  702.     }
  703.  
  704.     ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
  705.     if (ret) {
  706.         ESP_LOGE(GATTS_TAG, "%s enable controller failed\n", __func__);
  707.         return;
  708.     }
  709.     ret = esp_bluedroid_init();
  710.     if (ret) {
  711.         ESP_LOGE(GATTS_TAG, "%s init bluetooth failed\n", __func__);
  712.         return;
  713.     }
  714.     ret = esp_bluedroid_enable();
  715.     if (ret) {
  716.         ESP_LOGE(GATTS_TAG, "%s enable bluetooth failed\n", __func__);
  717.         return;
  718.     }
  719.  
  720.     ret = esp_ble_gatts_register_callback(gatts_event_handler);
  721.     if (ret){
  722.         ESP_LOGE(GATTS_TAG, "gatts register error, error code = %x", ret);
  723.         return;
  724.     }
  725.     ret = esp_ble_gap_register_callback(gap_event_handler);
  726.     if (ret){
  727.         ESP_LOGE(GATTS_TAG, "gap register error, error code = %x", ret);
  728.         return;
  729.     }
  730.     ret = esp_ble_gatts_app_register(PROFILE_A_APP_ID);
  731.     if (ret){
  732.         ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
  733.         return;
  734.     }
  735.     ret = esp_ble_gatts_app_register(PROFILE_B_APP_ID);
  736.     if (ret){
  737.         ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
  738.         return;
  739.     }
  740.     esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
  741.     if (local_mtu_ret){
  742.         ESP_LOGE(GATTS_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
  743.     }
  744.  
  745.     return;
  746. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!