From 76e254cfb0901f08597fe58499fff48d3a385667 Mon Sep 17 00:00:00 2001 From: Yuan Hong Hui Date: Fri, 30 Dec 2022 10:16:42 +0800 Subject: [PATCH] ble_mesh:example:change position of vendor model and generic onoff model callback(v4.2) --- .../ble_mesh_console/main/ble_mesh_adapter.h | 1 + .../ble_mesh_console/main/ble_mesh_model.h | 12 +- .../main/ble_mesh_reg_cfg_client_cmd.c | 12 +- .../main/ble_mesh_reg_gen_onoff_client_cmd.c | 74 ++++- .../main/ble_mesh_reg_test_perf_client_cmd.c | 125 ++++++-- .../main/ble_mesh_register_cmd.c | 287 +++--------------- 6 files changed, 229 insertions(+), 282 deletions(-) diff --git a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_adapter.h b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_adapter.h index de39517d22..04f43085f6 100644 --- a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_adapter.h +++ b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_adapter.h @@ -73,6 +73,7 @@ typedef struct { ble_mesh_node_statistics_t ble_mesh_node_statistics; extern SemaphoreHandle_t ble_mesh_node_sema; +extern ble_mesh_node_status node_status; #define SEND_MESSAGE_TIMEOUT (30000/portTICK_RATE_MS) diff --git a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_model.h b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_model.h index b0582f3a08..50d36fccf5 100644 --- a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_model.h +++ b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_model.h @@ -76,11 +76,19 @@ extern esp_ble_mesh_model_t config_models[]; #if (CONFIG_BLE_MESH_CFG_CLI) void ble_mesh_configuration_client_model_cb(esp_ble_mesh_cfg_client_cb_event_t event, - esp_ble_mesh_cfg_client_cb_param_t *param); + esp_ble_mesh_cfg_client_cb_param_t *param); #endif #if (CONFIG_BLE_MESH_GENERIC_ONOFF_CLI) void ble_mesh_generic_onoff_client_model_cb(esp_ble_mesh_generic_client_cb_event_t event, - esp_ble_mesh_generic_client_cb_param_t *param); + esp_ble_mesh_generic_client_cb_param_t *param); #endif + +#if(CONFIG_BLE_MESH_GENERIC_SERVER) +void ble_mesh_generic_server_model_cb(esp_ble_mesh_generic_server_cb_event_t event, + esp_ble_mesh_generic_server_cb_param_t *param); +#endif + +void ble_mesh_vendor_model_cb(esp_ble_mesh_model_cb_event_t event, esp_ble_mesh_model_cb_param_t *param); + #endif //_BLE_MESH_CFG_SRV_MODEL_H_ diff --git a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_cfg_client_cmd.c b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_cfg_client_cmd.c index 0631844f5a..41e8b9ba66 100644 --- a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_cfg_client_cmd.c +++ b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_cfg_client_cmd.c @@ -43,10 +43,10 @@ void ble_mesh_register_configuration_client_model(void) } void ble_mesh_configuration_client_model_cb(esp_ble_mesh_cfg_client_cb_event_t event, - esp_ble_mesh_cfg_client_cb_param_t *param) + esp_ble_mesh_cfg_client_cb_param_t *param) { uint32_t opcode; - ESP_LOGD(TAG, "enter %s, event = %x\n, error_code = %x\n", __func__, event, param->error_code); + ESP_LOGD(TAG, "enter %s, event = %x, error_code = %x", __func__, event, param->error_code); if (!param->error_code) { opcode = param->params->opcode; @@ -120,7 +120,7 @@ void ble_mesh_configuration_client_model_cb(esp_ble_mesh_cfg_client_cb_event_t e if (param->status_cb.model_pub_status.status == ESP_OK) { ESP_LOGI(TAG, "CfgClient:PublishSet,OK,0x%x", param->status_cb.model_pub_status.publish_addr); } else { - ESP_LOGI(TAG, "CfgClient:PublishSet,Fail"); + ESP_LOGI(TAG, "CfgClient:PublishSet,Fail,%d", param->status_cb.model_pub_status.status); } break; case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_ADD: @@ -208,7 +208,7 @@ void ble_mesh_configuration_client_model_cb(esp_ble_mesh_cfg_client_cb_event_t e } else { ESP_LOGI(TAG, "CnfClient:Fail,%d", param->error_code); } - ESP_LOGD(TAG, "exit %s \n", __func__); + ESP_LOGD(TAG, "exit %s", __func__); } int ble_mesh_configuration_client_model_operation(int argc, char **argv) @@ -258,8 +258,6 @@ int ble_mesh_configuration_client_model_operation(int argc, char **argv) return ESP_FAIL; } - ESP_LOGD(TAG, "enter %s \n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &configuration_client_model_operation); if (nerrors != 0) { arg_print_errors(stderr, configuration_client_model_operation.end, argv[0]); @@ -382,8 +380,6 @@ int ble_mesh_configuration_client_model_operation(int argc, char **argv) } else { ESP_LOGI(TAG, "ConfigClient:Fail"); } - - ESP_LOGD(TAG, "exit %s %d\n", __func__, err); return err; } diff --git a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_gen_onoff_client_cmd.c b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_gen_onoff_client_cmd.c index 81ee346757..f207f7e694 100644 --- a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_gen_onoff_client_cmd.c +++ b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_gen_onoff_client_cmd.c @@ -14,6 +14,8 @@ #include "esp_timer.h" #include "ble_mesh_adapter.h" +#include "esp_ble_mesh_defs.h" +#include "esp_ble_mesh_networking_api.h" #if (CONFIG_BLE_MESH_GENERIC_ONOFF_CLI) typedef struct { @@ -40,7 +42,7 @@ void ble_mesh_register_gen_onoff_client(void) } void ble_mesh_generic_onoff_client_model_cb(esp_ble_mesh_generic_client_cb_event_t event, - esp_ble_mesh_generic_client_cb_param_t *param) + esp_ble_mesh_generic_client_cb_param_t *param) { uint32_t opcode = param->params->opcode; @@ -100,7 +102,72 @@ void ble_mesh_generic_onoff_client_model_cb(esp_ble_mesh_generic_client_cb_event default: break; } - ESP_LOGD(TAG, "exit %s \n", __func__); + ESP_LOGD(TAG, "exit %s", __func__); +} + +void ble_mesh_generic_server_model_cb(esp_ble_mesh_generic_server_cb_event_t event, + esp_ble_mesh_generic_server_cb_param_t *param) +{ + uint32_t opcode = param->ctx.recv_op; + uint8_t status; + + ESP_LOGD(TAG, "enter %s: event is %d, opcode is 0x%04x", __func__, event, opcode); + + switch (event) { + case ESP_BLE_MESH_GENERIC_SERVER_STATE_CHANGE_EVT: + if (opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET) { + ESP_LOGI(TAG, "GenOnOffServer:Set,OK,%d", param->value.state_change.onoff_set.onoff); + ble_mesh_node_set_state(param->value.state_change.onoff_set.onoff); + } else if (opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK) { + ESP_LOGI(TAG, "GenOnOffServer:SetUnAck,OK,%d", param->value.state_change.onoff_set.onoff); + ble_mesh_node_set_state(param->value.state_change.onoff_set.onoff); + } + break; + case ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT: { + switch (opcode) { + case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_GET: + ESP_LOGI(TAG, "GenOnOffServer:Get,OK"); + ble_mesh_node_get_state(status); + esp_ble_mesh_server_model_send_msg(param->model, ¶m->ctx, ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, + sizeof(status), &status); + break; + default: + break; + } + break; + } + case ESP_BLE_MESH_GENERIC_SERVER_RECV_SET_MSG_EVT: { + if (opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET || opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK) { + esp_ble_mesh_gen_onoff_srv_t *srv = param->model->user_data; + if (param->value.set.onoff.op_en == false) { + srv->state.onoff = param->value.set.onoff.onoff; + } else { + /* TODO: Delay and state transition */ + srv->state.onoff = param->value.set.onoff.onoff; + } + } + + switch (opcode) { + case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET: + ESP_LOGI(TAG, "GenOnOffServer:Set,OK,%d", param->value.set.onoff.onoff); + ble_mesh_node_set_state(param->value.set.onoff.onoff); + ble_mesh_node_get_state(status); + esp_ble_mesh_server_model_send_msg(param->model, ¶m->ctx, ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, + sizeof(status), &status); + break; + case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK: + ble_mesh_node_set_state(param->value.set.onoff.onoff); + ESP_LOGI(TAG, "GenOnOffServer:SetUnAck,OK,%d", param->value.set.onoff.onoff); + break; + default: + break; + } + break; + } + default: + break; + } + ESP_LOGD(TAG, "exit %s", __func__); } int ble_mesh_generic_onoff_client_model(int argc, char **argv) @@ -114,8 +181,6 @@ int ble_mesh_generic_onoff_client_model(int argc, char **argv) .ctx.send_ttl = 7, }; - ESP_LOGD(TAG, "enter %s\n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &gen_onoff_state); if (nerrors != 0) { arg_print_errors(stderr, gen_onoff_state.end, argv[0]); @@ -153,7 +218,6 @@ int ble_mesh_generic_onoff_client_model(int argc, char **argv) err = esp_ble_mesh_generic_client_set_state(&onoff_common, &gen_client_set); } } - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } diff --git a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_test_perf_client_cmd.c b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_test_perf_client_cmd.c index 89043abeaa..dba40a11e8 100644 --- a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_test_perf_client_cmd.c +++ b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_reg_test_perf_client_cmd.c @@ -45,6 +45,8 @@ typedef struct { } ble_mesh_test_perf_client_model_statistics_t; ble_mesh_test_perf_client_model_statistics_t test_perf_client_model_statistics; +bool deinit_flag = false; + void ble_mesh_performance_client_model_command(void); void ble_mesh_register_mesh_test_performance_client(void) @@ -52,6 +54,89 @@ void ble_mesh_register_mesh_test_performance_client(void) ble_mesh_performance_client_model_command(); } +void ble_mesh_vendor_model_cb(esp_ble_mesh_model_cb_event_t event, esp_ble_mesh_model_cb_param_t *param) +{ + uint16_t result; + uint8_t data[4]; + uint64_t *start_time = NULL; + transaction_t *trans = NULL; + + ESP_LOGD(TAG, "enter %s, event=%x", __func__, event); + do { + trans = transaction_get(TRANS_TYPE_MESH_PERF, TRANS_MESH_SEND_MESSAGE, trans); + if (trans) { + start_time = (uint64_t *)trans->input; + break; + } + }while(trans); + + switch (event) { + case ESP_BLE_MESH_MODEL_OPERATION_EVT: + if (param->model_operation.model != NULL && param->model_operation.model->op != NULL) { + if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_SET) { + ESP_LOGI(TAG, "VndSrvModel:SetAck,Success,%d", param->model_operation.ctx->recv_ttl); + data[0] = param->model_operation.msg[0]; + data[1] = param->model_operation.msg[1]; + data[2] = param->model_operation.msg[2]; + data[3] = param->model_operation.ctx->recv_ttl; + result = ble_mesh_node_statistics_accumulate(param->model_operation.msg, param->model_operation.length, VENDOR_MODEL_PERF_OPERATION_TYPE_SET); + if (result == 0) { + esp_ble_mesh_server_model_send_msg(param->model_operation.model, param->model_operation.ctx, + ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_STATUS, sizeof(data), data); + } + } else if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_SET_UNACK) { + ESP_LOGI(TAG, "VndSrvModel:SetUnAck,Success,%d,%d", param->model_operation.ctx->recv_ttl, param->model_operation.length); + result = ble_mesh_node_statistics_accumulate(param->model_operation.msg, param->model_operation.length, VENDOR_MODEL_PERF_OPERATION_TYPE_SET_UNACK); + } else if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_STATUS) { + if (trans) { + uint64_t current_time = esp_timer_get_time(); + result = ble_mesh_test_performance_client_model_accumulate_time(((uint32_t)(current_time - *start_time) / 1000), param->model_operation.msg, + param->model_operation.ctx->recv_ttl, param->model_operation.length); + transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); + } + } + } + break; + case ESP_BLE_MESH_MODEL_SEND_COMP_EVT: + if (param->model_send_comp.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_SET_UNACK) { + transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); + } + if (param->model_send_comp.err_code == ESP_OK) { + ESP_LOGI(TAG, "VndModel:ModelSend,OK"); + } else { + ESP_LOGE(TAG, "VndModel:ModelSend,Fail"); + } + break; + case ESP_BLE_MESH_MODEL_PUBLISH_COMP_EVT: + ESP_LOGI(TAG, "VndModel:PublishSend,OK,0x%x,%d,", param->model_publish_comp.model->model_id, param->model_publish_comp.model->pub->msg->len); + break; + case ESP_BLE_MESH_CLIENT_MODEL_RECV_PUBLISH_MSG_EVT: + ESP_LOGI(TAG, "VndModel:PublishReceive,OK,0x%06x,%d,%d", param->client_recv_publish_msg.opcode, param->client_recv_publish_msg.length, param->client_recv_publish_msg.msg[1]); + if (trans) { + uint64_t current_time = esp_timer_get_time(); + result = ble_mesh_test_performance_client_model_accumulate_time(((uint32_t)(current_time - *start_time) / 2000), param->client_recv_publish_msg.msg, + param->client_recv_publish_msg.ctx->recv_ttl, param->client_recv_publish_msg.length); + transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); + } + break; + case ESP_BLE_MESH_MODEL_PUBLISH_UPDATE_EVT: + ESP_LOGI(TAG, "VndModel:PublishUpdate,OK"); + break; + case ESP_BLE_MESH_CLIENT_MODEL_SEND_TIMEOUT_EVT: + ESP_LOGI(TAG, "VndModel:TimeOut,0x%06x", param->client_send_timeout.opcode); + if (trans) { + transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); + } + break; + case ESP_BLE_MESH_MODEL_EVT_MAX: + ESP_LOGI(TAG, "VndModel:MaxEvt"); + break; + default: + break; + } + +} + void ble_mesh_test_performance_client_model_throughput(void *params) { uint16_t i; @@ -62,8 +147,6 @@ void ble_mesh_test_performance_client_model_throughput(void *params) ble_mesh_test_perf_throughput_data *profile_context = (ble_mesh_test_perf_throughput_data *)params; esp_err_t result = ESP_OK; - ESP_LOGD(TAG, "enter %s\n", __func__); - ctx.net_idx = profile_context->net_idx; ctx.app_idx = profile_context->app_idx; ctx.addr = profile_context->address; @@ -74,7 +157,7 @@ void ble_mesh_test_performance_client_model_throughput(void *params) // create send data data = malloc(profile_context->length); if (data == NULL) { - ESP_LOGE(TAG, " %s, %d, malloc fail\n", __func__, __LINE__); + ESP_LOGE(TAG, " %s, %d, malloc fail", __func__, __LINE__); goto cleanup; } @@ -88,13 +171,22 @@ void ble_mesh_test_performance_client_model_throughput(void *params) profile_context->length, data, 8000, profile_context->need_ack, profile_context->device_role); - ble_mesh_test_performance_client_model_accumulate_statistics(profile_context->length); - transaction_run(trans); - if (result == ESP_OK) { - ESP_LOGI(TAG, "VendorModel:SendPackage,OK"); - } else { - ESP_LOGI(TAG, "VendorModel:SendPackage,Fail"); + if (result != ESP_OK) { + ESP_LOGE(TAG, "VendorModel:SendPackage,Fail"); + } + + ble_mesh_test_performance_client_model_accumulate_statistics(profile_context->length); + + if (deinit_flag) { + ESP_LOGI(TAG, "Already deinit, stop sending message"); + break; + } + + result = transaction_run(trans); + if (result == ESP_ERR_INVALID_STATE) { + ESP_LOGI(TAG, "Already deinit, transactions abort"); + break; } } @@ -105,7 +197,6 @@ cleanup: if (data != NULL) { free(data); } - ESP_LOGD(TAG, "exit %s\n", __func__); vTaskDelete(NULL); } @@ -117,7 +208,6 @@ int ble_mesh_test_performance_client_model(int argc, char **argv) ble_mesh_test_perf_throughput_data *profile_data = NULL; uint16_t company_id = CID_ESP; - ESP_LOGD(TAG, "enter %s\n", __func__); int nerrors = arg_parse(argc, argv, (void **) &test_perf_client_model); if (nerrors != 0) { arg_print_errors(stderr, test_perf_client_model.end, argv[0]); @@ -132,7 +222,7 @@ int ble_mesh_test_performance_client_model(int argc, char **argv) model = esp_ble_mesh_find_vendor_model(element, company_id, ESP_BLE_MESH_VND_MODEL_ID_TEST_PERF_CLI); if (!model) { - ESP_LOGI(TAG, "VendorClient:LoadModel,Fail"); + ESP_LOGE(TAG, "VendorClient:LoadModel,Fail"); return ESP_FAIL; } @@ -147,7 +237,7 @@ int ble_mesh_test_performance_client_model(int argc, char **argv) profile_data = malloc(sizeof(ble_mesh_test_perf_throughput_data)); profile_data->model = model; if (profile_data == NULL) { - ESP_LOGE(TAG, " %s, %d malloc fail\n", __func__, __LINE__); + ESP_LOGE(TAG, " %s, %d malloc fail", __func__, __LINE__); return ESP_ERR_NO_MEM; } @@ -169,7 +259,6 @@ int ble_mesh_test_performance_client_model(int argc, char **argv) xTaskCreate(ble_mesh_test_performance_client_model_throughput, "MESHTHROUGHPUTSEND", 4048, profile_data, 1, NULL); } - ESP_LOGD(TAG, "exit %s\n", __func__); return result; } @@ -177,7 +266,6 @@ int ble_mesh_test_performance_client_model_performance(int argc, char **argv) { uint8_t result = 0; - ESP_LOGD(TAG, "enter %s\n", __func__); int nerrors = arg_parse(argc, argv, (void **) &test_perf_client_model_statistics); if (nerrors != 0) { arg_print_errors(stderr, test_perf_client_model_statistics.end, argv[0]); @@ -188,19 +276,18 @@ int ble_mesh_test_performance_client_model_performance(int argc, char **argv) result = ble_mesh_test_performance_client_model_init(test_perf_client_model_statistics.node_num->ival[0], test_perf_client_model_statistics.test_size->ival[0], test_perf_client_model_statistics.ttl->ival[0]); if (result == 0) { - ESP_LOGI(TAG, "VendorPerfTest:InitStatistics,OK\n"); + ESP_LOGI(TAG, "VendorPerfTest:InitStatistics,OK"); } } else if (strcmp(test_perf_client_model_statistics.action_type->sval[0], "get") == 0) { ble_mesh_test_performance_client_model_get(); } else if (strcmp(test_perf_client_model_statistics.action_type->sval[0], "destroy") == 0) { ble_mesh_test_performance_client_model_destroy(); - ESP_LOGI(TAG, "VendorPerfTest:DestroyStatistics,OK\n"); + ESP_LOGI(TAG, "VendorPerfTest:DestroyStatistics,OK"); } else if (strcmp(test_perf_client_model_statistics.action_type->sval[0], "percent") == 0) { ble_mesh_test_performance_client_model_get_received_percent(); - ESP_LOGI(TAG, "VendorPerfTest:GetPercent,OK\n"); + ESP_LOGI(TAG, "VendorPerfTest:GetPercent,OK"); } - ESP_LOGD(TAG, "exit %s\n", __func__); return 0; } diff --git a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_register_cmd.c b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_register_cmd.c index 1a2bec4497..ee65cc19df 100644 --- a/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_register_cmd.c +++ b/examples/bluetooth/esp_ble_mesh/ble_mesh_console/main/ble_mesh_register_cmd.c @@ -167,18 +167,18 @@ typedef struct { static ble_mesh_exceptional_list_t exceptional_list_test; #endif +extern bool deinit_flag; extern void ble_mesh_generic_onoff_client_model_cb(esp_ble_mesh_generic_client_cb_event_t event, - esp_ble_mesh_generic_client_cb_param_t *param); + esp_ble_mesh_generic_client_cb_param_t *param); extern void ble_mesh_configuration_client_model_cb(esp_ble_mesh_cfg_client_cb_event_t event, - esp_ble_mesh_cfg_client_cb_param_t *param); + esp_ble_mesh_cfg_client_cb_param_t *param); +extern void ble_mesh_vendor_model_cb(esp_ble_mesh_model_cb_event_t event, esp_ble_mesh_model_cb_param_t *param); +extern void ble_mesh_generic_server_model_cb(esp_ble_mesh_generic_server_cb_event_t event, + esp_ble_mesh_generic_server_cb_param_t *param); 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); -void ble_mesh_model_cb(esp_ble_mesh_model_cb_event_t event, esp_ble_mesh_model_cb_param_t *param); -void ble_mesh_generic_server_model_cb(esp_ble_mesh_generic_server_cb_event_t event, - esp_ble_mesh_generic_server_cb_param_t *param); - void ble_mesh_register_mesh_node(void) { @@ -187,92 +187,38 @@ void ble_mesh_register_mesh_node(void) int ble_mesh_register_cb(int argc, char** argv) { - ESP_LOGD(TAG, "enter %s\n", __func__); esp_ble_mesh_register_prov_callback(ble_mesh_prov_cb); - esp_ble_mesh_register_custom_model_callback(ble_mesh_model_cb); + esp_ble_mesh_register_custom_model_callback(ble_mesh_vendor_model_cb); esp_ble_mesh_register_generic_server_callback(ble_mesh_generic_server_model_cb); esp_ble_mesh_register_generic_client_callback(ble_mesh_generic_onoff_client_model_cb); esp_ble_mesh_register_config_client_callback(ble_mesh_configuration_client_model_cb); ESP_LOGI(TAG, "Bm:Reg,OK"); - ESP_LOGD(TAG, "exit %s\n", __func__); return 0; } -void ble_mesh_generic_server_model_cb(esp_ble_mesh_generic_server_cb_event_t event, - esp_ble_mesh_generic_server_cb_param_t *param) -{ - uint32_t opcode = param->ctx.recv_op; - uint8_t status; - - ESP_LOGD(TAG, "enter %s: event is %d, opcode is 0x%x\n", __func__, event, opcode); - - switch (event) { - case ESP_BLE_MESH_GENERIC_SERVER_STATE_CHANGE_EVT: - if (opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET) { - ESP_LOGI(TAG, "GenOnOffServer:SetStatus,OK,%d", param->value.state_change.onoff_set.onoff); - ble_mesh_node_set_state(param->value.state_change.onoff_set.onoff); - } else if (opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK) { - ESP_LOGI(TAG, "GenOnOffServer:SetUnAck,OK,%d", param->value.state_change.onoff_set.onoff); - ble_mesh_node_set_state(param->value.state_change.onoff_set.onoff); - } - break; - case ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT: { - switch (opcode) { - case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_GET: - ESP_LOGI(TAG, "GenOnOffServer:GetStatus,OK"); - ble_mesh_node_get_state(status); - esp_ble_mesh_server_model_send_msg(param->model, ¶m->ctx, ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, - sizeof(status), &status); - break; - default: - break; - } - break; - } - case ESP_BLE_MESH_GENERIC_SERVER_RECV_SET_MSG_EVT: { - if (opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET || opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK) { - esp_ble_mesh_gen_onoff_srv_t *srv = param->model->user_data; - if (param->value.set.onoff.op_en == false) { - srv->state.onoff = param->value.set.onoff.onoff; - } else { - /* TODO: Delay and state transition */ - srv->state.onoff = param->value.set.onoff.onoff; - } - } - - switch (opcode) { - case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET: - ESP_LOGI(TAG, "GenOnOffServer:SetStatus,OK,%d", param->value.set.onoff.onoff); - ble_mesh_node_set_state(param->value.set.onoff.onoff); - ble_mesh_node_get_state(status); - esp_ble_mesh_server_model_send_msg(param->model, ¶m->ctx, ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, - sizeof(status), &status); - break; - case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK: - ble_mesh_node_set_state(param->value.set.onoff.onoff); - ESP_LOGI(TAG, "GenOnOffServer:SetUNACK,OK,%d", param->value.set.onoff.onoff); - break; - default: - break; - } - break; - } - default: - break; - } - ESP_LOGD(TAG, "exit %s \n", __func__); -} - void ble_mesh_prov_cb(esp_ble_mesh_prov_cb_event_t event, esp_ble_mesh_prov_cb_param_t *param) { + transaction_t *trans = NULL; ESP_LOGD(TAG, "enter %s, event = %d", __func__, event); switch (event) { case ESP_BLE_MESH_PROV_REGISTER_COMP_EVT: ble_mesh_callback_check_err_code(param->prov_register_comp.err_code, "Bm:Init"); + if (param->prov_register_comp.err_code == ESP_OK) { + deinit_flag = false; + } break; case ESP_BLE_MESH_DEINIT_MESH_COMP_EVT: ble_mesh_callback_check_err_code(param->deinit_mesh_comp.err_code, "Bm:DeInit"); + if (param->deinit_mesh_comp.err_code == ESP_OK) { + deinit_flag = true; + do { + trans = transaction_get(TRANS_TYPE_MESH_PERF, TRANS_MESH_SEND_MESSAGE, trans); + if (trans) { + transaction_abort(trans, ESP_ERR_INVALID_STATE); + } + }while(trans); + } break; case ESP_BLE_MESH_NODE_PROV_ENABLE_COMP_EVT: ble_mesh_callback_check_err_code(param->node_prov_enable_comp.err_code, "Node:EnBearer"); @@ -388,117 +334,10 @@ void ble_mesh_prov_cb(esp_ble_mesh_prov_cb_event_t event, esp_ble_mesh_prov_cb_p ESP_LOGD(TAG, "exit %s", __func__); } -void ble_mesh_model_cb(esp_ble_mesh_model_cb_event_t event, esp_ble_mesh_model_cb_param_t *param) -{ - uint16_t result; - uint8_t data[4]; - esp_err_t outcome = ESP_OK; - uint8_t status; - uint64_t *start_time = NULL; - transaction_t *trans = NULL; - - ESP_LOGD(TAG, "enter %s, event=%x\n", __func__, event); - do { - trans = transaction_get(TRANS_TYPE_MESH_PERF, TRANS_MESH_SEND_MESSAGE, trans); - if (trans) { - start_time = (uint64_t *)trans->input; - break; - } - }while(trans); - - switch (event) { - case ESP_BLE_MESH_MODEL_OPERATION_EVT: - if (param->model_operation.model != NULL && param->model_operation.model->op != NULL) { - if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_SET) { - ESP_LOGI(TAG, "VendorModel:SetAck,Success,%d", param->model_operation.ctx->recv_ttl); - data[0] = param->model_operation.msg[0]; - data[1] = param->model_operation.msg[1]; - data[2] = param->model_operation.msg[2]; - data[3] = param->model_operation.ctx->recv_ttl; - result = ble_mesh_node_statistics_accumulate(param->model_operation.msg, param->model_operation.length, VENDOR_MODEL_PERF_OPERATION_TYPE_SET); - if (result == 0) { - esp_ble_mesh_server_model_send_msg(param->model_operation.model, param->model_operation.ctx, - ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_STATUS, sizeof(data), data); - } - } else if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_SET_UNACK) { - ESP_LOGI(TAG, "VendorModel:SetUnAck,Success,%d,%d", param->model_operation.ctx->recv_ttl, param->model_operation.length); - result = ble_mesh_node_statistics_accumulate(param->model_operation.msg, param->model_operation.length, VENDOR_MODEL_PERF_OPERATION_TYPE_SET_UNACK); - } - else if (param->model_operation.opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_GET) { - ESP_LOGI(TAG, "Node:GetStatus,OK"); - ble_mesh_node_get_state(status); - outcome = esp_ble_mesh_server_model_send_msg(param->model_operation.model, param->model_operation.ctx, ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, - sizeof(status), &status); - if (outcome != ESP_OK) { - ESP_LOGE(TAG, "Node:SendMsg,Fail"); - } - } else if (param->model_operation.opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET) { - ble_mesh_node_set_state(param->model_operation.msg[0]); - ESP_LOGI(TAG, "Node:SetAck,OK,%d,%d", param->model_operation.msg[0], param->model_operation.ctx->recv_ttl); - outcome = esp_ble_mesh_server_model_send_msg(param->model_operation.model, param->model_operation.ctx, ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, - sizeof(status), param->model_operation.msg); - if (outcome != ESP_OK) { - ESP_LOGE(TAG, "Node:SendMsg,Fail"); - } - } else if (param->model_operation.opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_SET_UNACK) { - ble_mesh_node_set_state(param->model_operation.msg[0]); - ESP_LOGI(TAG, "Node:SetUnAck,OK,%d,%d", param->model_operation.msg[0], param->model_operation.ctx->recv_ttl); - } else if (param->model_operation.opcode == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS) { - ESP_LOGI(TAG, "Node:Status,Success,%d", param->model_operation.length); - } else if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_SET) { - ESP_LOGI(TAG, "VendorModel:SetAck,OK,%d", param->model_operation.ctx->recv_ttl); - } else if (param->model_operation.opcode == ESP_BLE_MESH_VND_MODEL_OP_TEST_PERF_STATUS) { - if (trans) { - uint64_t current_time = esp_timer_get_time(); - outcome = ble_mesh_test_performance_client_model_accumulate_time(((uint32_t)(current_time - *start_time) / 1000), param->model_operation.msg, - param->model_operation.ctx->recv_ttl, param->model_operation.length); - transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); - } - } - } - break; - case ESP_BLE_MESH_MODEL_SEND_COMP_EVT: - if (param->model_send_comp.err_code == ESP_OK) { - ESP_LOGI(TAG, "Node:ModelSend,OK"); - } else { - ESP_LOGE(TAG, "Node:ModelSend,Fail"); - } - break; - case ESP_BLE_MESH_MODEL_PUBLISH_COMP_EVT: - ESP_LOGI(TAG, "PublishSend,OK,0x%x,%d,", param->model_publish_comp.model->model_id, param->model_publish_comp.model->pub->msg->len); - break; - case ESP_BLE_MESH_CLIENT_MODEL_RECV_PUBLISH_MSG_EVT: - ESP_LOGI(TAG, "Node:PublishReceive,OK,0x%04X,%d,%d", param->client_recv_publish_msg.opcode, param->client_recv_publish_msg.length, param->client_recv_publish_msg.msg[1]); - if (trans) { - uint64_t current_time = esp_timer_get_time(); - outcome = ble_mesh_test_performance_client_model_accumulate_time(((uint32_t)(current_time - *start_time) / 2000), param->client_recv_publish_msg.msg, - param->client_recv_publish_msg.ctx->recv_ttl, param->client_recv_publish_msg.length); - transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); - } - break; - case ESP_BLE_MESH_MODEL_PUBLISH_UPDATE_EVT: - ESP_LOGI(TAG, "PublishUpdate,OK"); - break; - case ESP_BLE_MESH_CLIENT_MODEL_SEND_TIMEOUT_EVT: - ESP_LOGI(TAG, "Node:TimeOut, 0x%04X", param->client_send_timeout.opcode); - if (trans) { - transaction_set_events(trans, TRANS_MESH_SEND_MESSAGE_EVT); - } - break; - case ESP_BLE_MESH_MODEL_EVT_MAX: - ESP_LOGI(TAG, "Node:MaxEvt"); - break; - default: - break; - } - - ESP_LOGD(TAG, "exit %s\n", __func__); -} - int ble_mesh_power_set(int argc, char **argv) { esp_err_t result = ESP_OK; - ESP_LOGD(TAG, "enter %s\n", __func__); + int nerrors = arg_parse(argc, argv, (void **) &power_set); if (nerrors != 0) { arg_print_errors(stderr, power_set.end, argv[0]); @@ -518,9 +357,8 @@ int ble_mesh_power_set(int argc, char **argv) } if (result == ESP_OK) { - ESP_LOGI(TAG, "Node:SetPower,OK\n"); + ESP_LOGI(TAG, "Node:SetPower,OK"); } - ESP_LOGD(TAG, "exit %s\n", __func__); return result; } @@ -541,8 +379,6 @@ static int ble_mesh_load_oob(int argc, char **argv) { uint8_t *static_val; - ESP_LOGD(TAG, "enter %s \n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &oob); if (nerrors != 0) { arg_print_errors(stderr, oob.end, argv[0]); @@ -558,7 +394,7 @@ static int ble_mesh_load_oob(int argc, char **argv) if (oob.static_val->count != 0) { static_val = malloc(oob.static_val_len->ival[0] + 1); if (static_val == NULL) { - ESP_LOGE(TAG, "malloc fail,%s,%d\n", __func__, __LINE__); + ESP_LOGE(TAG, "malloc fail,%s,%d", __func__, __LINE__); return ESP_ERR_NO_MEM; } get_value_string((char *)oob.static_val->sval[0], (char *)static_val); @@ -576,7 +412,7 @@ static int ble_mesh_load_oob(int argc, char **argv) if (oob.static_val->count != 0) { static_val = malloc(oob.static_val_len->ival[0] + 1); if (static_val == NULL) { - ESP_LOGE(TAG, "malloc fail,%s,%d\n", __func__, __LINE__); + ESP_LOGE(TAG, "malloc fail,%s,%d", __func__, __LINE__); return ESP_ERR_NO_MEM; } get_value_string((char *)oob.static_val->sval[0], (char *)static_val); @@ -586,9 +422,7 @@ static int ble_mesh_load_oob(int argc, char **argv) arg_int_to_value(oob.static_val_len, prov.prov_static_oob_len, "provisioner static value length"); #endif - ESP_LOGI(TAG, "OOB:Load,OK\n"); - - ESP_LOGD(TAG, "exit %s\n", __func__); + ESP_LOGI(TAG, "OOB:Load,OK"); return 0; } @@ -606,17 +440,16 @@ int ble_mesh_init(int argc, char **argv) err = ble_mesh_init_node_prestore_params(); if (err != ESP_OK) { - ESP_LOGE(TAG, "Bm:NodeInitPreParam,Fail\n"); + ESP_LOGE(TAG, "Bm:NodeInitPreParam,Fail"); return err; } - ESP_LOGD(TAG, "enter %s, module %x\n", __func__, component.model_type->ival[0]); local_component = ble_mesh_get_component(component.model_type->ival[0]); if (component.dev_uuid->count != 0) { 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__); + ESP_LOGE(TAG, "ble mesh malloc failed, %d", __LINE__); return ESP_ERR_NO_MEM; } err = get_value_string((char *)component.dev_uuid->sval[0], (char *)device_uuid); @@ -635,7 +468,6 @@ int ble_mesh_init(int argc, char **argv) err = esp_ble_mesh_init(&prov, local_component); free(device_uuid); - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } @@ -647,8 +479,6 @@ int ble_mesh_provisioner_heartbeat(int argc, char** argv) esp_ble_mesh_heartbeat_filter_info_t info; uint8_t op = 0; - ESP_LOGD(TAG, "enter %s\n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &heartbeat); if (nerrors != 0) { arg_print_errors(stderr, heartbeat.end, argv[0]); @@ -670,12 +500,10 @@ int ble_mesh_provisioner_heartbeat(int argc, char** argv) } if(result == ESP_OK){ - ESP_LOGI(TAG, "provisioner:OK\n"); + ESP_LOGI(TAG, "provisioner:OK"); }else{ - ESP_LOGE(TAG, "provisioner:ERROR\n"); + ESP_LOGE(TAG, "provisioner:ERROR"); } - - ESP_LOGD(TAG, "exit %s\n", __func__); return result; } @@ -683,8 +511,6 @@ int ble_mesh_node_enable_bearer(int argc, char **argv) { esp_err_t err = 0; - ESP_LOGD(TAG, "enter %s \n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &bearer); if (nerrors != 0) { arg_print_errors(stderr, bearer.end, argv[0]); @@ -702,8 +528,6 @@ int ble_mesh_node_enable_bearer(int argc, char **argv) } else { return 1; } - - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } @@ -725,7 +549,7 @@ int ble_mesh_exceptional_list_test(int argc, char **argv) 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__); + ESP_LOGE(TAG, "ble mesh malloc failed, %d", __LINE__); return ESP_ERR_NO_MEM; } else { get_value_string((char *)exceptional_list_test.info->sval[0], (char *)info); @@ -741,9 +565,9 @@ int ble_mesh_exceptional_list_test(int argc, char **argv) } if (err == ESP_OK) { - ESP_LOGI(TAG, "Bm:UpdateExcepList,OK\n"); + ESP_LOGI(TAG, "Bm:UpdateExcepList,OK"); } else { - ESP_LOGE(TAG, "Bm:UpdateExcepList,Fail\n"); + ESP_LOGE(TAG, "Bm:UpdateExcepList,Fail"); } if (info != NULL) { @@ -759,8 +583,6 @@ int ble_mesh_deinit(int argc, char **argv) int err; esp_ble_mesh_deinit_param_t param = {}; - ESP_LOGD(TAG, "enter %s \n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &deinit); if (nerrors != 0) { arg_print_errors(stderr, deinit.end, argv[0]); @@ -775,7 +597,6 @@ int ble_mesh_deinit(int argc, char **argv) } else { return 1; } - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } @@ -783,8 +604,6 @@ int ble_mesh_provisioner_enable_bearer(int argc, char **argv) { esp_err_t err = 0; - ESP_LOGD(TAG, "enter %s \n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &bearer); if (nerrors != 0) { arg_print_errors(stderr, bearer.end, argv[0]); @@ -800,19 +619,14 @@ int ble_mesh_provisioner_enable_bearer(int argc, char **argv) } else { return 1; } - - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } int ble_mesh_node_reset(int argc, char** argv) { esp_err_t err; - ESP_LOGD(TAG, "enter %s\n", __func__); err = esp_ble_mesh_node_local_reset(); - - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } @@ -826,20 +640,17 @@ int ble_mesh_node_statistics_regist(int argc, char **argv) return 1; } - ESP_LOGD(TAG, "enter %s\n", __func__); - if (strcmp(node_statistices.action_type->sval[0], "init") == 0) { result = ble_mesh_node_statistics_init(node_statistices.package_num->ival[0]); - ESP_LOGI(TAG, "Node:InitStatistics,OK\n"); + ESP_LOGI(TAG, "Node:InitStatistics,OK"); } else if (strcmp(node_statistices.action_type->sval[0], "get") == 0) { ble_mesh_node_statistics_get(); - ESP_LOGI(TAG, "Node:GetStatistics,OK\n"); + ESP_LOGI(TAG, "Node:GetStatistics,OK"); } else if (strcmp(node_statistices.action_type->sval[0], "destroy") == 0) { ble_mesh_node_statistics_destroy(); - ESP_LOGI(TAG, "Node:DestroyStatistics\n"); + ESP_LOGI(TAG, "Node:DestroyStatistics"); } - ESP_LOGD(TAG, "exit %s\n", __func__); return result; } @@ -857,8 +668,6 @@ int ble_mesh_node_enter_network_auto(int argc, char **argv) return 1; } - ESP_LOGD(TAG, "enter %s\n", __func__); - err = get_value_string((char *)node_network_info.net_key->sval[0], (char *)info.net_key); err = get_value_string((char *)node_network_info.dev_key->sval[0], (char *)info.dev_key); err = get_value_string((char *)node_network_info.app_key->sval[0], (char *)info.app_key); @@ -873,8 +682,6 @@ int ble_mesh_node_enter_network_auto(int argc, char **argv) } else { ESP_LOGE(TAG, "NODE:EnNetwork,FAIL,%d", err); } - - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } @@ -887,8 +694,6 @@ int ble_mesh_provision_address(int argc, char **argv) .flag = BIT(0), }; - ESP_LOGD(TAG, "enter %s \n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &provisioner_addr); if (nerrors != 0) { arg_print_errors(stderr, provisioner_addr.end, argv[0]); @@ -927,8 +732,6 @@ int ble_mesh_provision_address(int argc, char **argv) } else { ESP_LOGI(TAG, "Provisioner:AddDelAddr,OK"); } - - ESP_LOGD(TAG, "exit %s \n", __func__); return err; } @@ -940,7 +743,6 @@ int ble_mesh_provisioner_add_key(int argc, char **argv) .net_idx = 1, .flag = PROV_DATA_NET_IDX_FLAG, }; - ESP_LOGD(TAG, " enter %s\n", __func__); int nerrors = arg_parse(argc, argv, (void **) &provisioner_add_key); if (nerrors != 0) { @@ -963,8 +765,6 @@ int ble_mesh_provisioner_add_key(int argc, char **argv) } else { ESP_LOGI(TAG, "Provisioner:KeyAction,OK"); } - - ESP_LOGD(TAG, "exit %s\n", __func__); return err; } @@ -974,7 +774,6 @@ int ble_mesh_provisioner_get_node(int argc, char **argv) uint16_t i = 0; esp_ble_mesh_node_t *node_info; - ESP_LOGD(TAG, "enter %s\n", __func__); int nerrors = arg_parse(argc, argv, (void **) &provisioner_get_node); if (nerrors != 0) { arg_print_errors(stderr, provisioner_get_node.end, argv[0]); @@ -998,8 +797,6 @@ int ble_mesh_provisioner_get_node(int argc, char **argv) } printf("\n"); } - - ESP_LOGD(TAG, "exit %s\n", __func__); return ESP_OK; } @@ -1007,7 +804,6 @@ int ble_mesh_provisioner_add_node(int argc, char **argv) { struct bt_mesh_node node_info; esp_err_t result; - ESP_LOGD(TAG, " enter %s\n", __func__); int nerrors = arg_parse(argc, argv, (void **) &provisioner_add_node); if (nerrors != 0) { @@ -1029,12 +825,10 @@ int ble_mesh_provisioner_add_node(int argc, char **argv) result = bt_mesh_provisioner_store_node_info(&node_info); if (result == ESP_OK) { - ESP_LOGI(TAG, "Provisioner:AddNodeInfo,OK\n"); + ESP_LOGI(TAG, "Provisioner:AddNodeInfo,OK"); } else { - ESP_LOGI(TAG, "Provisioner:AddNodeInfo,ERROR,%d\n", result); + ESP_LOGI(TAG, "Provisioner:AddNodeInfo,ERROR,%d", result); } - - ESP_LOGD(TAG, "exit %s\n", __func__); return result; } @@ -1046,8 +840,6 @@ int ble_mesh_provision_bind_local_model(int argc, char **argv) uint16_t model_id = 0; uint16_t company_id = 0xFFFF; - ESP_LOGD(TAG, " enter %s\n", __func__); - int nerrors = arg_parse(argc, argv, (void **) &provisioner_local_bind); if (nerrors != 0) { arg_print_errors(stderr, provisioner_local_bind.end, argv[0]); @@ -1061,11 +853,10 @@ int ble_mesh_provision_bind_local_model(int argc, char **argv) err = esp_ble_mesh_provisioner_bind_app_key_to_local_model(element_addr, app_idx, model_id, company_id); if (err != ESP_OK) { - ESP_LOGE(TAG, "Provisioner:BindModel,Fail,%d\n", err); + ESP_LOGE(TAG, "Provisioner:BindModel,Fail,%d", err); } else { - ESP_LOGI(TAG, "Provisioner:BindModel,OK\n"); + ESP_LOGI(TAG, "Provisioner:BindModel,OK"); } - ESP_LOGD(TAG, "exit %s\n", __func__); return err; }