feat: 添加经典蓝牙

qianjiang/QJ500_7C_partitions_two_ota.csv

@@ -3,5 +3,5 @@
 nvs,      data, nvs,     ,        0x4000,
 otadata,  data, ota,     ,        0x2000,
 phy_init, data, phy,     ,        0x1000,
-ota_0,    app,  ota_0,   ,        1536K,
-ota_1,    app,  ota_1,   ,        1536K,
\ No newline at end of file
+ota_0,    app,  ota_0,   ,        0x800K,
+ota_1,    app,  ota_1,   ,        0x800K,
\ No newline at end of file

qianjiang/main/CMakeLists.txt

 # Embed the server root certificate into the final binary
 idf_build_get_property(project_dir PROJECT_DIR)
-idf_component_register(SRCS "gatts_table_creat_demo.c"
+idf_component_register(SRCS "bt_app_main.c" "bt_app_hf.c" "bt_app_core.c" "gatts_table_creat_demo.c"
                     "simple_ota_example.c"
                     "Protocol_CRC16.c"
                     "Protocol_Lib.c"

qianjiang/main/bt_app_core.c

+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include "freertos/xtensa_api.h"
+#include "freertos/FreeRTOSConfig.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "bt_app_core.h"
+
+static void bt_app_task_handler(void *arg);
+static bool bt_app_send_msg(bt_app_msg_t *msg);
+static void bt_app_work_dispatched(bt_app_msg_t *msg);
+
+static QueueHandle_t bt_app_task_queue = NULL;
+static TaskHandle_t bt_app_task_handle = NULL;
+
+bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback)
+{
+    ESP_LOGD(BT_APP_CORE_TAG, "%s event 0x%x, param len %d", __func__, event, param_len);
+
+    bt_app_msg_t msg;
+    memset(&msg, 0, sizeof(bt_app_msg_t));
+
+    msg.sig = BT_APP_SIG_WORK_DISPATCH;
+    msg.event = event;
+    msg.cb = p_cback;
+
+    if (param_len == 0) {
+        return bt_app_send_msg(&msg);
+    } else if (p_params && param_len > 0) {
+        if ((msg.param = malloc(param_len)) != NULL) {
+            memcpy(msg.param, p_params, param_len);
+            /* check if caller has provided a copy callback to do the deep copy */
+            if (p_copy_cback) {
+                p_copy_cback(&msg, msg.param, p_params);
+            }
+            return bt_app_send_msg(&msg);
+        }
+    }
+
+    return false;
+}
+
+static bool bt_app_send_msg(bt_app_msg_t *msg)
+{
+    if (msg == NULL) {
+        return false;
+    }
+
+    if (xQueueSend(bt_app_task_queue, msg, 10 / portTICK_PERIOD_MS) != pdTRUE) {
+        ESP_LOGE(BT_APP_CORE_TAG, "%s xQueue send failed", __func__);
+        return false;
+    }
+    return true;
+}
+
+static void bt_app_work_dispatched(bt_app_msg_t *msg)
+{
+    if (msg->cb) {
+        msg->cb(msg->event, msg->param);
+    }
+}
+
+static void bt_app_task_handler(void *arg)
+{
+    bt_app_msg_t msg;
+    for (;;) {
+        if (pdTRUE == xQueueReceive(bt_app_task_queue, &msg, (TickType_t)portMAX_DELAY)) {
+            ESP_LOGD(BT_APP_CORE_TAG, "%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
+            switch (msg.sig) {
+                case BT_APP_SIG_WORK_DISPATCH:
+                {
+                    bt_app_work_dispatched(&msg);
+                    break;
+                }
+
+                default:
+                    ESP_LOGW(BT_APP_CORE_TAG, "%s, unhandled sig: %d", __func__, msg.sig);
+                    break;
+            } // switch (msg.sig)
+
+            if (msg.param) {
+                free(msg.param);
+            }
+        }
+    }
+}
+
+void bt_app_task_start_up(void)
+{
+    bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
+    xTaskCreate(bt_app_task_handler, "BtAppT", 2048, NULL, configMAX_PRIORITIES - 3, &bt_app_task_handle);
+    return;
+}
+
+void bt_app_task_shut_down(void)
+{
+    if (bt_app_task_handle) {
+        vTaskDelete(bt_app_task_handle);
+        bt_app_task_handle = NULL;
+    }
+    if (bt_app_task_queue) {
+        vQueueDelete(bt_app_task_queue);
+        bt_app_task_queue = NULL;
+    }
+}

qianjiang/main/bt_app_core.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef __BT_APP_CORE_H__
+#define __BT_APP_CORE_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#define BT_APP_CORE_TAG                   "BT_APP_CORE"
+
+#define BT_APP_SIG_WORK_DISPATCH          (0x01)
+
+/**
+ * @brief     handler for the dispatched work
+ */
+typedef void (* bt_app_cb_t) (uint16_t event, void *param);
+
+/* message to be sent */
+typedef struct {
+    uint16_t             sig;      /*!< signal to bt_app_task */
+    uint16_t             event;    /*!< message event id */
+    bt_app_cb_t          cb;       /*!< context switch callback */
+    void                 *param;   /*!< parameter area needs to be the last */
+} bt_app_msg_t;
+
+/**
+ * @brief     parameter deep-copy function to be customized
+ */
+typedef void (* bt_app_copy_cb_t) (bt_app_msg_t *msg, void *p_dest, void *p_src);
+
+/**
+ * @brief     work dispatcher for the application task
+ */
+bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback);
+
+void bt_app_task_start_up(void);
+
+void bt_app_task_shut_down(void);
+
+#endif /* __BT_APP_CORE_H__ */

qianjiang/main/bt_app_hf.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef __BT_APP_HF_H__
+#define __BT_APP_HF_H__
+
+#include <stdint.h>
+#include "esp_hf_client_api.h"
+
+
+#define BT_HF_TAG               "BT_HF"
+
+/**
+ * @brief     callback function for HF client
+ */
+void bt_app_hf_client_cb(esp_hf_client_cb_event_t event, esp_hf_client_cb_param_t *param);
+
+
+#endif /* __BT_APP_HF_H__*/

qianjiang/main/bt_app_main.c

+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <inttypes.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 "bt_app_core.h"
+#include "esp_bt_main.h"
+#include "esp_bt_device.h"
+#include "esp_gap_bt_api.h"
+#include "esp_hf_client_api.h"
+#include "bt_app_hf.h"
+// #include "gpio_pcm_config.h"
+#include "esp_console.h"
+// #include "app_hf_msg_set.h"
+
+esp_bd_addr_t peer_addr = {0};
+static char peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
+static uint8_t peer_bdname_len;
+
+static const char remote_device_name[] = "ESP_HFP_AG";
+
+static bool get_name_from_eir(uint8_t *eir, char *bdname, uint8_t *bdname_len)
+{
+    uint8_t *rmt_bdname = NULL;
+    uint8_t rmt_bdname_len = 0;
+
+    if (!eir) {
+        return false;
+    }
+
+    rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &rmt_bdname_len);
+    if (!rmt_bdname) {
+        rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &rmt_bdname_len);
+    }
+
+    if (rmt_bdname) {
+        if (rmt_bdname_len > ESP_BT_GAP_MAX_BDNAME_LEN) {
+            rmt_bdname_len = ESP_BT_GAP_MAX_BDNAME_LEN;
+        }
+
+        if (bdname) {
+            memcpy(bdname, rmt_bdname, rmt_bdname_len);
+            bdname[rmt_bdname_len] = '\0';
+        }
+        if (bdname_len) {
+            *bdname_len = rmt_bdname_len;
+        }
+        return true;
+    }
+
+    return false;
+}
+
+void esp_bt_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: {
+        for (int i = 0; i < param->disc_res.num_prop; i++){
+            if (param->disc_res.prop[i].type == ESP_BT_GAP_DEV_PROP_EIR
+                && get_name_from_eir(param->disc_res.prop[i].val, peer_bdname, &peer_bdname_len)){
+                if (strcmp(peer_bdname, remote_device_name) == 0) {
+                    memcpy(peer_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
+                    ESP_LOGI(BT_HF_TAG, "Found a target device address: \n");
+                    esp_log_buffer_hex(BT_HF_TAG, peer_addr, ESP_BD_ADDR_LEN);
+                    ESP_LOGI(BT_HF_TAG, "Found a target device name: %s", peer_bdname);
+                    printf("Connect.\n");
+                    esp_hf_client_connect(peer_addr);
+                    esp_bt_gap_cancel_discovery();
+                }
+            }
+        }
+        break;
+    }
+    case ESP_BT_GAP_DISC_STATE_CHANGED_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_DISC_STATE_CHANGED_EVT");
+    case ESP_BT_GAP_RMT_SRVCS_EVT:
+    case ESP_BT_GAP_RMT_SRVC_REC_EVT:
+        break;
+    case ESP_BT_GAP_AUTH_CMPL_EVT: {
+        if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
+            ESP_LOGI(BT_HF_TAG, "authentication success: %s", param->auth_cmpl.device_name);
+            esp_log_buffer_hex(BT_HF_TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN);
+        } else {
+            ESP_LOGE(BT_HF_TAG, "authentication failed, status:%d", param->auth_cmpl.stat);
+        }
+        break;
+    }
+    case ESP_BT_GAP_PIN_REQ_EVT: {
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_PIN_REQ_EVT min_16_digit:%d", param->pin_req.min_16_digit);
+        if (param->pin_req.min_16_digit) {
+            ESP_LOGI(BT_HF_TAG, "Input pin code: 0000 0000 0000 0000");
+            esp_bt_pin_code_t pin_code = {0};
+            esp_bt_gap_pin_reply(param->pin_req.bda, true, 16, pin_code);
+        } else {
+            ESP_LOGI(BT_HF_TAG, "Input pin code: 1234");
+            esp_bt_pin_code_t pin_code;
+            pin_code[0] = '1';
+            pin_code[1] = '2';
+            pin_code[2] = '3';
+            pin_code[3] = '4';
+            esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pin_code);
+        }
+        break;
+    }
+
+#if (CONFIG_BT_SSP_ENABLED == true)
+    case ESP_BT_GAP_CFM_REQ_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %"PRIu32, param->cfm_req.num_val);
+        esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
+        break;
+    case ESP_BT_GAP_KEY_NOTIF_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey:%"PRIu32, param->key_notif.passkey);
+        break;
+    case ESP_BT_GAP_KEY_REQ_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
+        break;
+#endif
+
+    case ESP_BT_GAP_MODE_CHG_EVT:
+        ESP_LOGI(BT_HF_TAG, "ESP_BT_GAP_MODE_CHG_EVT mode:%d", param->mode_chg.mode);
+        break;
+
+    default: {
+        ESP_LOGI(BT_HF_TAG, "event: %d", event);
+        break;
+    }
+    }
+    return;
+}
+
+/* event for handler "bt_av_hdl_stack_up */
+enum {
+    BT_APP_EVT_STACK_UP = 0,
+};
+
+/* handler for bluetooth stack enabled events */
+static void bt_hf_client_hdl_stack_evt(uint16_t event, void *p_param);
+
+void bt_app_main_init(void)
+{
+    /* Initialize NVS — it is used to store PHY calibration data */
+    esp_err_t ret = nvs_flash_init();
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES) {
+        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_BLE));
+
+    esp_err_t err;
+    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+    if ((err = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    if ((err = esp_bt_controller_enable(ESP_BT_MODE_BTDM)) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    if ((err = esp_bluedroid_init()) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s initialize bluedroid failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    if ((err = esp_bluedroid_enable()) != ESP_OK) {
+        ESP_LOGE(BT_HF_TAG, "%s enable bluedroid failed: %s\n", __func__, esp_err_to_name(ret));
+        return;
+    }
+
+    /* create application task */
+    bt_app_task_start_up();
+
+    /* Bluetooth device name, connection mode and profile set up */
+    bt_app_work_dispatch(bt_hf_client_hdl_stack_evt, BT_APP_EVT_STACK_UP, NULL, 0, NULL);
+
+#if CONFIG_BT_HFP_AUDIO_DATA_PATH_PCM
+    /* configure the PCM interface and PINs used */
+    // app_gpio_pcm_io_cfg();
+#endif
+
+    /* configure externel chip for acoustic echo cancellation */
+#if ACOUSTIC_ECHO_CANCELLATION_ENABLE
+    // app_gpio_aec_io_cfg();
+#endif /* ACOUSTIC_ECHO_CANCELLATION_ENABLE */
+    // esp_console_repl_t *repl = NULL;
+    // esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
+    // esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
+    // repl_config.prompt = "hfp_hf>";
+
+    // // init console REPL environment
+    // ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl));
+
+    /* Register commands */
+    // register_hfp_hf();
+    printf("\n ==================================================\n");
+    printf(" |       Steps to test hfp_hf                     |\n");
+    printf(" |                                                |\n");
+    printf(" |  1. Print 'help' to gain overview of commands  |\n");
+    printf(" |  2. Setup a service level connection           |\n");
+    printf(" |  3. Run hfp_hf to test                         |\n");
+    printf(" |                                                |\n");
+    printf(" =================================================\n\n");
+
+    // start console REPL
+    // ESP_ERROR_CHECK(esp_console_start_repl(repl));
+}
+
+
+static void bt_hf_client_hdl_stack_evt(uint16_t event, void *p_param)
+{
+    ESP_LOGD(BT_HF_TAG, "%s evt %d", __func__, event);
+    switch (event) {
+    case BT_APP_EVT_STACK_UP: {
+        /* set up device name */
+        char *dev_name = "ESP_HFP_HF";
+        esp_bt_dev_set_device_name(dev_name);
+
+        /* register GAP callback function */
+        esp_bt_gap_register_callback(esp_bt_gap_cb);
+        esp_hf_client_register_callback(bt_app_hf_client_cb);
+        esp_hf_client_init();
+
+        esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_FIXED;
+        esp_bt_pin_code_t pin_code;
+        pin_code[0] = '0';
+        pin_code[1] = '0';
+        pin_code[2] = '0';
+        pin_code[3] = '0';
+        esp_bt_gap_set_pin(pin_type, 4, pin_code);
+
+        /* set discoverable and connectable mode, wait to be connected */
+        esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
+
+        /* start device discovery */
+        ESP_LOGI(BT_HF_TAG, "Starting device discovery...");
+        esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
+        break;
+    }
+    default:
+        ESP_LOGE(BT_HF_TAG, "%s unhandled evt %d", __func__, event);
+        break;
+    }
+}

qianjiang/main/bt_app_main.h

+/*
+ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#ifndef BT_APP_MAN_H
+#define BT_APP_MAN_H
+
+void bt_app_main_init(void);
+#endif
\ No newline at end of file

qianjiang/main/gatts_table_creat_demo.c

@@ -935,39 +935,39 @@ void bsp_Ble_Init(void)
     Get_Mac_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 = 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){
@@ -1017,57 +1017,57 @@ void bsp_Ble_Init(void)
 
 
     /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/
-    esp_ble_auth_req_t auth_req = ESP_LE_AUTH_REQ_SC_MITM_BOND;     //bonding with peer device after authentication
-    esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE;           //set the IO capability to No output No input
-    uint8_t key_size = 16;      //the key size should be 7~16 bytes
-    uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
-    uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
-    //set static passkey
-    uint32_t passkey = 123456;
-    uint8_t auth_option = ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_DISABLE;
-    uint8_t oob_support = ESP_BLE_OOB_DISABLE;
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_STATIC_PASSKEY, &passkey, sizeof(uint32_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH, &auth_option, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_OOB_SUPPORT, &oob_support, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    /* If your BLE device acts as a Slave, the init_key means you hope which types of key of the master should distribute to you,
-    and the response key means which key you can distribute to the master;
-    If your BLE device acts as a master, the response key means you hope which types of key of the slave should distribute to you,
-    and the init key means which key you can distribute to the slave. */
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
-    ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t));
-    if(ret)
-    {
-        printf("!!!!!!!!!!!!!!\r\n");
-    }
+    // esp_ble_auth_req_t auth_req = ESP_LE_AUTH_REQ_SC_MITM_BOND;     //bonding with peer device after authentication
+    // esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE;           //set the IO capability to No output No input
+    // uint8_t key_size = 16;      //the key size should be 7~16 bytes
+    // uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
+    // uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK;
+    // //set static passkey
+    // uint32_t passkey = 123456;
+    // uint8_t auth_option = ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_DISABLE;
+    // uint8_t oob_support = ESP_BLE_OOB_DISABLE;
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_STATIC_PASSKEY, &passkey, sizeof(uint32_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH, &auth_option, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_OOB_SUPPORT, &oob_support, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // /* If your BLE device acts as a Slave, the init_key means you hope which types of key of the master should distribute to you,
+    // and the response key means which key you can distribute to the master;
+    // If your BLE device acts as a master, the response key means you hope which types of key of the slave should distribute to you,
+    // and the init key means which key you can distribute to the slave. */
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
+    // ret = esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t));
+    // if(ret)
+    // {
+    //     printf("!!!!!!!!!!!!!!\r\n");
+    // }
 }

qianjiang/main/main_user.c

@@ -12,6 +12,7 @@
 #include "main_user.h"
 #include "Protocol_CRC16.h"
 #include "Protocol_User.h"
+#include "bt_app_main.h"
 
 #define TAG "MAIN_USER"
 
@@ -97,6 +98,7 @@ static void Sys_Run_Tasks(void *arg)
 
 void app_main(void)
 {
+    bt_app_main_init();
     Ble_User_Init();
     bsp_Ble_Init();
     bsp_Uart_Init();

qianjiang/sdkconfig

@@ -421,9 +421,20 @@ CONFIG_BT_BTC_TASK_STACK_SIZE=3072
 CONFIG_BT_BLUEDROID_PINNED_TO_CORE_0=y
 # CONFIG_BT_BLUEDROID_PINNED_TO_CORE_1 is not set
 CONFIG_BT_BLUEDROID_PINNED_TO_CORE=0
-CONFIG_BT_BTU_TASK_STACK_SIZE=4096
+CONFIG_BT_BTU_TASK_STACK_SIZE=4352
 # CONFIG_BT_BLUEDROID_MEM_DEBUG is not set
-# CONFIG_BT_CLASSIC_ENABLED is not set
+CONFIG_BT_CLASSIC_ENABLED=y
+# CONFIG_BT_CLASSIC_BQB_ENABLED is not set
+# CONFIG_BT_A2DP_ENABLE is not set
+# CONFIG_BT_SPP_ENABLED is not set
+# CONFIG_BT_L2CAP_ENABLED is not set
+CONFIG_BT_HFP_ENABLE=y
+CONFIG_BT_HFP_CLIENT_ENABLE=y
+CONFIG_BT_HFP_AG_ENABLE=y
+CONFIG_BT_HFP_AUDIO_DATA_PATH_PCM=y
+# CONFIG_BT_HFP_AUDIO_DATA_PATH_HCI is not set
+# CONFIG_BT_HID_ENABLED is not set
+CONFIG_BT_SSP_ENABLED=y
 CONFIG_BT_BLE_ENABLED=y
 CONFIG_BT_GATTS_ENABLE=y
 # CONFIG_BT_GATTS_PPCP_CHAR_GAP is not set
@@ -636,16 +647,28 @@ CONFIG_BT_BLE_RPA_TIMEOUT=900
 #
 # Controller Options
 #
-CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
+# CONFIG_BTDM_CTRL_MODE_BLE_ONLY is not set
 # CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY is not set
-# CONFIG_BTDM_CTRL_MODE_BTDM is not set
+CONFIG_BTDM_CTRL_MODE_BTDM=y
 CONFIG_BTDM_CTRL_BLE_MAX_CONN=3
-CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_EFF=0
+CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN=2
+CONFIG_BTDM_CTRL_BR_EDR_MAX_SYNC_CONN=2
+# CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_HCI is not set
+CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_PCM=y
+CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_EFF=1
+CONFIG_BTDM_CTRL_PCM_ROLE_EDGE_CONFIG=y
+CONFIG_BTDM_CTRL_PCM_ROLE_MASTER=y
+# CONFIG_BTDM_CTRL_PCM_ROLE_SLAVE is not set
+CONFIG_BTDM_CTRL_PCM_POLAR_FALLING_EDGE=y
+# CONFIG_BTDM_CTRL_PCM_POLAR_RISING_EDGE is not set
 CONFIG_BTDM_CTRL_PCM_ROLE_EFF=0
 CONFIG_BTDM_CTRL_PCM_POLAR_EFF=0
+# CONFIG_BTDM_CTRL_AUTO_LATENCY is not set
+CONFIG_BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT=y
+CONFIG_BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT_EFF=y
 CONFIG_BTDM_CTRL_BLE_MAX_CONN_EFF=3
-CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN_EFF=0
-CONFIG_BTDM_CTRL_BR_EDR_MAX_SYNC_CONN_EFF=0
+CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN_EFF=2
+CONFIG_BTDM_CTRL_BR_EDR_MAX_SYNC_CONN_EFF=2
 CONFIG_BTDM_CTRL_PINNED_TO_CORE_0=y
 # CONFIG_BTDM_CTRL_PINNED_TO_CORE_1 is not set
 CONFIG_BTDM_CTRL_PINNED_TO_CORE=0
@@ -1313,16 +1336,15 @@ CONFIG_HEAP_TRACING_OFF=y
 #
 # CONFIG_LOG_DEFAULT_LEVEL_NONE is not set
 # CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set
-CONFIG_LOG_DEFAULT_LEVEL_WARN=y
-# CONFIG_LOG_DEFAULT_LEVEL_INFO is not set
+# CONFIG_LOG_DEFAULT_LEVEL_WARN is not set
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
 # CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set
 # CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set
-CONFIG_LOG_DEFAULT_LEVEL=2
+CONFIG_LOG_DEFAULT_LEVEL=3
 CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT=y
-# CONFIG_LOG_MAXIMUM_LEVEL_INFO is not set
 # CONFIG_LOG_MAXIMUM_LEVEL_DEBUG is not set
 # CONFIG_LOG_MAXIMUM_LEVEL_VERBOSE is not set
-CONFIG_LOG_MAXIMUM_LEVEL=2
+CONFIG_LOG_MAXIMUM_LEVEL=3
 CONFIG_LOG_COLORS=y
 CONFIG_LOG_TIMESTAMP_SOURCE_RTOS=y
 # CONFIG_LOG_TIMESTAMP_SOURCE_SYSTEM is not set
@@ -1912,9 +1934,15 @@ CONFIG_BTC_TASK_STACK_SIZE=3072
 CONFIG_BLUEDROID_PINNED_TO_CORE_0=y
 # CONFIG_BLUEDROID_PINNED_TO_CORE_1 is not set
 CONFIG_BLUEDROID_PINNED_TO_CORE=0
-CONFIG_BTU_TASK_STACK_SIZE=4096
+CONFIG_BTU_TASK_STACK_SIZE=4352
 # CONFIG_BLUEDROID_MEM_DEBUG is not set
-# CONFIG_CLASSIC_BT_ENABLED is not set
+CONFIG_CLASSIC_BT_ENABLED=y
+# CONFIG_A2DP_ENABLE is not set
+CONFIG_HFP_ENABLE=y
+CONFIG_HFP_CLIENT_ENABLE=y
+CONFIG_HFP_AG_ENABLE=y
+CONFIG_HFP_AUDIO_DATA_PATH_PCM=y
+# CONFIG_HFP_AUDIO_DATA_PATH_HCI is not set
 CONFIG_GATTS_ENABLE=y
 # CONFIG_GATTS_SEND_SERVICE_CHANGE_MANUAL is not set
 CONFIG_GATTS_SEND_SERVICE_CHANGE_AUTO=y
@@ -2088,13 +2116,15 @@ CONFIG_BLUFI_INITIAL_TRACE_LEVEL=2
 CONFIG_SMP_ENABLE=y
 # CONFIG_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY is not set
 CONFIG_BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT=30
-CONFIG_BTDM_CONTROLLER_MODE_BLE_ONLY=y
+# CONFIG_BTDM_CONTROLLER_MODE_BLE_ONLY is not set
 # CONFIG_BTDM_CONTROLLER_MODE_BR_EDR_ONLY is not set
-# CONFIG_BTDM_CONTROLLER_MODE_BTDM is not set
+CONFIG_BTDM_CONTROLLER_MODE_BTDM=y
 CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN=3
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_ACL_CONN=2
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_SYNC_CONN=2
 CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN_EFF=3
-CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_ACL_CONN_EFF=0
-CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_SYNC_CONN_EFF=0
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_ACL_CONN_EFF=2
+CONFIG_BTDM_CONTROLLER_BR_EDR_MAX_SYNC_CONN_EFF=2
 CONFIG_BTDM_CONTROLLER_PINNED_TO_CORE=0
 CONFIG_BTDM_CONTROLLER_HCI_MODE_VHCI=y
 # CONFIG_BTDM_CONTROLLER_HCI_MODE_UART_H4 is not set