ESP32基于GATT Client蓝牙网关 （一主多从）

最新推荐文章于 2024-06-05 19:29:53 发布
最新推荐文章于 2024-06-05 19:29:53 发布
阅读量6.2k 收藏 61
点赞数 5
分类专栏： 蓝牙BLE ESP32 文章标签： esp32蓝牙网关 esp32 gattc esp32蓝牙一主多从
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/libin55/article/details/123071752
版权
前言

对于传统的BLE低功耗设备，通过手机ble作为主机角色进行通信。如果需要主动接入网络，通过esp32作为主机，采用一主多从的应用可以并行多台接入，本章主要针对Multi-connection的应用例程展开讲解

ESP32工作在GATT client的角色，扫描并连接GATT server的广播设备

如有异议，欢迎留言指正

模型架构

基于BLE GATT直连的方案，主从拓扑结构，通信消息统一由网关主机处理，组网方式为星型网络
在这里插入图片描述

一对多连接配置

IDF为每个BLE服务创建一个单独的配置文件，应用配置文件以ID号单独定义
在这里插入图片描述

配置流程

主要步骤

  • 系统初始化
  • 扫描参数配置
  • 发现附近的设备
  • 与匹配的设备进行连接
  • 注册服务通知 register notify
    在这里插入图片描述
修改最大连接数

进入配置工具菜单idf.py menuconfig中选择，进入Component config->Bluetooth->Bluedroid Options->BT/BLE MAX ACL CONNECTIONS
在这里插入图片描述

常用API
GAP

api头文件路径components/bt/host/bluedroid/api/include/api/esp_gap_ble_api.h

  • esp_err_t esp_ble_gap_register_callback(esp_gap_ble_cb_t callback)：注册GAP事件回调
    • callback：回调函数
  • esp_err_t esp_ble_gap_set_scan_params(esp_ble_scan_params_t *scan_params)：设置扫描参数
    • *scan_params：配置扫描类型、地址类型、滤波类型、间隔、窗口等
  • esp_err_t esp_ble_gap_start_scanning(uint32_t duration)：启动扫描
    • duration：扫描时间，单位sec；写0为持续扫描
  • esp_err_t esp_ble_gap_stop_scanning(void)：停止扫描
  • esp_err_t esp_ble_gap_read_rssi(esp_bd_addr_t remote_addr)：读取RSSI信号强度，结果通过ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT事件触发返回
  • esp_err_t esp_ble_gap_disconnect(esp_bd_addr_t remote_device)：断开连接
    • remote_device：断开peer目标地址

更多内容请参考GAP API

GATTC

api头文件路径components/bt/host/bluedroid/api/include/api/esp_gattc_api.h

  • esp_err_t esp_ble_gattc_register_callback(esp_gattc_cb_tcallback)：注册GATTC事件回调
    • callback：回调函数指针
  • esp_err_t esp_ble_gattc_app_register(uint16_t app_id)： 注册GATT服务应用
  • esp_err_t esp_ble_gattc_open(esp_gatt_if_t gattc_if, esp_bd_addr_t remote_bda, esp_ble_addr_type_t remote_addr_type, bool is_direct)：打开连接
    • gattc_if：gattc访问接口
    • remote_bda：远程设备地址
    • remote_addr_type：远程设备地址类型
    • is_direct：true - 直接连接；false - 后台连接
  • esp_err_t esp_ble_gattc_close(esp_gatt_if_t gattc_if, uint16_t conn_id)：关闭与gatt服务端连接
    • gattc_if：gattc访问接口
    • conn_id：连接id
  • esp_err_t esp_ble_gattc_send_mtu_req(esp_gatt_if_t gattc_if, uint16_t conn_id)：设置通道MTU大小
    • gattc_if：gattc访问接口
    • conn_id：连接id
  • esp_err_t esp_ble_gattc_search_service(esp_gatt_if_t gattc_if, uint16_t conn_id, esp_bt_uuid_t *filter_uuid)：查找指定服务，仅本地缓存中查找匹配
    • gattc_if：gattc访问接口
    • conn_id：连接id
    • filter_uuid：指定服务uuid
  • esp_gatt_status_t esp_ble_gattc_get_attr_count(esp_gatt_if_t gattc_if, uint16_t conn_id, esp_gatt_db_attr_type_t type, uint16_t start_handle, uint16_t end_handle, uint16_t char_handle, uint16_t *count)：获取指定服务或特征的属性个数
    • gattc_if：gattc访问接口
    • conn_id：连接id
    • type：属性类型
    • start_handle：属性起始句柄
    • end_handle：属性结束句柄
    • char_handle：特征句柄
    • count：输出查找匹配属性类型的个数
  • esp_gatt_status_t esp_ble_gattc_get_char_by_uuid(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t start_handle, uint16_t end_handle, esp_bt_uuid_t char_uuid, esp_gattc_char_elem_t *result, uint16_t *count)：获取指定特征UUID的特征，从本地缓存中获取
    • gattc_if：gattc访问接口
    • conn_id：连接id句柄
    • start_handle：属性起始句柄
    • end_handle：属性结束句柄
    • char_uuid：查找的特征uuid
    • result：输出匹配特征的指针
    • count：输入需要查找的特征数，并输出已经获取到的特征数
  • esp_gatt_status_t esp_ble_gattc_get_descr_by_uuid(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t start_handle, uint16_t end_handle, esp_bt_uuid_t char_uuid, esp_bt_uuid_t descr_uuid, esp_gattc_descr_elem_t *result, uint16_t *count)：获取具有给定特征uuid的描述符
    • gattc_if：gattc访问接口
    • conn_id：连接id句柄
    • start_handle：属性起始句柄
    • end_handle：属性结束句柄
    • char_uuid：特征uuid
    • descr_uuid：描述符uuid
    • result：输出匹配特征描述符的指针
    • count：输入需要查找的描述符数，并输出已经查找到的描述符数量
  • esp_err_t esp_ble_gattc_write_char(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t handle, uint16_t value_len, uint8_t *value, esp_gatt_write_type_t write_type, esp_gatt_auth_req_t auth_req)：gattc写入特征值
    • gattc_if：gattc访问接口
    • conn_id：连接id
    • handle：特征句柄
    • value_len：写入数据长度
    • value：写入数据缓存
    • write_type：写属性类型（需要应答、无需应答）
    • auth_req：认证请求（0 - 无需认证）
  • esp_err_t esp_ble_gattc_write_char_descr(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t handle, uint16_t value_len, uint8_t *value, esp_gatt_write_type_t write_type, esp_gatt_auth_req_t auth_req)：gattc写入特征描述符值
    • gattc_if：gattc访问接口
    • conn_id：连接id
    • handle：描述符句柄
    • value_len：写入数据长度
    • value：写入数据缓存
    • write_type：写属性类型（需要应答、无需应答）
    • auth_req：认证请求（0 - 无需认证）
  • esp_err_t esp_ble_gattc_register_for_notify(esp_gatt_if_t gattc_if, esp_bd_addr_t server_bda, uint16_t handle)：注册服务通知
    • gattc_if：gattc访问接口
    • server_bda：服务端地址
    • handle：服务特征句柄

详情内容请参考GATT CLIENT API

代码讲解

示例demo，目录examples/bluetooth/bluedroid/ble/gattc_multi_connect，例程为BLE GATT基础上，实现一个GATT客户端同时连接到三个不同的GATT服务端设备

入口app_main

app_main()中进行了蓝牙协议栈初始化与回调事件注册

esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
ret = esp_bt_controller_init(&bt_cfg); //初始化蓝牙控制器
if (ret) {
    ESP_LOGE(GATTC_TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(ret));
    return;
}
ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);//使能BLE模式
if (ret) {
    ESP_LOGE(GATTC_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
    return;
}
ret = esp_bluedroid_init();//初始化与分配资源
if (ret) {
    ESP_LOGE(GATTC_TAG, "%s init bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
    return;
}
ret = esp_bluedroid_enable();//使能蓝牙
if (ret) {
    ESP_LOGE(GATTC_TAG, "%s enable bluetooth failed: %s\n", __func__, esp_err_to_name(ret));
    return;
}
//register the  callback function to the gap module
ret = esp_ble_gap_register_callback(esp_gap_cb); //注册gap事件回调
if (ret){
    ESP_LOGE(GATTC_TAG, "gap register error, error code = %x", ret);
    return;
}
//register the callback function to the gattc module
ret = esp_ble_gattc_register_callback(esp_gattc_cb);//注册gattc事件回调
if(ret){
    ESP_LOGE(GATTC_TAG, "gattc register error, error code = %x", ret);
    return;
}
ret = esp_ble_gattc_app_register(PROFILE_A_APP_ID); //注册GATT A服务app
if (ret){
    ESP_LOGE(GATTC_TAG, "gattc app register error, error code = %x", ret);
    return;
}
ret = esp_ble_gattc_app_register(PROFILE_B_APP_ID);//注册GATT B服务app
if (ret){
    ESP_LOGE(GATTC_TAG, "gattc app register error, error code = %x", ret);
    return;
}
ret = esp_ble_gattc_app_register(PROFILE_C_APP_ID);//注册GATT C服务app
if (ret){
    ESP_LOGE(GATTC_TAG, "gattc app register error, error code = %x", ret);
    return;
}
ret = esp_ble_gatt_set_local_mtu(200);//设置MTU为200
if (ret){
    ESP_LOGE(GATTC_TAG, "set local  MTU failed, error code = %x", ret);
}
esp_gap_cb回调

通过esp_gap_cb回调，通过获取扫描结果事件ESP_GAP_BLE_SCAN_RESULT_EVT，对比广播名称来判断需要连接的设备

  • remote_device_name定义了设备广播名称，可以根据实际的定义进行修改
static const char remote_device_name[3][20] = {"ESP_GATTS_DEMO_1", "ESP_GATTS_DEMO_2", “ESP_GATTS_DEMO_3"};
  • 匹配结果与执行连接
//提取广播名称
adv_name = esp_ble_resolve_adv_data(scan_result->scan_rst.ble_adv,
                                    ESP_BLE_AD_TYPE_NAME_CMPL, &adv_name_len);
ESP_LOGI(GATTC_TAG, "Searched Device Name Len %d", adv_name_len);
//获取到广播名称
if (adv_name != NULL) 
{
    //比对名称与长度
    //设备a
    if (strlen(remote_device_name[0]) == adv_name_len && strncmp((char *)adv_name, remote_device_name[0], adv_name_len) == 0)
    {
        if (conn_device_a == false) //未连接
        {
            conn_device_a = true;
            ESP_LOGI(GATTC_TAG, "Searched device %s", remote_device_name[0]);
            esp_ble_gap_stop_scanning(); //停止扫描
            esp_ble_gattc_open(gl_profile_tab[PROFILE_A_APP_ID].gattc_if, scan_result->scan_rst.bda, scan_result->scan_rst.ble_addr_type, true);//执行连接(使用设备a配置文件)
            Isconnecting = true;//置位连接中状态
        }
        break;
    }  
    //设备b
    else if (strlen(remote_device_name[1]) == adv_name_len && strncmp((char *)adv_name, remote_device_name[1], adv_name_len) == 0) {
    ...
    ...
    }
    //设备a
    else if (strlen(remote_device_name[2]) == adv_name_len && strncmp((char *)adv_name, remote_device_name[1], adv_name_len) == 0) {
    ...
    ...
    }
GATTC事件回调

在BT初始化时，为每一个从设备注册了gattc回调事件，针对每一台设备的profile匹配唯一的gattc处理回调

static void gattc_profile_a_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
static void gattc_profile_b_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
static void gattc_profile_c_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
A、B、C处理基本相同，重点看下内部的事件处理
  • ESP_GATTC_OPEN_EVT：当设备连接后，会触发该事件
    case ESP_GATTC_OPEN_EVT:
        if (p_data->open.status != ESP_GATT_OK){
            //open failed, ignore the first device, connect the second device
            ESP_LOGE(GATTC_TAG, "connect device failed, status %d", p_data->open.status);
            conn_device_a = false;//a连接失败，尝试连接b设备
            //start_scan();
            break;
        }
        //连接成功
        memcpy(gl_profile_tab[PROFILE_A_APP_ID].remote_bda, p_data->open.remote_bda, 6);//地址拷贝
        gl_profile_tab[PROFILE_A_APP_ID].conn_id = p_data->open.conn_id; //保存连接id
        ESP_LOGI(GATTC_TAG, "ESP_GATTC_OPEN_EVT conn_id %d, if %d, status %d, mtu %d", p_data->open.conn_id, gattc_if, p_data->open.status, p_data->open.mtu);
        ESP_LOGI(GATTC_TAG, "REMOTE BDA:");
        esp_log_buffer_hex(GATTC_TAG, p_data->open.remote_bda, sizeof(esp_bd_addr_t));
        esp_err_t mtu_ret = esp_ble_gattc_send_mtu_req (gattc_if, p_data->open.conn_id);//发送mtu请求200
        if (mtu_ret){
            ESP_LOGE(GATTC_TAG, "config MTU error, error code = %x", mtu_ret);
        }
        break;
  • ESP_GATTC_CFG_MTU_EVT： MTU配置完成事件，进行搜索服务；服务定义在remote_filter_service_uuid结构中
    case ESP_GATTC_CFG_MTU_EVT:
        if (param->cfg_mtu.status != ESP_GATT_OK){
            ESP_LOGE(GATTC_TAG,"Config mtu failed");
        }
        ESP_LOGI(GATTC_TAG, "Status %d, MTU %d, conn_id %d", param->cfg_mtu.status, param->cfg_mtu.mtu, param->cfg_mtu.conn_id);
        esp_ble_gattc_search_service(gattc_if, param->cfg_mtu.conn_id, &remote_filter_service_uuid); //搜索服务
        break;
  • ESP_GATTC_SEARCH_RES_EVT：服务搜索到后触发，进行置位标志
   case ESP_GATTC_SEARCH_RES_EVT: {
        ESP_LOGI(GATTC_TAG, "SEARCH RES: conn_id = %x is primary service %d", p_data->search_res.conn_id, p_data->search_res.is_primary);
        ESP_LOGI(GATTC_TAG, "start handle %d end handle %d current handle value %d", p_data->search_res.start_handle, p_data->search_res.end_handle, p_data->search_res.srvc_id.inst_id);
        if (p_data->search_res.srvc_id.uuid.len == ESP_UUID_LEN_16 && p_data->search_res.srvc_id.uuid.uuid.uuid16 == REMOTE_SERVICE_UUID) {
            ESP_LOGI(GATTC_TAG, "UUID16: %x", p_data->search_res.srvc_id.uuid.uuid.uuid16);
            get_service_a = true; //置位标志
            gl_profile_tab[PROFILE_A_APP_ID].service_start_handle = p_data->search_res.start_handle;//保存句柄
            gl_profile_tab[PROFILE_A_APP_ID].service_end_handle = p_data->search_res.end_handle;
        }
        break;
  • ESP_GATTC_SEARCH_CMPL_EVT：所有服务搜索完成后该事件触发，进行特征的获取与注册通知notify
case ESP_GATTC_SEARCH_CMPL_EVT:
        if (p_data->search_cmpl.status != ESP_GATT_OK){
            ESP_LOGE(GATTC_TAG, "search service failed, error status = %x", p_data->search_cmpl.status);
            break;
        }
        if (get_service_a){
            uint16_t count = 0;
            //获取属性
            esp_gatt_status_t status = esp_ble_gattc_get_attr_count( gattc_if,
                                                                     p_data->search_cmpl.conn_id,
                                                                     ESP_GATT_DB_CHARACTERISTIC,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].service_start_handle,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].service_end_handle,
                                                                     INVALID_HANDLE,
                                                                     &count);
            if (status != ESP_GATT_OK){
                ESP_LOGE(GATTC_TAG, "esp_ble_gattc_get_attr_count error");
            }
            if (count > 0) {
                char_elem_result_a = (esp_gattc_char_elem_t *)malloc(sizeof(esp_gattc_char_elem_t) * count);
                if (!char_elem_result_a){
                    ESP_LOGE(GATTC_TAG, "gattc no mem");
                }else {
                   //获取指定uuid
                    status = esp_ble_gattc_get_char_by_uuid( gattc_if,
                                                             p_data->search_cmpl.conn_id,
                                                             gl_profile_tab[PROFILE_A_APP_ID].service_start_handle,
                                                             gl_profile_tab[PROFILE_A_APP_ID].service_end_handle,
                                                             remote_filter_char_uuid,
                                                             char_elem_result_a,
                                                             &count);
                    if (status != ESP_GATT_OK){
                        ESP_LOGE(GATTC_TAG, "esp_ble_gattc_get_char_by_uuid error");
                    }
                    /*  Every service have only one char in our 'ESP_GATTS_DEMO' demo, so we used first 'char_elem_result' */
                    if (count > 0 && (char_elem_result_a[0].properties & ESP_GATT_CHAR_PROP_BIT_NOTIFY)){
                        gl_profile_tab[PROFILE_A_APP_ID].char_handle = char_elem_result_a[0].char_handle;
                        //注册通知服务
                        esp_ble_gattc_register_for_notify (gattc_if, gl_profile_tab[PROFILE_A_APP_ID].remote_bda, char_elem_result_a[0].char_handle);
                    }
                }
                /* free char_elem_result */
                free(char_elem_result_a);
            }else {
                ESP_LOGE(GATTC_TAG, "no char found");
            }
        }
        break;
  • ESP_GATTC_REG_FOR_NOTIFY_EVT：注册通知服务完成事件，写入CCC配置特征使能通知notify

   case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
        if (p_data->reg_for_notify.status != ESP_GATT_OK){
            ESP_LOGE(GATTC_TAG, "reg notify failed, error status =%x", p_data->reg_for_notify.status);
            break;
        }
        uint16_t count = 0;
        uint16_t notify_en = 1;
        //获取属性数量
        esp_gatt_status_t ret_status = esp_ble_gattc_get_attr_count( gattc_if,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].conn_id,
                                                                     ESP_GATT_DB_DESCRIPTOR,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].service_start_handle,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].service_end_handle,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].char_handle,
                                                                     &count);
        if (ret_status != ESP_GATT_OK){
            ESP_LOGE(GATTC_TAG, "esp_ble_gattc_get_attr_count error");
        }
        if (count > 0){
            descr_elem_result_a = (esp_gattc_descr_elem_t *)malloc(sizeof(esp_gattc_descr_elem_t) * count);
            if (!descr_elem_result_a){
                ESP_LOGE(GATTC_TAG, "malloc error, gattc no mem");
            }else{
              // 获取描述符
                ret_status = esp_ble_gattc_get_descr_by_char_handle( gattc_if,
                                                                     gl_profile_tab[PROFILE_A_APP_ID].conn_id,
                                                                     p_data->reg_for_notify.handle,
                                                                     notify_descr_uuid,
                                                                     descr_elem_result_a,
                                                                     &count);
                if (ret_status != ESP_GATT_OK){
                    ESP_LOGE(GATTC_TAG, "esp_ble_gattc_get_descr_by_char_handle error");
                }
                /* Every char has only one descriptor in our 'ESP_GATTS_DEMO' demo, so we used first 'descr_elem_result' */
                if (count > 0 && descr_elem_result_a[0].uuid.len == ESP_UUID_LEN_16 && descr_elem_result_a[0].uuid.uuid.uuid16 == ESP_GATT_UUID_CHAR_CLIENT_CONFIG){
                    //使能通知 notify_en = 1
                    ret_status = esp_ble_gattc_write_char_descr( gattc_if,
                                                                 gl_profile_tab[PROFILE_A_APP_ID].conn_id,
                                                                 descr_elem_result_a[0].handle,
                                                                 sizeof(notify_en),
                                                                 (uint8_t *)&notify_en,
                                                                 ESP_GATT_WRITE_TYPE_RSP,
                                                                 ESP_GATT_AUTH_REQ_NONE);
                }
                if (ret_status != ESP_GATT_OK){
                    ESP_LOGE(GATTC_TAG, "esp_ble_gattc_write_char_descr error");
                }
                /* free descr_elem_result */
                free(descr_elem_result_a);
            }
        }
        else{
            ESP_LOGE(GATTC_TAG, "decsr not found");
        }
        break;
  • ESP_GATTC_NOTIFY_EVT：数据接收通知事件，例程中将数据打印
    case ESP_GATTC_NOTIFY_EVT:
        ESP_LOGI(GATTC_TAG, "ESP_GATTC_NOTIFY_EVT, Receive notify value:");
        esp_log_buffer_hex(GATTC_TAG, p_data->notify.value, p_data->notify.value_len);
        break;
  • ESP_GATTC_WRITE_DESCR_EVT：描述符写入事件，例程写入发送了35字节累加数字；写入完成后会触发ESP_GATTC_WRITE_CHAR_EVT事件
    case ESP_GATTC_WRITE_DESCR_EVT:
        if (p_data->write.status != ESP_GATT_OK){
            ESP_LOGE(GATTC_TAG, "write descr failed, error status = %x", p_data->write.status);
            break;
        }
        ESP_LOGI(GATTC_TAG, "write descr success");
        uint8_t write_char_data[35];
        for (int i = 0; i < sizeof(write_char_data); ++i)
        {
            write_char_data[i] = i % 256;
        }
        esp_ble_gattc_write_char( gattc_if,
                                  gl_profile_tab[PROFILE_A_APP_ID].conn_id,
                                  gl_profile_tab[PROFILE_A_APP_ID].char_handle,
                                  sizeof(write_char_data),
                                  write_char_data,
                                  ESP_GATT_WRITE_TYPE_RSP,
                                  ESP_GATT_AUTH_REQ_NONE);
        break;
  • ESP_GATTC_DISCONNECT_EVT：断开事件
    case ESP_GATTC_DISCONNECT_EVT:
        //Start scanning again
        start_scan(); //开启扫描
        if (memcmp(p_data->disconnect.remote_bda, gl_profile_tab[PROFILE_A_APP_ID].remote_bda, 6) == 0){
            ESP_LOGI(GATTC_TAG, "device a disconnect");
            conn_device_a = false; //清标志
            get_service_a = false;
        }
        break;
总结

移植例程代码，仅需要修改为对应设备的配置文件和广播名称即可；而增加设备数量相对应增加profile配置文件与gattc回调实现，由于代码处理几乎相同，会出现较大的代码冗余，可以在esp_gattc_cb判断中进行优化和合并

玉怀一捧雪
关注
  • 5
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LoRa-Gateway-with-ESP32:使用esp32NiceRF-Lora1276（915Mhz）构建网关所需的库
05-14
具有ESP32 / NiceRF-Lora1276（915Mhz）的LoRa网关 使用esp32构建网关所需的库 原始图书馆 测验 带有NiceRF-Lora1276收发器的基于ESP32的节点。 连接数 Esp32Pin ---------------------- NiceRF-Lora1276（915Mhz） 3.3V ---------------------------------- 3.3V Gnd ----------------------------------- Gnd GPIO18 -------------------------------- SCK GPIO19 -------------------------------- MISO GPIO23 -------------------------------- MOSI GPIO5 ------
使用ESP32-C3 蓝牙传输温湿度传感器数据给手机端，手机端发送指令控制板载SK6812 LED
06-17
我的博文《ESP32-C3 应用 篇（实例二、通过蓝牙将传感器数据发送给手机，手机端...使用 ESP32-C3 的蓝牙 GATT，做一个数据通信的应用实例。 蓝牙传输温湿度传感器数据给手机端，手机端发送指令控制板载SK6812 LED。
ESP32低功耗蓝牙BLE通信
优信电子的博客
09-21 3443
ESP32作为低功耗蓝牙BLE设备的基础使用
低功耗蓝牙中ATT/GATT/Profile/Service/Characteristic详解
最新发布
weixin_40543589的博客
06-05 702
蓝牙协议栈架构
ESPIDF开发ESP32学习笔记【经典蓝牙与BLE】
qq_40500005的博客
02-18 1万+
文章目录低功耗蓝牙（BLE）协议栈层次协议蓝牙核心协议（Bluetooth Core）包含的层次简介蓝牙应用协议（Bluetooth Application）包含的层次简介BT与BLE的区别经典蓝牙模块（BT）低功耗蓝牙模块（BLE）其他分类BLE的两种模式ATT简述属性的种类和分组服务项Service特征值characteristic属性Attribute的数据结构属性协议ATT PDURequest后缀通用属性协议GATT简述通用访问协议GAPGAP广播GATT协议GATT结构BLE从初始化到建立连接的
【ESP32填坑日记】问题篇⑤ ESP32主从一体下的MTU协商问题
weixin_42037809的博客
11-10 492
ESP32主从一体下的MTU协商问题
ESP32学习笔记（48）——WiFi蓝牙网关
Leung的博客
05-17 6466
一、项目简介 蓝牙网关 又叫蓝牙探针，是采集蓝牙设备的蓝牙数据，通过 WIFI 等方式传至服务器的一款中继设备。如果类比的话，就如同 WIFI 网络中的无线 AP 的作用。WIFI 网络中无线 AP 是将 WIFI 设备接入网络，而蓝牙网络中的蓝牙网关，是将蓝牙设备接入网络。 帮普通的蓝牙设备和服务器端之间做一个蓝牙广播上报的功能。 项目特性： 采用 240MHz Xtensa 32-bit LX6 双核处理器 支持 STA 工作模式 支持 Smart Config/AirKiss 一键配网 内嵌
【ESP32】以蓝牙网关为例，记录队列的使用
欢迎私信、留言交流
09-12 379
> 本文档自己下载并烧录测试过的，工程结构非常清晰，是一个非常好的学习框架。 > 主要学了： > 这里是引用 > 1. 队列的使用，内存的管理 > 2. socket tcp 服务器的连接 > 3. 普通蓝牙协议连接通信
ESP32学习笔记（34）——BLE一主多从连接
热门推荐
Leung的博客
07-14 1万+
一、简介 由于蓝牙主机和从机组网，如果不使用 Mesh 的话，只能组微微网。蓝牙5.0的微微网最大可以连接20个从机。 1.1 连接句柄 在主机与从机发生连接的时候会进行连接句柄的分配。连接句柄的作用是在蓝牙数据进行分组的时候进行设备区分的。连接句柄相当于一个“令牌”，从设备一旦和主设备发生连接，主设备就给从设备分配一个“令牌”。主设备通过这个“令牌”来识别与区分从设备。因此对于连接句柄的分配将是实现一主多从连接，并且进行通信的关键。 1.2 Bluedroid主机架构 在 ESP-IDF 中，使用经过大
【产品笔记】ESP32及其物联网硬件设备——ESP32智能网关
hzdusun_com的博客
01-26 1829
在嵌入式系统和物联网应用领域，ESP32是一款广受欢迎的微控制器和片上系统(SoC)。你可能会对为什么选择无线SOC进行物联网硬件开发以及如何选择感兴趣？ESP32是众所周知的ESP8266的替代品，ESP8266因其内置WiFi而广受欢迎。除了WiFi，ESP32还内置了蓝牙和Wi-Fi。ESP32是一个适用于各种项目的灵活平台，因为它包括双核处理器、Wi-Fi和蓝牙连接、不同的输入/输出端口以及一系列外设。它采用Xtensa LX6微体系结构，时钟速度最高可达240 MHz。
Gamepad-ESP32.zip
01-04
总结起来，基于ESP32的蓝牙游戏手柄项目涉及硬件选型、蓝牙通信协议的理解、传感器数据处理以及软件编程等多个环节。通过这个项目，开发者不仅可以掌握ESP32的相关知识，还能深入了解蓝牙设备的设计与实现，为今后的...
esp32_bluetooth_architecture_cn.rar_bluetooth_esp32_wifi_蓝牙 ESP3
07-15
ESP32 蓝牙介绍。蓝牙可分为控制器? (Controller) 和主机 (Host) 两大部分：控制器包括了PHY、Baseband、Link Controller、Link Manager、Device Manager、HCI 等模块，用于硬件接口管理理、链路路管理理等等；主机...
gattclient:一个基于bluez堆栈的gatt客户端-仅使用套接字
05-08
加特客户端一个基于bluez堆栈的gatt客户端-仅使用套接字查看客户端功能语境Bluez是Linux的蓝牙堆栈之一。 我一直在寻找gatt客户进行ble测试。 直到知道我没有成功通过简单的体系结构“轻松”理解C代码。 我发现在...
gatt.rar_BLUE_gatt_蓝牙协议gatt
09-24
标题中的“gatt.rar_BLUE_gatt_蓝牙协议gatt”暗示了这个压缩包与蓝牙（Bluetooth）技术有关，特别是GATT（Generic Attribute Profile）协议。GATT是蓝牙低功耗（Bluetooth Low Energy, BLE）的核心部分，用于设备间...
【ESP32蓝牙通信】gatt_client 和 gatt_server 调试
欢迎私信、留言交流
11-15 4672
ESP32 客户端和服务器端的代码解析
ESP-C3入门17. 低功耗蓝牙GATT Server
编程圈子-谢厂节的博客
03-31 1174
GATT (Generic Attribute Profile) 是蓝牙低功耗 (Bluetooth Low Energy, BLE) 协议栈中的一部分，它定义了 BLE 设备之间交换数据的格式和规范。GATT 是基于属性 (attribute) 和服务 (service) 的概念，通过将数据封装在属性中，从而实现设备之间的通信。在 GATT 中，一个服务表示一个特定的功能，一个服务可以包含多个属性。每个属性都有一个唯一的标识符 (UUID)，可以用来识别它们。属性可以是只读的 (Read)，也可以是可写的
esp32蓝牙关闭与启动的问题
夜雨凭栏的博客
03-02 2484
esp32主动断开蓝牙的问题
【ESP32填坑日记】问题篇② ESP32主从一体机
weixin_42037809的博客
11-10 378
ESP32主从一体机
ESP32 BLE 一从多主
可可芯意的博客
04-08 3277
一、SDK版本和例子 这里采用的SDK版本为 4.4版本 从机例子：esp-idf-4.4/examples/bluetooth/bluedroid/ble/gatt_server 主机例子：esp-idf-4.4/examples/bluetooth/bluedroid/ble/gatt_client 二、注意事项 最大链接数，为9个，无论是一主多从，还是一从多主，这是和ble的 controller 相关的，具体可以看看 issue https://github.com/espressif/esp
esp32蓝牙GATT协议介绍
04-04
ESP32是一款集成了Wi-Fi和蓝牙功能的微控制器，它支持蓝牙经典模式和低功耗蓝牙模式。在低功耗蓝牙模式下，ESP32支持GATT协议。 GATT（通用属性配置文件）协议是蓝牙低功耗设备之间通信的核心协议。它定义了一种通用的基于属性的协议，用于在低功耗蓝牙设备之间传输数据。GATT协议使得低功耗蓝牙设备之间的通信更加高效和可靠。 在ESP32上，GATT协议的实现需要使用BLE设备模块。BLE设备模块是ESP32开发板上的一个软件模块，它提供了与蓝牙低功耗设备通信所需的所有功能。通过使用BLE设备模块，ESP32可以充当GATT服务器或GATT客户端。 作为GATT服务器，ESP32可以提供属性服务和属性特征，供GATT客户端读取或写入数据。作为GATT客户端，ESP32可以扫描周围的低功耗蓝牙设备并连接到它们，然后读取或写入它们提供的属性服务和属性特征。 总之，ESP32的支持GATT协议为低功耗蓝牙设备之间的通信提供了更加高效和可靠的方式，使得开发低功耗蓝牙设备更加容易和便捷。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值