蓝牙gatt打不开notify

蓝牙Gatt是蓝牙通信协议的一种，用于在蓝牙设备之间进行数据传输和通信。当蓝牙Gatt打不开Notify时可能是由于多种原因造成的。

首先，可能是由于硬件问题，例如蓝牙模块故障或者设备不支持Notify功能，这时候需要检查设备的硬件情况，确保蓝牙模块和设备都能够正常工作。

其次，可能是由于软件设置问题，比如蓝牙Gatt的Notify设置未正确配置或者被禁用了，需要在软件层面进行配置和调试，确保Notify功能能够正常工作。

另外，也有可能是由于设备之间的通信协议不一致或者版本不匹配，需要检查设备之间的通信协议和版本，确保它们之间的兼容性。

最后，还有可能是由于其他未知原因造成的，这时候需要进行更深入的调试和排查，可能需要使用专业的调试工具和设备来进行诊断并解决问题。

总之，要解决蓝牙Gatt打不开Notify的问题，需要从硬件、软件、协议和版本等多个方面进行全面排查和调试，确保各个方面都能够正常工作。

相关问题

蓝牙设备怎么 添加service 和characteristic

要添加蓝牙设备的服务和特征，需要进行以下步骤：

1. 为设备创建一个 GATT Server 对象。
2. 创建一个 Service 对象，其中包含 Service 的 UUID 和 Service 的类型（Primary 或 Secondary）。
3. 为 Service 添加一个或多个 Characteristic 对象，其中包含 Characteristic 的 UUID 和 Characteristic 的属性（例如读、写、通知）。
4. 在 Characteristic 中添加一个或多个 Descriptor 对象，其中包含 Descriptor 的 UUID 和 Descriptor 的值。
5. 将 Service 添加到 GATT Server 中。
6. 将 GATT Server 对象添加到 Bluetooth Adapter 中。

下面是一个简单的 Android 示例代码，用于添加一个 Service 和一个 Characteristic：

// 创建一个 GATT Server 对象
BluetoothGattServer gattServer = bluetoothManager.openGattServer(context, gattServerCallback);

// 创建一个 Service 对象
BluetoothGattService service = new BluetoothGattService(SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY);

// 创建一个 Characteristic 对象
BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(CHARACTERISTIC_UUID, BluetoothGattCharacteristic.PROPERTY_READ | BluetoothGattCharacteristic.PROPERTY_NOTIFY, BluetoothGattCharacteristic.PERMISSION_READ);

// 将 Characteristic 添加到 Service 中
service.addCharacteristic(characteristic);

// 将 Service 添加到 GATT Server 中
gattServer.addService(service);

在这个示例中，`SERVICE_UUID` 和 `CHARACTERISTIC_UUID` 是自定义的 UUID 值，可以根据实际需要进行更改。`gattServerCallback` 是一个实现了 BluetoothGattServerCallback 接口的对象，用于处理 GATT 服务器的事件。

espidf蓝牙数据发送接收例程

ESP-IDF是一款用于ESP32和ESP8266的官方开发框架，其中包含了丰富的蓝牙接口。下面是一个简单的蓝牙数据发送接收例程。

发送数据：

#include <stdio.h>
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_ble_api.h"

#define GATTS_TAG "GATTS_DEMO"

//定义GATT服务UUID
#define GATTS_SERVICE_UUID_TEST_A   0x00FF
//定义GATT特征UUID
#define GATTS_CHAR_UUID_TEST_A      0xFF01

static uint8_t adv_config_done = 0;

//GATT服务定义
static uint8_t test_service_uuid[16] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    //first uuid, 16bit, [12],[13] is the value
    0x1b,0x9a,
    //second uuid, 16bit, [12],[13] is the value
    0x12,0x34,
    //third uuid, 32bit, [12],[13],[14],[15] is the value, 0x0000XXXX is a placeholder
    0x11,0x22,0x33,0x44,
    0x00,0x00,0x00,0x00,
};
//GATT特征定义
static uint8_t test_char_uuid[16] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    //first uuid, 16bit, [12],[13] is the value
    0x1b,0x9a,
    //second uuid, 16bit, [12],[13] is the value
    0x12,0x34,
    //third uuid, 32bit, [12],[13],[14],[15] is the value, 0x0000XXXX is a placeholder
    0x11,0x22,0x33,0x44,
    0x00,0x00,0x00,0x00,
};
//GATT特征值
static uint8_t test_char_value[20] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};

//GATT事件处理函数
static esp_gatts_cb_event_t gatts_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:
            //注册GATT事件
            esp_ble_gap_set_device_name("ESP_GATTS_DEMO");
            esp_ble_gatts_create_attr_tab((esp_gatts_attr_db_t *)param->create.db, gatts_if, 
                                          param->create.svc_inst_id, param->create.num_handle);
            break;
        case ESP_GATTS_CREAT_ATTR_TAB_EVT:
            if (param->add_attr_tab.status != ESP_GATT_OK) {
                printf("create attribute table failed, error code=0x%x\n", param->add_attr_tab.status);
            } else if (param->add_attr_tab.num_handle != ESP_GATT_AUTO_RSP) {
                //获取特征值句柄
                printf("create attribute table success, the number handle = %d\n", param->add_attr_tab.num_handle);
            } else {
                printf("create attribute table success, the number handle = %d\n", param->add_attr_tab.num_handle);
            }
            //注册服务
            esp_ble_gatts_start_service(param->add_attr_tab.handles[0]);
            break;
        case ESP_GATTS_CONNECT_EVT:
            printf("a remote device connected\n");
            break;
        case ESP_GATTS_DISCONNECT_EVT:
            printf("a remote device disconnected\n");
            break;
        case ESP_GATTS_WRITE_EVT:
            if (param->write.handle == test_handle_table[IDX_CHAR_VAL_A]) {
                memcpy(test_char_value, param->write.value, param->write.len);
                printf("write test_char_value=%x,%x,%x,%x,%x,%x,%x,%x,%x,%x\n", 
                        test_char_value[0],test_char_value[1],test_char_value[2],test_char_value[3],
                        test_char_value[4],test_char_value[5],test_char_value[6],test_char_value[7],
                        test_char_value[8],test_char_value[9]);
            }
            //确认写入数据
            esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
            break;
        case ESP_GATTS_EXEC_WRITE_EVT:
            esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
            break;
        default:
            break;
    }
    return ESP_GATT_OK;
}

void gatt_server_init(void)
{
    //GATT参数初始化
    esp_err_t ret;
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) {
        printf("%s initialize controller failed\n", __func__);
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BTDM);
    if (ret) {
        printf("%s enable controller failed\n", __func__);
        return;
    }

    ret = esp_bluedroid_init();
    if (ret) {
        printf("%s init bluetooth failed\n", __func__);
        return;
    }

    ret = esp_bluedroid_enable();
    if (ret) {
        printf("%s enable bluetooth failed\n", __func__);
        return;
    }

    //GATT事件注册
    esp_ble_gatts_register_callback(gatts_event_handler);
    esp_ble_gatts_app_register(GATTS_APP_ID);

    //创建服务表
    esp_ble_gatts_create_service(GATTS_IF_NUM, test_service_uuid, GATTS_NUM_HANDLE_TEST_A);
}

void app_main()
{
    gatt_server_init();
    //循环发送数据
    while (1) {
        esp_ble_gatts_set_attr_value(test_handle_table[IDX_CHAR_VAL_A], sizeof(test_char_value), test_char_value);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

接收数据：

#include <stdio.h>
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_ble_api.h"

#define GATTC_TAG "GATTC_DEMO"

static uint8_t remote_bda[ESP_BD_ADDR_LEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
static esp_gattc_char_elem_t *char_elem_result = NULL;
static esp_gattc_descr_elem_t *descr_elem_result = NULL;
static uint16_t char_handle = 0;
static uint16_t descr_handle = 0;

//GATT事件处理函数
static void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param)
{
    switch (event) {
        case ESP_GATTC_REG_EVT:
            //注册GATT事件
            esp_ble_gap_set_scan_params(&ble_scan_params);
            break;
        case ESP_GATTC_CONNECT_EVT:
            printf("a GATT client connected\n");
            esp_ble_gattc_search_service(gattc_if, param->connect.conn_id, NULL);
            break;
        case ESP_GATTC_SEARCH_RES_EVT:
            //搜索到服务
            printf("search service uuid: ");
            esp_log_buffer_hex(GATTC_TAG, param->search_res.srvc_id.uuid.uuid, param->search_res.srvc_id.uuid.len);
            printf("search service start handle %d end handle %d\n", param->search_res.start_handle, param->search_res.end_handle);
            //搜索特征
            esp_ble_gattc_get_char_by_uuid(gattc_if, param->search_res.conn_id, &param->search_res.srvc_id, &char_uuid, char_elem_result, &count, 0);
            break;
        case ESP_GATTC_SEARCH_CMPL_EVT:
            //搜索完成
            printf("search complete\n");
            break;
        case ESP_GATTC_GET_CHAR_EVT:
            //获取特征
            printf("get char %s, handle %d\n", char_elem_result->uuid.uuid.uuid16, char_elem_result->char_handle);
            char_handle = char_elem_result->char_handle;
            //获取特征描述符
            esp_ble_gattc_get_descr_by_char_handle(gattc_if, param->search_res.conn_id, char_handle, &descr_uuid, descr_elem_result, &count, 0);
            break;
        case ESP_GATTC_GET_DESCR_EVT:
            //获取特征描述符
            printf("get descr %s, handle %d\n", descr_elem_result->uuid.uuid.uuid16, descr_elem_result->descr_handle);
            descr_handle = descr_elem_result->descr_handle;
            //开启特征通知
            esp_ble_gattc_register_for_notify(gattc_if, remote_bda, char_handle);
            break;
        case ESP_GATTC_REG_FOR_NOTIFY_EVT:
            //注册通知事件
            printf("register for notify\n");
            break;
        case ESP_GATTC_NOTIFY_EVT:
            //接收到通知
            printf("receive notify value:");
            esp_log_buffer_hex(GATTC_TAG, param->notify.value, param->notify.value_len);
            break;
        default:
            break;
    }
}

void gatt_client_init(void)
{
    //GATT参数初始化
    esp_err_t ret;
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) {
        printf("%s initialize controller failed\n", __func__);
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BTDM);
    if (ret) {
        printf("%s enable controller failed\n", __func__);
        return;
    }

    ret = esp_bluedroid_init();
    if (ret) {
        printf("%s init bluetooth failed\n", __func__);
        return;
    }

    ret = esp_bluedroid_enable();
    if (ret) {
        printf("%s enable bluetooth failed\n", __func__);
        return;
    }

    //GATT事件注册
    esp_ble_gattc_register_callback(gattc_event_handler);
    esp_ble_gattc_app_register(0);

    //开始扫描
    esp_ble_gap_start_scanning(10);
}

void app_main()
{
    gatt_client_init();
}

以上代码仅供参考，实际使用中需要根据具体情况进行调整。