pikascript/package/bluetooth/_bluetooth.c

#include "pikaScript.h"
#include "nimble/ble.h"
#include "nimble/nimble_port.h"
#include "nimble/nimble_port_freertos.h"
// #include "nimble/host/include/host/ble_gap.h"
#include "host/ble_hs.h"
#include "host/util/util.h"
#include "services/gap/ble_svc_gap.h"
#include "services/gatt/ble_svc_gatt.h"
#include "services/ans/ble_svc_ans.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_log.h"
// #include "ble_uuid.h"
#include "cb_event_id.h"
// TODO:发布的时候怎么将printf隐藏掉

#define printf pika_platform_printf

ble_uuid_any_t GAP_UUID = {
    .u.type = 0,
    .u16.value = 0x0000
};

// BLE_UUID_base = 0x00000000-0000-1000-8000-00805F9B34FB;

static const char *tag = "NimBLE_BLE";

bool BLE_ONLY = false;                           //只使用BLE,默认否
bool FLASH_FIRST_INIT = true;                    //是否第一次初始化,默认是
bool BLE_INIT   = false;                         //蓝牙是否初始化,默认不是
PikaEventListener *g_pika_ble_listener = NULL;   //事件监听器
int  g_ble_addr_mode    = 0;                     //地址模式
bool g_ble_connectable  = 1;                     //是否可连接 
int  g_interval = 0;                             //间隔
bool g_new_service = 0;                          //间隔有新服务
uint8_t g_all_chr_count = 0;                     //全部特性数量
uint16_t * g_chrs_handle = NULL;                 //特性句柄数组
struct ble_gatt_svc_def* gatt_svr_svcs = NULL;   // BLE服务句柄，TODO:用于释放对应空间


// 函数声明
// GATT 服务端回调函数
static int ble_gatt_svc_access_cb(uint16_t conn_handle, uint16_t attr_handle,struct ble_gatt_access_ctxt *ctxt, void *arg);

// GATT 客户端写回调函数
static int ble_gatt_client_write_cb(uint16_t conn_handle,
                       const struct ble_gatt_error *error,
                       struct ble_gatt_attr *attr,
                       void *arg);

// GATT 客户端读回调函数
static int ble_gatt_client_read_cb(uint16_t conn_handle,
                       const struct ble_gatt_error *error,
                       struct ble_gatt_attr *attr,
                       void *arg);

// GATT mtu_exchange回调函数
static int ble_gatt_mtu_exchange_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            uint16_t mtu, void *arg);

// GATT 查找所有服务回调函数
static int ble_gatt_disc_all_svcs_cb(uint16_t conn_handle,
                                 const struct ble_gatt_error *error,
                                 const struct ble_gatt_svc *service,
                                 void *arg);

// GATT 查找所有服务回调函数
static int ble_gatt_disc_svcs_by_uuid_cb(uint16_t conn_handle,
                                 const struct ble_gatt_error *error,
                                 const struct ble_gatt_svc *service,
                                 void *arg);

// GATT 查找所有特性回调函数
static int ble_gatt_disc_all_chrs_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            const struct ble_gatt_chr *chr, void *arg);

// GATT 查找特定UUID特性回调函数
static int ble_gatt_disc_chrs_by_uuid_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            const struct ble_gatt_chr *chr, void *arg);

// GATT 查找所有描述符回调函数
static int ble_gatt_disc_all_dscs_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            uint16_t chr_val_handle,
                            const struct ble_gatt_dsc *dsc, void *arg);

// GAP层回调函数
static int ble_gap_event_cb(struct ble_gap_event *event, void *arg);

// gatt初始化基本服务
void gatt_svr_init(void);

// 从字符串中读取UUID
int read_uuid_from_str(char* buf, int len, ble_uuid_any_t* uuid_struct);

// 反转数组
void data_inver(const void *addr,uint8_t *addr_inver,uint8_t size);

int _bluetooth_BLE_adv(int interval);

// 填充UUID
int fill_UUID(ble_uuid_any_t* UUID,int UUID_bytes, uint8_t* bytes_UUID)
{
    if(UUID_bytes == 2){
        UUID->u.type       = BLE_UUID_TYPE_16;
        UUID->u16.value    = bytes_UUID[0] << 8 | bytes_UUID[1];
    }else if(UUID_bytes == 4) {
        UUID->u.type       = BLE_UUID_TYPE_32;
        UUID->u32.value    = bytes_UUID[0] << 24 | bytes_UUID[1] << 16 | bytes_UUID[2] << 8 | bytes_UUID[3];
    }else{
        UUID->u.type       = BLE_UUID_TYPE_128;
        data_inver(bytes_UUID,UUID->u128.value,16);
    }
    return 0;
}

// 蓝牙任务
void ble_host_task(void *param)
{
    ESP_LOGI(tag, "BLE Host Task Started");
    /* This function will return only when nimble_port_stop() is executed */
    nimble_port_run();
    nimble_port_freertos_deinit();
}

// 获取地址类型
uint8_t get_addr_type(int addr_mode)
{
    uint8_t own_addr_type;
    switch (addr_mode) {
        case 0:
            own_addr_type = BLE_OWN_ADDR_PUBLIC;
            break;
        case 1:
            own_addr_type = BLE_OWN_ADDR_RANDOM;
            break;
        case 2:
            own_addr_type = BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT;
            break;
        case 3:
            own_addr_type = BLE_OWN_ADDR_RPA_RANDOM_DEFAULT;
            break;
    }
    return own_addr_type;
}

// int _bluetooth_BLE_init(PikaObj *self)
int _bluetooth_BLE_init(PikaObj *self)
{
    printf("_bluetooth_BLE___init__\r\n");
    if (FLASH_FIRST_INIT)
    {
        //初始化flash
        esp_err_t 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);
        FLASH_FIRST_INIT = false;
    }
    return 1;
}

pika_bool _bluetooth_BLE_pyi_active(PikaObj *self, pika_bool active)
{
    printf("_bluetooth_BLE_pyi_active\r\n");
    if(active == true){
        //开始任务
        // nimble_port_freertos_init(ble_host_task);
        // 初始化堆栈
        // TODO: 多蓝牙对象时会报错
        // printf("ble_hs_is_enabled : %d\r\n",ble_hs_is_enabled());
        if(!BLE_INIT){
            nimble_port_init();
            BLE_INIT = true;
        }
        return true;
    }else {
        if(BLE_INIT){
            nimble_port_deinit();
            BLE_INIT = false;
        }
        // nimble_port_stop();
        return false;
    }
}

pika_bool _bluetooth_BLE_pyi_check_active(PikaObj *self)
{
    printf("_bluetooth_BLE_pyi_check_active\r\n");
    return BLE_INIT;
}

int _bluetooth_BLE_pyi_test(PikaObj *self)
{
    printf("_bluetooth_BLE_test\r\n");
    return 1;
}

void data_inver(const void *addr,uint8_t *addr_inver,uint8_t size)
{
    const uint8_t *u8p;
    u8p = addr;
    for ( int i = 0; i < size; i++){
        addr_inver[i] =  u8p[size - i - 1];
    }
}

void print_addr(const void *addr)
{
    const uint8_t *u8p;
    u8p = addr;
    printf("%02x:%02x:%02x:%02x:%02x:%02x\r\n",u8p[5], u8p[4], u8p[3], u8p[2], u8p[1], u8p[0]);
}

void print_uuid_128(uint8_t *uuid)
{
    for (size_t i = 0; i < 16; i++)
        {
            printf("%02x",uuid[15 - i]);
        }
        printf("\r\n");
}

void print_data(uint8_t *data,uint8_t count)
{
    for (size_t i = 0; i < count; i++)
        {
            printf("%02x",data[i]);
        }
        printf("\r\n");
}

/**
 * Logs information about a connection to the console.
 */
static void print_conn_desc(struct ble_gap_conn_desc *desc)
{
    MODLOG_DFLT(INFO, "handle=%d our_ota_addr_type=%d our_ota_addr=",
                desc->conn_handle, desc->our_ota_addr.type);
    print_addr(desc->our_ota_addr.val);
    MODLOG_DFLT(INFO, " our_id_addr_type=%d our_id_addr=",
                desc->our_id_addr.type);
    print_addr(desc->our_id_addr.val);
    MODLOG_DFLT(INFO, " peer_ota_addr_type=%d peer_ota_addr=",
                desc->peer_ota_addr.type);
    print_addr(desc->peer_ota_addr.val);
    MODLOG_DFLT(INFO, " peer_id_addr_type=%d peer_id_addr=",
                desc->peer_id_addr.type);
    print_addr(desc->peer_id_addr.val);
    MODLOG_DFLT(INFO, " conn_itvl=%d conn_latency=%d supervision_timeout=%d "
                "encrypted=%d authenticated=%d bonded=%d\r\n",
                desc->conn_itvl, desc->conn_latency,
                desc->supervision_timeout,
                desc->sec_state.encrypted,
                desc->sec_state.authenticated,
                desc->sec_state.bonded);
}

// pyi 绑定的advertise函数
int _bluetooth_BLE_advertise(PikaObj *self, int addr, int interval, pika_bool connectable, 
        uint8_t * adv_data, int adv_data_len, pika_bool adv_data_append, uint8_t * rsp_data, int rsp_data_len)
{
    // 如果注册服务之后nimble_port_freertos_init了，就不需要再此处调用
    nimble_port_freertos_init(ble_host_task);
    printf("_bluetooth_BLE_gap_advertise\r\n");
    //  声明并初始化广播结构体
    struct ble_hs_adv_fields fields;
    memset(&fields, 0, sizeof fields);

    fields.flags = BLE_HS_ADV_F_DISC_GEN ;
    if(BLE_ONLY  == true){
        fields.flags |= BLE_HS_ADV_F_BREDR_UNSUP;
    }

    // 添加广播数据
    if(adv_data_append == true) // 添加0XFF自定义数据
    {
        fields.tx_pwr_lvl_is_present = 0;
        fields.tx_pwr_lvl = BLE_HS_ADV_TX_PWR_LVL_AUTO;

        char* name = ble_svc_gap_device_name();
        fields.name = (uint8_t *)name;
        fields.name_len = strlen(name);
        fields.name_is_complete = 1;

        if (GAP_UUID.u.type != 0){
            if(GAP_UUID.u.type == BLE_UUID_TYPE_16){
                fields.uuids16 = &GAP_UUID;
                fields.num_uuids16 = 1;
                fields.uuids16_is_complete = 1;
            }
            else if (GAP_UUID.u.type == BLE_UUID_TYPE_32)
            {
                fields.uuids32 = &GAP_UUID;
                fields.num_uuids32 = 1;
                fields.uuids32_is_complete = 1;
            }else if (GAP_UUID.u.type == BLE_UUID_TYPE_128)
            {
                fields.uuids128 = &GAP_UUID;
                fields.num_uuids128 = 1;
                fields.uuids128_is_complete = 1;
            }  
        }

        if(adv_data_len > 0)
        {
            fields.mfg_data = (uint8_t *)adv_data;
            fields.mfg_data_len = adv_data_len;
        }

        int rc = ble_gap_adv_set_fields(&fields);
        if (rc != 0) {
            printf("error setting advertisement data; rc=%d\r\n", rc);
            return -1 ;
        }

    }else{ //所有数据都是自定义数据
        ble_gap_adv_set_data(adv_data,adv_data_len);
    }
    
    //设置rsp data
    if(rsp_data_len > 0) {
        uint8_t* rsp_data_new = (uint8_t*)malloc(rsp_data_len + 2);
        rsp_data_new[0] = rsp_data_len + 1;
        rsp_data_new[1] = 0xff;
        memcpy(rsp_data_new + 2, rsp_data, rsp_data_len); 
        int rc;
        rc =  ble_gap_adv_rsp_set_data(rsp_data_new,rsp_data_len+2);
        if (rc != 0) {
            printf("error setting advertisement response data; rc=%d\r\n", rc);
            free(rsp_data_new);
            return -1 ;
        }
        free(rsp_data_new);
    }

    // 设置全局变量
    g_ble_addr_mode = addr;
    g_ble_connectable = connectable;
    g_interval = interval;
    return _bluetooth_BLE_adv(interval);
}

//TODO:1. 换个命名 2.再次进行广播，之前的值应该清零？
// 在C文件里调用, 方便没有连接上的时候，能够恢复广播
int _bluetooth_BLE_adv(int interval) 
{
    printf("_bluetooth_BLE_adv\r\n");
    // 声明并初始化广播结构体
    struct ble_gap_adv_params *adv_params = NULL;
    adv_params = (struct ble_gap_adv_params *)calloc(1, sizeof(struct ble_gap_adv_params));
    
    uint8_t own_addr_type =  get_addr_type(g_ble_addr_mode);
    // 连接模式
    uint8_t connet_mode;
    if(g_ble_connectable == true){
        connet_mode = BLE_GAP_CONN_MODE_UND;
    }else {
        connet_mode = BLE_GAP_CONN_MODE_NON;
    }

    adv_params->conn_mode = connet_mode;
    adv_params->disc_mode = BLE_GAP_DISC_MODE_GEN;
    if(interval == 0){       // 默认值是104, 65ms
        adv_params->itvl_min = 0;
        adv_params->itvl_max = 0;
    }else if (interval < 35){  //需要大于35，
        adv_params->itvl_min = 35; 
        adv_params->itvl_max = 36; 
    }else{  
        adv_params->itvl_min = interval; 
        adv_params->itvl_max = interval + 1; //只能和adv_params.itvl_min差1
    }

    if(ble_gap_adv_active() == 1){    //是否原有广播任务
        printf("ble_gap_adv_stop\r\n");
        ble_gap_adv_stop();
    }

    int rc = ble_gap_adv_start(own_addr_type, NULL, BLE_HS_FOREVER, adv_params, ble_gap_event_cb, NULL);
    if(rc != 0)
        return rc;
    free(adv_params);

    // 清空服务信息结构体
    if(g_new_service == 1)
    {
        uint8_t *  one_bytes_handle;
        one_bytes_handle = (uint8_t *)malloc(g_all_chr_count);
        for (int i = 0; i < g_all_chr_count; i++)
        {
            one_bytes_handle[i] = g_chrs_handle[i];
        }
        
        // 将实际注册到的handle发送给python
        pika_eventListener_send(g_pika_ble_listener,_IRQ_DIY_REGISTER_HANDLE,
            arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_DIY_REGISTER_HANDLE),
                arg_newBytes(one_bytes_handle,g_all_chr_count)
                )));

        free(one_bytes_handle);

        // 释放内存空间的时候需要遍历结构体 
        // TODO:释放空间内存占比反而高了
        // struct ble_gatt_chr_def* gatt_svr_chrs;
        // struct ble_gatt_dsc_def* gatt_svr_dscs;
        // int i=0,j=0;
        // while (true){
        //     j = 0;
        //     if(gatt_svr_svcs[i].type == 0)        // 服务数量中止符
        //         break;
        //     else {
        //         gatt_svr_chrs = gatt_svr_svcs[i].characteristics;
        //         while (true){
        //             if(gatt_svr_chrs[j].uuid == 0) // 特性数量中止
        //                 break;
        //             else{
        //                 // free(gatt_svr_chrs[j].uuid); // 特性的UUID
        //                 gatt_svr_dscs = gatt_svr_chrs[j].descriptors;
        //                 free(gatt_svr_dscs);         // 特性的描述符
        //                 j++;}
        //             }
        //         // TODO:这里的uuid释放后，蓝牙连接断开时会报错 
        //         // free((ble_uuid_any_t*)gatt_svr_svcs[i].uuid); // 服务的UUID
        //         free(gatt_svr_chrs);         // 服务的特性
        //         i++;
        //     }
        // }
        // free(gatt_svr_svcs); // 服务组
        // gatt_svr_svcs = NULL;
        g_new_service = 0;
    }
    return 0;
}

// 停止广播
int _bluetooth_BLE_stop_advertise(PikaObj *self)
{
    printf("_bluetooth_BLE_stop_advertise\r\n");
    if(ble_gap_adv_active() == 1){
        return ble_gap_adv_stop();
    }else{
        return 0;
    }
}

int _bluetooth_BLE_pyi_gap_connect(PikaObj *self, uint8_t* peer_addr, int peer_addr_type, int scan_duration_ms)
{
    // nimble_port_freertos_init(ble_host_task);
    printf("_bluetooth_BLE_gap_connect\r\n");
    int rc = ble_gap_disc_active();
    if (rc != 0) {
        printf("Failed to cancel scan; rc=%d\n", rc);
        return rc;
    }

    uint8_t own_addr_type ;
    rc = ble_hs_id_infer_auto(0, &own_addr_type);
    printf("own_addr_type = %d\r\n", own_addr_type);
    
    if (rc != 0) {
        MODLOG_DFLT(ERROR, "error determining address type; rc=%d\n", rc);
        return rc;
    }

    ble_addr_t addr_peer = {
        .type = peer_addr_type,
    };
    
    data_inver(peer_addr,addr_peer.val,6);
    return ble_gap_connect(own_addr_type,&addr_peer,scan_duration_ms,NULL,ble_gap_event_cb,NULL);
}

int _bluetooth_BLE_pyi_gap_disconnect(PikaObj *self, int conn_handle)
{
    printf("_bluetooth_BLE_gap_disconnect\r\n");
    return ble_gap_terminate(conn_handle, BLE_ERR_REM_USER_CONN_TERM);
}

int _bluetooth_BLE_gap_disc(PikaObj *self, int addr_mode, int duration_ms, int interval, int window, pika_bool active)
{
    nimble_port_freertos_init(ble_host_task);
    printf("_bluetooth_BLE_gap_disc\r\n");
    // 获取地址类型                                             
    uint8_t own_addr_type =  get_addr_type(addr_mode);

    // 声明并初始化结构体实例
    struct ble_gap_disc_params disc_params = {
        .itvl = interval,
        .window = window,
        .passive = ~active,
        .limited = 0,
        .filter_duplicates = 0
    };

    if(ble_gap_disc_active() == 1)
        ble_gap_disc_cancel();

    if (duration_ms == 0){
        return ble_gap_disc(own_addr_type, BLE_HS_FOREVER, &disc_params, ble_gap_event_cb, NULL);
    }else{
        return ble_gap_disc(own_addr_type, duration_ms, &disc_params, ble_gap_event_cb, NULL);
    }
    
}

// 停止扫描
// TODO:不会引发扫描中止事件
int _bluetooth_BLE_gap_stop_disc(PikaObj *self)
{
    printf("_bluetooth_BLE_gap_stop_scan\r\n");
    return ble_gap_disc_cancel();
}

// 注册服务
int _bluetooth_BLE_gatts_register_svcs(PikaObj *self, PikaObj* services_info,int all_chr_count)
{
    // nimble_port_stop();
    printf("_bluetooth_BLE_gatts_register_svcs\r\n");
    ble_gatts_reset();                                //重置GATT服务
    g_new_service = 1;                                //有新服务
    g_all_chr_count = all_chr_count;                  //同步全部特性数量
    g_chrs_handle = (uint16_t * )calloc(g_all_chr_count,sizeof(uint16_t));

    if(g_chrs_handle == NULL){
        printf("calloc g_chrs_handle error\r\n");
        return -1;
    }

    size_t service_count , chr_count, dsc_count;
    uint8_t i,j,k;
    uint8_t  UUID_bytes,handle_index = 0;

    struct ble_gatt_chr_def* gatt_svr_chrs;
    struct ble_gatt_dsc_def* gatt_svr_dscs;

    service_count = pikaTuple_getSize(services_info);            //服务的个数,是不确定的
    // printf("services_info service_count = %d\r\n",service_count);

    gatt_svr_svcs = (struct ble_gatt_svc_def*) malloc((service_count + 1) * sizeof(struct ble_gatt_svc_def)); //申请空间
    if(gatt_svr_svcs == NULL){
        printf("malloc svcs memory error\r\n");
        return -1;
    }
    

    gatt_svr_svcs[service_count].type = 0; //服务数量中止

    for (i = 0;i < service_count;i++){                                            //对于每个服务
        PikaObj* service = arg_getObj(pikaTuple_getArg(services_info, i));        //读取服务
        uint8_t* service_bytes_UUID = arg_getBytes(pikaTuple_getArg(service,0));  //获取服务的UUID
        UUID_bytes   = arg_getInt(pikaTuple_getArg(service,1));                   //获取服务的UUID大小
        
        int service_struct_size = pikaTuple_getSize(service);

        if(service_struct_size == 2){ // 无属性
            // 设置服务
            ble_uuid_any_t* service_UUID = (ble_uuid_any_t*) malloc(sizeof(ble_uuid_any_t));
            if(service_UUID == NULL){
                printf("malloc service_UUID memory error\r\n");
                return -1;
            }
            gatt_svr_svcs[i].type = BLE_GATT_SVC_TYPE_PRIMARY;
            gatt_svr_svcs[i].characteristics = NULL;
            gatt_svr_svcs[i].uuid = &(service_UUID->u);
            gatt_svr_svcs[i].includes = NULL; //很关键
            
            fill_UUID(service_UUID,UUID_bytes,service_bytes_UUID);

        }else{ //有属性
            PikaObj* chrs = arg_getObj(pikaTuple_getArg(service, 2));                 //读取属性合集
            chr_count = pikaTuple_getSize(chrs);                                      // 属性的个数,是不确定的

            gatt_svr_chrs = (struct ble_gatt_chr_def*) malloc((chr_count  + 1)* sizeof(struct ble_gatt_chr_def)); //申请空间
            if(gatt_svr_chrs == NULL){
                printf("malloc chrs memory error\r\n");
                return -1;
            }    
            gatt_svr_chrs[chr_count].uuid = 0;    //特性数量中止

            // 设置服务
            ble_uuid_any_t* service_UUID = (ble_uuid_any_t*) malloc(sizeof(ble_uuid_any_t));
            if(service_UUID == NULL){
                printf("malloc service_UUID memory error\r\n");
                return -1;
            }

            gatt_svr_svcs[i].type = BLE_GATT_SVC_TYPE_PRIMARY;
            gatt_svr_svcs[i].characteristics = gatt_svr_chrs;
            gatt_svr_svcs[i].uuid = &(service_UUID->u);
            gatt_svr_svcs[i].includes = NULL; //很关键
            
            fill_UUID(service_UUID,UUID_bytes,service_bytes_UUID);
            // printf("service %d chrs size %d \r\n",i,chr_count);
            for (j = 0;j < chr_count;j++){                                                  // 对于每个属性
                PikaObj* chr = arg_getObj(pikaTuple_getArg(chrs, j));                       //读取属性

                uint8_t * chr_bytes_UUID = arg_getBytes(pikaTuple_getArg(chr,0));           //属性UUID
                uint8_t UUID_bytes = arg_getInt(pikaTuple_getArg(chr,1));                   //属性UUID大小
                uint64_t chr_flags = pikaTuple_getInt(chr,2);                               //属性FLAG   

                int chr_struct_size = pikaTuple_getSize(chr);
                if(chr_struct_size == 3){ // 无描述符
                    // 设置属性
                    ble_uuid_any_t* chr_UUID = (ble_uuid_any_t*) malloc(sizeof(ble_uuid_any_t));
                    if(chr_UUID == NULL){
                        printf("malloc chr_UUID memory error\r\n");
                        return -1;
                    }
                    gatt_svr_chrs[j].uuid        = &(chr_UUID->u);
                    gatt_svr_chrs[j].access_cb   = ble_gatt_svc_access_cb;
                    gatt_svr_chrs[j].arg         = self;
                    gatt_svr_chrs[j].flags       = chr_flags;
                    gatt_svr_chrs[j].descriptors = NULL;
                    gatt_svr_chrs[j].val_handle  = &(g_chrs_handle[handle_index]);//蓝牙同步之后,才会有有效值
                    fill_UUID(chr_UUID,UUID_bytes,chr_bytes_UUID);
                    handle_index++;
                }else{                    // 有描述符
                    PikaObj* dscs = arg_getObj(pikaTuple_getArg(chr, 3));                       // dscs = 描述符合集
                    dsc_count = pikaTuple_getSize(dscs);                                        //描述符的个数，是不确定的
                    gatt_svr_dscs = (struct ble_gatt_dsc_def*) malloc((dsc_count + 1 )* sizeof(struct ble_gatt_dsc_def)); //申请空间
                    if(gatt_svr_dscs == NULL){
                        printf("malloc dscs memory error\r\n");
                        return -1;
                    }

                    gatt_svr_dscs[dsc_count].uuid = 0; //描述符数量中止

                    // 设置属性
                    ble_uuid_any_t* chr_UUID = (ble_uuid_any_t*) malloc(sizeof(ble_uuid_any_t));
                    if(chr_UUID == NULL){
                        printf("malloc chr_UUID memory error\r\n");
                        return -1;
                    }

                    gatt_svr_chrs[j].uuid        = &(chr_UUID->u);
                    gatt_svr_chrs[j].access_cb   = ble_gatt_svc_access_cb;
                    gatt_svr_chrs[j].arg         = self;
                    gatt_svr_chrs[j].flags       = chr_flags;
                    gatt_svr_chrs[j].descriptors = gatt_svr_dscs;
                    gatt_svr_chrs[j].val_handle  = &(g_chrs_handle[handle_index]);//蓝牙同步之后,才会有有效值
                    fill_UUID(chr_UUID,UUID_bytes,chr_bytes_UUID);
                    
                    handle_index++;
                    // printf("chr_UUID_size : %d chr_flags %d dscs size:%d\r\n",UUID_bytes,chr_flags,dsc_count);

                    for(k = 0;k < dsc_count;k++){                        //对于每个描述符
                        PikaObj * dsc = arg_getObj(pikaTuple_getArg(dscs, k));
                        uint8_t * dsc_bytes_UUID = arg_getBytes(pikaTuple_getArg(dsc,0));  
                        uint8_t UUID_bytes = arg_getInt(pikaTuple_getArg(dsc,1));
                        uint16_t dsc_flags = pikaTuple_getInt(dsc, 2);

                        // 设置描述符
                        ble_uuid_any_t* dsc_UUID = (ble_uuid_any_t*) malloc(sizeof(ble_uuid_any_t));
                        
                        if(dsc_UUID == NULL){
                            printf("malloc dsc_UUID memory error\r\n");
                            return -1;
                        }

                        gatt_svr_dscs[k].uuid        = &(dsc_UUID->u);
                        gatt_svr_dscs[k].access_cb   = ble_gatt_svc_access_cb;
                        gatt_svr_dscs[k].arg         = self;
                        gatt_svr_dscs[k].att_flags   = dsc_flags;
                        fill_UUID(dsc_UUID,UUID_bytes,dsc_bytes_UUID);
                    }
                }
            }
        }
    }

    //注册基本服务
    gatt_svr_init(); 

    // 注册服务
    int rc = ble_gatts_count_cfg(gatt_svr_svcs);
    if (rc != 0) {
        return rc;
    }

    rc = ble_gatts_add_svcs(gatt_svr_svcs);
    if (rc != 0) {
        return rc;
    }

    // nimble_port_freertos_init(ble_host_task);
    // int rc = 0;
    return rc;
}

// 设置广播数据
// 在设置前需要蓝牙协议栈处于同步状态, nimble_port_freertos_init(ble_host_task)
// 直接发送传入内容, 不按照规范补充格式
// 若要按规范补充则需要调用ble_gap_adv_set_fields(const struct ble_hs_adv_fields *rsp_fields)函数
int _bluetooth_BLE_set_adv_data(PikaObj *self, uint8_t* data, int data_len)
{
    printf("_bluetooth_BLE_set_adv_data\r\n");
    return ble_gap_adv_set_data(data,data_len);
}

// 设置扫描响应数据
// 在设置前需要蓝牙协议栈处于同步状态, nimble_port_freertos_init(ble_host_task)
// 直接发送传入内容, 不按照规范补充格式
// 若要按规范补充则需要调用ble_gap_adv_rsp_set_fields(const struct ble_hs_adv_fields *rsp_fields)函数
// int _bluetooth_BLE_set_rsp_data(PikaObj *self, char* data, int data_len)
int _bluetooth_BLE_set_rsp_data(PikaObj *self, uint8_t* data, int data_len)
{
    printf("_bluetooth_BLE_set_rsp_data\r\n");
    // printf("%hx %hx %hx %hx\r\n",data[0],data[1],data[2],data[3]);
    // printf("%d %d %d %d\r\n",data[0],data[1],data[2],data[3]);
    return  ble_gap_adv_rsp_set_data(data,data_len);
}


char * _bluetooth_BLE_config_mac_get(PikaObj *self)
{
    // nimble_port_freertos_init(ble_host_task);
    printf("_bluetooth_BLE_config_mac_get\r\n");
    uint8_t own_addr_type;
    uint8_t addr_val[6] = {0};
    int rc = ble_hs_id_infer_auto(0, &own_addr_type);
    if (rc != 0) {
        printf("error determining address type; rc=%d\n", rc);
        return obj_cacheStr(self,"");
    }
    rc = ble_hs_id_copy_addr(own_addr_type, addr_val, NULL);
    // print_addr(addr_val);
    char mac[18];
    sprintf(&mac, "%02x:%02x:%02x:%02x:%02x:%02x",addr_val[5], addr_val[4], addr_val[3], addr_val[2], addr_val[1], addr_val[0]);
    // nimble_port_stop();
    return obj_cacheStr(self,mac);
}


// 测试通过
char* _bluetooth_BLE_config_gap_name_get(PikaObj *self){
    printf("_bluetooth_BLE_config_addr_gap_name_get\r\n");
    char *name = ble_svc_gap_device_name();
    return obj_cacheStr(self, name);
}


int _bluetooth_BLE_config_addr_mode_get(PikaObj *self){
    printf("_bluetooth_BLE_config_addr_mode_get\r\n");
    // nimble_port_freertos_init(ble_host_task);
    uint8_t own_addr_type;
    int rc = ble_hs_id_infer_auto(0, &own_addr_type);
    // nimble_port_stop();
    return own_addr_type;
}

int _bluetooth_BLE_config_mtu_get(PikaObj *self){
    printf("_bluetooth_BLE_config_mtu_get\r\n");
    return 0;
}

int _bluetooth_BLE_config_addr_rxbuf_get(PikaObj *self){
    printf("_bluetooth_BLE_config_addr_rxbuf_get\r\n");
    return 0;
}

int _bluetooth_BLE_config_bond_get(PikaObj *self){
    printf("_bluetooth_BLE_config_bond_get\r\n");
    return 0;
}

int _bluetooth_BLE_config_io_get(PikaObj *self)
{
    printf("_bluetooth_BLE_config_io_get\r\n");
    return 0;
}

int _bluetooth_BLE_config_le_secure_get(PikaObj *self)
{
    printf("_bluetooth_BLE_config_le_secure_get\r\n");
    return 0;
}

int _bluetooth_BLE_config_mitm_get(PikaObj *self)
{
    printf("_bluetooth_BLE_config_mitm_get\r\n");
    return 0;
}


int _bluetooth_BLE_config_addr_mode_update(PikaObj *self)
{
    printf("_bluetooth_BLE_config_addr_mode_update\r\n");
    return 0;
}

int _bluetooth_BLE_config_bond_update(PikaObj *self, pika_bool bond)
{
    printf("_bluetooth_BLE_config_bond_update\r\n");
    return 0;
}

// 基本测试通过
int _bluetooth_BLE_config_gap_name_update(PikaObj *self, char* gap_name)
{
    printf("_bluetooth_BLE_config_gap_name_update\r\n");
    return ble_svc_gap_device_name_set(gap_name);
}

// TODO:未实现
Arg* _bluetooth_BLE_config_gap_uuid_get(PikaObj *self)
{
    Arg* arg = arg_newBytes(NULL,0);
    return arg;
}

int _bluetooth_BLE_config_gap_uuid_update(PikaObj *self, uint8_t* uuid,int len)
{
    printf("_bluetooth_BLE_config_gap_uuid_update\r\n");
    if(len == 2){
        GAP_UUID.u16.u.type = BLE_UUID_TYPE_16;
        GAP_UUID.u16.value = uuid[0] << 8 | uuid[1];
    }else if(len == 4){
        GAP_UUID.u32.u.type = BLE_UUID_TYPE_32;
        GAP_UUID.u32.value = uuid[0] << 24 | uuid[1] << 16 | uuid[2] << 8 | uuid[3];
    }else{
        GAP_UUID.u128.u.type = BLE_UUID_TYPE_128;
        data_inver(uuid,GAP_UUID.u128.value,16);
    }
    return 0;
}

// TODO:未找到对应函数
int _bluetooth_BLE_config_io_update(PikaObj *self, int io){
    printf("_bluetooth_BLE_config_io_update\r\n");
    return 0;
}

int _bluetooth_BLE_config_le_secure_update(PikaObj *self, pika_bool le_secure)
{
    ESP_LOGD(tag, "_bluetooth_BLE_config_le_secure_update\r\n");
    // TODO:需要进行判断，若BLE处于广播状态则不能修改
    if(ble_gap_adv_active()){
        ESP_LOGI(tag, "an advertisement procedure is currently in progress\r\n");
        return -1;
    }
    else{
        BLE_ONLY = le_secure;
        ESP_LOGI(tag, "secure update succeed\r\n");
        return 0;
    }
}

// TODO:未找到实现方法
int _bluetooth_BLE_config_mac_update(PikaObj *self)
{
    printf("_bluetooth_BLE_config_mac_update\r\n");
    return 0;
}

// TODO:未找到对应函数
int _bluetooth_BLE_config_mitm_update(PikaObj *self, pika_bool mitm)
{
    printf("_bluetooth_BLE_config_mitm_update\r\n");
    return 0;
}

// TODO:未找到对应函数
int _bluetooth_BLE_config_mtu_update(PikaObj *self, int mtu)
{
    printf("_bluetooth_BLE_config_mtu_update\r\n");
    return 0;
}

// TODO:未找到对应函数
int _bluetooth_BLE_config_rxbuf_update(PikaObj *self, int rxbuf)
{
    printf("_bluetooth_BLE_config_rxbuf_update\r\n");
    return 0;
}


int _bluetooth_BLE_pyi_test2(PikaObj *self)
{
    uint8_t data[2];
    data[0] = 0x00;
    data[1] = 0x00;
    struct os_mbuf *om = ble_hs_mbuf_from_flat(data, 2);
    return ble_gattc_write_no_rsp(1, 38, om);
}

int _bluetooth_BLE_pyi_test3(PikaObj *self, int connhandle, int valuehandle)
{
    printf("_bluetooth_BLE_pyi_test3\r\n");
    
    // uint8_t data[2];
    // data[0] = 0x00;
    // // data[1] = 0x02;
    // struct os_mbuf *om = ble_hs_mbuf_from_flat(data, 2);
    // return  ble_gattc_write_no_rsp(1, 38, om);

    // ble_gatts_notify(1,32);
    printf("ble_hs_is_enabled(void) %d\r\n", ble_hs_is_enabled());
    return 0;
}

int _bluetooth_BLE_test_call_some_name(PikaObj *self)
{
    printf("_bluetooth_BLE_test_call_some_name\r\n");
    return 0;
}

//查找全部服务
int _bluetooth_BLE_gattc_dis_svcs(PikaObj *self, int conn_handle){
    return ble_gattc_disc_all_svcs(conn_handle, ble_gatt_disc_all_svcs_cb, NULL);
}

//通过UUID查找服务
int _bluetooth_BLE_gattc_dis_svcs_by_uuid(PikaObj *self, int conn_handle, uint8_t* uuid,int len){
    ble_uuid_any_t uuid_any = {0};
    // printf("UUID: %02x %02x\r\n",uuid[0],uuid[1]);
    if(len == 2){
        uuid_any.u16.u.type = BLE_UUID_TYPE_16;
        uuid_any.u16.value = uuid[0] << 8 | uuid[1];
        // uuid_any.u16.value = uuid[0] * 256 +  uuid[1];
        // uuid_any.u16.value = 0x1800;
        // uuid_any.u16.value = 0x26;
        // memcpy((uint8_t*)&(uuid_any.u16.value),uuid,2);
    }else if(len == 4){
        uuid_any.u32.u.type = BLE_UUID_TYPE_32;
        uuid_any.u32.value = uuid[0] << 24 | uuid[1] << 16 | uuid[2] << 8 | uuid[3];
    }else{
        // uint8_t data[16];
        uuid_any.u128.u.type = BLE_UUID_TYPE_128;
        data_inver(uuid,uuid_any.u128.value,16);
        
    }
    return ble_gattc_disc_svc_by_uuid(conn_handle,&uuid_any.u,ble_gatt_disc_svcs_by_uuid_cb, NULL);
}

//通过UUID查找全部属性
int _bluetooth_BLE_gattc_dis_chrs(PikaObj *self, int conn_handle, int start_handle, int end_handle){
    return ble_gattc_disc_all_chrs(conn_handle,start_handle,end_handle,ble_gatt_disc_all_chrs_cb,NULL);;
}

//通过UUID查找属性
int _bluetooth_BLE_gattc_dis_chrs_by_uuid(PikaObj *self, int conn_handle, int start_handle, int end_handle, uint8_t* uuid,int len){
    ble_uuid_any_t uuid_any = {0};
    if(len == 2){
        uuid_any.u16.u.type = BLE_UUID_TYPE_16;
        uuid_any.u16.value = uuid[0] << 8 | uuid[1];
    }else if(len == 4){
        uuid_any.u32.u.type = BLE_UUID_TYPE_32;
        uuid_any.u32.value = uuid[0] << 24 | uuid[1] << 16 | uuid[2] << 8 | uuid[3];
    }else{
        uuid_any.u128.u.type = BLE_UUID_TYPE_128;
        data_inver(uuid,uuid_any.u128.value,16);
    }
    return ble_gattc_disc_chrs_by_uuid(conn_handle,start_handle,end_handle,&uuid_any.u,ble_gatt_disc_chrs_by_uuid_cb,NULL);
}

//查找全部描述符
int _bluetooth_BLE_gattc_dis_dscs(PikaObj *self, int conn_handle, int start_handle, int end_handle){
    return ble_gattc_disc_all_dscs(conn_handle,start_handle,end_handle,ble_gatt_disc_all_dscs_cb,NULL);
}

// GATT读属性、描述符
int _bluetooth_BLE_pyi_gattc_read(PikaObj *self, int conn_handle, int value_handle){
    return ble_gattc_read(conn_handle, value_handle,ble_gatt_client_read_cb, NULL);
}

int client_subscribe_vertify_cb(uint16_t conn_handle,
                             const struct ble_gatt_error *error,
                             struct ble_gatt_attr *attr,
                             void *arg){
    uint8_t flags = attr->om->om_data[0];
    uint8_t data_len = attr->om->om_len;
    printf("data =  %02x data_len = %d error = %02x\r\n",flags, data_len,error->status);

    pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTS_SUBSCRIBE,
    arg_newObj(New_pikaTupleFrom(
        arg_newInt(_IRQ_GATTS_SUBSCRIBE),
        arg_newInt(conn_handle),
        arg_newInt(attr->handle - 1),
        arg_newInt(flags),
        arg_newInt(error->status)
        )));
    return 0;
}


int client_subscribe_cb(uint16_t conn_handle,
                             const struct ble_gatt_error *error,
                             struct ble_gatt_attr *attr,
                             void *arg){
    
    // printf("subscribe callback conn_handle %d value handle error %d\r\n", conn_handle,error->att_handle,error->status);
    // printf("ble_gatt_attr_fn handle  %d  offset %d \r\n", attr->handle,attr->offset);
    return ble_gattc_read(conn_handle,attr->handle,client_subscribe_vertify_cb,NULL);
}

int _bluetooth_BLE_pyi_gattc_subscribe(PikaObj *self, int conn_handle, int value_handle, int subscribe){

    uint8_t data[2];
    data[0] = subscribe;
    data[1] = 0x00;
    struct os_mbuf * txom = ble_hs_mbuf_from_flat(data,2);
    return ble_gattc_write(conn_handle, value_handle + 1 ,txom, client_subscribe_cb, NULL);
}

// int _bluetooth_BLE_pyi_gattc_subscribe_indicate(PikaObj *self, int conn_handle, int value_handle, pika_bool subscribe){

//     uint8_t data[2];
//     if(subscribe){
//         data[0] = 0x02;
//     }else{
//         data[0] = 0x00;
//     }
//     data[1] = 0x00;
//     struct os_mbuf * txom = ble_hs_mbuf_from_flat(data,2);
//     return ble_gattc_write(conn_handle, value_handle + 1 ,txom, client_subscribe_cb, NULL);
// }


// int _bluetooth_BLE_pyi_gattc_subscribe_notify(PikaObj *self, int conn_handle, int value_handle, pika_bool subscribe){
//     uint8_t data[2];
//     if(subscribe){
//         data[0] = 0x01;
//     }else{
//         data[0] = 0x00;
//     }
//     data[1] = 0x00;
//     struct os_mbuf * txom = ble_hs_mbuf_from_flat(data,2);
//     return ble_gattc_write(conn_handle, value_handle + 1,txom,client_subscribe_cb, NULL);
// }


// GATT写属性、描述符
//TODO:还有一个相同功能的函数但不知道区别
// ble_gattc_write_no_rsp(uint16_t conn_handle, uint16_t attr_handle, struct os_mbuf *om)
int _bluetooth_BLE_gattc_write_with_no_rsp(PikaObj *self, int conn_handle, int value_handle, char* data, int data_len){
    return ble_gattc_write_no_rsp_flat(conn_handle,value_handle,data,data_len);
}

// GATT写属性、描述符
//TODO:还有一个相同功能的函数但不知道区别
// ble_gattc_write(uint16_t conn_handle, uint16_t attr_handle,struct os_mbuf *txom, ble_gatt_attr_fn *cb, void *cb_arg)
int _bluetooth_BLE_gattc_write_with_rsp(PikaObj *self, int conn_handle, int value_handle, char* data, int data_len){
    return ble_gattc_write_flat(conn_handle,value_handle,data,data_len,ble_gatt_client_write_cb,NULL);
}

int _bluetooth_BLE_gatts_chr_updated(PikaObj *self, int chr_val_handle)
{
    ble_gatts_chr_updated(chr_val_handle);
    return 0;
}


// GATT indicate
int _bluetooth_BLE_pyi_gatts_indicate(PikaObj *self, int conn_handle, int value_handle, uint8_t* data, int data_size)
{
    printf("_bluetooth_BLE_pyi_gatts_indicate\r\n");
    struct os_mbuf *om = ble_hs_mbuf_from_flat(data, data_size);
    if (om == NULL)
    {
        printf("ble_hs_mbuf_from_flat error\r\n");
    }
    printf("conn_handle %d value_handle %d  data_size %d data %02x\r\n", conn_handle, value_handle, data_size,data[0]);
    return ble_gatts_indicate_custom(conn_handle,value_handle,om);
}

int _bluetooth_BLE_pyi_gatts_notify(PikaObj *self, int conn_handle, int value_handle, uint8_t* data, int data_size)
{
    printf("_bluetooth_BLE_pyi_gatts_notify\r\n");
    struct os_mbuf *om = ble_hs_mbuf_from_flat(data, data_size);
    if (om == NULL)
    {
        printf("ble_hs_mbuf_from_flat error\r\n");
    }
    printf("conn_handle %d value_handle %d  data_size %d data %02x\r\n", conn_handle, value_handle, data_size,data[0]);

    return ble_gatts_notify_custom(conn_handle,value_handle,om);
}

int _bluetooth_BLE_pyi_gatts_show_local(PikaObj *self)
{
    printf("_bluetooth_BLE_pyi_gatts_show_local");
    ble_gatts_show_local();
    return 0;
}


// 未找到正确的使用方法与效果
// TODO:待验证
int _bluetooth_BLE_pyi_gattc_exchange_mtu(PikaObj *self, int conn_handle){
    return ble_gattc_exchange_mtu(conn_handle,ble_gatt_mtu_exchange_cb,NULL);
}

// 回调函数注册
void _bluetooth_BLE_setCallback(PikaObj *self, Arg* cb)
{
    printf("_bluetooth_BLE_setCallback\r\n");
    if (g_pika_ble_listener == NULL) {
        pika_eventListener_init(&g_pika_ble_listener);
        printf("g_pika_ble_listener init\r\n");
    }

    uint32_t i = 0;
    for ( i = 0; i < _IRQ_COUNT + 1; i++){
        pika_eventListener_registEventCallback(g_pika_ble_listener,i,cb);
    }
    for ( i = 101; i < _IRQ_DIY_MAX_ID + 1; i++){
        pika_eventListener_registEventCallback(g_pika_ble_listener,i,cb);
    }
}

// 基本服务注册
void gatt_svr_init(void)
{
    ble_svc_gap_init();
    ble_svc_gatt_init();
    // ble_svc_ans_init();
}

// 从字符串中读取UUID 结构体
int read_uuid_from_str(char* buf, int len, ble_uuid_any_t* uuid_struct)
{
    unsigned int a[16];
    if (len == 4){
        sscanf(buf, "%02x%02x", &a[0],&a[1]);
        uuid_struct->u16.u.type = BLE_UUID_TYPE_16;
        uuid_struct->u16.value = (a[0] << 8) | a[1];
        return 16;
    }
    else if (len == 8){
        sscanf(buf, "%02x%02x%02x%02x", &a[0],&a[1],&a[2],&a[3]);
        uuid_struct->u32.u.type = BLE_UUID_TYPE_32;
        uuid_struct->u32.value  = (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]; 
        return 32;
    }
    else if (len == 36){
        sscanf(buf, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",\
         &a[15],&a[14],&a[13],&a[12],&a[11],&a[10],&a[9],&a[8],&a[7],&a[6],&a[5],&a[4],&a[3],&a[2],&a[1],&a[0]);
        // // &a[0],&a[1],&a[2],&a[3],&a[4],&a[5],&a[6],&a[7],&a[8],&a[9],&a[10],&a[11],&a[12],&a[13],&a[14],&a[15]);
        uuid_struct->u128.u.type = BLE_UUID_TYPE_128;
        memcpy(uuid_struct->u128.value,a,16);
        return 128;
    }
    return 0;
}


// GATT层: 服务端 回调函数
static int ble_gatt_svc_access_cb(uint16_t conn_handle, uint16_t attr_handle,
                struct ble_gatt_access_ctxt *ctxt, void *arg){
    const ble_uuid_t *uuid;
    int rc;
    printf("ble_gatt_svc_access_cb\r\n");
    
    switch (ctxt->op) {                       
        case BLE_GATT_ACCESS_OP_READ_CHR:       //读属性值
            if (conn_handle != BLE_HS_CONN_HANDLE_NONE) {
                printf("Characteristic read: conn_handle=%d attr_handle=%d\r\n",conn_handle, attr_handle);
                PikaObj * self = arg;
                obj_setArg(self, "data", arg_newObj(New_pikaTupleFrom(
                                                arg_newInt(_IRQ_GATTS_READ_REQUEST),
                                                arg_newInt(conn_handle),
                                                arg_newInt(attr_handle)
                                            )));

                obj_run(self, "res = _callback(data)");
                Arg* res = obj_getArg(self, "res");
                
                PikaObj* tuple = arg_getObj(res);
                int res_int    = arg_getInt(pikaTuple_getArg(tuple,0)); 
                int byte_count = arg_getInt(pikaTuple_getArg(tuple,1)); 
                uint8_t * value = (uint8_t * )calloc(byte_count,sizeof(uint8_t));
                value = arg_getBytes(pikaTuple_getArg(tuple,2));
                printf("res_int %d byte_count %d data %02x\r\n",res_int,byte_count,value[0]);
                // int res_int = arg_getInt(res); 
                if(res_int == _GATTS_NO_ERROR){ 
                    rc = os_mbuf_append(ctxt->om, value,byte_count);
                    return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
                }
                return 0;
            } else {
                printf("Characteristic read by NimBLE stack; attr_handle=%d\n",attr_handle);
                PikaObj * self = arg;
                obj_setArg(self, "data", arg_newObj(New_pikaTupleFrom(
                                                arg_newInt(_IRQ_DIY_NIMBLE_READ),
                                                arg_newInt(attr_handle)
                                            )));
                obj_run(self, "res = _callback(data)");
                Arg* res = obj_getArg(self, "res");
                PikaObj* tuple = arg_getObj(res);
                int byte_count = arg_getInt(pikaTuple_getArg(tuple,0)); 
                uint8_t * value = (uint8_t * )calloc(byte_count,sizeof(uint8_t));
                value = arg_getBytes(pikaTuple_getArg(tuple,1));

                printf("byte_count %d data %02x\r\n",byte_count,value[0]);
                rc = os_mbuf_append(ctxt->om,value,byte_count);
                return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
            }
            return -1;
        case BLE_GATT_ACCESS_OP_WRITE_CHR:              //写属性值
            if (conn_handle != BLE_HS_CONN_HANDLE_NONE) {
                printf("Characteristic write; conn_handle=%d attr_handle=%d\r\n", conn_handle, attr_handle);
                uint16_t total_length       =  *(ctxt->om->om_databuf);
                uint8_t * value = (uint8_t*)calloc(total_length,sizeof(uint8_t));
                
                // uint16_t current_buf_length =  ctxt->om->om_len;
                uint16_t current_buf_length;
                uint16_t remain_length      = total_length;
                struct os_mbuf* buf_pointer = ctxt->om;
                while (true){
                    current_buf_length = buf_pointer->om_len;
                    memcpy((value + (total_length - remain_length)), buf_pointer->om_data,current_buf_length); 
                    remain_length -= current_buf_length;

                    if(remain_length > 0)
                        buf_pointer = buf_pointer->om_next.sle_next;
                    else
                        break;
                }

                // printf("ctxt->om->om_pkthdr_len = %d\r\n",ctxt->om->om_pkthdr_len);
                // printf("ctxt->om->om_len = %d\r\n",ctxt->om->om_next.sle_next->om_len);
                // printf("ctxt->om->om_databuf[0] = %02x\r\n",*(ctxt->om->om_databuf));
                // printf("ctxt->om->om_databuf[1] = %02x\r\n",*(ctxt->om->om_databuf+1));
                // printf("ctxt->om->om_databuf[2] = %02x\r\n",*(ctxt->om->om_databuf+2));
                pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTS_WRITE,
                    arg_newObj(New_pikaTupleFrom(
                            arg_newInt(_IRQ_GATTS_WRITE),
                            arg_newInt(conn_handle), 
                            arg_newInt(attr_handle),
                            arg_newBytes(value,total_length) 
                            )));
            } else {
                printf("Characteristic write by NimBLE stack; attr_handle=%d\r\n",attr_handle);
            }
            return 0;

        case BLE_GATT_ACCESS_OP_READ_DSC:     //读描述符(回调函数与属性值先不做区分) TODO:读不到描述符吧？
            if (conn_handle != BLE_HS_CONN_HANDLE_NONE) {
                printf("Descriptor read; conn_handle=%d attr_handle=%d\r\n",conn_handle, attr_handle);

                Arg* res = pika_eventListener_sendAwaitResult(g_pika_ble_listener,_IRQ_GATTS_READ_REQUEST,
                    arg_newObj(New_pikaTupleFrom(
                            arg_newInt(_IRQ_GATTS_READ_REQUEST),
                            arg_newInt(conn_handle),
                            arg_newInt(attr_handle)
                            )));
                
                int res_int = arg_getInt(res);  
                if(res_int == _GATTS_NO_ERROR){ //允许读,如何返回被拒绝访问解决结果?
                    uint8_t gatt_svr_dsc_val = 0xFF;
                    rc = os_mbuf_append(ctxt->om,
                                &gatt_svr_dsc_val,
                                sizeof(gatt_svr_dsc_val));
                    return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
                }

            } else {
                printf("Descriptor read by NimBLE stack; attr_handle=%d\r\n",attr_handle);
            }
            return 0;

        case BLE_GATT_ACCESS_OP_WRITE_DSC:      //写描述符
            if (conn_handle != BLE_HS_CONN_HANDLE_NONE) {
                printf("Descriptor write; conn_handle=%d attr_handle=%d\r\n",conn_handle, attr_handle);
                pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTS_WRITE,
                    arg_newObj(New_pikaTupleFrom(
                            arg_newInt(_IRQ_GATTS_WRITE),
                            arg_newInt(conn_handle),
                            arg_newInt(attr_handle)
                            )));
            } else {
                printf("Descriptor read by NimBLE stack; attr_handle=%d\r\n",attr_handle);
            }
            return 0;
    }
    return 0;
}


// GATT层：客户端读服务回调函数
static int ble_gatt_client_read_cb(uint16_t conn_handle,
                       const struct ble_gatt_error *error,
                       struct ble_gatt_attr *attr,
                       void *arg)
{
    printf("Read complete for the subscribable characteristic; "
            "status=%d conn_handle=%d\r\n", error->status, conn_handle);
    //读取成功
    // TODO:读完之后不会引起其他事件，所以要done 和result一起触发
    if (error->status == 0) {
        //读到数据
        // printf("om_data:%d\r\n",*(attr->om->om_data));
        // printf("om_flags:%d\r\n",attr->om->om_flags);
        // printf("om_pkthdr_len:%d\r\n",attr->om->om_pkthdr_len);
        // printf("om_data:%d\r\n",attr->om->om_len);
        // print_mbuf(attr->om); //TODO:该函数无引用，但在blecentn能够使用
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_READ_RESULT,
            arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_READ_RESULT),
                    arg_newInt(conn_handle),
                    arg_newInt(attr->handle), //应该是value handle
                    arg_newBytes(attr->om->om_data,attr->om->om_len) 
                    )));

        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_READ_DONE ,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_READ_DONE),
                arg_newInt(conn_handle),
                arg_newInt(attr->handle),
                arg_newInt(error->status) 
                )));
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_READ_DONE ,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_READ_DONE),
                arg_newInt(conn_handle),
                arg_newInt(-1),
                arg_newInt(error->status) 
                )));
    }
    return 0;
}

// GATT层：客户端写服务回调函数
static int ble_gatt_client_write_cb(uint16_t conn_handle,
                        const struct ble_gatt_error *error,
                        struct ble_gatt_attr *attr,
                        void *arg)
{
    const struct peer_chr *chr;
    const struct peer *peer;
    int rc;

    MODLOG_DFLT(INFO,
                "Write to the custom subscribable characteristic complete; "
                "status=%d conn_handle=%d attr_handle=%d\n",
                error->status, conn_handle, attr->handle);
    if (error->status == 0) {       
        //读到数据
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_WRITE_DONE,
            arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_WRITE_DONE ),
                    arg_newInt(conn_handle),
                    arg_newInt(attr->handle),
                    arg_newInt(error->status) 
                    )));
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_WRITE_DONE,
            arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_WRITE_DONE),
                arg_newInt(conn_handle),
                arg_newInt(-1),
                arg_newInt(error->status) 
                )));
    }
    return 0;
}

//GATT层 MTU exchange 回调函数
static int ble_gatt_mtu_exchange_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            uint16_t mtu, void *arg)
{
    if(error->status == 0){
        pika_eventListener_send(g_pika_ble_listener,_IRQ_MTU_EXCHANGED ,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_MTU_EXCHANGED),
                arg_newInt(conn_handle),
                arg_newInt(mtu)
                )));
    }
    return 0;
}


// GAP层：广播事件回调函数
static int ble_gap_event_cb(struct ble_gap_event *event, void *arg)
{
    struct ble_gap_conn_desc desc;
    int rc;
    uint8_t addr[6];

    switch (event->type) {
    case BLE_GAP_EVENT_CONNECT: 
        printf("connection %s; status=%d ",
            event->connect.status == 0 ? "established" : "failed", event->connect.status);
        printf("\r\n");
        if (event->connect.status == 0) {
            rc = ble_gap_conn_find(event->connect.conn_handle, &desc);
            assert(rc == 0);
            print_conn_desc(&desc);
            data_inver(desc.peer_ota_addr.val,&addr,6);

            if(desc.role == BLE_GAP_ROLE_SLAVE){
                pika_eventListener_send(g_pika_ble_listener,_IRQ_CENTRAL_CONNECT,
                            arg_newObj(New_pikaTupleFrom(
                                    arg_newInt(_IRQ_CENTRAL_CONNECT),
                                    arg_newInt(event->connect.conn_handle),
                                    arg_newInt(desc.peer_id_addr.type),
                                    arg_newBytes(addr,6)
                                    )));
            } else if (desc.role == BLE_GAP_ROLE_MASTER){
                pika_eventListener_send(g_pika_ble_listener,_IRQ_PERIPHERAL_CONNECT  ,
                     arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_PERIPHERAL_CONNECT),
                    arg_newInt(event->connect.conn_handle),
                    arg_newInt(desc.peer_id_addr.type),
                    arg_newBytes(addr,6)
                    )));
            }
            
        }else if (event->connect.status != 0) {
            /* Connection failed; resume advertising. */
            // bleprph_advertise();
            // TODO: 重新广播，或通知客户端
            if(desc.role == BLE_GAP_ROLE_SLAVE){
                _bluetooth_BLE_adv(g_interval);
                printf("Connection failed; resume advertising.");\
            }
        }
        return 0;

    case BLE_GAP_EVENT_DISCONNECT: //断开连接
        printf("disconnect; reason=%d \r\n", event->disconnect.reason);
        // print_conn_desc(&event->disconnect.conn);

        data_inver(event->disconnect.conn.peer_ota_addr.val,&addr,6);
        if(event->disconnect.conn.role == BLE_GAP_ROLE_SLAVE){
            pika_eventListener_send(g_pika_ble_listener,_IRQ_CENTRAL_DISCONNECT,
                    arg_newObj(New_pikaTupleFrom(
                            arg_newInt(_IRQ_CENTRAL_DISCONNECT),
                            arg_newInt(event->disconnect.conn.conn_handle),
                            arg_newInt(desc.peer_id_addr.type),
                            arg_newBytes(addr,6)
                            )));
        }else if(event->disconnect.conn.role == BLE_GAP_ROLE_MASTER){
            pika_eventListener_send(g_pika_ble_listener,_IRQ_PERIPHERAL_DISCONNECT ,
                                arg_newObj(New_pikaTupleFrom(
                                        arg_newInt(_IRQ_PERIPHERAL_DISCONNECT),
                                        arg_newInt(event->disconnect.conn.conn_handle),
                                        arg_newInt(desc.peer_id_addr.type),
                                        arg_newBytes(addr,6)
                                        )));
        }
        return 0;

    case BLE_GAP_EVENT_CONN_UPDATE: //返回结果
        /* The central has updated the connection parameters. */
        printf("connection updated; status=%d \r\n",event->conn_update.status);
        rc = ble_gap_conn_find(event->conn_update.conn_handle, &desc);
        assert(rc == 0);
        print_conn_desc(&desc);
        return 0;

    case BLE_GAP_EVENT_CONN_UPDATE_REQ :
        // MicroPython : conn_handle, conn_interval, conn_latency, supervision_timeout, status 
        printf("BLE_GAP_EVENT_CONN_UPDATE_REQ\r\n");
        pika_eventListener_send(g_pika_ble_listener,_IRQ_CONNECTION_UPDATE,
                    arg_newObj(New_pikaTupleFrom(
                            arg_newInt(_IRQ_CONNECTION_UPDATE),
                            arg_newInt(event->conn_update_req.conn_handle),
                            arg_newInt(event->conn_update_req.peer_params->itvl_min),
                            arg_newInt(event->conn_update_req.peer_params->latency),
                            arg_newInt(event->conn_update_req.peer_params->supervision_timeout)//,
                            // arg_newInt(event->conn_update.status) TODO:status在上一事件中
                            )));
         return 0;

    case BLE_GAP_EVENT_L2CAP_UPDATE_REQ :
        printf("BLE_GAP_EVENT_L2CAP_UPDATE_REQ\r\n");
        return 0;

    case BLE_GAP_EVENT_TERM_FAILURE:
        printf("BLE_GAP_EVENT_TERM_FAILURE; conn_handle=%d reason=%d\r\n",event->term_failure.conn_handle,event->term_failure.status);
        return 0;
    
    case BLE_GAP_EVENT_DISC: //扫描发现
        struct ble_gap_conn_desc desc;
        struct ble_hs_adv_fields fields;
        int rc;
        rc = ble_hs_adv_parse_fields(&fields, event->disc.data,event->disc.length_data);
        if (rc != 0) {
            return 0;
        }
        data_inver(event->disc.addr.val,addr,6);
        pika_eventListener_send(g_pika_ble_listener,_IRQ_SCAN_RESULT,
            arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_SCAN_RESULT),
                    arg_newInt(event->disc.addr.type),
                    arg_newBytes(addr,6),
                    arg_newInt(event->disc.event_type),
                    arg_newInt(event->disc.rssi),
                    arg_newBytes(event->disc.data,event->disc.length_data)
                    )));
        return 0;

    case BLE_GAP_EVENT_DISC_COMPLETE: // 扫描结束
    // MicroPython None
        printf("discovery complete; reason=%d\r\n",event->disc_complete.reason);
        pika_eventListener_send(g_pika_ble_listener,_IRQ_SCAN_DONE,
            arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_SCAN_DONE),
                    arg_newInt(event->disc_complete.reason)
                    )));
        return 0;

    case BLE_GAP_EVENT_ADV_COMPLETE: //广播完成
    // MicroPython 没有这个事件
        printf("advertise complete; reason=%d\r\n",event->adv_complete.reason);
        return 0;

    case BLE_GAP_EVENT_ENC_CHANGE:
    // 暂时不理
        /* Encryption has been enabled or disabled for this connection. */
        printf("encryption change event; status=%d \r\n",event->enc_change.status);
        rc = ble_gap_conn_find(event->enc_change.conn_handle, &desc);
        assert(rc == 0);
        print_conn_desc(&desc);
        MODLOG_DFLT(INFO, "\n");
        return 0;

    case BLE_GAP_EVENT_PASSKEY_ACTION :
    // 暂时不理
        printf("PASSKEY_ACTION_EVENT started \r\n");
        struct ble_sm_io pkey = {0};
        // int key = 0;

        if (event->passkey.params.action == BLE_SM_IOACT_DISP) {
            pkey.action = event->passkey.params.action;
            pkey.passkey = 123456; // This is the passkey to be entered on peer
            ESP_LOGI(tag, "Enter passkey %" PRIu32 "on the peer side", pkey.passkey);
            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
        } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
            ESP_LOGI(tag, "Passkey on device's display: %" PRIu32 , event->passkey.params.numcmp);
            ESP_LOGI(tag, "Accept or reject the passkey through console in this format -> key Y or key N");
            pkey.action = event->passkey.params.action;
            // if (scli_receive_key(&key)) {
            //     pkey.numcmp_accept = key;
            // } else {
            //     pkey.numcmp_accept = 0;
            //     ESP_LOGE(tag, "Timeout! Rejecting the key");
            // }
            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
        } else if (event->passkey.params.action == BLE_SM_IOACT_OOB) {
            static uint8_t tem_oob[16] = {0};
            pkey.action = event->passkey.params.action;
            for (int i = 0; i < 16; i++) {
                pkey.oob[i] = tem_oob[i];
            }
            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
        } else if (event->passkey.params.action == BLE_SM_IOACT_INPUT) {
            ESP_LOGI(tag, "Enter the passkey through console in this format-> key 123456");
            pkey.action = event->passkey.params.action;
            // if (scli_receive_key(&key)) {
            //     pkey.passkey = key;
            // } else {
            //     pkey.passkey = 0;
            //     ESP_LOGE(tag, "Timeout! Passing 0 as the key");
            // }
            rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
            ESP_LOGI(tag, "ble_sm_inject_io result: %d\n", rc);
        }
        return 0;

    case BLE_GAP_EVENT_NOTIFY_RX: // 客户端
        printf("received %s; conn_handle=%d attr_handle=%d attr_len=%d",
                event->notify_rx.indication ? "indication" : "notification",
                event->notify_rx.conn_handle,
                event->notify_rx.attr_handle,
                OS_MBUF_PKTLEN(event->notify_rx.om));
        printf("\r\n");
        if(event->notify_rx.indication == 1){ // indication
            // MicroPython : conn_handle, value_handle, notify_data
            uint16_t len = event->notify_rx.om->om_len;
            char *indic_str = (char *)malloc(len + 1);
            memcpy(indic_str, event->notify_rx.om->om_data, len);
            indic_str[len] = '\0';

            pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_INDICATE,
                arg_newObj(New_pikaTupleFrom(
                        arg_newInt(_IRQ_GATTC_INDICATE),
                        arg_newInt(event->notify_rx.conn_handle),
                        arg_newInt(event->notify_rx.attr_handle),
                        arg_newStr(indic_str)
                        )));
            free(indic_str);
        }
        else {  // notify
            uint16_t len = event->notify_rx.om->om_len;
            char *indic_str = (char *)malloc(len + 1);
            memcpy(indic_str, event->notify_rx.om->om_data, len);
            indic_str[len] = '\0';

            pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_NOTIFY,
                arg_newObj(New_pikaTupleFrom(
                        arg_newInt(_IRQ_GATTC_NOTIFY),
                        arg_newInt(event->notify_rx.conn_handle),
                        arg_newInt(event->notify_rx.attr_handle),
                        arg_newStr(indic_str)
                        )));
            free(indic_str);
        }
        
        return 0;

    case BLE_GAP_EVENT_NOTIFY_TX: //通知发送完成
        printf("notify_tx event conn_handle=%d attr_handle=%d status=%d is_indication=%d\r\n",
                    event->notify_tx.conn_handle,
                    event->notify_tx.attr_handle,
                    event->notify_tx.status,
                    event->notify_tx.indication);
        if(event->notify_tx.indication == 1){ // indication
            // MicroPython : conn_handle, value_handle, notify_data
            pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTS_INDICATE_DONE,
                arg_newObj(New_pikaTupleFrom(
                        arg_newInt(_IRQ_GATTS_INDICATE_DONE),
                        arg_newInt(event->notify_tx.conn_handle),
                        arg_newInt(event->notify_tx.attr_handle),
                        arg_newInt(event->notify_tx.status)
                        )));
        }        
        return 0;
    case BLE_GAP_EVENT_SUBSCRIBE://订阅 客户端向服务端订阅的事件(新增)
        printf("subscribe event; conn_handle=%d attr_handle=%d "
                    "reason=%d prevn=%d curn=%d previ=%d curi=%d\r\n",
                    event->subscribe.conn_handle,
                    event->subscribe.attr_handle,
                    event->subscribe.reason,
                    event->subscribe.prev_notify,
                    event->subscribe.cur_notify,
                    event->subscribe.prev_indicate,
                    event->subscribe.cur_indicate);
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SUBSCRIBE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_SUBSCRIBE),
                arg_newInt(event->subscribe.conn_handle),
                arg_newInt(event->subscribe.attr_handle),
                arg_newInt(event->subscribe.reason),
                arg_newInt(event->subscribe.cur_notify),
                arg_newInt(event->subscribe.cur_indicate)
                )));
        return 0;

    case BLE_GAP_EVENT_MTU:
        printf("mtu update event; conn_handle=%d cid=%d mtu=%d\r\n",
                    event->mtu.conn_handle,
                    event->mtu.channel_id,
                    event->mtu.value);
        return 0;

    case BLE_GAP_EVENT_IDENTITY_RESOLVED:
            printf("BLE_GAP_EVENT_IDENTITY_RESOLVED\r\n");
        return 0;

    case BLE_GAP_EVENT_REPEAT_PAIRING:
        /* We already have a bond with the peer, but it is attempting to
         * establish a new secure link.  This app sacrifices security for
         * convenience: just throw away the old bond and accept the new link.
         */
        printf("BLE_GAP_EVENT_REPEAT_PAIRING\r\n");


        /* Delete the old bond. */
        rc = ble_gap_conn_find(event->repeat_pairing.conn_handle, &desc);
        assert(rc == 0);
        ble_store_util_delete_peer(&desc.peer_id_addr);

        /* Return BLE_GAP_REPEAT_PAIRING_RETRY to indicate that the host should
         * continue with the pairing operation.
         */
        return BLE_GAP_REPEAT_PAIRING_RETRY;

        case BLE_GAP_EVENT_PHY_UPDATE_COMPLETE:
            printf("BLE_GAP_EVENT_PHY_UPDATE_COMPLETE\r\n");
            return 0;

        case BLE_GAP_EVENT_EXT_DISC:
            printf("BLE_GAP_EVENT_EXT_DISC\r\n");
            return 0;

        case BLE_GAP_EVENT_PERIODIC_SYNC:
            printf("BLE_GAP_EVENT_PERIODIC_SYNC\r\n");
            return 0;

        case BLE_GAP_EVENT_PERIODIC_REPORT:
            printf("BLE_GAP_EVENT_PERIODIC_REPORT\r\n");
            return 0;

        case BLE_GAP_EVENT_PERIODIC_SYNC_LOST:
            printf("BLE_GAP_EVENT_PERIODIC_SYNC_LOST\r\n");
            return 0;

        case BLE_GAP_EVENT_SCAN_REQ_RCVD:
            printf("BLE_GAP_EVENT_SCAN_REQ_RCVD\r\n");
            return 0;

        case BLE_GAP_EVENT_PERIODIC_TRANSFER:
            printf("BLE_GAP_EVENT_PERIODIC_TRANSFER\r\n");
            return 0;

        case BLE_GAP_EVENT_PATHLOSS_THRESHOLD:
            printf("BLE_GAP_EVENT_PATHLOSS_THRESHOLD\r\n");
            return 0;

        case BLE_GAP_EVENT_TRANSMIT_POWER:
            printf("BLE_GAP_EVENT_TRANSMIT_POWER\r\n");
            return 0;

        case BLE_GAP_EVENT_SUBRATE_CHANGE:// 这个是啥事件？
            printf("BLE_GAP_EVENT_SUBRATE_CHANGE\r\n");
            return 0;
    }
    return 0;
}

// GATT 查找所有服务回调函数
static int ble_gatt_disc_all_svcs_cb(uint16_t conn_handle,
                                 const struct ble_gatt_error *error,
                                 const struct ble_gatt_svc *service,
                                 void *arg){
    printf("ble_gatt_disc_all_svcs_cb\r\n");
    if(error->status == 0)
    {
        uint8_t data_len = service->uuid.u.type;
        uint8_t *uuid;
        if(data_len == 16){ // = 16 
            uint16_t value = service->uuid.u16.value;
            uuid    = (uint8_t *)malloc(2);
            uuid[0] = (uint8_t)(value >> 8);        // 取高位字节
            uuid[1] = (uint8_t) value;             // 取低位字节
        }else if(data_len == 32){ // 32
            uint16_t value = service->uuid.u32.value;
            uuid    = (uint8_t *)malloc(4);
            uuid[0] = (uint8_t)(value >> 24); // 取高位字节
            uuid[1] = (uint8_t)(value >> 16); // 取次高位字节
            uuid[2] = (uint8_t)(value >> 8);  // 取次低位字节
            uuid[3] = (uint8_t)value;         // 取低位字节
        }else{ // 128 
            uuid    = (uint8_t *)malloc(16);
            data_inver(service->uuid.u128.value,uuid,16);
        }

        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SERVICE_RESULT,
                arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_SERVICE_RESULT),
                    arg_newInt(conn_handle),
                    arg_newInt(service->start_handle),
                    arg_newInt(service->end_handle),
                    arg_newBytes(uuid,data_len/8)
                )));
        free(uuid);
        return 0;
    }else if(error->status == 14){
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SERVICE_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_SERVICE_DONE),
                arg_newInt(conn_handle),
                arg_newInt(0)
                )));
        return 0;
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SERVICE_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_SERVICE_DONE),
                arg_newInt(conn_handle),
                arg_newInt(error->status)
                )));
        return 0;
    }
}

// GATT 查找特定UUID服务回调函数
static int ble_gatt_disc_svcs_by_uuid_cb(uint16_t conn_handle,
                                 const struct ble_gatt_error *error,
                                 const struct ble_gatt_svc *service,
                                 void *arg){

    printf("ble_gatt_disc_svcs_by_uuid_cb\r\n");
    printf("error: %d,att handle %d\r\n",error->status,error->att_handle);
    // printf("start handle: %d,end handle %d\r\n",service->start_handle,service->end_handle);
    if(error->status == 0)
    {
        uint8_t data_len = service->uuid.u.type;
        uint8_t *uuid;
        if(data_len == 16){ // = 16 
            uint16_t value = service->uuid.u16.value;
            uuid    = (uint8_t *)malloc(2);
            uuid[0] = (uint8_t)(value >> 8);        // 取高位字节
            uuid[1] = (uint8_t) value;             // 取低位字节
        }else if(data_len == 32){ // 32
            uint16_t value = service->uuid.u32.value;
            uuid    = (uint8_t *)malloc(4);
            uuid[0] = (uint8_t)(value >> 24); // 取高位字节
            uuid[1] = (uint8_t)(value >> 16); // 取次高位字节
            uuid[2] = (uint8_t)(value >> 8);  // 取次低位字节
            uuid[3] = (uint8_t)value;         // 取低位字节
        }else{ // 128 
            uuid    = (uint8_t *)malloc(16);
            data_inver(service->uuid.u128.value,uuid,16);
        }

        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SERVICE_RESULT,
                arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_SERVICE_RESULT),
                    arg_newInt(conn_handle),
                    arg_newInt(service->start_handle),
                    arg_newInt(service->end_handle),
                    arg_newBytes(uuid,data_len/8)
                )));
        free(uuid);
        return 0;
    }else if(error->status == 14){
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SERVICE_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_SERVICE_DONE),
                arg_newInt(conn_handle),
                arg_newInt(0)
                )));
        return 0;
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_SERVICE_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_SERVICE_DONE),
                arg_newInt(conn_handle),
                arg_newInt(error->status)
                )));
        return 0;
    }
}

// GATT 查找所有特性回调函数
static int ble_gatt_disc_all_chrs_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            const struct ble_gatt_chr *chr, void *arg){
        
    printf("ble_gatt_disc_all_chrs_cb\r\n");
    if(error->status == 0){
        uint8_t data_len = chr->uuid.u.type;
        uint8_t *uuid;
        if(data_len == 16){ // = 16 
            uint16_t value = chr->uuid.u16.value;
            uuid    = (uint8_t *)malloc(2);
            uuid[0] = (uint8_t)(value >> 8);        // 取高位字节
            uuid[1] = (uint8_t) value;             // 取低位字节
        }else if(data_len == 32){ // 32
            uint16_t value = chr->uuid.u32.value;
            uuid    = (uint8_t *)malloc(4);
            uuid[0] = (uint8_t)(value >> 24); // 取高位字节
            uuid[1] = (uint8_t)(value >> 16); // 取次高位字节
            uuid[2] = (uint8_t)(value >> 8);  // 取次低位字节
            uuid[3] = (uint8_t)value;         // 取低位字节
        }else{ // 128 
            uuid    = (uint8_t *)malloc(16);
            data_inver(chr->uuid.u128.value,uuid,16);
        }
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_CHARACTERISTIC_RESULT,
                arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_CHARACTERISTIC_RESULT),
                    arg_newInt(conn_handle),
                    arg_newInt(chr->def_handle),  // 定义的句柄
                    arg_newInt(chr->val_handle),  // 值的句柄
                    arg_newInt(chr->properties),
                    arg_newBytes(uuid,data_len/8)
                )));
        free(uuid);
        return 0;
    }else if(error->status == 14){
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_CHARACTERISTIC_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_CHARACTERISTIC_DONE),
                arg_newInt(conn_handle),
                arg_newInt(0)
                )));
        return 0;
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_CHARACTERISTIC_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_CHARACTERISTIC_DONE),
                arg_newInt(conn_handle),
                arg_newInt(error->status)
                )));
        return 0;
    }
}

// GATT 查找特定UUID特性回调函数
static int ble_gatt_disc_chrs_by_uuid_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            const struct ble_gatt_chr *chr, void *arg){
    printf("ble_gatt_disc_chrs_by_uuid_cb\r\n");
    if(error->status == 0){
        uint8_t data_len = chr->uuid.u.type;
        uint8_t *uuid;
        if(data_len == 16){ // = 16 
            uint16_t value = chr->uuid.u16.value;
            uuid    = (uint8_t *)malloc(2);
            uuid[0] = (uint8_t)(value >> 8);        // 取高位字节
            uuid[1] = (uint8_t) value;             // 取低位字节
        }else if(data_len == 32){ // 32
            uint16_t value = chr->uuid.u32.value;
            uuid    = (uint8_t *)malloc(4);
            uuid[0] = (uint8_t)(value >> 24); // 取高位字节
            uuid[1] = (uint8_t)(value >> 16); // 取次高位字节
            uuid[2] = (uint8_t)(value >> 8);  // 取次低位字节
            uuid[3] = (uint8_t)value;         // 取低位字节
        }else{ // 128 
            uuid    = (uint8_t *)malloc(16);
            data_inver(chr->uuid.u128.value,uuid,16);
        }
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_CHARACTERISTIC_RESULT,
                arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_CHARACTERISTIC_RESULT),
                    arg_newInt(conn_handle),
                    arg_newInt(chr->def_handle),  
                    arg_newInt(chr->val_handle),
                    arg_newInt(chr->properties),
                    arg_newBytes(uuid,data_len/8)
                )));
        free(uuid);
        return 0;
    }else if(error->status == 14){
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_CHARACTERISTIC_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_CHARACTERISTIC_DONE),
                arg_newInt(conn_handle),
                arg_newInt(0)
                )));
        return 0;
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_CHARACTERISTIC_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_CHARACTERISTIC_DONE),
                arg_newInt(conn_handle),
                arg_newInt(error->status)
                )));
        return 0;
    }
}

// GATT 查找所有描述符回调函数
// TODO:把描述符也显示了
static int ble_gatt_disc_all_dscs_cb(uint16_t conn_handle,
                            const struct ble_gatt_error *error,
                            uint16_t chr_val_handle,
                            const struct ble_gatt_dsc *dsc,
                            void *arg){
    printf("ble_gatt_disc_all_dscs_cb\r\n");
    if(error->status == 0){        
        uint8_t data_len = dsc->uuid.u.type;
        uint8_t *uuid;
        if(data_len == 16){ // = 16 
            uint16_t value = dsc->uuid.u16.value;
            uuid    = (uint8_t *)malloc(2);
            uuid[0] = (uint8_t)(value >> 8);        // 取高位字节
            uuid[1] = (uint8_t) value;             // 取低位字节
        }else if(data_len == 32){ // 32
            uint16_t value = dsc->uuid.u32.value;
            uuid    = (uint8_t *)malloc(4);
            uuid[0] = (uint8_t)(value >> 24); // 取高位字节
            uuid[1] = (uint8_t)(value >> 16); // 取次高位字节
            uuid[2] = (uint8_t)(value >> 8);  // 取次低位字节
            uuid[3] = (uint8_t)value;         // 取低位字节
        }else{ // 128 
            uuid    = (uint8_t *)malloc(16);
            data_inver(dsc->uuid.u128.value,uuid,16);
        }
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_DESCRIPTOR_RESULT,
                arg_newObj(New_pikaTupleFrom(
                    arg_newInt(_IRQ_GATTC_DESCRIPTOR_RESULT),
                    arg_newInt(conn_handle),
                    // arg_newInt(chr_val_handle),
                    arg_newInt(dsc->handle),  
                    arg_newBytes(uuid,data_len/8)
                )));
        free(uuid);
        return 0;
    }else if(error->status == 14){
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_DESCRIPTOR_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_DESCRIPTOR_DONE),
                arg_newInt(conn_handle),
                arg_newInt(0)
                )));
        return 0;
    }else{
        pika_eventListener_send(g_pika_ble_listener,_IRQ_GATTC_DESCRIPTOR_DONE,
        arg_newObj(New_pikaTupleFrom(
                arg_newInt(_IRQ_GATTC_DESCRIPTOR_DONE),
                arg_newInt(conn_handle),
                arg_newInt(error->status)
                )));
        return 0;
    }   
    return 0;
}