ESP32 Forum

ESP32 Official Forum
http://esp32.io/

BLE GATTS not gating notify

http://esp32.io/viewtopic.php?f=13&t=37135

Page 1 of 1

BLE GATTS not gating notify

Posted: Mon Dec 04, 2023 12:29 pm
by DavidPilant
base on ble_spp_server example

I'm taring to use this code to send data (notify type) to client
Code: [Select all] [Expand/Collapse]
  1. int set_status(const char* status, uint8_t size)
  2. {
  3.     ESP_LOGI(GATTS_TAG, "%s.", status);
  4.     return esp_ble_gatts_set_attr_value(40 + SPP_IDX_SPP_STATUS_VAL, size, (const uint8_t*)status);
  5. }
GeSHi © Codebox Plus Extension


but in the client side i'm not gating any notification but if i check the data r there.
any help will be will be welcomed.

Code: [Select all] [Expand/Collapse]
  1. /*
  2.   * bala_geet_server.c
  3.  *
  4.  *  Created on: 21 Sep 2023
  5.  *      Author: ddial
  6.  */
  7.  
  8. #include <stdio.h>
  9.  
  10. #include "freertos/FreeRTOS.h"
  11. #include "freertos/task.h"
  12. #include "freertos/event_groups.h"
  13. #include "freertos/semphr.h"
  14.  
  15. #include "esp_system.h"
  16. #include "esp_random.h"
  17. #include "esp_log.h"
  18. #include "nvs_drv.h"
  19. #include "esp_bt.h"
  20.  
  21. #include "string.h"
  22.  
  23. #include "esp_gap_ble_api.h"
  24. #include "esp_gatts_api.h"
  25. #include "esp_gatt_defs.h"
  26. #include "esp_bt_main.h"
  27. #include "esp_gatt_common_api.h"
  28. #include "interface.h"
  29.  
  30. #include "bala_geet_server.h"
  31.  
  32. #define GATTS_TAG "[GATTS]"
  33.  
  34. #define SPP_PROFILE_NUM             1
  35. #define SPP_PROFILE_APP_IDX         0
  36. #define ESP_SPP_APP_ID              0x56
  37.  
  38. #define SAMPLE_DEVICE_NAME          "ESP_SPP_SERV_1"    //The Device Name Characteristics in GAP
  39. #define SPP_SVC_INST_ID             0
  40.  
  41. /// SPP Service
  42. static const uint16_t spp_service_uuid = 0xABF0;
  43. /// Characteristic UUID
  44. #define ESP_GATT_UUID_SPP_DATA_RECEIVE      0xABF1
  45. #define ESP_GATT_UUID_SPP_DATA_NOTIFY       0xABF2
  46. #define ESP_GATT_UUID_SPP_COMMAND_RECEIVE   0xABF3
  47. #define ESP_GATT_UUID_SPP_COMMAND_NOTIFY    0xABF4
  48.  
  49. 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);
  50.  
  51. /// Local variables ////////////////////////////////////////////////////////////
  52. static SemaphoreHandle_t ble_geets_init_mutex_h = NULL;
  53. static uint16_t spp_handle_table[SPP_IDX_NB];
  54. static uint16_t spp_mtu_size = 23;
  55. static uint16_t spp_conn_id = 0xffff;
  56. static esp_gatt_if_t spp_gatts_if = 0xff;
  57. static bool is_connected = false;
  58. static esp_bd_addr_t spp_remote_bda = {0x0,};
  59. static bool enable_data_ntf = false;
  60. static QueueHandle_t cmd_cmd_queue = NULL;
  61.  
  62. typedef struct spp_receive_data_node{
  63.     int32_t len;
  64.     uint8_t * node_buff;
  65.     struct spp_receive_data_node * next_node;
  66. }spp_receive_data_node_t;
  67.  
  68. static spp_receive_data_node_t * temp_spp_recv_data_node_p1 = NULL;
  69. static spp_receive_data_node_t * temp_spp_recv_data_node_p2 = NULL;
  70.  
  71. typedef struct spp_receive_data_buff{
  72.     int32_t node_num;
  73.     int32_t buff_size;
  74.     spp_receive_data_node_t * first_node;
  75. }spp_receive_data_buff_t;
  76.  
  77. static spp_receive_data_buff_t SppRecvDataBuff = {
  78.     .node_num   = 0,
  79.     .buff_size  = 0,
  80.     .first_node = NULL
  81. };
  82.  
  83. static esp_ble_adv_params_t spp_adv_params = {
  84.     .adv_int_min        = 0x20,
  85.     .adv_int_max        = 0x40,
  86.     .adv_type           = ADV_TYPE_IND,
  87.     .own_addr_type      = BLE_ADDR_TYPE_PUBLIC,
  88.     .channel_map        = ADV_CHNL_ALL,
  89.     .adv_filter_policy  = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
  90. };
  91.  
  92. struct gatts_profile_inst {
  93.     esp_gatts_cb_t gatts_cb;
  94.     uint16_t gatts_if;
  95.     uint16_t app_id;
  96.     uint16_t conn_id;
  97.     uint16_t service_handle;
  98.     esp_gatt_srvc_id_t service_id;
  99.     uint16_t char_handle;
  100.     esp_bt_uuid_t char_uuid;
  101.     esp_gatt_perm_t perm;
  102.     esp_gatt_char_prop_t property;
  103.     uint16_t descr_handle;
  104.     esp_bt_uuid_t descr_uuid;
  105. };
  106.  
  107. /* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */
  108. static struct gatts_profile_inst spp_profile_tab[SPP_PROFILE_NUM] = {
  109.     [SPP_PROFILE_APP_IDX] = {
  110.         .gatts_cb = gatts_profile_event_handler,
  111.         .gatts_if = ESP_GATT_IF_NONE,       /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
  112.     },
  113. };
  114.  
  115. static const uint8_t spp_adv_data[23] = {
  116.     /* Flags */
  117.     0x02,0x01,0x06,
  118.     /* Complete List of 16-bit Service Class UUIDs */
  119.     0x03,0x03,0xF0,0xAB,
  120.     /* Complete Local Name in advertising */
  121.     0x0F,0x09, 'E', 'S', 'P', '_', 'S', 'P', 'P', '_', 'S', 'E', 'R','V', '_', '1'
  122. };
  123.  
  124. /*
  125.  *  SPP PROFILE ATTRIBUTES
  126.  ****************************************************************************************
  127.  */
  128.  
  129. #define CHAR_DECLARATION_SIZE   (sizeof(uint8_t))
  130. static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE;
  131. static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE;
  132. static const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG;
  133. static const uint8_t char_prop_read_notify = ESP_GATT_CHAR_PROP_BIT_READ|ESP_GATT_CHAR_PROP_BIT_NOTIFY;
  134. static const uint8_t char_prop_read_write = ESP_GATT_CHAR_PROP_BIT_WRITE_NR|ESP_GATT_CHAR_PROP_BIT_READ;
  135.  
  136. #ifdef SUPPORT_HEARTBEAT
  137. static const uint8_t char_prop_read_write_notify = ESP_GATT_CHAR_PROP_BIT_READ|ESP_GATT_CHAR_PROP_BIT_WRITE_NR|ESP_GATT_CHAR_PROP_BIT_NOTIFY;
  138. #endif
  139.  
  140. ///SPP Service - data receive characteristic, read&write without response
  141. static const uint16_t spp_data_receive_uuid = ESP_GATT_UUID_SPP_DATA_RECEIVE;
  142. static const uint8_t  spp_data_receive_val[SPP_DATA_MAX_LEN] = { 0 };
  143.  
  144. ///SPP Service - data notify characteristic, notify&read
  145. static const uint16_t spp_data_notify_uuid = ESP_GATT_UUID_SPP_DATA_NOTIFY;
  146. static const uint8_t  spp_data_notify_val[20] = { 0 };
  147. static const uint8_t  spp_data_notify_ccc[2] = { 0 };
  148.  
  149. ///SPP Service - command characteristic, read&write without response
  150. static const uint16_t spp_command_uuid = ESP_GATT_UUID_SPP_COMMAND_RECEIVE;
  151. static const uint8_t  spp_command_val[SPP_CMD_MAX_LEN] = { 0 };
  152.  
  153. ///SPP Service - status characteristic, notify&read
  154. static const uint16_t spp_status_uuid = ESP_GATT_UUID_SPP_COMMAND_NOTIFY;
  155. static const uint8_t  spp_status_val[SPP_STATUS_MAX_LEN] = { 0 };
  156. static const uint8_t  spp_status_ccc[2] = { 0 };
  157.  
  158. #ifdef SUPPORT_HEARTBEAT
  159. ///SPP Server - Heart beat characteristic, notify&write&read
  160. static const uint16_t spp_heart_beat_uuid = ESP_GATT_UUID_SPP_HEARTBEAT;
  161. static const uint8_t  spp_heart_beat_val[2] = {0x00, 0x00};
  162. static const uint8_t  spp_heart_beat_ccc[2] = {0x00, 0x00};
  163. #endif
  164.  
  165.  
  166. ///Full HRS Database Description - Used to add attributes into the database
  167. static const esp_gatts_attr_db_t spp_gatt_db[SPP_IDX_NB] =
  168. {
  169.     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  170.     //SPP -  Service Declaration
  171.     [SPP_IDX_SVC] =                                         /// esp_gatts_attr_db_t
  172.     {                                                       /// {
  173.         {                                                   ///     esp_attr_control_t {
  174.                 ESP_GATT_AUTO_RSP                           ///         uint8_t auto_rsp;
  175.         },                                                  ///     }
  176.         {                                                   ///     esp_attr_desc_t {
  177.             ESP_UUID_LEN_16,                                ///         uint16_t uuid_length;              /*!< UUID length */
  178.             (uint8_t *)&primary_service_uuid,               ///         uint8_t  *uuid_p;                  /*!< UUID value */
  179.             ESP_GATT_PERM_READ,                             ///         uint16_t perm;                     /*!< Attribute permission */
  180.             sizeof(spp_service_uuid),                       ///         uint16_t max_length;               /*!< Maximum length of the element*/
  181.             sizeof(spp_service_uuid),                       ///         uint16_t length;                   /*!< Current length of the element*/
  182.             (uint8_t *)&spp_service_uuid                    ///         uint8_t  *value;                   /*!< Element value array*/
  183.         }                                                   ///     }
  184.     },                                                      /// }
  185.  
  186.     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  187.     //SPP -  data receive characteristic Declaration
  188.     [SPP_IDX_SPP_DATA_RECV_CHAR] = {
  189.     {ESP_GATT_AUTO_RSP }, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
  190.     CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},
  191.     //SPP -  data receive characteristic Value
  192.     [SPP_IDX_SPP_DATA_RECV_VAL] = {
  193.     {ESP_GATT_AUTO_RSP }, { ESP_UUID_LEN_16, (uint8_t *)&spp_data_receive_uuid, (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE),
  194.     SPP_DATA_MAX_LEN, sizeof(spp_data_receive_val), (uint8_t *)spp_data_receive_val}},
  195.  
  196.     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  197.     //SPP -  data notify characteristic Declaration
  198.     [SPP_IDX_SPP_DATA_NOTIFY_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid,
  199.     ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},
  200.     //SPP -  data notify characteristic Value
  201.     [SPP_IDX_SPP_DATA_NTY_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_notify_uuid,
  202.     ESP_GATT_PERM_READ, sizeof(spp_data_notify_val), sizeof(spp_data_notify_val), (uint8_t *)spp_data_notify_val}},
  203.     //SPP -  data notify characteristic - Client Characteristic Configuration Descriptor
  204.     [SPP_IDX_SPP_DATA_NTF_CFG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid,
  205.     (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE), sizeof(uint16_t), sizeof(spp_data_notify_ccc), (uint8_t *)spp_data_notify_ccc}},
  206.  
  207.     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  208.     //SPP -  command characteristic Declaration
  209.     [SPP_IDX_SPP_COMMAND_CHAR] = {{ESP_GATT_AUTO_RSP},{ESP_UUID_LEN_16,(uint8_t *)&character_declaration_uuid,
  210.     ESP_GATT_PERM_READ,CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE,(uint8_t *)&char_prop_read_write}},
  211.     //SPP -  command characteristic Value
  212.     [SPP_IDX_SPP_COMMAND_VAL] = {{ESP_GATT_AUTO_RSP},{
  213.     ESP_UUID_LEN_16, (uint8_t *)&spp_command_uuid, (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE),
  214.     SPP_CMD_MAX_LEN, SPP_CMD_MAX_LEN, (uint8_t *)spp_command_val}},
  215.  
  216.  
  217.     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  218.     //SPP -  status characteristic Declaration
  219.     [SPP_IDX_SPP_STATUS_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid,
  220.     ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},
  221.     //SPP -  status characteristic Value
  222.     [SPP_IDX_SPP_STATUS_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_status_uuid,
  223.     ESP_GATT_PERM_READ, SPP_STATUS_MAX_LEN, SPP_STATUS_MAX_LEN, (uint8_t *)spp_status_val}},
  224.     //SPP -  status characteristic - Client Characteristic Configuration Descriptor
  225.     [SPP_IDX_SPP_STATUS_CFG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid,
  226.     (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE), sizeof(uint16_t), sizeof(spp_status_ccc), (uint8_t *)spp_status_ccc}},
  227.  
  228. #ifdef SUPPORT_HEARTBEAT
  229.     //SPP -  Heart beat characteristic Declaration
  230.     [SPP_IDX_SPP_HEARTBEAT_CHAR]  =
  231.     {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
  232.     CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}},
  233.  
  234.     //SPP -  Heart beat characteristic Value
  235.     [SPP_IDX_SPP_HEARTBEAT_VAL]   =
  236.     {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_heart_beat_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
  237.     sizeof(spp_heart_beat_val), sizeof(spp_heart_beat_val), (uint8_t *)spp_heart_beat_val}},
  238.  
  239.     //SPP -  Heart beat characteristic - Client Characteristic Configuration Descriptor
  240.     [SPP_IDX_SPP_HEARTBEAT_CFG]         =
  241.     {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE,
  242.     sizeof(uint16_t),sizeof(spp_data_notify_ccc), (uint8_t *)spp_heart_beat_ccc}},
  243. #endif
  244. };
  245.  
  246. /// Local functions ////////////////////////////////////////////////////////////
  247. static uint8_t find_char_and_desr_index(uint16_t handle)
  248. {
  249.     int i = 0;
  250.     uint8_t error = 0xff;
  251.  
  252.     for(i = 0; i < SPP_IDX_NB ; i++)
  253.     {
  254.         if(handle == spp_handle_table[i])
  255.         {
  256.             return i;
  257.         }
  258.     }
  259.  
  260.     return error;
  261. }
  262.  
  263. static bool store_wr_buffer(esp_ble_gatts_cb_param_t *p_data)
  264. {
  265.     temp_spp_recv_data_node_p1 = (spp_receive_data_node_t *)malloc(sizeof(spp_receive_data_node_t));
  266.  
  267.     if(temp_spp_recv_data_node_p1 == NULL)
  268.     {
  269.         ESP_LOGI(GATTS_TAG, "malloc error %s %d", __func__, __LINE__);
  270.         return false;
  271.     }
  272.  
  273.     if(temp_spp_recv_data_node_p2 != NULL)
  274.     {
  275.         temp_spp_recv_data_node_p2->next_node = temp_spp_recv_data_node_p1;
  276.     }
  277.  
  278.     temp_spp_recv_data_node_p1->len = p_data->write.len;
  279.     SppRecvDataBuff.buff_size += p_data->write.len;
  280.     temp_spp_recv_data_node_p1->next_node = NULL;
  281.     temp_spp_recv_data_node_p1->node_buff = (uint8_t *)malloc(p_data->write.len);
  282.     temp_spp_recv_data_node_p2 = temp_spp_recv_data_node_p1;
  283.     memcpy(temp_spp_recv_data_node_p1->node_buff,p_data->write.value,p_data->write.len);
  284.     if(SppRecvDataBuff.node_num == 0)
  285.     {
  286.         SppRecvDataBuff.first_node = temp_spp_recv_data_node_p1;
  287.         SppRecvDataBuff.node_num++;
  288.     }
  289.     else
  290.     {
  291.         SppRecvDataBuff.node_num++;
  292.     }
  293.  
  294.     return true;
  295. }
  296.  
  297. static void free_write_buffer(void)
  298. {
  299.     temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node;
  300.  
  301.     while(temp_spp_recv_data_node_p1 != NULL)
  302.     {
  303.         temp_spp_recv_data_node_p2 = temp_spp_recv_data_node_p1->next_node;
  304.         free(temp_spp_recv_data_node_p1->node_buff);
  305.         free(temp_spp_recv_data_node_p1);
  306.         temp_spp_recv_data_node_p1 = temp_spp_recv_data_node_p2;
  307.     }
  308.  
  309.     SppRecvDataBuff.node_num = 0;
  310.     SppRecvDataBuff.buff_size = 0;
  311.     SppRecvDataBuff.first_node = NULL;
  312. }
  313.  
  314. static void print_write_buffer(void)
  315. {
  316.     temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node;
  317.  
  318.     while(temp_spp_recv_data_node_p1 != NULL)
  319.     {
  320. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  321.         esp_log_buffer_char(GATTS_TAG, (char *)(temp_spp_recv_data_node_p1->node_buff),temp_spp_recv_data_node_p1->len);
  322. #endif
  323.         //uart_write_bytes(UART_NUM_0, (char *)(temp_spp_recv_data_node_p1->node_buff), temp_spp_recv_data_node_p1->len);
  324.         temp_spp_recv_data_node_p1 = temp_spp_recv_data_node_p1->next_node;
  325.     }
  326. }
  327.  
  328.  
  329. //DAVID
  330. /*
  331. void get_cmd_handler_task(void * arg)
  332. {
  333.     uint8_t * cmd_id;
  334.  
  335.     for(;;)
  336.     {
  337.         vTaskDelay(50 / portTICK_PERIOD_MS);
  338.         if(xQueueReceive(cmd_cmd_queue, &cmd_id, portMAX_DELAY))
  339.         {
  340. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  341.             esp_log_buffer_hex(GATTS_TAG,(char *)(cmd_id), strlen((char *)cmd_id));
  342. #endif
  343.             free(cmd_id);
  344.         }
  345.     }
  346.  
  347.     vTaskDelete(NULL);
  348. }
  349.  
  350.  
  351. static void spp_task_init(void)
  352. {
  353. #ifdef SUPPORT_HEARTBEAT
  354.     cmd_heartbeat_queue = xQueueCreate(10, sizeof(uint32_t));
  355.     xTaskCreate(spp_heartbeat_task, "spp_heartbeat_task", 2048, NULL, 10, NULL);
  356. #endif
  357.  
  358.     cmd_cmd_queue = xQueueCreate(10, sizeof(uint32_t));
  359.     xTaskCreate(get_cmd_handler_task, "get_cmd_handler_task", 2048, NULL, 10, NULL);
  360. }
  361. */
  362.  
  363. static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
  364. {
  365.     int idx = 0;
  366.  
  367. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  368.     ESP_LOGI(GATTS_TAG, "EVT %d, gatts if %d", event, gatts_if);
  369. #endif
  370.  
  371.     /* If event is register event, store the gatts_if for each profile */
  372.     if (event == ESP_GATTS_REG_EVT)
  373.     {
  374.         if (param->reg.status == ESP_GATT_OK)
  375.         {
  376.             spp_profile_tab[SPP_PROFILE_APP_IDX].gatts_if = gatts_if;
  377.         }
  378.         else
  379.         {
  380.             ESP_LOGI(GATTS_TAG, "Reg app failed, app_id %04x, status %d", param->reg.app_id, param->reg.status);
  381.             return;
  382.         }
  383.     }
  384.  
  385.     /* If the gatts_if equal to profile A, call profile A cb handler, so here call each profile's callback */
  386.     for (idx = 0; idx < SPP_PROFILE_NUM; idx++)
  387.     {
  388.         if (gatts_if == ESP_GATT_IF_NONE || /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
  389.                 gatts_if == spp_profile_tab[idx].gatts_if)
  390.         {
  391.             if (spp_profile_tab[idx].gatts_cb)
  392.             {
  393.                 spp_profile_tab[idx].gatts_cb(event, gatts_if, param);
  394.             }
  395.         }
  396.     }
  397. }
  398.  
  399. static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
  400. {
  401.     esp_err_t err = ESP_FAIL;
  402.  
  403. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  404.     ESP_LOGE(GATTS_TAG, "GAP_EVT, event %d", event);
  405. #endif
  406.  
  407.     switch (event)
  408.     {
  409.     case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
  410.  
  411. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  412.         ESP_LOGI(GATTS_TAG, "ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT");
  413. #endif
  414.  
  415.         esp_ble_gap_start_advertising(&spp_adv_params);         // Trigger ESP_GAP_BLE_ADV_START_COMPLETE_EVT
  416.  
  417.         break;
  418.  
  419.     case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
  420. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  421.         ESP_LOGI(GATTS_TAG, "ESP_GAP_BLE_ADV_START_COMPLETE_EVT");
  422. #endif
  423.  
  424.         //advertising start complete event to indicate advertising start successfully or failed
  425.         if((err = param->adv_start_cmpl.status) != ESP_BT_STATUS_SUCCESS)
  426.         {
  427.             ESP_LOGE(GATTS_TAG, "Advertising start failed: %s", esp_err_to_name(err));
  428.         }
  429.  
  430.         break;
  431.  
  432.     default:
  433.         break;
  434.     }
  435. }
  436.  
  437. 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)
  438. {
  439.     uint8_t res = 0xff;
  440.     //xMessage* pxMessage = NULL;
  441.     esp_ble_gatts_cb_param_t *p_data = (esp_ble_gatts_cb_param_t *) param;
  442.  
  443. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  444.     ESP_LOGI(GATTS_TAG, "event = %x, handle %d.", event, p_data->write.handle);
  445. #endif
  446.  
  447.     switch (event)
  448.     {
  449.     case ESP_GATTS_REG_EVT:                     /*!< When register application id, the event comes */
  450. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  451.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_REG_EVT");
  452.  
  453.         ESP_LOGI(GATTS_TAG, "%s %d", __func__, __LINE__);
  454. #endif
  455.         esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME);
  456. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  457.         ESP_LOGI(GATTS_TAG, "%s %d", __func__, __LINE__);
  458. #endif
  459.         esp_ble_gap_config_adv_data_raw((uint8_t *)spp_adv_data, sizeof(spp_adv_data));         // Trigger ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT
  460. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  461.         ESP_LOGI(GATTS_TAG, "%s %d", __func__, __LINE__);
  462. #endif
  463.         esp_ble_gatts_create_attr_tab(spp_gatt_db, gatts_if, SPP_IDX_NB, SPP_SVC_INST_ID);      // Trigger ESP_GATTS_CREAT_ATTR_TAB_EVT
  464.         break;
  465.  
  466.     case ESP_GATTS_READ_EVT:                    /*!< When GATT client request read operation, the event comes */
  467. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  468.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_READ_EVT");
  469. #endif
  470.         res = find_char_and_desr_index(p_data->read.handle);
  471.         if(res == SPP_IDX_SPP_DATA_RECV_VAL)
  472.         {
  473. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  474.             ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_DATA_RECV_VAL");
  475. #endif
  476.         }
  477.         else if(res == SPP_IDX_SPP_DATA_NTY_VAL)
  478.         {
  479. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  480.             ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_DATA_NTY_VAL");
  481. #endif
  482.         }
  483.         else if(res == SPP_IDX_SPP_COMMAND_VAL)     // add command to Q.
  484.         {
  485. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  486.             ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_COMMAND_VAL");
  487. #endif
  488.         }
  489.         else if(res == SPP_IDX_SPP_STATUS_VAL)
  490.         {
  491. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  492.             ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_STATUS_VAL handle %d.", p_data->write.handle);
  493. #endif
  494.             //TODO:client read the status characteristic
  495.             //ESP_LOGI(GATTS_TAG, "send OK, write handle %d.", p_data->write.handle);
  496.             //esp_ble_gatts_set_attr_value(p_data->write.handle, 2, (const uint8_t*)"OK");
  497.  
  498.         }
  499.  
  500.         break;
  501.  
  502.     case ESP_GATTS_WRITE_EVT:                   /*!< When GATT client request write operation, the event comes */
  503. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  504.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_WRITE_EVT");
  505. #endif
  506.  
  507.         res = find_char_and_desr_index(p_data->write.handle);
  508.         if(p_data->write.is_prep == false)
  509.         {
  510. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  511.             ESP_LOGI(GATTS_TAG, " handle = %d", res);
  512. #endif
  513.             if(res == SPP_IDX_SPP_COMMAND_VAL)      // add command to Q.
  514.             {
  515. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  516.                 ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_COMMAND_VAL\n");
  517. #endif
  518.  
  519.                 uint8_t * spp_cmd_buff = NULL;
  520.                 spp_cmd_buff = (uint8_t *)malloc((spp_mtu_size - 3) * sizeof(uint8_t));
  521.                 if(spp_cmd_buff == NULL)
  522.                 {
  523.                     ESP_LOGE(GATTS_TAG, "%s malloc failed\n", __func__);
  524.                     set_status("ERR M 7", 7);
  525.                     break;
  526.                 }
  527.  
  528.                 memset(spp_cmd_buff, 0x0,(spp_mtu_size - 3));
  529.                 memcpy(spp_cmd_buff, p_data->write.value, p_data->write.len);
  530.  
  531.  
  532.                 if (xQueueSend(interface_queue, &spp_cmd_buff, 10 / portTICK_PERIOD_MS) != pdPASS)
  533.                     set_status("ERR Q 7", 7);
  534.                 else
  535.                     set_status("OK 7 UID", 8);
  536. /*
  537.                 pxMessage = (xMessage*)malloc(sizeof(xMessage));
  538.                 if(pxMessage == NULL)
  539.                 {
  540.                     ESP_LOGE(GATTS_TAG, "%s malloc failed\n", __func__);
  541.                     set_status("ERR M 7", 7);
  542.                     break;
  543.                 }
  544.  
  545.                 pxMessage->ucDataBuff = (uint8_t*)malloc((spp_mtu_size - 3) * sizeof(uint8_t));
  546.                 if(pxMessage->ucDataBuff == NULL)
  547.                 {
  548.                     ESP_LOGE(GATTS_TAG, "%s malloc failed\n", __func__);
  549.                     set_status("ERR M 7", 7);
  550.                     break;
  551.                 }
  552.  
  553.                 memset(pxMessage->ucDataBuff, 0x0,(spp_mtu_size - 3));
  554.                 memcpy(pxMessage->ucDataBuff, (p_data->write.value)+1, (p_data->write.len)-1);
  555.                 pxMessage->usMessageUID = esp_random();
  556.                 pxMessage->usDataLen = p_data->write.len;
  557.                 pxMessage->ucMessageID = p_data->write.value[0];
  558.  
  559.                 ESP_LOGI(GATTS_TAG, "message[0x%d]: ID%d, UID%d, DATA[%s].", (int)pxMessage, pxMessage->ucMessageID, pxMessage->usMessageUID, pxMessage->ucDataBuff);
  560.  
  561.                 if (interface_queue != NULL)
  562.                 {
  563.                     if (xQueueSend(interface_queue, (void*)pxMessage, 10 / portTICK_PERIOD_MS) != pdPASS)
  564.                         set_status("ERR Q 7", 7);
  565.                     else
  566.                         set_status("OK 7 UID", 8);
  567.                 }
  568.                 else
  569.                     set_status("OK 7 UID", 8);
  570. */
  571.             }
  572.             else if(res == SPP_IDX_SPP_DATA_NTF_CFG)
  573.             {
  574. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  575.                 ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_DATA_NTF_CFG");
  576.                 esp_log_buffer_char(GATTS_TAG,(char *)(p_data->write.value),p_data->write.len);
  577. #endif
  578.                 if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00))
  579.                 {
  580.                     enable_data_ntf = true;
  581.                 }
  582.                 else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00))
  583.                 {
  584.                     enable_data_ntf = false;
  585.                 }
  586.             }
  587. #ifdef SUPPORT_HEARTBEAT
  588.             else if(res == SPP_IDX_SPP_HEARTBEAT_CFG)
  589.             {
  590.                 if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00))
  591.                 {
  592.                     enable_heart_ntf = true;
  593.                 }
  594.                 else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00))
  595.                 {
  596.                     enable_heart_ntf = false;
  597.                 }
  598.             }
  599.             else if(res == SPP_IDX_SPP_HEARTBEAT_VAL)
  600.             {
  601.                 if((p_data->write.len == sizeof(heartbeat_s))&&(memcmp(heartbeat_s,p_data->write.value,sizeof(heartbeat_s)) == 0))
  602.                 {
  603.                     heartbeat_count_num = 0;
  604.                 }
  605.             }
  606. #endif
  607.             else if(res == SPP_IDX_SPP_DATA_RECV_VAL)   // print row data.
  608.             {
  609. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  610.                 ESP_LOGI(GATTS_TAG, "SPP_IDX_SPP_DATA_RECV_VAL handle %d.", p_data->write.handle);
  611.                 esp_log_buffer_char(GATTS_TAG,(char *)(p_data->write.value),p_data->write.len);
  612. #endif
  613.                 // TODO process row data.
  614.                 set_status("OK 2 UID", 8);
  615.             }
  616.             else
  617.             {
  618.                 //TODO:
  619.             }
  620.         }
  621.         else if((p_data->write.is_prep == true)&&(res == SPP_IDX_SPP_DATA_RECV_VAL))
  622.         {
  623. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  624.             ESP_LOGI(GATTS_TAG, "ESP_GATTS_PREP_WRITE_EVT : handle = %d.", res);
  625. #endif
  626.             store_wr_buffer(p_data);
  627.         }
  628.  
  629.         break;
  630.  
  631.     case ESP_GATTS_EXEC_WRITE_EVT:
  632. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  633.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_EXEC_WRITE_EVT");
  634. #endif
  635.         if(p_data->exec_write.exec_write_flag)
  636.         {
  637.             print_write_buffer();
  638.             free_write_buffer();
  639.         }
  640.  
  641.         break;
  642.  
  643.     case ESP_GATTS_MTU_EVT:
  644. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  645.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT");
  646. #endif
  647.         spp_mtu_size = p_data->mtu.mtu;
  648.         break;
  649.  
  650.     case ESP_GATTS_CONF_EVT:
  651. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  652.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT");
  653. #endif
  654.         break;
  655.  
  656.     case ESP_GATTS_UNREG_EVT:
  657. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  658.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_UNREG_EVT");
  659. #endif
  660.         break;
  661.  
  662.     case ESP_GATTS_DELETE_EVT:
  663. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  664.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_DELETE_EVT");
  665. #endif
  666.         break;
  667.  
  668.     case ESP_GATTS_START_EVT:
  669. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  670.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_START_EVT");
  671. #endif
  672.         break;
  673.  
  674.     case ESP_GATTS_STOP_EVT:
  675. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  676.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_STOP_EVT");
  677. #endif
  678.         break;
  679.  
  680.     case ESP_GATTS_CONNECT_EVT:
  681. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  682.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONNECT_EVT");
  683. #endif
  684.         spp_conn_id = p_data->connect.conn_id;
  685.         spp_gatts_if = gatts_if;
  686.         is_connected = true;
  687.         memcpy(&spp_remote_bda,&p_data->connect.remote_bda, sizeof(esp_bd_addr_t));
  688. #ifdef SUPPORT_HEARTBEAT
  689.         uint16_t cmd = 0;
  690.         xQueueSend(cmd_heartbeat_queue, &cmd, 10/portTICK_PERIOD_MS);
  691. #endif
  692.  
  693.         break;
  694.  
  695.     case ESP_GATTS_DISCONNECT_EVT:
  696. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  697.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_DISCONNECT_EVT");
  698. #endif
  699.         is_connected = false;
  700.         enable_data_ntf = false;
  701. #ifdef SUPPORT_HEARTBEAT
  702.         enable_heart_ntf = false;
  703.         heartbeat_count_num = 0;
  704. #endif
  705.         esp_ble_gap_start_advertising(&spp_adv_params);
  706.  
  707.         break;
  708.  
  709.     case ESP_GATTS_OPEN_EVT:
  710. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  711.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_OPEN_EVT");
  712. #endif
  713.         break;
  714.  
  715.     case ESP_GATTS_CANCEL_OPEN_EVT:
  716. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  717.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CANCEL_OPEN_EVT");
  718. #endif
  719.         break;
  720.  
  721.     case ESP_GATTS_CLOSE_EVT:
  722. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  723.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CLOSE_EVT");
  724. #endif
  725.         break;
  726.  
  727.     case ESP_GATTS_LISTEN_EVT:
  728. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  729.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_LISTEN_EVT");
  730. #endif
  731.         break;
  732.  
  733.     case ESP_GATTS_CONGEST_EVT:
  734. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  735.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONGEST_EVT");
  736. #endif
  737.         break;
  738.  
  739.     case ESP_GATTS_CREAT_ATTR_TAB_EVT:
  740. #ifdef BLE_SPP_GEET_SERVER_DEBUG
  741.         ESP_LOGI(GATTS_TAG, "ESP_GATTS_CREAT_ATTR_TAB_EVT");
  742.  
  743.         ESP_LOGI(GATTS_TAG, "The number handle =%x",param->add_attr_tab.num_handle);
  744. #endif
  745.         if (param->add_attr_tab.status != ESP_GATT_OK)
  746.         {
  747.             ESP_LOGE(GATTS_TAG, "Create attribute table failed, error code=0x%x", param->add_attr_tab.status);
  748.         }
  749.         else if (param->add_attr_tab.num_handle != SPP_IDX_NB)
  750.         {
  751.             ESP_LOGE(GATTS_TAG, "Create attribute table abnormally, num_handle (%d) doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, SPP_IDX_NB);
  752.         }
  753.         else
  754.         {
  755.             memcpy(spp_handle_table, param->add_attr_tab.handles, sizeof(spp_handle_table));
  756.             esp_ble_gatts_start_service(spp_handle_table[SPP_IDX_SVC]);     // Trigger ESP_GATTS_START_EVT
  757.         }
  758.         break;
  759.  
  760.     default:
  761.         break;
  762.     }
  763. }
  764.  
  765. ///////////////////////////////////////////////////////////////////////////////
  766. int set_cmd(const char* cmd, uint8_t size)
  767. {
  768.     ESP_LOGI(GATTS_TAG, "%s.", cmd);
  769.     return esp_ble_gatts_set_attr_value(40 + SPP_IDX_SPP_COMMAND_VAL, size, (const uint8_t*)cmd);
  770. }
  771.  
  772. int set_data(const char* data, uint8_t size)
  773. {
  774.     ESP_LOGI(GATTS_TAG, "%s.", data);
  775.     return esp_ble_gatts_set_attr_value(40 + SPP_IDX_SPP_DATA_RECV_VAL, size, (const uint8_t*)data);
  776. }
  777.  
  778. int set_data_nty(const char* data, uint8_t size)
  779. {
  780.     ESP_LOGI(GATTS_TAG, "%s.", data);
  781.     return esp_ble_gatts_set_attr_value(40 + SPP_IDX_SPP_DATA_NTY_VAL, size, (const uint8_t*)data);
  782. }
  783.  
  784. int set_status(const char* status, uint8_t size)
  785. {
  786.     ESP_LOGI(GATTS_TAG, "%s.", status);
  787.     return esp_ble_gatts_set_attr_value(40 + SPP_IDX_SPP_STATUS_VAL, size, (const uint8_t*)status);
  788. }
  789.  
  790.  
  791. /// Global variables ///////////////////////////////////////////////////////////
  792.  
  793. /// Global functions ///////////////////////////////////////////////////////////
  794. void getts_init_variable(void)
  795. {
  796.     is_connected = false;
  797.     ble_geets_init_mutex_h = xSemaphoreCreateMutex();                           // Create MUTEX.
  798. }
  799.  
  800. esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();        // crash when in gett_server_init()
  801.  
  802. void gett_server_init(uint32_t timeout_ms)
  803. {
  804.     esp_err_t ret = ESP_FAIL;
  805.  
  806.     ESP_LOGI(GATTS_TAG, "Init.");
  807.  
  808.     if(ble_geets_init_mutex_h != NULL)
  809.     {
  810.         xSemaphoreTake(ble_geets_init_mutex_h, 0);                              // Take the MUTEX to lock all API..
  811.  
  812.         // init in main. TODO nvs init.
  813.  
  814.         ////////////////////////////////////////////////////////////////////////////////////////////////////////
  815.         ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
  816.  
  817.         ret = esp_bt_controller_init(&bt_cfg);
  818.         if (ret)
  819.         {
  820.             ESP_LOGE(GATTS_TAG, "%s initialize controller failed: %s", __func__, esp_err_to_name(ret));
  821.             return;
  822.         }
  823.  
  824.         ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
  825.         if (ret)
  826.         {
  827.             ESP_LOGE(GATTS_TAG, "%s enable controller failed: %s", __func__, esp_err_to_name(ret));
  828.             return;
  829.         }
  830.  
  831.         ////////////////////////////////////////////////////////////////////////////////////////////////////////
  832.         ESP_LOGI(GATTS_TAG, "%s Init bluetooth.", __func__);
  833.  
  834.         ret = esp_bluedroid_init();
  835.         if (ret)
  836.         {
  837.             ESP_LOGE(GATTS_TAG, "%s init bluetooth failed: %s", __func__, esp_err_to_name(ret));
  838.             return;
  839.         }
  840.  
  841.         ret = esp_bluedroid_enable();
  842.         if (ret)
  843.         {
  844.             ESP_LOGE(GATTS_TAG, "%s enable bluetooth failed: %s", __func__, esp_err_to_name(ret));
  845.             return;
  846.         }
  847.  
  848.         ////////////////////////////////////////////////////////////////////////////////////////////////////////
  849.         ret = esp_ble_gatts_register_callback(gatts_event_handler);
  850.         if (ret)
  851.         {
  852.             ESP_LOGE(GATTS_TAG, "gatts register error, error code = %x", ret);
  853.             return;
  854.         }
  855.  
  856.         ret = esp_ble_gap_register_callback(gap_event_handler);
  857.         if (ret)
  858.         {
  859.             ESP_LOGE(GATTS_TAG, "gap register error, error code = %x", ret);
  860.             return;
  861.         }
  862.  
  863.         ret = esp_ble_gatts_app_register(ESP_SPP_APP_ID);
  864.         if (ret)
  865.         {
  866.             ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
  867.             return;
  868.         }
  869.  
  870.         //DAVID spp_task_init();
  871.         ////////////////////////////////////////////////////////////////////////////////////////////////////////
  872.         xSemaphoreGive(ble_geets_init_mutex_h);                                 // Release the MUTEX if success.
  873.     }
  874.     else
  875.     {
  876.         /// TODO error CreateMutex.
  877.     }
  878.  
  879.  
  880. }
  881.  
  882. void gett_server_deinit(void)
  883. {
  884.     // esp_ble_gatts_app_unregister(?)
  885.     ////////////////////////////////////////////////////////////////////////////////////////////////////////
  886.     esp_bluedroid_disable();
  887.     esp_bluedroid_deinit();
  888.     ////////////////////////////////////////////////////////////////////////////////////////////////////////
  889.     esp_bt_controller_deinit();
  890.     esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT);
  891. }
  892.  
  893. bool is_ble_device_connected(void)
  894. {
  895.     return is_connected;
  896. }
GeSHi © Codebox Plus Extension
All times are UTC
Page 1 of 1
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/