ESP-C3入门18. 低功耗蓝牙SPP Server端功能测试
一、功能简介
1. GATT
GATT是一种基于属性的协议，它定义了一组属性，这些属性可以用于描述设备的服务和特征。
2. SPP
SPP是一种基于蓝牙的串口传输协议，它可以将串口数据通过蓝牙传输到其他设备，它通常是在经典蓝牙中的 L2CAP（逻辑链路控制和适配协议）层上实现的。
在低功耗蓝牙中，可以使用具有模拟串行端口特性的自定义 GATT 服务来实现类似的功能。在ESP32-C3中，SPP功能通过GATT协议实现，它包括四个特征：
- 数据接收
- 数据通知
- 命令接收
- 命令通知
其中，数据接收和命令接收特征支持读写操作，数据通知和命令通知特征支持读和通知操作。
通过这些特征，可以实现串口数据的传输和控制。
另外，实现中可以选择是否实现心跳特征。
3. SPP Server和 SPP Client
SPP server是提供串口数据的设备，SPP client是接收串口数据的设备。
SPP client可以通过扫描周围的蓝牙设备，找到SPP server并连接到它，然后接收串口数据。在连接建立后，SPP server和SPP client之间可以进行数据传输和控制。
本文介绍实现SPP Server的过程 。
二、 SPP Server开发步骤
本文使用ESP32 IDF官方的 ble_spp_server_demo 示例。
在低功耗蓝牙上实现SPP Server，整体可分为两步：
- 启动 GATT Server；
- 启动 SPP Server服务。
其它是围绕这两步的必要的事件注册等程序。
1. 启动 GATT Server
与前一篇文章类似 ：
esp_err_t ret;
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
// Initialize NVS
ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// 如果没有足够的空闲页或发现新版本，则擦除NVS闪存
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK( ret );
// 释放经典蓝牙模式下的控制器内存
ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
// 初始化蓝牙控制器
ret = esp_bt_controller_init(&bt_cfg);
if (ret) {
ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
return;
}
// 启用蓝牙控制器
ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
if (ret) {
ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
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: %s\n", __func__, esp_err_to_name(ret));
return;
}
ret = esp_bluedroid_enable();
if (ret) {
// 启用蓝牙失败
ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
return;
}
// 注册GATT事件处理程序
esp_ble_gatts_register_callback(gatts_event_handler);
// 注册GAP事件处理程序
esp_ble_gap_register_callback(gap_event_handler);
2. SPP 任务初始化
在SPP任务初始中，要uart也初始化、创建命令任务队列、心跳命令队列。
// SPP任务初始化
static void spp_task_init(void)
{
// UART初始化
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);
}
3. 注册 SPP应用程序
// 注册SPP应用程序
esp_ble_gatts_app_register(ESP_SPP_APP_ID);
// SPP任务初始化
spp_task_init();
4. UART 初始化
uart也需要创建任务队列。
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, // 接收缓冲区阈值
.source_clk = UART_SCLK_DEFAULT, // 时钟源
};
// 安装UART驱动程序并获取队列
uart_driver_install(UART_NUM_0, 4096, 8192, 10,&spp_uart_queue,0);
// 设置UART参数
uart_param_config(UART_NUM_0, &uart_config);
// 设置UART引脚
uart_set_pin(UART_NUM_0, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
xTaskCreate(uart_task, "uTask", 2048, (void*)UART_NUM_0, 8, NULL);
}
5. UART 事件处理程序
// UART任务
void uart_task(void *pvParameters)
{
uart_event_t event;
uint8_t total_num = 0;
uint8_t current_num = 0;
for (;;) {
// 等待UART事件
if (xQueueReceive(spp_uart_queue, (void * )&event, (TickType_t)portMAX_DELAY)) {
switch (event.type) {
// UART接收数据事件
case UART_DATA:
break;
default:
break;
}
}
}
vTaskDelete(NULL);
}
二、完整程序
1. 代码和注释
/*
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#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 "esp_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" //The Device Name Characteristics in GAP
#define SPP_SVC_INST_ID 0
/// SPP Service
static const uint16_t spp_service_uuid = 0xABF0;
// 用于SPP蓝牙通信服务的接收UUID
#define ESP_GATT_UUID_SPP_DATA_RECEIVE 0xABF1
// 用于SPP蓝牙通信服务的通知UUID
#define ESP_GATT_UUID_SPP_DATA_NOTIFY 0xABF2
// 用于SPP蓝牙通信服务，接收命令
#define ESP_GATT_UUID_SPP_COMMAND_RECEIVE 0xABF3
// 用于SPP蓝牙通信服务，通知命令
#define ESP_GATT_UUID_SPP_COMMAND_NOTIFY 0xABF4
#ifdef SUPPORT_HEARTBEAT
// 用于识别通过SPP蓝牙通信服务发送的心跳包
#define ESP_GATT_UUID_SPP_HEARTBEAT 0xABF5
#endif
static const uint8_t spp_adv_data[23] = {
/* Flags */
0x02,0x01,0x06,
/* Complete List of 16-bit Service Class UUIDs */
0x03,0x03,0xF0,0xAB,
/* Complete Local Name in advertising */
0x0F,0x09, 'E', 'S', 'P', '_', 'S', 'P', 'P', '_', 'S', 'E', 'R','V', 'E', 'R'
};
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 QueueHandle_t cmd_cmd_queue = NULL;
#ifdef SUPPORT_HEARTBEAT
static QueueHandle_t 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,};
// 定义SPP服务的句柄表
static uint16_t spp_handle_table[SPP_IDX_NB];
// 定义SPP广播参数
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, // 广播过滤策略
};
// 定义GATT服务的实例结构体
struct gatts_profile_inst {
esp_gatts_cb_t gatts_cb; // GATT事件回调函数
uint16_t gatts_if; // GATT接口
uint16_t app_id; // 应用ID
uint16_t conn_id; // 连接ID
uint16_t service_handle; // 服务句柄
esp_gatt_srvc_id_t service_id; // 服务ID
uint16_t char_handle; // 特征句柄
esp_bt_uuid_t char_uuid; // 特征UUID
esp_gatt_perm_t perm; // 特征权限
esp_gatt_char_prop_t property; // 特征属性
uint16_t descr_handle; // 描述符句柄
esp_bt_uuid_t descr_uuid; // 描述符UUID
};
// 定义SPP接收数据节点结构体
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;
// 用于存储通过SPP蓝牙通信服务接收到的数据节点
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;
// 定义SPP接收数据缓存结构体
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;
// 定义SPP接收数据缓存
static spp_receive_data_buff_t SppRecvDataBuff = {
.node_num = 0, // 节点数量
.buff_size = 0, // 缓存大小
.first_node = NULL // 第一个节点
};
// 定义SPP服务的句柄
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))
// 定义主服务UUID
static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE;
// 定义特征声明UUID
static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE;
// 定义客户端配置UUID
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;
// SPP服务 - 心跳特征属性
#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服务 - 数据接收特征，读写无响应
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服务 - 数据通知特征，通知和读
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服务 - 命令特征，读写无响应
static const uint16_t spp_command_uuid = ESP_GATT_UUID_SPP_COMMAND_RECEIVE;
static const uint8_t spp_command_val[10] = {
0x00};
///SPP服务 - 状态特征，通知和读
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服务 - 心跳特征，通知和读和写
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
// 定义SPP服务的属性数据库
static const esp_gatts_attr_db_t spp_gatt_db[SPP_IDX_NB] =
{
// SPP服务声明
[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数据接收特征声明
[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数据接收特征值
[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数据通知特征声明
[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数据通知特征值
[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数据通知特征 - 客户端特征配置描述符
[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命令特征声明
[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命令特征值
[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 - 状态特征声明
[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 - 状态特征值
[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 - 状态特征 - 客户端特征配置描述符
[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 - 心跳特征声明
[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 - 心跳特征值
[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 - 心跳特征 - 客户端特征配置描述符
[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;
}
/**
* @brief 存储写缓冲区数据
*
* @param p_data 指向 esp_ble_gatts_cb_param_t 数据结构的指针
* @return true 存储成功
* @return false 存储失败
*/
static bool store_wr_buffer(esp_ble_gatts_cb_param_t *p_data)
{
// 分配存储通过SPP蓝牙服务接收到的数据节点的空间
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;\n memcpy(temp_spp_recv_data_node_p1->node_buff, p_data->write.value, p_data->write.len);
// 如果数据节点数量为0，则将第一个节点指向当前节点并更新节点数量
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_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;
}
/*
*将写缓冲区中的数据节点依次打印输出到UART0串口
*参数：无
*返回值：无
*/
static void print_write_buffer(void)
{
// 将temp_spp_recv_data_node_p1指针赋值为第一个数据节点
temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node;
while(temp_spp_recv_data_node_p1 != NULL){
// 循环遍历写缓冲区中的所有数据节点
// 将当前数据节点的缓冲区中的数据通过UART0串口打印输出
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;
}
}
// UART任务
void uart_task(void *pvParameters)
{
uart_event_t event;
uint8_t total_num = 0;
uint8_t current_num = 0;
for (;;) {
// 等待UART事件
if (xQueueReceive(spp_uart_queue, (void * )&event, (TickType_t)portMAX_DELAY)) {
switch (event.type) {
// UART接收数据事件
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);
}
// UART初始化
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, // 接收缓冲区阈值
.source_clk = UART_SCLK_DEFAULT, // 时钟源
};
// 安装UART驱动程序并获取队列
uart_driver_install(UART_NUM_0, 4096, 8192, 10,&spp_uart_queue,0);
// 设置UART参数
uart_param_config(UART_NUM_0, &uart_config);
// 设置UART引脚
uart_set_pin(UART_NUM_0, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
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);
}
// SPP任务初始化
static void spp_task_init(void)
{
// UART初始化
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);
}
// GAP事件处理程序
static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
esp_err_t err;
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:
// 广告启动完成事件，用于指示广告启动成功或失败
if((err = param->adv_start_cmpl.status) != ESP_BT_STATUS_SUCCESS) {
ESP_LOGE(GATTS_TABLE_TAG, "Advertising start failed: %s\n", esp_err_to_name(err));
}
break;
default:
break;
}
}
// GATT事件处理程序
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_LOGI(GATTS_TABLE_TAG, "event = %x\n",event);
switch (event) {
case ESP_GATTS_REG_EVT:
// 注册事件
ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
// 设置蓝牙设备名称为SAMPLE_DEVICE_NAME
esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME);
ESP_LOGI(GATTS_TABLE_TAG, "%s %d\n", __func__, __LINE__);
// 配置蓝牙广播数据为spp_adv_datav
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__);
// 创建一个包含属性的GATT数据库，
// 其中参数spp_gatt_db为属性列表，
// gatts_if为GATT接口，SPP_IDX_NB为属性数量，SPP_SVC_INST_ID为服务实例ID
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);
// 如果索引为 SPP_IDX_SPP_COMMAND_VAL，则表示客户端正在写入命令特征值
if(res == SPP_IDX_SPP_COMMAND_VAL){
// 申请一段连续的内存空间作为 spp_cmd_buff
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;
}
// 清空 spp_cmd_buff
memset(spp_cmd_buff,0x0,(spp_mtu_size - 3));
// 将写入的数据复制到 spp_cmd_buff 中
memcpy(spp_cmd_buff,p_data->write.value,p_data->write.len);
// 将 spp_cmd_buff 发送到命令队列 cmd_cmd_queue
xQueueSend(cmd_cmd_queue,&spp_cmd_buff,10/portTICK_PERIOD_MS);
}else if(res == SPP_IDX_SPP_DATA_NTF_CFG){
// 如果写入的数据长度为 2，并且第一个字节为 0x01，第二个字节为 0x00，则启用数据通知
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)){
// 如果写入的数据长度为 2，并且第一个字节为 0x00，第二个字节为 0x00，则禁用数据通知
enable_data_ntf = false;
}
}
#ifdef SUPPORT_HEARTBEAT
// 如果索引为 SPP_IDX_SPP_HEARTBEAT_CFG，则表示客户端正在设置心跳特征值
else if(res == SPP_IDX_SPP_HEARTBEAT_CFG){
// 如果写入的数据长度为 2，并且第一个字节为 0x01，第二个字节为 0x00，则启用心跳通知
if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x01)&&(p_data->write.value[1] == 0x00)){
enable_heart_ntf = true;
// 如果写入的数据长度为 2，并且第一个字节为 0x00，第二个字节为 0x00，则禁用心跳通知
}else if((p_data->write.len == 2)&&(p_data->write.value[0] == 0x00)&&(p_data->write.value[1] == 0x00)){
enable_heart_ntf = false;
}
// 如果索引为 SPP_IDX_SPP_HEARTBEAT_VAL，则表示客户端正在写入心跳特征值
}else if(res == SPP_IDX_SPP_HEARTBEAT_VAL){
// 如果写入的数据长度等于 heartbeat_s 的长度，并且两者相等，则将 heartbeat_count_num 重置为 0
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;
}
}
// GATT事件处理程序
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);
/* 如果事件是注册事件，则为每个配置文件存储gatts_if */
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(void)
{
esp_err_t ret;
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
// Initialize NVS
ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// 如果没有足够的空闲页或发现新版本，则擦除NVS闪存
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK( ret );
// 释放经典蓝牙模式下的控制器内存
ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
// 初始化蓝牙控制器
ret = esp_bt_controller_init(&bt_cfg);
if (ret) {
ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
return;
}
// 启用蓝牙控制器
ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
if (ret) {
ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
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: %s\n", __func__, esp_err_to_name(ret));
return;
}
ret = esp_bluedroid_enable();
if (ret) {
// 启用蓝牙失败
ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
return;
}
// 注册GATT事件处理程序
esp_ble_gatts_register_callback(gatts_event_handler);
// 注册GAP事件处理程序
esp_ble_gap_register_callback(gap_event_handler);
// 注册SPP应用程序
esp_ble_gatts_app_register(ESP_SPP_APP_ID);
// SPP任务初始化
spp_task_init();
return;
}
2. 运行方法
烧录固件后，ESP32-C3将启动一个名为 ESP_SPP_SERVER 的广播。
使用手机端蓝牙测试APP，连接此蓝牙设备即可与ESP32-C3进行通讯。
在ESP32-C3的串口接到电脑串口工具，在手机端的蓝牙测试APP和电脑串口工具间进行收发数据测试。
固件启动：
客户端连接：
接收客户端数据
调试助手查看广播包：
调试助手发送数据：
