alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Merge branch 'bugfix/change_log_print_forv5.0' into 'release/v5.0'

Browse Source 
ble_mesh:example:Add command to test the function of duplicate exceptional list(v5.0)

See merge request espressif/esp-idf!21125
This commit is contained in:
Jiang Jiang Jian 2022-12-02 20:33:05 +08:00
commit b20c0b59d9
6 changed files with 107 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_adapter.c
View File

@ -158,7 +158,7 @@ int ble_mesh_node_statistics_init(uint16_t package_num)
ble_mesh_node_statistics.total_package_num = package_num;
if (ble_mesh_node_statistics.package_index == NULL) {
ESP_LOGE(TAG, " %s, %d malloc fail\n", __func__, __LINE__);
return 1;
return ESP_ERR_NO_MEM;
}
ble_mesh_node_statistics.package_num = 0;
@ -318,12 +318,13 @@ int ble_mesh_test_performance_client_model_init(uint16_t node_num, uint32_t test
test_perf_statistics.time = malloc(test_num * sizeof(uint16_t));
if (test_perf_statistics.time == NULL) {
ESP_LOGE(TAG, " %s %d, malloc fail\n", __func__, __LINE__);
return 1;
return ESP_ERR_NO_MEM;
}
test_perf_statistics.package_index = malloc(test_num * sizeof(uint16_t));
if (test_perf_statistics.package_index == NULL) {
ESP_LOGE(TAG, " %s %d, malloc fail\n", __func__, __LINE__);
return ESP_ERR_NO_MEM;
}
for (i = 0; i < test_num; i++) {
test_perf_statistics.time[i] = 0;

5
examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_console_lib.h
View File

@ -16,6 +16,11 @@
#include "esp_console.h"
#include "argtable3/argtable3.h"
#ifndef MAC2STR
#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
#endif
bool str_2_mac(uint8_t *str, uint8_t *dest);
int hexstr_2_bin(const char *hex, uint8_t *buf, uint32_t len);
int get_value_string(char *value_in, char *buf);

2
examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_test_perf_client_cmd.c
View File

@ -126,7 +126,7 @@ int ble_mesh_test_performance_client_model(int argc, char **argv)
profile_data->model = model;
if (profile_data == NULL) {
ESP_LOGE(TAG, " %s, %d malloc fail\n", __func__, __LINE__);
return 1;
return ESP_ERR_NO_MEM;
}
arg_int_to_value(test_perf_client_model.playload_byte, profile_data->length, "length");

92
examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_register_cmd.c
View File

@ -20,6 +20,10 @@
#include "esp_ble_mesh_config_model_api.h"
#include "ble_mesh_console_decl.h"
/* We include the internal header file mesh_bearer_adapt.h here
just for some specific test purpose, which is not recommended for the other applications. */
#include "mesh_bearer_adapt.h"
typedef struct {
struct arg_str *static_val;
struct arg_int *static_val_len;
@ -145,6 +149,16 @@ typedef struct {
} ble_mesh_provisioner_heartbeat_t;
static ble_mesh_provisioner_heartbeat_t heartbeat;
#ifdef CONFIG_BLE_MESH_USE_DUPLICATE_SCAN
typedef struct {
struct arg_str *action_type;
struct arg_int *type;
struct arg_str *info;
struct arg_end *end;
} ble_mesh_exceptional_list_t;
static ble_mesh_exceptional_list_t exceptional_list_test;
#endif
void ble_mesh_register_cmd(void);
// Register callback function
void ble_mesh_prov_cb(esp_ble_mesh_prov_cb_event_t event, esp_ble_mesh_prov_cb_param_t *param);
@ -293,12 +307,12 @@ void ble_mesh_prov_cb(esp_ble_mesh_prov_cb_event_t event, esp_ble_mesh_prov_cb_p
break;
#if (CONFIG_BLE_MESH_PROVISIONER)
case ESP_BLE_MESH_PROVISIONER_RECV_UNPROV_ADV_PKT_EVT:
ESP_LOGD(TAG, "Provisioner recv unprovisioned device beacon:");
ESP_LOG_BUFFER_HEX("Device UUID", param->provisioner_recv_unprov_adv_pkt.dev_uuid, 16);
ESP_LOG_BUFFER_HEX("Address", param->provisioner_recv_unprov_adv_pkt.addr, 6);
ESP_LOGD(TAG, "Address type 0x%x, oob_info 0x%04x, adv_type 0x%x, bearer 0x%x",
param->provisioner_recv_unprov_adv_pkt.addr_type, param->provisioner_recv_unprov_adv_pkt.oob_info,
param->provisioner_recv_unprov_adv_pkt.adv_type, param->provisioner_recv_unprov_adv_pkt.bearer);
ESP_LOGI(TAG, "Provisioner:%s,"MACSTR",0x%x,0x%04x,0x%x",
param->provisioner_recv_unprov_adv_pkt.bearer == ESP_BLE_MESH_PROV_ADV ? "PB-ADV" : "PB-GATT",
MAC2STR(param->provisioner_recv_unprov_adv_pkt.addr),
param->provisioner_recv_unprov_adv_pkt.addr_type,
param->provisioner_recv_unprov_adv_pkt.oob_info,
param->provisioner_recv_unprov_adv_pkt.adv_type);
break;
case ESP_BLE_MESH_PROVISIONER_PROV_LINK_OPEN_EVT:
ESP_LOGI(TAG, "Provisioner:LinkOpen,OK,%d", param->provisioner_prov_link_open.bearer);
@ -530,6 +544,7 @@ static int ble_mesh_load_oob(int argc, char **argv)
static_val = malloc(oob.static_val_len->ival[0] + 1);
if (static_val == NULL) {
ESP_LOGE(TAG, "malloc fail,%s,%d\n", __func__, __LINE__);
return ESP_ERR_NO_MEM;
}
get_value_string((char *)oob.static_val->sval[0], (char *)static_val);
prov.static_val = static_val;
@ -547,6 +562,7 @@ static int ble_mesh_load_oob(int argc, char **argv)
static_val = malloc(oob.static_val_len->ival[0] + 1);
if (static_val == NULL) {
ESP_LOGE(TAG, "malloc fail,%s,%d\n", __func__, __LINE__);
return ESP_ERR_NO_MEM;
}
get_value_string((char *)oob.static_val->sval[0], (char *)static_val);
prov.prov_static_oob_val = static_val;
@ -586,6 +602,7 @@ int ble_mesh_init(int argc, char **argv)
device_uuid = malloc((ESP_BLE_MESH_OCTET16_LEN + 1) * sizeof(uint8_t));
if (device_uuid == NULL) {
ESP_LOGE(TAG, "ble mesh malloc failed, %d\n", __LINE__);
return ESP_ERR_NO_MEM;
}
err = get_value_string((char *)component.dev_uuid->sval[0], (char *)device_uuid);
if (err == ESP_OK) {
@ -675,6 +692,53 @@ int ble_mesh_node_enable_bearer(int argc, char **argv)
return err;
}
#ifdef CONFIG_BLE_MESH_USE_DUPLICATE_SCAN
int ble_mesh_exceptional_list_test(int argc, char **argv)
{
esp_err_t err = ESP_FAIL;
uint32_t type = BLE_MESH_EXCEP_INFO_MESH_BEACON;
uint8_t *info = NULL;
int nerrors = arg_parse(argc, argv, (void **) &exceptional_list_test);
if (nerrors != 0) {
arg_print_errors(stderr, exceptional_list_test.end, argv[0]);
return 1;
}
arg_int_to_value(exceptional_list_test.type, type, "device info type");
if (exceptional_list_test.info->count != 0) {
info = malloc((BD_ADDR_LEN + 1) * sizeof(uint8_t));
if (info == NULL) {
ESP_LOGE(TAG, "ble mesh malloc failed, %d\n", __LINE__);
return ESP_ERR_NO_MEM;
} else {
get_value_string((char *)exceptional_list_test.info->sval[0], (char *)info);
}
}
if (strcmp(exceptional_list_test.action_type->sval[0], "add") == 0) {
err = bt_mesh_update_exceptional_list(BLE_MESH_EXCEP_LIST_ADD, type, info);
} else if (strcmp(exceptional_list_test.action_type->sval[0], "remove") == 0) {
err = bt_mesh_update_exceptional_list( BLE_MESH_EXCEP_LIST_REMOVE, type, info);
} else if (strcmp(exceptional_list_test.action_type->sval[0], "clean") == 0) {
err = bt_mesh_update_exceptional_list(BLE_MESH_EXCEP_LIST_CLEAN, type, NULL);
}
if (err == ESP_OK) {
ESP_LOGI(TAG, "Bm:UpdateExcepList,OK\n");
} else {
ESP_LOGE(TAG, "Bm:UpdateExcepList,Fail\n");
}
if (info != NULL) {
free(info);
}
return err;
}
#endif
int ble_mesh_deinit(int argc, char **argv)
{
int err;
@ -1213,5 +1277,21 @@ void ble_mesh_register_cmd(void)
};
ESP_ERROR_CHECK(esp_console_cmd_register(&provisioner_heartbeat_cmd));
#ifdef CONFIG_BLE_MESH_USE_DUPLICATE_SCAN
exceptional_list_test.action_type = arg_str1("z", NULL, "<action type>", "action type");
exceptional_list_test.type = arg_int1("t", NULL, "<type>", "device info type");
exceptional_list_test.info = arg_str0("a", NULL, "<info>", "info");
exceptional_list_test.end = arg_end(1);
const esp_console_cmd_t ble_mesh_exceptional_list_test_cmd = {
.command = "bmel",
.help = "ble mesh: duplicate scan exceptional list test",
.hint = NULL,
.func = &ble_mesh_exceptional_list_test,
.argtable = &exceptional_list_test,
};
ESP_ERROR_CHECK(esp_console_cmd_register(&ble_mesh_exceptional_list_test_cmd));
#endif
init_transactions();
}

14
examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_register_server_cmd.c
View File

@ -46,7 +46,12 @@ int ble_mesh_module_publish_message(int argc, char **argv)
}
data = malloc(strlen(msg_publish.data->sval[0]));
get_value_string((char *)msg_publish.data->sval[0], (char *) data);
if (data == NULL) {
ESP_LOGE(TAG, "ble mesh malloc failed, %d\n", __LINE__);
return ESP_ERR_NO_MEM;
} else {
get_value_string((char *)msg_publish.data->sval[0], (char *) data);
}
arg_int_to_value(msg_publish.role, device_role, "device role");
model = ble_mesh_get_model(msg_publish.model->ival[0]);
@ -69,8 +74,11 @@ int ble_mesh_module_publish_message(int argc, char **argv)
if (msg_publish.data->count != 0) {
length = strlen(msg_publish.data->sval[0]);
data = malloc((length + 1) * sizeof(uint8_t));
if (data != NULL) {
err = get_value_string((char *)msg_publish.data->sval[0], (char *) data);
if (data == NULL) {
ESP_LOGE(TAG, "ble mesh malloc failed, %d\n", __LINE__);
return ESP_ERR_NO_MEM;
} else {
get_value_string((char *)msg_publish.data->sval[0], (char *) data);
}
}

5
examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/register_bluetooth.c
View File

@ -5,8 +5,8 @@
*/
#include "string.h"
#include "esp_console.h"
#include "ble_mesh_console_lib.h"
#ifdef CONFIG_BT_BLUEDROID_ENABLED
#include "esp_bt_device.h"
@ -16,9 +16,6 @@
#include "host/ble_hs.h"
#endif
#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
void register_ble_address(void);
void register_bluetooth(void)