Bluetooth classic for micropython using BTStack

[LeoStefa02]

I'm new to micropython but I understood that it's possible to add new features adding external C modules. The BTStack project of BlueKitchen GmbH (https://github.com/bluekitchen/btstack) offers a port for the ESP32 so I was wandering if it is possible to add what BTStack offers in micropython especially the HFP (hands free profile). I managed to use the a2dp profile in python using the C code from ESP-IDF and adding it as an external module. The fact is that the code I wrote for the module is not well written and maybe it's possible with some more experienced fellow to do a better work.

#include <string.h>
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "esp_gap_bt_api.h"
#include "esp_a2dp_api.h"
#include "py/runtime.h"
#include "esp_bt.h"

#ifndef MICROPY_INCLUDED_ESP32_A2DP_H
#define MICROPY_INCLUDED_ESP32_A2DP_H

static esp_bd_addr_t target_bda;

static mp_obj_t init() {
    // Release BLE memory (we only need Classic Bluetooth)
    esp_bt_controller_mem_release(ESP_BT_MODE_BLE);

    // Configure and initialize Bluetooth controller
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    esp_bt_controller_init(&bt_cfg);
    esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT);

    // Initialize and enable the Bluedroid stack
    esp_bluedroid_init();
    esp_bluedroid_enable();

    return mp_obj_new_bool(true);
}

static MP_DEFINE_CONST_FUN_OBJ_0(init_obj, init);

char target_device_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1] = {0};

// GAP Callback: Discover and connect to the target device
static void bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param) {
    if (event == ESP_BT_GAP_DISC_RES_EVT) {
        uint8_t *eir = NULL;
        char device_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1] = {0};

        for (int i = 0; i < param->disc_res.num_prop; i++) {
            esp_bt_gap_dev_prop_t *prop = param->disc_res.prop + i;
            if (prop->type == ESP_BT_GAP_DEV_PROP_EIR) {
                eir = (uint8_t *)prop->val;
                uint8_t name_len = 0;
                uint8_t *name = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &name_len);
                if (!name) {
                    name = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &name_len);
                }
                if (name) {
                    snprintf(device_name, name_len + 1, "%s", name);
                    if (strcmp(device_name, target_device_name) == 0) {
                        memcpy(target_bda, param->disc_res.bda, ESP_BD_ADDR_LEN);
                        esp_bt_gap_cancel_discovery();
                        esp_a2d_source_connect(target_bda);
                        return;
                    }
                }
            }
        }
    }
}

static mp_obj_t connect(mp_obj_t target_name) {
    const char *name = mp_obj_str_get_str(target_name);
    esp_bt_gap_set_device_name("ESP32");

    // Copy the string into the device_name array
    strncpy(target_device_name, name, sizeof(target_device_name) - 1);
    // Register callback
    esp_bt_gap_register_callback(bt_gap_cb);
    esp_a2d_source_init();
    esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);

    return mp_obj_new_bool(true); 
}

static MP_DEFINE_CONST_FUN_OBJ_1(connect_obj, connect);

static const mp_rom_map_elem_t a2dp_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_a2dp) },
    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&init_obj) },
    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&connect_obj) },
};
static MP_DEFINE_CONST_DICT(a2dp_module_globals, a2dp_module_globals_table);

// Define module object.
const mp_obj_module_t a2dp_user_cmodule = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t *)&a2dp_module_globals,
};

MP_REGISTER_MODULE(MP_QSTR_a2dp, a2dp_user_cmodule);

#endif

This code initiate bluetooth for a2dp and then connect to a device. For a project I need to use the HFP but the code offered by ESP-IDF doesn't work so BTStack is needed. I managed to use the code from BTStack for HFP but using it in micropython would be awesome.

[mattytrentini]

You may also be interested in esp32-bluetooth-classic-micropython.

[LeoStefa02]

I saw the project but it uses the ESP-IDF framework that doesn't support HFP : (. Also the readme of the project says that it can't run wifi along BT classic and it would be a nice thing to use both simultaneously.

[shariltumin]

Maybe this is what you are looking for

https://github.com/espressif/esp-idf/blob/master/examples/bluetooth/bluedroid/classic_bt/hfp_hf/README.md

[LeoStefa02]

Yes in theory this should work but it doesn't keep the connection with the HF device. I saw also a video on youtube of a guy that says the same thing (https://www.youtube.com/watch?v=0jR-QNTfydA&pp=ygUUbWljcm9waG9uZSBoZnAgZXNwMzI%3D). So BTStack is needed and I managed to compile an example and use it to connect the esp32 to my headphones and send some data but I'd like to make the same thing from micropython. And being new to micropython implementing BTStack as an external module doesn't seem so easy.