【ESP32】ESP-IDF开发 | 经典蓝牙开发 | 蓝牙串口协议（SPP） + 客户端和服务端例程

发布于：2025-03-16 ⋅ 阅读:(21) ⋅ 点赞:(0)

1. 简介

        相信我们最早接触蓝牙，就是在某宝上买一个小巧的蓝牙模块，接到单片机上，通过AT指令进行简单配置，就可以用手机连接该模块，然后远程发送信息给单片机。这里面用到的就是SPP协议（Serial Port Protocol），全称蓝牙串口协议。

1.1 SPP协议

        SPP协议是一个经典蓝牙才有的协议，用于完成蓝牙设备之间创建串口进行数据传输，它的协议和过程充分借鉴了RS232总线的通信。它的简要通信流程如下：

1. 创建虚拟连接。

  • 使用SDP协议提交一个请求来查找RFCOMM服务信道号码；
  • 请求对远端设备进行认证；
  • 向远端的RFCOMM通道发起一个新的L2CAP请求；
  • 在L2CAP通道上初始化一个RFCOMM连接；
  • 在RFCOMM连接上创建一个新的数据连接。

2. 接受虚拟串口连接。

  • 接受发起设备端的认证请求并做处理；
  • 在L2CAP层接收一个新的连接；
  • 接受RFCOMM连接请求在RFCOMM通道上；
  • 在RFCOMM通道上接收数据连接请求。

3. 在本地SDP数据上注册服务。

2. 例程

        例程部分有2个，一个是ESP32做发送端，连接服务端并定时发送消息；另一个是ESP32做服务端，手机或电脑做客户端向ESP32发消息。

        我这里使用手机进行测试，在应用商店搜“蓝牙调试助手”就会有很多的调试上位机，选一个下载即可，一定要选支持SPP协议的上位机。

代码部分包含Bluedroid和GAP协议的部分在上一篇文章中有详细的介绍，所以下面不再赘述；同样menuconfig配置也只说明与之前不同的地方。

2.1 menuconfig

        menuconfig中需要打开SPP、L2CAP和SDP协议的支持。 

2.2 客户端例程

2.2.1 代码 

#include <stdint.h>
#include <string.h>
#include <inttypes.h>
#include <stdbool.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "nvs.h"
#include "nvs_flash.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "esp_gap_bt_api.h"
#include "esp_spp_api.h"

#define TAG "app"

#define OWN_NAME "ESP32"
#define SERVER_NAME "Jackie的P40 Pro"
#define SPP_DATA "Hello from ESP32"

#define SPP_DATA_SEND_BIT (1 << 0)

#define BDASTR "%02X:%02X:%02X:%02X:%02X:%02X"
#define BDA2STR(x) (x)[0], (x)[1], (x)[2], (x)[3], (x)[4], (x)[5]
#define MIN(x, y) ((x) < (y) ? (x) : (y))

typedef struct {
    esp_bd_addr_t bda;
    char name[ESP_BT_GAP_MAX_BDNAME_LEN];
    uint32_t handle;
} bt_dev_t;

static bt_dev_t server = {0};
static EventGroupHandle_t event_group = NULL;


static bool check_device(esp_bt_gap_cb_param_t *param)
{
    esp_bt_gap_dev_prop_t *p = param->disc_res.prop;
    for (int i = 0; i < param->disc_res.num_prop; i++) {
        if (p[i].type == ESP_BT_GAP_DEV_PROP_BDNAME && p[i].val && p[i].len > 0) {
            ESP_LOGI(TAG, "name: %s", (char*) p[i].val);

            if (memcmp(p[i].val, SERVER_NAME, MIN(p[i].len, strlen(SERVER_NAME)))) {
                uint8_t len = p[i].len > ESP_BT_GAP_MAX_BDNAME_LEN - 1 ? ESP_BT_GAP_MAX_BDNAME_LEN - 1 : p[i].len;
                memcpy(server.name, p[i].val, len);
                memcpy(server.bda, param->disc_res.bda, sizeof(esp_bd_addr_t));
                return true;
            }
        }
        /* 从EIR字段中提取服务端名 */
        else if (strlen(server.name) == 0 && p[i].type == ESP_BT_GAP_DEV_PROP_EIR && p[i].val && p[i].len > 0) {
            uint8_t* eir = (uint8_t *)(p[i].val);
            uint8_t len = 0;
            uint8_t* bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &len);
            if (!bdname) {
                bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &len);
            }
            if (bdname) {
                ESP_LOGI(TAG, "name: %s", bdname);

                if (memcmp(p[i].val, SERVER_NAME, MIN(p[i].len, strlen(SERVER_NAME)))) {
                    len = len > ESP_BT_GAP_MAX_BDNAME_LEN - 1 ? ESP_BT_GAP_MAX_BDNAME_LEN - 1 : len;
                    memcpy(server.name, bdname, len);
                    memcpy(server.bda, param->disc_res.bda, sizeof(esp_bd_addr_t));
                    return true;
                }
            }
        }
    }

    return false;
}

static void esp_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
{
    switch (event) {
        /* 设备搜索结果 */
        case ESP_BT_GAP_DISC_RES_EVT:
        {
            if (check_device(param)) {
                esp_bt_gap_cancel_discovery();
                esp_spp_start_discovery(server.bda);
            }
            break;
        }

        /* 搜索状态改变 */
        case ESP_BT_GAP_DISC_STATE_CHANGED_EVT:
        {
            if (param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STOPPED) {
                // ESP_LOGI(TAG, "Discovery stopped");
                if (strlen(server.name) == 0) {
                    esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 4, 30);    
                }
            } else if (param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STARTED) {
                ESP_LOGI(TAG, "Discoverying devices...");
            }
            break;
        }

        /* 验证完成 */
        case ESP_BT_GAP_AUTH_CMPL_EVT:
        {
            if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
                ESP_LOGI(TAG, "authentication success: %s", param->auth_cmpl.device_name);
                ESP_LOG_BUFFER_HEX(TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN);
            } else {
                ESP_LOGE(TAG, "authentication failed, status:%d", param->auth_cmpl.stat);
            }
            break;
        }

    
        default:
            break;
    }
}

static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
{
    switch (event) {
        /* 初始化完成 */
        case ESP_SPP_INIT_EVT:
            if (param->init.status == ESP_SPP_SUCCESS) {
                esp_bt_gap_set_device_name(OWN_NAME);
                esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
                esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 4, 30);
            } else {
                ESP_LOGE(TAG, "spp init failed, status: %d", param->init.status);
            }
            break;

        /* 服务发现完成 */
        case ESP_SPP_DISCOVERY_COMP_EVT:
            if (param->disc_comp.status == ESP_SPP_SUCCESS) {
                ESP_LOGI(TAG, "spp discovered %d services:", param->disc_comp.scn_num);
                for (uint8_t i = 0; i < param->disc_comp.scn_num; i++) {
                    ESP_LOGI(TAG, "%d. SCN: %d, name: %s", i, param->disc_comp.scn[i], param->disc_comp.service_name[i]);
                }
                /* 连接第一个服务 */
                esp_spp_connect(ESP_SPP_SEC_NONE, ESP_SPP_ROLE_MASTER, param->disc_comp.scn[0], server.bda);
            } else {
                ESP_LOGE(TAG, "spp discovery failed, status: %d", param->disc_comp.status);
            }
            break;

        /* 连接开启 */
        case ESP_SPP_OPEN_EVT:
            if (param->open.status == ESP_SPP_SUCCESS) {
                server.handle = param->open.handle;
                ESP_LOGI(TAG, "spp connection opened, handle: %" PRIu32 " rem_bda: " BDASTR, param->open.handle, BDA2STR(param->open.rem_bda));

                /* 通知写数据 */
                xEventGroupSetBits(event_group, SPP_DATA_SEND_BIT);
            } else {
                ESP_LOGE(TAG, "spp connection opened failed, status:%d", param->open.status);
            }
            break;
        
        /* 连接关闭 */
        case ESP_SPP_CLOSE_EVT:
            ESP_LOGI(TAG, "spp connection closed, status:%d handle: %" PRIu32 " close_by_remote: %d", param->close.status, param->close.handle, param->close.async);
            break;

        /* 从机连接初始化 */
        case ESP_SPP_CL_INIT_EVT:
            if (param->cl_init.status == ESP_SPP_SUCCESS) {
                ESP_LOGI(TAG, "spp connected, handle: %" PRIu32 " sec_id: %d", param->cl_init.handle, param->cl_init.sec_id);
            } else {
                ESP_LOGE(TAG, "spp connection failed, status:%d", param->cl_init.status);
            }
            break;
        
        /* 写数据 */
        case ESP_SPP_WRITE_EVT:
            if (param->write.status == ESP_SPP_SUCCESS) {
                ESP_LOGI(TAG, "spp write %d bytes of data, cong: %d", param->write.len, param->write.cong);
            } else {
                ESP_LOGE(TAG, "spp write data failed, status: %d", param->write.status);
            }

            /* 检查管道阻塞 */
            if (!param->write.cong) {
                xEventGroupSetBits(event_group, SPP_DATA_SEND_BIT);
            }
            break;

        /* 阻塞状态改变 */
        case ESP_SPP_CONG_EVT:
            if (!param->cong.cong) {
                xEventGroupSetBits(event_group, SPP_DATA_SEND_BIT);
            }
            break;

        default:
            break;
    }
}

int app_main()
{
    /* 初始化NVS */
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ESP_ERROR_CHECK(nvs_flash_init());
    }

    /* 释放低功耗蓝牙资源 */
    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));

    /* 初始化蓝牙控制器 */
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    if ((ret = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
        ESP_LOGE(TAG, "initialize controller failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 使能蓝牙控制器 */
    if ((ret = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT)) != ESP_OK) {
        ESP_LOGE(TAG, "enable controller failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 初始化bluedroid */
    esp_bluedroid_config_t bluedroid_cfg = BT_BLUEDROID_INIT_CONFIG_DEFAULT();
    if ((ret = esp_bluedroid_init_with_cfg(&bluedroid_cfg)) != ESP_OK) {
        ESP_LOGE(TAG, "initialize bluedroid failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 使能bluedroid */
    if ((ret = esp_bluedroid_enable()) != ESP_OK) {
        ESP_LOGE(TAG, "enable bluedroid failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 注册GAP协议回调 */
    if ((ret = esp_bt_gap_register_callback(esp_gap_cb)) != ESP_OK) {
        ESP_LOGE(TAG, "gap register failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 注册SPP协议回调 */
    if ((ret = esp_spp_register_callback(esp_spp_cb)) != ESP_OK) {
        ESP_LOGE(TAG, "spp register failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 初始化SPP */
    const esp_spp_cfg_t spp_cfg = {
        .mode = ESP_SPP_MODE_CB,
        .enable_l2cap_ertm = true,
        .tx_buffer_size = 0,
    };
    if ((ret = esp_spp_enhanced_init(&spp_cfg)) != ESP_OK) {
        ESP_LOGE(TAG, "spp init failed: %s", esp_err_to_name(ret));
        return -1;
    }


    event_group = xEventGroupCreate();
    /* 定时发送消息 */
    while (1) {
        xEventGroupWaitBits(event_group, SPP_DATA_SEND_BIT, pdTRUE, pdTRUE, portMAX_DELAY);
        if (esp_spp_write(server.handle, strlen(SPP_DATA), (uint8_t*) SPP_DATA) != ESP_OK) {
            ESP_LOGE(TAG, "spp send data failed: %s", esp_err_to_name(ret));
        }
        vTaskDelay(2000 / portTICK_PERIOD_MS);
    }

    return 0;
}

1. 初始化NVS。

2. 初始化蓝牙控制器。

3. 初始化Bluedroid。

4. 注册GAP协议回调。

        回调函数中，设备发现结果事件中依次查询设备的名字，主要关注BDNAME和EIR两个属性，从这两个属性中提取名字，如果名字匹配就会关闭GAP设备发现并使能SPP服务发现。

        设备发现状态改变事件，发现结束后如果仍然找不到服务端，那么会重新开始设备发现。

        验证完成事件，连接SPP服务端时会进行验证，验证完成后会发送该事件。

5. 注册SPP协议回调。

        初始化完成事件，这时就可以使能GAP的设备发现。

        服务发现完成事件，一个蓝牙设备其实是可以同时开启多个SPP服务的，在这里我们连接第一个服务，调用esp_spp_connect函数；第一个参数表示验证方式，取决于上位机的配置，默认就是无安全验证；第二个参数表示对方的角色，主机或从机，这里填主机；第三个参数为对方的SCN码；第四个参数为对方的BDA码。

        连接开启事件，当成功开启串口通信时会触发，此时会返回一个handle，之后的读写操作都是要用到的。

        连接关闭事件，当串口通信被关闭时触发，会返回handle和关闭方。

        从机连接初始化完成事件，当从机成功创建了一个SPP连接时会触发。

        写数据事件，当数据成功发送时触发，会返回发送的字节数和当前管道的状态；通过判断管道状态（有无阻塞），来决定是否要继续发送消息。

        阻塞状态改变事件，通过这个事件可以关注管道的状态，调整消息的发送。

6. 初始化SPP协议。

        调用esp_spp_enhanced_init函数，初始化结构体如下：

typedef struct {
    esp_spp_mode_t mode;
    bool enable_l2cap_ertm;
    uint16_t tx_buffer_size;
} esp_spp_cfg_t;
  • mode：模式，有2个ESP_SPP_MODE_CB和ESP_SPP_MODE_VFS，前者是通过回调函数处理消息，后者是通过虚拟文件系统处理消息。
  • enable_l2cap_ertm：使能L2CAP协议增强重传模式，推荐开启。
  • tx_buffer_size：发送缓冲区大小，仅VFS模式使用。

7. 主函数。

        主函数我们通过EventGroup来控制消息发送，它用来等待管道空闲，之后会调用esp_spp_write函数发送消息，发送后等待2秒就会继续尝试发送。

2.2.2 效果

        先在手机上创建SPP客户端，等待设备连接。然后启动ESP32，如果配置正确那么将会自动连接。

2.3 服务端例程

2.3.1 代码

#include <stdint.h>
#include <string.h>
#include <inttypes.h>
#include <stdbool.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"

#include "nvs.h"
#include "nvs_flash.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "esp_gap_bt_api.h"
#include "esp_spp_api.h"

#define TAG "app"

#define OWN_NAME "ESP32"
#define SPP_DATA "I received your message"

#define BDASTR "%02X:%02X:%02X:%02X:%02X:%02X"
#define BDA2STR(x) (x)[0], (x)[1], (x)[2], (x)[3], (x)[4], (x)[5]

typedef struct {
    esp_bd_addr_t bda;
    uint32_t handle;
} spp_dev_t;

static spp_dev_t client;
static QueueHandle_t send_queue;


static void update_client(const esp_spp_cb_param_t* param)
{
    memcpy(client.bda, param->open.rem_bda, sizeof(esp_bd_addr_t));
    client.handle = param->open.handle;
}

static void delete_client()
{
    memset(&client, 0, sizeof(spp_dev_t));
}

static void esp_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
{
    switch (event) {
        /* 验证完成 */
        case ESP_BT_GAP_AUTH_CMPL_EVT:
        {
            if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
                ESP_LOGI(TAG, "authentication success: %s [" BDASTR "]", param->auth_cmpl.device_name, BDA2STR(param->auth_cmpl.bda));
            } else {
                ESP_LOGE(TAG, "authentication failed, status:%d", param->auth_cmpl.stat);
            }
            break;
        }

        default:
            break;
    }
}

static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
{
    switch (event) {
        /* 初始化完成 */
        case ESP_SPP_INIT_EVT:
            if (param->init.status == ESP_SPP_SUCCESS) {
                esp_spp_start_srv(ESP_SPP_SEC_NONE, ESP_SPP_ROLE_SLAVE, 0, OWN_NAME);
            } else {
                ESP_LOGE(TAG, "spp init failed, status: %d", param->init.status);
            }
            break;

        /* 服务端启动完成 */
        case ESP_SPP_START_EVT:
            if (param->start.status == ESP_SPP_SUCCESS) {
                ESP_LOGI(TAG, "server started, handle:%" PRIu32 " sec_id: %d scn: %d", param->start.handle, param->start.sec_id, param->start.scn);
                esp_bt_gap_set_device_name(OWN_NAME);
                esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
            } else {
                ESP_LOGE(TAG, "server start failed, status: %d", param->start.status);
            }
            break;
    
        /* 连接开启 */
        case ESP_SPP_OPEN_EVT:
            if (param->open.status == ESP_SPP_SUCCESS) {
                /* 保存客户端信息 */
                update_client(param);
                ESP_LOGI(TAG, "spp connection opened, handle: %" PRIu32 " rem_bda: " BDASTR, param->open.handle, BDA2STR(param->open.rem_bda));
            } else {
                ESP_LOGE(TAG, "spp connection opened failed, status:%d", param->open.status);
            }
            break;

        /* 连接关闭 */
        case ESP_SPP_CLOSE_EVT:
            /* 清除客户端 */
            delete_client();
            ESP_LOGI(TAG, "spp connection closed, status:%d handle: %" PRIu32 " close_by_remote: %d", param->close.status, param->close.handle, param->close.async);
            break;

        /* 读数据事件 */
        case ESP_SPP_DATA_IND_EVT:
            ESP_LOGI(TAG, "[" BDASTR "]: %s", BDA2STR(client.bda), param->data_ind.data);
            /* 通知回复 */
            xQueueSend(send_queue, &param->data_ind.handle, portMAX_DELAY);
            break;

        /* 写数据事件 */
        case ESP_SPP_WRITE_EVT:
            if (param->write.status == ESP_SPP_SUCCESS) {
                ESP_LOGI(TAG, "server write %d bytes of data, cong: %d", param->write.len, param->write.cong);
            } else {
                ESP_LOGE(TAG, "server write data failed, status: %d", param->write.status);
            }

        default:
            break;
    }
}

int app_main()
{
    /* 初始化NVS */
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ESP_ERROR_CHECK(nvs_flash_init());
    }

    /* 释放低功耗蓝牙资源 */
    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));

    /* 初始化蓝牙 */
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    if ((ret = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
        ESP_LOGE(TAG, "initialize controller failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 使能蓝牙控制器 */
    if ((ret = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT)) != ESP_OK) {
        ESP_LOGE(TAG, "enable controller failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 初始化blueroid */
    esp_bluedroid_config_t bluedroid_cfg = BT_BLUEDROID_INIT_CONFIG_DEFAULT();
    if ((ret = esp_bluedroid_init_with_cfg(&bluedroid_cfg)) != ESP_OK) {
        ESP_LOGE(TAG, "initialize bluedroid failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 使能blueroid */
    if ((ret = esp_bluedroid_enable()) != ESP_OK) {
        ESP_LOGE(TAG, "enable bluedroid failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 注册GAP协议回调 */
    if ((ret = esp_bt_gap_register_callback(esp_gap_cb)) != ESP_OK) {
        ESP_LOGE(TAG, "gap register failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 注册SPP协议回调 */
    if ((ret = esp_spp_register_callback(esp_spp_cb)) != ESP_OK) {
        ESP_LOGE(TAG, "spp register failed: %s", esp_err_to_name(ret));
        return -1;
    }

    /* 初始化SPP */
    const esp_spp_cfg_t spp_cfg = {
        .mode = ESP_SPP_MODE_CB,
        .enable_l2cap_ertm = true,
        .tx_buffer_size = 0,
    };
    if ((ret = esp_spp_enhanced_init(&spp_cfg)) != ESP_OK) {
        ESP_LOGE(TAG, "spp init failed: %s", esp_err_to_name(ret));
        return -1;
    }

    send_queue = xQueueCreate(3, sizeof(uint32_t));
    while (1) {
        uint32_t handle = 0;
        if (pdTRUE == xQueueReceive(send_queue, &handle, portMAX_DELAY)) {
            if (esp_spp_write(handle, strlen(SPP_DATA), (uint8_t*) SPP_DATA) != ESP_OK) {
                ESP_LOGE(TAG, "server send data failed: %s", esp_err_to_name(ret));
            }
        }
    }

    return 0;
}

        代码与前面主要是回调函数的内容有差别。

        GAP回调函数只保留了验证成功事件。

        SPP回调函数，初始化完成事件，这里面负责启动服务端，调用esp_spp_start_srv函数，第一个参数设置验证类型，我这里选择无需验证；第二个参数设置对方的角色（主机/从机），这里设置从机；第三个参数设置通道，默认置0，表示选择任意通道；第四个参数设置服务端的名字。

        服务端启动完成事件，这里主要就是设置GAP协议下的名字和设备可检测性。

        连接开启事件，当客户端成功开启服务端串口时触发，会返回客户端的handle，这个在后面的读写操作是要用到的，同时这里会保存客户端的信息。

        连接关闭事件，当串口关闭时触发，返回handle和中断方，这里的处理是复位客户端信息。

        数据接收事件，当接收到客户端数据时触发，这里就是简单地做一个打印。

        写数据数据事件，当调用esp_spp_write成功后会触发。

        主函数中创建一个消息队列用来接收客户端的句柄，这是在数据接收事件中发送过来的，通过这个句柄服务器发送一条回复消息到客户端。

2.3.2 效果

        烧录程序后等待服务创建完成，这时候打开手机上的上位机，找到我们的ESP32。

        点击“连接”，配对成功就会进入到一个串口助手类似的界面，这时就可以向ESP32发消息了，ESP32接收到消息后就会回复对应的消息。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布