diff --git a/examples/bluetooth/ble_spp_server/Makefile b/examples/bluetooth/ble_spp_server/Makefile new file mode 100644 index 000000000..0a272359d --- /dev/null +++ b/examples/bluetooth/ble_spp_server/Makefile @@ -0,0 +1,11 @@ +# +# This is a project Makefile. It is assumed the directory this Makefile resides in is a +# project subdirectory. +# + +PROJECT_NAME := ble_spp_server_demo + +COMPONENT_ADD_INCLUDEDIRS := components/include + +include $(IDF_PATH)/make/project.mk + diff --git a/examples/bluetooth/ble_spp_server/README.rst b/examples/bluetooth/ble_spp_server/README.rst new file mode 100644 index 000000000..17298a363 --- /dev/null +++ b/examples/bluetooth/ble_spp_server/README.rst @@ -0,0 +1,5 @@ +ESP-IDF GATT SERVER SPP demo +=============================================== + +This is the demo for user to realization BLE Serial Port Profile. + diff --git a/examples/bluetooth/ble_spp_server/main/ble_spp_server_demo.c b/examples/bluetooth/ble_spp_server/main/ble_spp_server_demo.c new file mode 100644 index 000000000..f0d1567a2 --- /dev/null +++ b/examples/bluetooth/ble_spp_server/main/ble_spp_server_demo.c @@ -0,0 +1,693 @@ +// Copyright 2015-2017 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/event_groups.h" +#include "esp_system.h" +#include "esp_log.h" +#include "nvs_flash.h" +#include "bt.h" +#include "driver/uart.h" +#include "string.h" + +#include "esp_gap_ble_api.h" +#include "esp_gatts_api.h" +#include "esp_bt_defs.h" +#include "esp_bt_main.h" +#include "ble_spp_server_demo.h" + +#define GATTS_TABLE_TAG "GATTS_SPP_DEMO" + +#define SPP_PROFILE_NUM 1 +#define SPP_PROFILE_APP_IDX 0 +#define ESP_SPP_APP_ID 0x56 +#define SAMPLE_DEVICE_NAME "ESP_SPP_SERVER" +#define SPP_SVC_INST_ID 0 + +/// SPP Service +static const uint16_t spp_service_uuid = 0xABF0; +/// Characteristic UUID +#define ESP_GATT_UUID_SPP_DATA_RECEIVE 0xABF1 +#define ESP_GATT_UUID_SPP_DATA_NOTIFY 0xABF2 +#define ESP_GATT_UUID_SPP_COMMAND_RECEIVE 0xABF3 +#define ESP_GATT_UUID_SPP_COMMAND_NOTIFY 0xABF4 + +#ifdef SUPPORT_HEARTBEAT +#define ESP_GATT_UUID_SPP_HEARTBEAT 0xABF5 +#endif + +static const uint8_t spp_adv_data[23] = { + 0x02,0x01,0x06, + 0x03,0x03,0xF0,0xAB, + 0x0F,0x09,0x45,0x53,0x50,0x5f,0x53,0x50,0x50,0x5f,0x53,0x45,0x52,0x56,0x45,0x52 +}; + +static uint16_t spp_mtu_size = 23; +static uint16_t spp_conn_id = 0xffff; +static esp_gatt_if_t spp_gatts_if = 0xff; +QueueHandle_t spp_uart_queue = NULL; +static xQueueHandle cmd_cmd_queue = NULL; + +#ifdef SUPPORT_HEARTBEAT +static xQueueHandle cmd_heartbeat_queue = NULL; +static uint8_t heartbeat_s[9] = {'E','s','p','r','e','s','s','i','f'}; +static bool enable_heart_ntf = false; +static uint8_t heartbeat_count_num = 0; +#endif + +static bool enable_data_ntf = false; +static bool is_connected = false; +static esp_bd_addr_t spp_remote_bda = {0x0,}; + +static uint16_t spp_handle_table[SPP_IDX_NB]; + +static esp_ble_adv_params_t spp_adv_params = { + .adv_int_min = 0x20, + .adv_int_max = 0x40, + .adv_type = ADV_TYPE_IND, + .own_addr_type = BLE_ADDR_TYPE_PUBLIC, + .channel_map = ADV_CHNL_ALL, + .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY, +}; + +struct gatts_profile_inst { + esp_gatts_cb_t gatts_cb; + uint16_t gatts_if; + uint16_t app_id; + uint16_t conn_id; + uint16_t service_handle; + esp_gatt_srvc_id_t service_id; + uint16_t char_handle; + esp_bt_uuid_t char_uuid; + esp_gatt_perm_t perm; + esp_gatt_char_prop_t property; + uint16_t descr_handle; + esp_bt_uuid_t descr_uuid; +}; + +typedef struct spp_receive_data_node{ + int32_t len; + uint8_t * node_buff; + struct spp_receive_data_node * next_node; +}spp_receive_data_node_t; + +static spp_receive_data_node_t * temp_spp_recv_data_node_p1 = NULL; +static spp_receive_data_node_t * temp_spp_recv_data_node_p2 = NULL; + +typedef struct spp_receive_data_buff{ + int32_t node_num; + int32_t buff_size; + spp_receive_data_node_t * first_node; +}spp_receive_data_buff_t; + +static spp_receive_data_buff_t SppRecvDataBuff = { + .node_num = 0, + .buff_size = 0, + .first_node = NULL +}; + +static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param); + +/* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */ +static struct gatts_profile_inst spp_profile_tab[SPP_PROFILE_NUM] = { + [SPP_PROFILE_APP_IDX] = { + .gatts_cb = gatts_profile_event_handler, + .gatts_if = ESP_GATT_IF_NONE, /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */ + }, +}; + +/* + * SPP PROFILE ATTRIBUTES + **************************************************************************************** + */ + +#define CHAR_DECLARATION_SIZE (sizeof(uint8_t)) +static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE; +static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE; +static const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG; + +static const uint8_t char_prop_read_notify = ESP_GATT_CHAR_PROP_BIT_READ|ESP_GATT_CHAR_PROP_BIT_NOTIFY; +static const uint8_t char_prop_read_write = ESP_GATT_CHAR_PROP_BIT_WRITE_NR|ESP_GATT_CHAR_PROP_BIT_READ; + +#ifdef SUPPORT_HEARTBEAT +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; +#endif + +///SPP Service - data receive characteristic, read&write without response +static const uint16_t spp_data_receive_uuid = ESP_GATT_UUID_SPP_DATA_RECEIVE; +static const uint8_t spp_data_receive_val[20] = {0x00}; + +///SPP Service - data notify characteristic, notify&read +static const uint16_t spp_data_notify_uuid = ESP_GATT_UUID_SPP_DATA_NOTIFY; +static const uint8_t spp_data_notify_val[20] = {0x00}; +static const uint8_t spp_data_notify_ccc[2] = {0x00, 0x00}; + +///SPP Service - command characteristic, read&write without response +static const uint16_t spp_command_uuid = ESP_GATT_UUID_SPP_COMMAND_RECEIVE; +static const uint8_t spp_command_val[10] = {0x00}; + +///SPP Service - status characteristic, notify&read +static const uint16_t spp_status_uuid = ESP_GATT_UUID_SPP_COMMAND_NOTIFY; +static const uint8_t spp_status_val[10] = {0x00}; +static const uint8_t spp_status_ccc[2] = {0x00, 0x00}; + +#ifdef SUPPORT_HEARTBEAT +///SPP Server - Heart beat characteristic, notify&write&read +static const uint16_t spp_heart_beat_uuid = ESP_GATT_UUID_SPP_HEARTBEAT; +static const uint8_t spp_heart_beat_val[2] = {0x00, 0x00}; +static const uint8_t spp_heart_beat_ccc[2] = {0x00, 0x00}; +#endif + +///Full HRS Database Description - Used to add attributes into the database +static const esp_gatts_attr_db_t spp_gatt_db[SPP_IDX_NB] = +{ + //SPP - Service Declaration + [SPP_IDX_SVC] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ, + sizeof(spp_service_uuid), sizeof(spp_service_uuid), (uint8_t *)&spp_service_uuid}}, + + //SPP - data receive characteristic Declaration + [SPP_IDX_SPP_DATA_RECV_CHAR] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}}, + + //SPP - data receive characteristic Value + [SPP_IDX_SPP_DATA_RECV_VAL] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_receive_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + SPP_DATA_MAX_LEN,sizeof(spp_data_receive_val), (uint8_t *)spp_data_receive_val}}, + + //SPP - data notify characteristic Declaration + [SPP_IDX_SPP_DATA_NOTIFY_CHAR] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}}, + + //SPP - data notify characteristic Value + [SPP_IDX_SPP_DATA_NTY_VAL] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_notify_uuid, ESP_GATT_PERM_READ, + SPP_DATA_MAX_LEN, sizeof(spp_data_notify_val), (uint8_t *)spp_data_notify_val}}, + + //SPP - data notify characteristic - Client Characteristic Configuration Descriptor + [SPP_IDX_SPP_DATA_NTF_CFG] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + sizeof(uint16_t),sizeof(spp_data_notify_ccc), (uint8_t *)spp_data_notify_ccc}}, + + //SPP - command characteristic Declaration + [SPP_IDX_SPP_COMMAND_CHAR] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}}, + + //SPP - command characteristic Value + [SPP_IDX_SPP_COMMAND_VAL] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_command_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + SPP_CMD_MAX_LEN,sizeof(spp_command_val), (uint8_t *)spp_command_val}}, + + //SPP - status characteristic Declaration + [SPP_IDX_SPP_STATUS_CHAR] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}}, + + //SPP - status characteristic Value + [SPP_IDX_SPP_STATUS_VAL] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_status_uuid, ESP_GATT_PERM_READ, + SPP_STATUS_MAX_LEN,sizeof(spp_status_val), (uint8_t *)spp_status_val}}, + + //SPP - status characteristic - Client Characteristic Configuration Descriptor + [SPP_IDX_SPP_STATUS_CFG] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + sizeof(uint16_t),sizeof(spp_status_ccc), (uint8_t *)spp_status_ccc}}, + +#ifdef SUPPORT_HEARTBEAT + //SPP - Heart beat characteristic Declaration + [SPP_IDX_SPP_HEARTBEAT_CHAR] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}}, + + //SPP - Heart beat characteristic Value + [SPP_IDX_SPP_HEARTBEAT_VAL] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_heart_beat_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + sizeof(spp_heart_beat_val), sizeof(spp_heart_beat_val), (uint8_t *)spp_heart_beat_val}}, + + //SPP - Heart beat characteristic - Client Characteristic Configuration Descriptor + [SPP_IDX_SPP_HEARTBEAT_CFG] = + {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + sizeof(uint16_t),sizeof(spp_data_notify_ccc), (uint8_t *)spp_heart_beat_ccc}}, +#endif +}; + +static uint8_t find_char_and_desr_index(uint16_t handle) +{ + uint8_t error = 0xff; + + for(int i = 0; i < SPP_IDX_NB ; i++){ + if(handle == spp_handle_table[i]){ + return i; + } + } + + return error; +} + +static bool store_wr_buffer(esp_ble_gatts_cb_param_t *p_data) +{ + temp_spp_recv_data_node_p1 = (spp_receive_data_node_t *)malloc(sizeof(spp_receive_data_node_t)); + + if(temp_spp_recv_data_node_p1 == NULL){ + ESP_LOGI(GATTS_TABLE_TAG, "malloc error %s %d\n", __func__, __LINE__); + return false; + } + if(temp_spp_recv_data_node_p2 != NULL){ + temp_spp_recv_data_node_p2->next_node = temp_spp_recv_data_node_p1; + } + temp_spp_recv_data_node_p1->len = p_data->write.len; + SppRecvDataBuff.buff_size += p_data->write.len; + temp_spp_recv_data_node_p1->next_node = NULL; + temp_spp_recv_data_node_p1->node_buff = (uint8_t *)malloc(p_data->write.len); + temp_spp_recv_data_node_p2 = temp_spp_recv_data_node_p1; + memcpy(temp_spp_recv_data_node_p1->node_buff,p_data->write.value,p_data->write.len); + if(SppRecvDataBuff.node_num == 0){ + SppRecvDataBuff.first_node = temp_spp_recv_data_node_p1; + SppRecvDataBuff.node_num++; + }else{ + SppRecvDataBuff.node_num++; + } + + return true; +} + +static void free_write_buffer(void) +{ + temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node; + + while(temp_spp_recv_data_node_p1 != NULL){ + temp_spp_recv_data_node_p2 = temp_spp_recv_data_node_p1->next_node; + free(temp_spp_recv_data_node_p1->node_buff); + free(temp_spp_recv_data_node_p1); + temp_spp_recv_data_node_p1 = temp_spp_recv_data_node_p2; + } + + SppRecvDataBuff.node_num = 0; + SppRecvDataBuff.buff_size = 0; + SppRecvDataBuff.first_node = NULL; +} + +static void print_write_buffer(void) +{ + temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node; + + while(temp_spp_recv_data_node_p1 != NULL){ + uart_write_bytes(UART_NUM_0, (char *)(temp_spp_recv_data_node_p1->node_buff), temp_spp_recv_data_node_p1->len); + temp_spp_recv_data_node_p1 = temp_spp_recv_data_node_p1->next_node; + } +} + +void uart_task(void *pvParameters) +{ + uart_event_t event; + uint8_t total_num = 0; + uint8_t current_num = 0; + + for (;;) { + //Waiting for UART event. + if (xQueueReceive(spp_uart_queue, (void * )&event, (portTickType)portMAX_DELAY)) { + switch (event.type) { + //Event of UART receving data + case UART_DATA: + if ((event.size)&&(is_connected)) { + uint8_t * temp = NULL; + uint8_t * ntf_value_p = NULL; +#ifdef SUPPORT_HEARTBEAT + if(!enable_heart_ntf){ + ESP_LOGE(GATTS_TABLE_TAG, "%s do not enable heartbeat Notify\n", __func__); + break; + } +#endif + if(!enable_data_ntf){ + ESP_LOGE(GATTS_TABLE_TAG, "%s do not enable data Notify\n", __func__); + break; + } + temp = (uint8_t *)malloc(sizeof(uint8_t)*event.size); + if(temp == NULL){ + ESP_LOGE(GATTS_TABLE_TAG, "%s malloc.1 failed\n", __func__); + break; + } + memset(temp,0x0,event.size); + uart_read_bytes(UART_NUM_0,temp,event.size,portMAX_DELAY); + if(event.size <= (spp_mtu_size - 3)){ + esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_DATA_NTY_VAL],event.size, temp, false); + }else if(event.size > (spp_mtu_size - 3)){ + if((event.size%(spp_mtu_size - 7)) == 0){ + total_num = event.size/(spp_mtu_size - 7); + }else{ + total_num = event.size/(spp_mtu_size - 7) + 1; + } + current_num = 1; + ntf_value_p = (uint8_t *)malloc((spp_mtu_size-3)*sizeof(uint8_t)); + if(ntf_value_p == NULL){ + ESP_LOGE(GATTS_TABLE_TAG, "%s malloc.2 failed\n", __func__); + free(temp); + break; + } + while(current_num <= total_num){ + if(current_num < total_num){ + ntf_value_p[0] = '#'; + ntf_value_p[1] = '#'; + ntf_value_p[2] = total_num; + ntf_value_p[3] = current_num; + memcpy(ntf_value_p + 4,temp + (current_num - 1)*(spp_mtu_size-7),(spp_mtu_size-7)); + esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_DATA_NTY_VAL],(spp_mtu_size-3), ntf_value_p, false); + }else if(current_num == total_num){ + ntf_value_p[0] = '#'; + ntf_value_p[1] = '#'; + ntf_value_p[2] = total_num; + ntf_value_p[3] = current_num; + memcpy(ntf_value_p + 4,temp + (current_num - 1)*(spp_mtu_size-7),(event.size - (current_num - 1)*(spp_mtu_size - 7))); + esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_DATA_NTY_VAL],(event.size - (current_num - 1)*(spp_mtu_size - 7) + 4), ntf_value_p, false); + } + vTaskDelay(20 / portTICK_PERIOD_MS); + current_num++; + } + free(ntf_value_p); + } + free(temp); + } + break; + default: + break; + } + } + } + vTaskDelete(NULL); +} + +static void spp_uart_init(void) +{ + uart_config_t uart_config = { + .baud_rate = 115200, + .data_bits = UART_DATA_8_BITS, + .parity = UART_PARITY_DISABLE, + .stop_bits = UART_STOP_BITS_1, + .flow_ctrl = UART_HW_FLOWCTRL_RTS, + .rx_flow_ctrl_thresh = 122, + }; + + //Set UART parameters + uart_param_config(UART_NUM_0, &uart_config); + //Set UART pins + uart_set_pin(UART_NUM_0, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); + //Install UART driver, and get the queue. + uart_driver_install(UART_NUM_0, 4096, 8192, 10,&spp_uart_queue,0); + xTaskCreate(uart_task, "uTask", 2048, (void*)UART_NUM_0, 8, NULL); +} + +#ifdef SUPPORT_HEARTBEAT +void spp_heartbeat_task(void * arg) +{ + uint16_t cmd_id; + + for(;;) { + vTaskDelay(50 / portTICK_PERIOD_MS); + if(xQueueReceive(cmd_heartbeat_queue, &cmd_id, portMAX_DELAY)) { + while(1){ + heartbeat_count_num++; + vTaskDelay(5000/ portTICK_PERIOD_MS); + if((heartbeat_count_num >3)&&(is_connected)){ + esp_ble_gap_disconnect(spp_remote_bda); + } + if(is_connected && enable_heart_ntf){ + esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_HEARTBEAT_VAL],sizeof(heartbeat_s), heartbeat_s, false); + }else if(!is_connected){ + break; + } + } + } + } + vTaskDelete(NULL); +} +#endif + +void spp_cmd_task(void * arg) +{ + uint8_t * cmd_id; + + for(;;){ + vTaskDelay(50 / portTICK_PERIOD_MS); + if(xQueueReceive(cmd_cmd_queue, &cmd_id, portMAX_DELAY)) { + esp_log_buffer_char(GATTS_TABLE_TAG,(char *)(cmd_id),strlen((char *)cmd_id)); + free(cmd_id); + } + } + vTaskDelete(NULL); +} + +static void spp_task_init(void) +{ + spp_uart_init(); + +#ifdef SUPPORT_HEARTBEAT + cmd_heartbeat_queue = xQueueCreate(10, sizeof(uint32_t)); + xTaskCreate(spp_heartbeat_task, "spp_heartbeat_task", 2048, NULL, 10, NULL); +#endif + + cmd_cmd_queue = xQueueCreate(10, sizeof(uint32_t)); + xTaskCreate(spp_cmd_task, "spp_cmd_task", 2048, NULL, 10, NULL); +} + +static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) +{ + ESP_LOGE(GATTS_TABLE_TAG, "GAP_EVT, event %d\n", event); + + switch (event) { + case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT: + esp_ble_gap_start_advertising(&spp_adv_params); + break; + case ESP_GAP_BLE_ADV_START_COMPLETE_EVT: + //advertising start complete event to indicate advertising start successfully or failed + if(param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) { + ESP_LOGE(GATTS_TABLE_TAG, "Advertising start failed\n"); + } + break; + default: + break; + } +} + +static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) +{ + esp_ble_gatts_cb_param_t *p_data = (esp_ble_gatts_cb_param_t *) param; + uint8_t res = 0xff; + + ESP_LOGE(GATTS_TABLE_TAG, "event = %x\n",event); + switch (event) { + case ESP_GATTS_REG_EVT: + ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__); + esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME); + + ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__); + esp_ble_gap_config_adv_data_raw((uint8_t *)spp_adv_data, sizeof(spp_adv_data)); + + ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__); + esp_ble_gatts_create_attr_tab(spp_gatt_db, gatts_if, SPP_IDX_NB, SPP_SVC_INST_ID); + break; + case ESP_GATTS_READ_EVT: + res = find_char_and_desr_index(p_data->read.handle); + if(res == SPP_IDX_SPP_STATUS_VAL){ + //TODO:client read the status characteristic + } + break; + case ESP_GATTS_WRITE_EVT: { + res = find_char_and_desr_index(p_data->write.handle); + if(p_data->write.is_prep == false){ + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_WRITE_EVT : handle = %d\n", res); + if(res == SPP_IDX_SPP_COMMAND_VAL){ + uint8_t * spp_cmd_buff = NULL; + spp_cmd_buff = (uint8_t *)malloc((spp_mtu_size - 3) * sizeof(uint8_t)); + if(spp_cmd_buff == NULL){ + ESP_LOGE(GATTS_TABLE_TAG, "%s malloc failed\n", __func__); + break; + } + memset(spp_cmd_buff,0x0,(spp_mtu_size - 3)); + memcpy(spp_cmd_buff,p_data->write.value,p_data->write.len); + xQueueSend(cmd_cmd_queue,&spp_cmd_buff,10/portTICK_PERIOD_MS); + }else if(res == SPP_IDX_SPP_DATA_NTF_CFG){ + if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00)){ + enable_data_ntf = true; + }else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00)){ + enable_data_ntf = false; + } + } +#ifdef SUPPORT_HEARTBEAT + else if(res == SPP_IDX_SPP_HEARTBEAT_CFG){ + if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00)){ + enable_heart_ntf = true; + }else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00)){ + enable_heart_ntf = false; + } + }else if(res == SPP_IDX_SPP_HEARTBEAT_VAL){ + if((p_data->write.len == sizeof(heartbeat_s))&&(memcmp(heartbeat_s,p_data->write.value,sizeof(heartbeat_s)) == 0)){ + heartbeat_count_num = 0; + } + } +#endif + else if(res == SPP_IDX_SPP_DATA_RECV_VAL){ +#ifdef SPP_DEBUG_MODE + esp_log_buffer_char(GATTS_TABLE_TAG,(char *)(p_data->write.value),p_data->write.len); +#else + uart_write_bytes(UART_NUM_0, (char *)(p_data->write.value), p_data->write.len); +#endif + }else{ + //TODO: + } + }else if((p_data->write.is_prep == true)&&(res == SPP_IDX_SPP_DATA_RECV_VAL)){ + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_PREP_WRITE_EVT : handle = %d\n", res); + store_wr_buffer(p_data); + } + break; + } + case ESP_GATTS_EXEC_WRITE_EVT:{ + ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_EXEC_WRITE_EVT\n"); + if(p_data->exec_write.exec_write_flag){ + print_write_buffer(); + free_write_buffer(); + } + break; + } + case ESP_GATTS_MTU_EVT: + spp_mtu_size = p_data->mtu.mtu; + break; + case ESP_GATTS_CONF_EVT: + break; + case ESP_GATTS_UNREG_EVT: + break; + case ESP_GATTS_DELETE_EVT: + break; + case ESP_GATTS_START_EVT: + break; + case ESP_GATTS_STOP_EVT: + break; + case ESP_GATTS_CONNECT_EVT: + spp_conn_id = p_data->connect.conn_id; + spp_gatts_if = gatts_if; + is_connected = true; + memcpy(&spp_remote_bda,&p_data->connect.remote_bda,sizeof(esp_bd_addr_t)); +#ifdef SUPPORT_HEARTBEAT + uint16_t cmd = 0; + xQueueSend(cmd_heartbeat_queue,&cmd,10/portTICK_PERIOD_MS); +#endif + break; + case ESP_GATTS_DISCONNECT_EVT: + is_connected = false; + enable_data_ntf = false; +#ifdef SUPPORT_HEARTBEAT + enable_heart_ntf = false; + heartbeat_count_num = 0; +#endif + esp_ble_gap_start_advertising(&spp_adv_params); + break; + case ESP_GATTS_OPEN_EVT: + break; + case ESP_GATTS_CANCEL_OPEN_EVT: + break; + case ESP_GATTS_CLOSE_EVT: + break; + case ESP_GATTS_LISTEN_EVT: + break; + case ESP_GATTS_CONGEST_EVT: + break; + case ESP_GATTS_CREAT_ATTR_TAB_EVT:{ + ESP_LOGI(GATTS_TABLE_TAG, "The number handle =%x\n",param->add_attr_tab.num_handle); + if (param->add_attr_tab.status != ESP_GATT_OK){ + ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table failed, error code=0x%x", param->add_attr_tab.status); + } + else if (param->add_attr_tab.num_handle != SPP_IDX_NB){ + ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table abnormally, num_handle (%d) doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, SPP_IDX_NB); + } + else { + memcpy(spp_handle_table, param->add_attr_tab.handles, sizeof(spp_handle_table)); + esp_ble_gatts_start_service(spp_handle_table[SPP_IDX_SVC]); + } + break; + } + default: + break; + } +} + + +static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) +{ + ESP_LOGI(GATTS_TABLE_TAG, "EVT %d, gatts if %d\n", event, gatts_if); + + /* If event is register event, store the gatts_if for each profile */ + if (event == ESP_GATTS_REG_EVT) { + if (param->reg.status == ESP_GATT_OK) { + spp_profile_tab[SPP_PROFILE_APP_IDX].gatts_if = gatts_if; + } else { + ESP_LOGI(GATTS_TABLE_TAG, "Reg app failed, app_id %04x, status %d\n",param->reg.app_id, param->reg.status); + return; + } + } + + do { + int idx; + for (idx = 0; idx < SPP_PROFILE_NUM; idx++) { + if (gatts_if == ESP_GATT_IF_NONE || /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */ + gatts_if == spp_profile_tab[idx].gatts_if) { + if (spp_profile_tab[idx].gatts_cb) { + spp_profile_tab[idx].gatts_cb(event, gatts_if, param); + } + } + } + } while (0); +} + +void app_main() +{ + esp_err_t ret; + esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT(); + + nvs_flash_init(); + ret = esp_bt_controller_init(&bt_cfg); + if (ret) { + ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed\n", __func__); + return; + } + + ret = esp_bt_controller_enable(ESP_BT_MODE_BTDM); + if (ret) { + ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed\n", __func__); + return; + } + + ESP_LOGI(GATTS_TABLE_TAG, "%s init bluetooth\n", __func__); + ret = esp_bluedroid_init(); + if (ret) { + ESP_LOGE(GATTS_TABLE_TAG, "%s init bluetooth failed\n", __func__); + return; + } + ret = esp_bluedroid_enable(); + if (ret) { + ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed\n", __func__); + return; + } + + esp_ble_gatts_register_callback(gatts_event_handler); + esp_ble_gap_register_callback(gap_event_handler); + esp_ble_gatts_app_register(ESP_SPP_APP_ID); + + spp_task_init(); + + return; +} diff --git a/examples/bluetooth/ble_spp_server/main/ble_spp_server_demo.h b/examples/bluetooth/ble_spp_server/main/ble_spp_server_demo.h new file mode 100644 index 000000000..6cd300610 --- /dev/null +++ b/examples/bluetooth/ble_spp_server/main/ble_spp_server_demo.h @@ -0,0 +1,57 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + + +#include +#include +#include + +/* + * DEFINES + **************************************************************************************** + */ +//#define SUPPORT_HEARTBEAT +//#define SPP_DEBUG_MODE + +#define spp_sprintf(s,...) sprintf((char*)(s), ##__VA_ARGS__) +#define SPP_DATA_MAX_LEN (512) +#define SPP_CMD_MAX_LEN (20) +#define SPP_STATUS_MAX_LEN (20) +#define SPP_DATA_BUFF_MAX_LEN (2*1024) +///Attributes State Machine +enum{ + SPP_IDX_SVC, + + SPP_IDX_SPP_DATA_RECV_CHAR, + SPP_IDX_SPP_DATA_RECV_VAL, + + SPP_IDX_SPP_DATA_NOTIFY_CHAR, + SPP_IDX_SPP_DATA_NTY_VAL, + SPP_IDX_SPP_DATA_NTF_CFG, + + SPP_IDX_SPP_COMMAND_CHAR, + SPP_IDX_SPP_COMMAND_VAL, + + SPP_IDX_SPP_STATUS_CHAR, + SPP_IDX_SPP_STATUS_VAL, + SPP_IDX_SPP_STATUS_CFG, + +#ifdef SUPPORT_HEARTBEAT + SPP_IDX_SPP_HEARTBEAT_CHAR, + SPP_IDX_SPP_HEARTBEAT_VAL, + SPP_IDX_SPP_HEARTBEAT_CFG, +#endif + + SPP_IDX_NB, +}; diff --git a/examples/bluetooth/ble_spp_server/main/component.mk b/examples/bluetooth/ble_spp_server/main/component.mk new file mode 100644 index 000000000..a98f634ea --- /dev/null +++ b/examples/bluetooth/ble_spp_server/main/component.mk @@ -0,0 +1,4 @@ +# +# "main" pseudo-component makefile. +# +# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) diff --git a/examples/bluetooth/ble_spp_server/sdkconfig.defaults b/examples/bluetooth/ble_spp_server/sdkconfig.defaults new file mode 100644 index 000000000..e435f383c --- /dev/null +++ b/examples/bluetooth/ble_spp_server/sdkconfig.defaults @@ -0,0 +1,14 @@ +# Override some defaults so BT stack is enabled +# in this example + +# +# BT config +# +CONFIG_BT_ENABLED=y + +# +# ESP32-specific config +# +CONFIG_ESP32_ENABLE_STACK_BT=y +# CONFIG_ESP32_ENABLE_STACK_NONE is not set +CONFIG_MEMMAP_BT=y