ESP32+idf开发—蓝牙通信入门之ble数据收发(notify)

ESPIDF开发ESP32学习笔记【经典蓝牙与BLE】_esp32蓝牙串口库是经典蓝牙还是ble蓝牙 BLE外设的通信主要通过Characteristic,通过在Characteristic中读写数据就实现了双向通信,也可以通过实现类似串口的Service来配置TxCharacteristic和RxCharacteristic,这些都是具体项目的选择了。 阅读详情
AI摘要

本文介绍了如何使用ESP32结合idf框架开发蓝牙从机,实现与手机蓝牙调试助手的通信,包括接收控制命令以开关LED灯和主动发送温度数据。通过GATT服务和特性,esp32作为蓝牙从机能接收到主机的数据并解析,同时在接收到notify订阅后定时发送模拟的温度数据。文章详细讲解了蓝牙BLE的架构和服务特性,并提供了相应的代码示例。

ESP32+idf开发之蓝牙通信入门—ble数据收发(notify)

一、实现功能:

esp32作为蓝牙从机,与手机端蓝牙调试助手(如LightBlue)主机进行通信,实现数据的收发功能:

1、收:蓝牙调试助手发送数据控制esp32开发板led灯的亮灭;

2、发(notify):esp32将传感器数据(如温度数据)主动每隔2s发送给蓝牙调试助手,实现通知(notify)功能;

二、蓝牙BLE概述:

​ 1、BLE(低功耗蓝牙)采用了client/server (C/S) 架构来进行数据交互。这里讲的C/S架构和前面tcp/udp编程时所讲的C/S架构是相同的。 一般而言蓝牙设备提供服务,因此设备是server,手机使用设备提供的服务,因此手机是client。比如蓝牙体温计,它可以提供 “体温” 数据服务,因此是一个server,而手机则可以请求“体温”数据以显示在手机上,因此手机是一个client。

image-20230512151558628

​ 中央设备(主机)即通信的发起者,只能与外围设备通信;外围设备(从机)无法启动通信,只能与中央设备通信;同一时间外围设备只能与一个中央设备通信;外围设备无法与其他外围设备通信。

​ 2、蓝牙协议栈:

image-20230512151906691

​ profile 可以理解为一种规范,建立的蓝牙应用任务,蓝牙任务实际上分为两类: 标准蓝牙任务规范 profile(公有任务),非标准蓝牙任务规范 profile(私有任务)。标准蓝牙任务规范 profile:指的是从蓝牙特别兴趣小组 SIG 的官网上已经发布的 GATT 规范列表,包括警告通知(alert notification),血压测量(blood pressure),心率(heart rate),电池(battery)等等。它们都是针对具体的低功耗蓝牙的应用实例来设计的。profile的结构如下:

图片.png

​ service即服务:在 BLE 从机中有多个服务,例如:电量信息服务、系统信息服务等;每个 service 中又包含多个 characteristic 特征值;

​ characteristic即特征,上面讲到: Service通过characteristic对数据进行封装,每个service中又包含多个 characteristic 特征值。一个characteristic包含三种条目:characteristic声明,characteristic的值以及characteristic的描述符。Characteristic是在GATT规范中最小的逻辑数据单元,由一个Value和多个描述特性的Desciptior组成。实际上,在与蓝牙设备打交道,主要就是读写Characteristic的value来完成。

​ Attribute 是属于 ATT属性层的东西,它是 ATT层 的核心。Attribute其实就是一条一条的数据。前面说过,每个蓝牙设备就是用来提供服务的,而服务就是众多数据的合集,这个合集可以称为数据库,数据库里面每个条目都是一个attribute。Attribute 由以下 4 部分组成:属性句柄(Attribute Handler)、属性类型(AttributeType)、属性值(Attribute Value)、属性权限(Attribute Permissions)。

​ UUID(universally uniqueidentifier,通用唯一识别码)是一个软件构建标准,一个合法的UUID,一定是随机的、全球唯一的。(UUID并不是BLE独有的概念)上面提到的 service 和 characteristic,都需要一个唯一的uuid来标识。

​ GATT (通用属性配置,Generic Attribute Profile) ,它定义两个 BLE 设备通过 Service 和 Characteristic 进行通信;GATT 就是使用了 ATT(Attribute Protocol)协议,ATT层定义了一个通信的基本框架,数据的基本结构,以及通信的指令,Service 和 characteristic 就是GATT层定义的, GATT层用来赋予每个数据一个具体的内涵,让数据变得有结构和意义。一旦两个设备建立起了连接,GATT 就开始起作用了,这里需要说明的是,GATT 连接必需先经过 GAP 协议。

​ GAP(通用访问规范,Generic Access Profile)在用来控制设备连接和广播,用于提供蓝牙设备的通用访问功能,包括设备发现、连接、鉴权、服务发现等等。GATT是建立连接后通信规范, 而蓝牙是通过GAP建立通信的。GAP 使你的设备被其他设备可见,并决定了你的设备是否可以或者怎样与合同设备进行交互。

三、步骤

1、使用模板gatt_server_service_table创建新工程。

image-20230512154134431

2、修改蓝牙名并不使用默认广播数据:

image-20230512154508951

3、增加属性表配置特征值用来描述LED和温度的相关信息:(可仿照特征A来写),同时将相关的宏定义和相关保存LED灯状态和温度值的变量进行定义完善。

image-20230512155807798

image-20230512160404032

image-20230512160227499

image-20230512160757994

2、获取得到主机蓝牙调试助手发来的数据,并进行判断,封装led组件,调用组件接口驱动LED亮灭

image-20230512174048249

3、收到蓝牙主机调试助手的notify订阅后创建任务进行温度数据采集并发送到主机,此处采用温度数据模拟;收到取消notify后则任务删除。

image-20230512174354286

image-20230512174434981

image-20230512174601981

四、完整代码

gatts_table_creat_demo.c:

/*
   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

/****************************************************************************
 *
 * This demo showcases creating a GATT database using a predefined attribute table.
 * It acts as a GATT server and can send adv data, be connected by client.
 * Run the gatt_client demo, the client demo will automatically connect to the gatt_server_service_table demo.
 * Client demo will enable GATT server's notify after connection. The two devices will then exchange
 * data.
 *
 ****************************************************************************/

#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 "esp_gap_ble_api.h"
#include "esp_gatts_api.h"
#include "esp_bt_main.h"
#include "gatts_table_creat_demo.h"
#include "esp_gatt_common_api.h"

#include <led.h>

#define GATTS_TABLE_TAG "GATTS_TABLE_DEMO"

#define PROFILE_NUM 1
#define PROFILE_APP_IDX 0
#define ESP_APP_ID 0x55
#define SAMPLE_DEVICE_NAME "rocket_iot" // 修改蓝牙名
#define SVC_INST_ID 0

/* The max length of characteristic value. When the GATT client performs a write or prepare write operation,
 *  the data length must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX.
 */
#define GATTS_DEMO_CHAR_VAL_LEN_MAX 500
#define PREPARE_BUF_MAX_SIZE 1024
#define CHAR_DECLARATION_SIZE (sizeof(uint8_t))

#define ADV_CONFIG_FLAG (1 << 0)
#define SCAN_RSP_CONFIG_FLAG (1 << 1)

static uint8_t adv_config_done = 0;

uint16_t heart_rate_handle_table[HRS_IDX_NB];

typedef struct
{
    uint8_t *prepare_buf;
    int prepare_len;
} prepare_type_env_t;

static prepare_type_env_t prepare_write_env;

// #define CONFIG_SET_RAW_ADV_DATA
#ifdef CONFIG_SET_RAW_ADV_DATA
static uint8_t raw_adv_data[] = {
    /* flags */
    0x02, 0x01, 0x06,
    /* tx power*/
    0x02, 0x0a, 0xeb,
    /* service uuid */
    0x03, 0x03, 0xFF, 0x00,
    /* device name */
    0x0f, 0x09, 'E', 'S', 'P', '_', 'G', 'A', 'T', 'T', 'S', '_', 'D', 'E', 'M', 'O'};
static uint8_t raw_scan_rsp_data[] = {
    /* flags */
    0x02, 0x01, 0x06,
    /* tx power */
    0x02, 0x0a, 0xeb,
    /* service uuid */
    0x03, 0x03, 0xFF, 0x00};

#else
static uint8_t service_uuid[16] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    // first uuid, 16bit, [12],[13] is the value
    0xfb,
    0x34,
    0x9b,
    0x5f,
    0x80,
    0x00,
    0x00,
    0x80,
    0x00,
    0x10,
    0x00,
    0x00,
    0xFF,
    0x00,
    0x00,
    0x00,
};

/* The length of adv data must be less than 31 bytes */
static esp_ble_adv_data_t adv_data = {
    .set_scan_rsp = false,
    .include_name = true,
    .include_txpower = true,
    .min_interval = 0x0006, // slave connection min interval, Time = min_interval * 1.25 msec
    .max_interval = 0x0010, // slave connection max interval, Time = max_interval * 1.25 msec
    .appearance = 0x00,
    .manufacturer_len = 0,       // TEST_MANUFACTURER_DATA_LEN,
    .p_manufacturer_data = NULL, // test_manufacturer,
    .service_data_len = 0,
    .p_service_data = NULL,
    .service_uuid_len = sizeof(service_uuid),
    .p_service_uuid = service_uuid,
    .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
};

// scan response data
static esp_ble_adv_data_t scan_rsp_data = {
    .set_scan_rsp = true,
    .include_name = true,
    .include_txpower = true,
    .min_interval = 0x0006,
    .max_interval = 0x0010,
    .appearance = 0x00,
    .manufacturer_len = 0,       // TEST_MANUFACTURER_DATA_LEN,
    .p_manufacturer_data = NULL, //&test_manufacturer[0],
    .service_data_len = 0,
    .p_service_data = NULL,
    .service_uuid_len = sizeof(service_uuid),
    .p_service_uuid = service_uuid,
    .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
};
#endif /* CONFIG_SET_RAW_ADV_DATA */

static esp_ble_adv_params_t 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;
};

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 heart_rate_profile_tab[PROFILE_NUM] = {
    [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 */
    },
};

/* Service */
static const uint16_t GATTS_SERVICE_UUID_TEST = 0x00FF;
static const uint16_t GATTS_CHAR_UUID_TEST_A = 0xFF01;
static const uint16_t GATTS_CHAR_UUID_TEST_B = 0xFF02;
static const uint16_t GATTS_CHAR_UUID_TEST_C = 0xFF03;
static const uint16_t GATTS_CHAR_UUID_TEST_LED = 0xFF04;
static const uint16_t GATTS_CHAR_UUID_TEST_TEMP = 0xFF05;

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 = ESP_GATT_CHAR_PROP_BIT_READ;
static const uint8_t char_prop_write = ESP_GATT_CHAR_PROP_BIT_WRITE;
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_notify = ESP_GATT_CHAR_PROP_BIT_WRITE | ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
static const uint8_t heart_measurement_ccc[2] = {0x00, 0x00};
static const uint8_t char_value[4] = {0x11, 0x22, 0x33, 0x44};
static const uint8_t led_value[1] = {0x00};
static const uint8_t temp_value[1] = {0x00};

/* Full Database Description - Used to add attributes into the database */
static const esp_gatts_attr_db_t gatt_db[HRS_IDX_NB] =
    {
        // Service Declaration
        [IDX_SVC] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ, sizeof(uint16_t), sizeof(GATTS_SERVICE_UUID_TEST), (uint8_t *)&GATTS_SERVICE_UUID_TEST}},

        /* Characteristic Declaration */
        [IDX_CHAR_A] =
            {{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}},

        /* Characteristic Value */
        [IDX_CHAR_VAL_A] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_A, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}},

        /* Client Characteristic Configuration Descriptor */
        [IDX_CHAR_CFG_A] =
            {{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(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},

        /* Characteristic Declaration */
        [IDX_CHAR_LED] =
            {{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}},

        /* Characteristic Value */
        [IDX_CHAR_VAL_LED] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_LED, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(led_value), (uint8_t *)led_value}},

        /* Characteristic Declaration */
        [IDX_CHAR_TEMP] =
            {{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}},

        /* Characteristic Value */
        [IDX_CHAR_VAL_TEMP] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_TEMP, ESP_GATT_PERM_READ, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(temp_value), (uint8_t *)temp_value}},

        /* Client Characteristic Configuration Descriptor */
        [IDX_CHAR_CFG_TEMP] =
            {{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(heart_measurement_ccc), (uint8_t *)heart_measurement_ccc}},

        /* Characteristic Declaration */
        [IDX_CHAR_B] =
            {{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}},

        /* Characteristic Value */
        [IDX_CHAR_VAL_B] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_B, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}},

        /* Characteristic Declaration */
        [IDX_CHAR_C] =
            {{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_write}},

        /* Characteristic Value */
        [IDX_CHAR_VAL_C] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&GATTS_CHAR_UUID_TEST_C, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, GATTS_DEMO_CHAR_VAL_LEN_MAX, sizeof(char_value), (uint8_t *)char_value}},

};

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
    switch (event)
    {
#ifdef CONFIG_SET_RAW_ADV_DATA
    case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
        adv_config_done &= (~ADV_CONFIG_FLAG);
        if (adv_config_done == 0)
        {
            esp_ble_gap_start_advertising(&adv_params);
        }
        break;
    case ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT:
        adv_config_done &= (~SCAN_RSP_CONFIG_FLAG);
        if (adv_config_done == 0)
        {
            esp_ble_gap_start_advertising(&adv_params);
        }
        break;
#else
    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
        adv_config_done &= (~ADV_CONFIG_FLAG);
        if (adv_config_done == 0)
        {
            esp_ble_gap_start_advertising(&adv_params);
        }
        break;
    case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT:
        adv_config_done &= (~SCAN_RSP_CONFIG_FLAG);
        if (adv_config_done == 0)
        {
            esp_ble_gap_start_advertising(&adv_params);
        }
        break;
#endif
    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");
        }
        else
        {
            ESP_LOGI(GATTS_TABLE_TAG, "advertising start successfully");
        }
        break;
    case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT:
        if (param->adv_stop_cmpl.status != ESP_BT_STATUS_SUCCESS)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "Advertising stop failed");
        }
        else
        {
            ESP_LOGI(GATTS_TABLE_TAG, "Stop adv successfully\n");
        }
        break;
    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "update connection params status = %d, min_int = %d, max_int = %d,conn_int = %d,latency = %d, timeout = %d",
                 param->update_conn_params.status,
                 param->update_conn_params.min_int,
                 param->update_conn_params.max_int,
                 param->update_conn_params.conn_int,
                 param->update_conn_params.latency,
                 param->update_conn_params.timeout);
        break;
    default:
        break;
    }
}

void example_prepare_write_event_env(esp_gatt_if_t gatts_if, prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param)
{
    ESP_LOGI(GATTS_TABLE_TAG, "prepare write, handle = %d, value len = %d", param->write.handle, param->write.len);
    esp_gatt_status_t status = ESP_GATT_OK;
    if (prepare_write_env->prepare_buf == NULL)
    {
        prepare_write_env->prepare_buf = (uint8_t *)malloc(PREPARE_BUF_MAX_SIZE * sizeof(uint8_t));
        prepare_write_env->prepare_len = 0;
        if (prepare_write_env->prepare_buf == NULL)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "%s, Gatt_server prep no mem", __func__);
            status = ESP_GATT_NO_RESOURCES;
        }
    }
    else
    {
        if (param->write.offset > PREPARE_BUF_MAX_SIZE)
        {
            status = ESP_GATT_INVALID_OFFSET;
        }
        else if ((param->write.offset + param->write.len) > PREPARE_BUF_MAX_SIZE)
        {
            status = ESP_GATT_INVALID_ATTR_LEN;
        }
    }
    /*send response when param->write.need_rsp is true */
    if (param->write.need_rsp)
    {
        esp_gatt_rsp_t *gatt_rsp = (esp_gatt_rsp_t *)malloc(sizeof(esp_gatt_rsp_t));
        if (gatt_rsp != NULL)
        {
            gatt_rsp->attr_value.len = param->write.len;
            gatt_rsp->attr_value.handle = param->write.handle;
            gatt_rsp->attr_value.offset = param->write.offset;
            gatt_rsp->attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE;
            memcpy(gatt_rsp->attr_value.value, param->write.value, param->write.len);
            esp_err_t response_err = esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, gatt_rsp);
            if (response_err != ESP_OK)
            {
                ESP_LOGE(GATTS_TABLE_TAG, "Send response error");
            }
            free(gatt_rsp);
        }
        else
        {
            ESP_LOGE(GATTS_TABLE_TAG, "%s, malloc failed", __func__);
        }
    }
    if (status != ESP_GATT_OK)
    {
        return;
    }
    memcpy(prepare_write_env->prepare_buf + param->write.offset,
           param->write.value,
           param->write.len);
    prepare_write_env->prepare_len += param->write.len;
}

void example_exec_write_event_env(prepare_type_env_t *prepare_write_env, esp_ble_gatts_cb_param_t *param)
{
    if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC && prepare_write_env->prepare_buf)
    {
        esp_log_buffer_hex(GATTS_TABLE_TAG, prepare_write_env->prepare_buf, prepare_write_env->prepare_len);
    }
    else
    {
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATT_PREP_WRITE_CANCEL");
    }
    if (prepare_write_env->prepare_buf)
    {
        free(prepare_write_env->prepare_buf);
        prepare_write_env->prepare_buf = NULL;
    }
    prepare_write_env->prepare_len = 0;
}

TaskHandle_t *pTask = NULL;
volatile bool notify_flag = false;
static void get_temp(void *arg)
{
    while (1)
    {
        if (notify_flag == true)
        {
            uint8_t temp = 20 + rand() % 11;
            esp_ble_gatts_set_attr_value(heart_rate_handle_table[IDX_CHAR_VAL_TEMP], 1, &temp);
            esp_ble_gatts_send_indicate(heart_rate_profile_tab[0].gatts_if, heart_rate_profile_tab[0].conn_id,
                                                        heart_rate_handle_table[IDX_CHAR_VAL_TEMP], 1, &temp, false);
        }else{
            vTaskDelete(NULL);
        }
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}
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)
{
    switch (event)
    {
    case ESP_GATTS_REG_EVT:
    {
        esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name(SAMPLE_DEVICE_NAME);
        if (set_dev_name_ret)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "set device name failed, error code = %x", set_dev_name_ret);
        }
#ifdef CONFIG_SET_RAW_ADV_DATA
        esp_err_t raw_adv_ret = esp_ble_gap_config_adv_data_raw(raw_adv_data, sizeof(raw_adv_data));
        if (raw_adv_ret)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "config raw adv data failed, error code = %x ", raw_adv_ret);
        }
        adv_config_done |= ADV_CONFIG_FLAG;
        esp_err_t raw_scan_ret = esp_ble_gap_config_scan_rsp_data_raw(raw_scan_rsp_data, sizeof(raw_scan_rsp_data));
        if (raw_scan_ret)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "config raw scan rsp data failed, error code = %x", raw_scan_ret);
        }
        adv_config_done |= SCAN_RSP_CONFIG_FLAG;
#else
        // config adv data
        esp_err_t ret = esp_ble_gap_config_adv_data(&adv_data);
        if (ret)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "config adv data failed, error code = %x", ret);
        }
        adv_config_done |= ADV_CONFIG_FLAG;
        // config scan response data
        ret = esp_ble_gap_config_adv_data(&scan_rsp_data);
        if (ret)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "config scan response data failed, error code = %x", ret);
        }
        adv_config_done |= SCAN_RSP_CONFIG_FLAG;
#endif
        esp_err_t create_attr_ret = esp_ble_gatts_create_attr_tab(gatt_db, gatts_if, HRS_IDX_NB, SVC_INST_ID);
        if (create_attr_ret)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "create attr table failed, error code = %x", create_attr_ret);
        }
    }
    break;
    case ESP_GATTS_READ_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_READ_EVT");
        break;
    case ESP_GATTS_WRITE_EVT:
        if (!param->write.is_prep)
        {
            // the data length of gattc write  must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX.
            ESP_LOGI(GATTS_TABLE_TAG, "GATT_WRITE_EVT, handle = %d, value len = %d, value :", param->write.handle, param->write.len);
            esp_log_buffer_hex(GATTS_TABLE_TAG, param->write.value, param->write.len);
            if (heart_rate_handle_table[IDX_CHAR_VAL_LED] == param->write.handle)
            {
                ESP_LOGI(GATTS_TABLE_TAG, "write:0x%x", param->write.value[0]);
                if (param->write.value[0] == 0x00)
                {
                    led_off(); // 收到数据0x00关灯
                }
                else if (param->write.value[0] == 0x01)
                {
                    led_on(); // 收到数据0x01开灯
                }
            }
            if (heart_rate_handle_table[IDX_CHAR_CFG_TEMP] == param->write.handle && param->write.len == 2)
            {
                uint16_t descr_value = param->write.value[1] << 8 | param->write.value[0];
                if (descr_value == 0x0001)
                {
                    ESP_LOGI(GATTS_TABLE_TAG, "notify enable");
                    xTaskCreate(get_temp, "get temp", 8192, NULL, 10, pTask);
                    notify_flag=true;
                    // ESP_LOGI(GATTS_TABLE_TAG, "notify enable");
                    // uint8_t notify_data[15];
                    // for (int i = 0; i < sizeof(notify_data); ++i)
                    // {
                    //     notify_data[i] = i % 0xff;
                    // }
                    // // the size of notify_data[] need less than MTU size
                    // esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, heart_rate_handle_table[IDX_CHAR_VAL_A],
                    //                             sizeof(notify_data), notify_data, false);
                }
                else if (descr_value == 0x0002)
                {
                    ESP_LOGI(GATTS_TABLE_TAG, "indicate enable");
                    uint8_t indicate_data[15];
                    for (int i = 0; i < sizeof(indicate_data); ++i)
                    {
                        indicate_data[i] = i % 0xff;
                    }
                    // the size of indicate_data[] need less than MTU size
                    esp_ble_gatts_send_indicate(gatts_if, param->write.conn_id, heart_rate_handle_table[IDX_CHAR_VAL_A],
                                                sizeof(indicate_data), indicate_data, true);
                }
                else if (descr_value == 0x0000)
                {
                    ESP_LOGI(GATTS_TABLE_TAG, "notify/indicate disable ");
                    notify_flag=false;
                    //vTaskDelete(pTask);
                }
                else
                {
                    ESP_LOGE(GATTS_TABLE_TAG, "unknown descr value");
                    esp_log_buffer_hex(GATTS_TABLE_TAG, param->write.value, param->write.len);
                }
            }
            /* send response when param->write.need_rsp is true*/
            if (param->write.need_rsp)
            {
                esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
            }
        }
        else
        {
            /* handle prepare write */
            example_prepare_write_event_env(gatts_if, &prepare_write_env, param);
        }
        break;
    case ESP_GATTS_EXEC_WRITE_EVT:
        // the length of gattc prepare write data must be less than GATTS_DEMO_CHAR_VAL_LEN_MAX.
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_EXEC_WRITE_EVT");
        example_exec_write_event_env(&prepare_write_env, param);
        break;
    case ESP_GATTS_MTU_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
        break;
    case ESP_GATTS_CONF_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_CONF_EVT, status = %d, attr_handle %d", param->conf.status, param->conf.handle);
        break;
    case ESP_GATTS_START_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "SERVICE_START_EVT, status %d, service_handle %d", param->start.status, param->start.service_handle);
        break;
    case ESP_GATTS_CONNECT_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_CONNECT_EVT, conn_id = %d", param->connect.conn_id);
        esp_log_buffer_hex(GATTS_TABLE_TAG, param->connect.remote_bda, 6);
        esp_ble_conn_update_params_t conn_params = {0};
        memcpy(conn_params.bda, param->connect.remote_bda, sizeof(esp_bd_addr_t));
        /* For the iOS system, please refer to Apple official documents about the BLE connection parameters restrictions. */
        conn_params.latency = 0;
        conn_params.max_int = 0x20; // max_int = 0x20*1.25ms = 40ms
        conn_params.min_int = 0x10; // min_int = 0x10*1.25ms = 20ms
        conn_params.timeout = 400;  // timeout = 400*10ms = 4000ms
        heart_rate_profile_tab[0].conn_id = param->connect.conn_id;
        // start sent the update connection parameters to the peer device.
        esp_ble_gap_update_conn_params(&conn_params);
        break;
    case ESP_GATTS_DISCONNECT_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_DISCONNECT_EVT, reason = 0x%x", param->disconnect.reason);
        esp_ble_gap_start_advertising(&adv_params);
        break;
    case ESP_GATTS_CREAT_ATTR_TAB_EVT:
    {
        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 != HRS_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, HRS_IDX_NB);
        }
        else
        {
            ESP_LOGI(GATTS_TABLE_TAG, "create attribute table successfully, the number handle = %d\n", param->add_attr_tab.num_handle);
            memcpy(heart_rate_handle_table, param->add_attr_tab.handles, sizeof(heart_rate_handle_table));
            esp_ble_gatts_start_service(heart_rate_handle_table[IDX_SVC]);
        }
        break;
    }
    case ESP_GATTS_STOP_EVT:
    case ESP_GATTS_OPEN_EVT:
    case ESP_GATTS_CANCEL_OPEN_EVT:
    case ESP_GATTS_CLOSE_EVT:
    case ESP_GATTS_LISTEN_EVT:
    case ESP_GATTS_CONGEST_EVT:
    case ESP_GATTS_UNREG_EVT:
    case ESP_GATTS_DELETE_EVT:
    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)
{

    /* 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)
        {
            heart_rate_profile_tab[PROFILE_APP_IDX].gatts_if = gatts_if;
        }
        else
        {
            ESP_LOGE(GATTS_TABLE_TAG, "reg app failed, app_id %04x, status %d",
                     param->reg.app_id,
                     param->reg.status);
            return;
        }
    }
    do
    {
        int idx;
        for (idx = 0; idx < PROFILE_NUM; idx++)
        {
            /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
            if (gatts_if == ESP_GATT_IF_NONE || gatts_if == heart_rate_profile_tab[idx].gatts_if)
            {
                if (heart_rate_profile_tab[idx].gatts_cb)
                {
                    heart_rate_profile_tab[idx].gatts_cb(event, gatts_if, param);
                }
            }
        }
    } while (0);
}

void app_main(void)
{
    esp_err_t ret;

    led_init();

    /* Initialize NVS. */
    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());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s", __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", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bluedroid_init();
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s init bluetooth failed: %s", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bluedroid_enable();
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed: %s", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_ble_gatts_register_callback(gatts_event_handler);
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "gatts register error, error code = %x", ret);
        return;
    }

    ret = esp_ble_gap_register_callback(gap_event_handler);
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "gap register error, error code = %x", ret);
        return;
    }

    ret = esp_ble_gatts_app_register(ESP_APP_ID);
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "gatts app register error, error code = %x", ret);
        return;
    }

    esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
    if (local_mtu_ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
    }
}

组件led相关代码有:led.c

#include <stdio.h>
#include "led.h"
#include<driver/gpio.h>


void led_init(){
    gpio_config_t cfg={
        .pin_bit_mask=1<<LED_PIN,
        .mode=GPIO_MODE_OUTPUT,
        .intr_type=GPIO_INTR_DISABLE,
        .pull_up_en=GPIO_PULLUP_DISABLE,
        .pull_down_en=GPIO_PULLDOWN_DISABLE,
    };
    ESP_ERROR_CHECK(gpio_config(&cfg));
}
void led_on(){
    ESP_ERROR_CHECK(gpio_set_level(LED_PIN,1));
}
void led_off(){
    ESP_ERROR_CHECK(gpio_set_level(LED_PIN,0));
}

led.h

#ifndef __LED_H__
#define __LED_H__

#define LED_PIN GPIO_NUM_2

void led_init();
void led_on();
void led_off();

#endif

五、测试

1、控制led灯测试,默认不亮,蓝牙调试APP发送0x01,esp灯亮;发送0x00,led灯灭。

image-20230512183614968

image-20230512184134267

image-20230512184158638

2、调试助手APP点击notify开关监听ESP32发来的温度数据并16进制显示,关闭后则停止,同时esp32终端打印相关信息。

image-20230512184650112

image-20230512183844682

蓝牙notify和indicate消息区别 Notify是单向的,不需要确认。Indicate是双向的,需要确认响应。这两种机制使得BLE设备能够有效地进行数据交换,同时保持低功耗的特性。Notify适合于那些对实时性要求高但可以容忍丢包的应用场景,如心率监测。而Indicate则适合于需要可靠传输的场景,如步数统计。 阅读详情

相关推荐

关于esp32蓝牙模块的使用——esp32学习笔记

关于esp32蓝牙模块的使用——esp32学习笔记 零、前言 esp32自带蓝牙模块可以让我们进行蓝牙连接并进行数据交换 一、经典蓝牙BT 首先来编写代码,经典蓝牙的使用非常简单,首先声明使用了BluetoothSerial这个库,然后使用SerialBT.begin函数设置蓝牙的名字,再然后就是设置配对码,由于这里没有用到配对码,所以我将注释掉。当配对成功我们就使用printf函数打印出蓝牙配对成功。 #include <Arduino.h> #include <BluetoothSer

qq_53965184的博客 5万+

微信小程序——Ble之notify通信

文章目录前言准备注意事项开发文档概述扩展代码开发关于notify开启成功后,onBLECharacteristicValueChange无法监听的问题 前言 之前BLE蓝牙通信博客中,重点说明了使用读 -- 写的模式,实现手机端和设备端的BLE信息交互操作。 但在一般的BLE设备中,存在可以使用notify通信的方式。 本篇博客重点说明小程序 BLE使用notify实现数据交互的方式,以及部分测试时碰见的坑! 准备 在开始写具体代码之前,需要准备以下材料: 微信小程序开发者工具 带有BLE的设备,且某个特

专注写bug 8051

ESP32蓝牙通信实战:从BLE协议选型到GATT服务端开发与手机联调

低功耗蓝牙(BLE)是一种面向短距离、低功耗数据传输的无线通信技术,其核心原理是通过广播与扫描建立连接,再基于GATT协议以服务、特征值、描述符的层级结构组织数据,支持读写与通知等交互方式。在嵌入式开发中,BLE常用于设备配网、近场控制与传感器数据透传,尤其适合与WiFi形成互补。ESP32同时支持经典蓝牙与BLE,开发者需根据手机兼容性、功耗与内存资源选择协议栈。本文围绕ESP-IDF与VSCode环境,系统讲解蓝牙配网、GATT服务端实现、广播配置、Notify数据发送及nRF Connect联调排错,

weixin_34253126的博客 531

BLE相关基础知识

BLE mac地址 BLE mac address 包括了Public Device Address、Random Device Address,其中,Random Device Address又包括了Static Device Address、Private Device Address。 Public Device Address是需要购买的公开的mac; Random Device Address是BLE模块自己生成的,根据是否定期更新分为static和private,static是掉电之后根据

LynnZhang的博客 6152

ESP32蓝牙双向通信实战:从BLE协议到物联网应用开发

蓝牙通信是物联网设备实现无线交互的核心技术之一,其低功耗蓝牙(BLE)协议栈尤其适用于电池供电的传感器节点。BLE基于GATT(通用属性协议)模型,通过定义服务、特征和描述符,构建了一个结构化的数据交换框架。该技术的关键价值在于实现了设备间高效、低功耗的双向数据传输,使得智能家居、穿戴设备和工业传感等场景中的状态监控与远程控制成为可能。在工程实践中,ESP32作为一款集成了经典蓝牙与BLE双模的芯片,为开发者提供了灵活的硬件平台。通过Arduino框架和ESP32 BLE Arduino库,可以快速构建一个

weixin_34109408的博客 458

ESP32蓝牙开发实战:ESP-IDF+VSCode实现BLE连接与通信

低功耗蓝牙(BLE)是物联网设备近场通信的核心技术,通过GAP和GATT协议实现设备发现与数据交互。在ESP32开发中,BLE常用于设备配网、手机遥控和传感器数据上报等场景。基于ESP-IDF和VSCode,开发者可以快速搭建BLE服务端,利用Bluedroid协议栈完成广播、连接、数据收发及Notify/Indicate通信。本文聚焦ESP32蓝牙开发,详解GAP与GATT模型、工程配置、代码实现及调试技巧,帮助开发者掌握BLE连接与通信的完整流程。

weixin_33461476的博客 249

ESP32下的ble数据notify收发(支持ESP-IDF4.4\ESPIDF5.1)

## 增加配置属性。

qq_43940227的博客 2793

ESP32蓝牙开发实战:ESP-IDF与VSCode下BLE通信从入门到避坑

BLE(低功耗蓝牙)是一种面向近距离、低功耗场景的无线通信协议,其核心原理是基于GATT(通用属性配置文件)构建服务与特征的数据交互模型。在嵌入式开发中,BLE常用于设备配网、点对点控制与传感器数据上报,技术价值在于低功耗与手机直连的便捷性。典型应用场景包括智能穿戴、智能家居与工业传感网络。ESP32作为主流物联网芯片,通过ESP-IDF与VSCode可快速搭建BLE数据收发服务,但需注意协议栈选型、广播参数配置及WiFi共存等工程问题。

weixin_34413103的博客 356

【IoT】Arduino 实现 ESP32 BLE 与 Android 手机的数据交互

1、效果描述: 通过简单的 Android APP 实现与 ESP32 的双向蓝牙通信。 2、实现步骤 Step 1:ESP32 硬件支持 1、支持蓝牙 4.0 以上协议的安卓手机; 2、支持 Micro USB 的 ESP32 dev board; Step 2:配置 Arduino IDE 环境 1、下载 Arduino IDE:https://www.arduino.cc/en...

产品线负责人 2万+

ESP-IDF+VSCode深度开发ESP32蓝牙通信实战指南

蓝牙低功耗(BLE)是嵌入式物联网设备实现点对点、低功耗、无网直连通信的核心技术,其底层基于GATT服务模型与ATT属性协议,区别于传统串口的流式传输。理解HCI层交互、GATT数据库构建、连接参数协商及MTU机制,是保障稳定通信的基础。ESP-IDF框架深度适配XTensa双核,提供从Controller到Host的全栈BLE支持,而VSCode通过ESP-IDF扩展、C/C++智能感知和Cortex-Debug实现高效调试闭环。本文聚焦工业级BLE开发痛点——如广播不可见、Notify失效、多连接丢包、

weixin_33898876的博客 357

手机App控制ESP32:BLE蓝牙通信实战指南与避坑笔记

在物联网与智能硬件开发中,手机与单片机之间的通信是开发者绕不开的核心环节。蓝牙BLE作为一种低功耗、近距离无线通信技术,凭借其连接稳定、配对简单的优势,成为控制开发板、传输传感器数据的理想选择。ESP32作为集成WiFi与蓝牙的双模芯片,既能通过GATT服务模型高效组织数据,也能与手机App建立双向通信通道。理解BLE的Service、Characteristic与Notify机制,是打通硬件与软件链路的基础。从开发环境搭建、蓝牙服务编写,到手机端扫描、连接与数据收发,合理设计通信协议与错误排查流程,能显著

weixin_28684757的博客 356

使用Arduino开发ESP32(十八):BLE_uart,BLE的异步通信及安卓app测试

基础介绍: 1、UART universal asynchronous receiver and transmitter通用异步收发器 2、USART universal synchronous asynchronous receiver and transmitter通用同步异步收发器 区别 1.“异步通信”是一种很常用的通信方式(效率较低)异步通信在发送字符时,发送端可以在任意时刻开始发送字符,因此必须在每一个字符的开始和结束的地方加上标志,即加上开始位和停止位,以便使接收端能够正确地将每一个字符接收下

Newbie_H的学习之路 3973

ESP32蓝牙通信实战:ESP-IDF与VSCode下的BLE与经典蓝牙选型及开发指南

蓝牙通信是ESP32开发中实现设备互联的关键技术,尤其适合低功耗、手机直连的场景。其原理基于GAP广播与GATT服务模型,通过特征值读写与通知机制完成数据交互。在ESP-IDF与VSCode环境下,开发者需合理选型经典蓝牙或BLE,并配置协议栈参数以平衡功耗与吞吐量。典型应用包括手机App控制、传感器数据上报及串口透传。本文聚焦ESP32蓝牙连接与通信的完整链路,涵盖协议栈选型、工程配置、广播扫描、数据收发及常见问题排查,帮助开发者快速落地蓝牙项目。

weixin_34072637的博客 291

ESP32-BLE蓝牙开发

初始化BLE蓝牙的基本步骤包括:释放经典蓝牙内存,配置并初始化蓝牙控制器,启用BLE模式,初始化并使能蓝牙协议栈,注册GATT与GAP回调函数,最后注册应用程序Profile。通过这些步骤,ESP32可成功启动BLE服务,实现设备广播、连接管理及数据通信功能。

Zs1379111341的博客 2024

ESP32蓝牙通信实战:BLE协议栈解析与数据收发调优

低功耗蓝牙(BLE)是ESP32在物联网设备中实现短距离通信的核心技术,基于GAP和GATT协议栈,通过广播、连接、Service与Characteristic等机制完成设备发现与数据交互。其技术价值在于低功耗、手机原生支持好,适合配网、调试和传感器数据上报等场景。在ESP-IDF中,开发者可选用Bluedroid或NimBLE协议栈,通过Write和Notify实现双向通信,并需合理配置连接间隔、延迟与超时参数以平衡功耗与响应速度。同时,蓝牙与WiFi共存时需注意射频竞争,可通过错峰使用或调整连接参数提升

weixin_29189373的博客 241

Android 蓝牙 ble Notification和Indication,Write Request 和Write Command的区别

android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程 Android 蓝牙低功耗ble 广播、扫描、连接、数据读写源码流程分析大全 - 点击下载 notify和indication的区别在于: 1、notification只是将你要发的数据发送给手机,没有确认机制,不会保证数据发送是否到达。 2、而indication的方式在手机收到数据时会主动回一个ack回来。即有确认机制,只有收到这个ack你才能继续发送下一个数据。这保证了数据的正确到达,也起到了流控

手机-手表蓝牙开发工程师的博客 6025

【免费下载】 ESP-IDF低功耗蓝牙(BLE)开发入门指南

低功耗蓝牙(Bluetooth Low Energy, BLE)作为物联网领域的重要通信技术,凭借其低功耗、低成本的特点,在智能家居、可穿戴设备等场景中广泛应用。本文将基于ESP-IDF开发框架,系统介绍BLE技术基础,并通过实践案例帮助开发者快速上手BLE应用开发。 ## 低功耗蓝牙技术基础 ### 1. BLE与经典蓝牙的区别 低功耗蓝牙(BLE)与传统经典蓝牙(Bluetooth Cl...

gitblog_00055的博客 672

新手避坑指南:用COMSOL Multiphysics仿真气体放电(汤逊vs.流注)

本文详细介绍了使用COMSOL Multiphysics仿真气体放电的实战指南,涵盖汤逊理论和流注模型的实现方法。通过对比两种放电模型的关键参数和物理场配置,帮助新手避免常见错误,准确预测气体击穿过程。文章还提供了工程应用案例,如高压绝缘子设计优化,展示了仿真技术在电力设备绝缘设计中的实际价值。

weixin_28716181的博客 479

ESP32 BLE蓝牙通信实战:从服务端配置到客户端交互

本文详细介绍了ESP32 BLE蓝牙通信的实战开发流程。从选择ESP32进行BLE开发的优势讲起,逐步指导如何刷写AT固件、配置BLE服务端(包括初始化、创建服务、设置广播),并通过手机客户端(如nRF Connect)实现连接与数据收发(Notify/Indicate/透传)。文章还涵盖了ESP32作为客户端连接其他设备的进阶应用,并提供了关键的避坑指南与调试技巧,帮助开发者快速上手低功耗蓝牙通信项目。

wind6的博客 371

深度可分离卷积(DepthwiseSeparableConvolution):Depthwise卷积与Pointwise卷积

深度可分离卷积不用多说,在轻量级网络架构方面是一个绕不开的话题,只要接触深度学习多多少少会接触。深度可分离卷积即DepthwiseSeparableConvolution,该卷积将一个常规卷积过程划分成两个完成Depthwise卷积和Pointwise卷积,在保证输出一样时,计算量大大降低。首先来看,一个常规卷积是怎么实现的。其示意图如果我们从通道数变换的角度来看,卷积就是将3通道的tensor变为了4通道的tensor,我们来看看深度可分离卷积是怎么实现通道的变化的。...

xu.hyj 1万+

FLUKA软件在Ubuntu的安装指南(亲测有效)

FLUKA其强大的蒙特卡洛模拟能力使得用户能够模拟复杂的辐射相互作用过程

chencheng1127的博客 2889
上一篇: ESP32+idf开发之WIFI通信入门(5)HTTP通信
rocket_iot
博客等级 码龄8年 46粉丝 6原创
评论 15
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值