From 7542c86d9c0d747318b3f0e033689f0a705d32bc Mon Sep 17 00:00:00 2001 From: lly Date: Sun, 28 Jun 2020 15:28:22 +0800 Subject: [PATCH 1/8] ble_mesh: stack: Update client model msg send --- .../btc/btc_ble_mesh_config_model.c | 138 ++-- .../btc/btc_ble_mesh_health_model.c | 66 +- .../bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c | 19 +- .../bt/esp_ble_mesh/mesh_core/cfg_cli.c | 721 ++++++------------ .../bt/esp_ble_mesh/mesh_core/health_cli.c | 102 +-- .../esp_ble_mesh/mesh_core/include/cfg_cli.h | 149 ++-- .../mesh_core/include/health_cli.h | 16 +- .../mesh_models/client/client_common.c | 42 +- .../mesh_models/client/generic_client.c | 8 +- .../client/include/client_common.h | 10 +- .../mesh_models/client/lighting_client.c | 8 +- .../mesh_models/client/sensor_client.c | 4 +- .../mesh_models/client/time_scene_client.c | 8 +- 13 files changed, 498 insertions(+), 793 deletions(-) diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c index c9c48e7138..1d18f4fb65 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c @@ -20,8 +20,6 @@ #include "cfg_cli.h" #include "esp_ble_mesh_config_model_api.h" -extern s32_t config_msg_timeout; - /* Configuration Client Model related functions */ static inline void btc_ble_mesh_config_client_cb_to_app(esp_ble_mesh_cfg_client_cb_event_t event, @@ -383,7 +381,7 @@ void btc_ble_mesh_config_client_publish_callback(u32_t opcode, struct bt_mesh_mo static int btc_ble_mesh_config_client_get_state(esp_ble_mesh_client_common_param_t *params, esp_ble_mesh_cfg_client_get_state_t *get) { - struct bt_mesh_msg_ctx ctx = {0}; + bt_mesh_client_common_param_t param = {0}; if (params == NULL) { BT_ERR("%s, Invalid parameter", __func__); @@ -410,63 +408,64 @@ static int btc_ble_mesh_config_client_get_state(esp_ble_mesh_client_common_param break; } - ctx.net_idx = params->ctx.net_idx; - ctx.app_idx = BLE_MESH_KEY_DEV; - ctx.addr = params->ctx.addr; - ctx.send_rel = params->ctx.send_rel; - ctx.send_ttl = params->ctx.send_ttl; + param.opcode = params->opcode; + param.model = (struct bt_mesh_model *)params->model; + param.ctx.net_idx = params->ctx.net_idx; + param.ctx.app_idx = BLE_MESH_KEY_DEV; + param.ctx.addr = params->ctx.addr; + param.ctx.send_rel = params->ctx.send_rel; + param.ctx.send_ttl = params->ctx.send_ttl; + param.msg_timeout = params->msg_timeout; - config_msg_timeout = params->msg_timeout; - - switch (params->opcode) { + switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_BEACON_GET: - return bt_mesh_cfg_beacon_get(&ctx); + return bt_mesh_cfg_beacon_get(¶m); case ESP_BLE_MESH_MODEL_OP_DEFAULT_TTL_GET: - return bt_mesh_cfg_ttl_get(&ctx); + return bt_mesh_cfg_ttl_get(¶m); case ESP_BLE_MESH_MODEL_OP_FRIEND_GET: - return bt_mesh_cfg_friend_get(&ctx); + return bt_mesh_cfg_friend_get(¶m); case ESP_BLE_MESH_MODEL_OP_GATT_PROXY_GET: - return bt_mesh_cfg_gatt_proxy_get(&ctx); + return bt_mesh_cfg_gatt_proxy_get(¶m); case ESP_BLE_MESH_MODEL_OP_RELAY_GET: - return bt_mesh_cfg_relay_get(&ctx); + return bt_mesh_cfg_relay_get(¶m); case ESP_BLE_MESH_MODEL_OP_MODEL_PUB_GET: - return bt_mesh_cfg_mod_pub_get(&ctx, get->model_pub_get.element_addr, + return bt_mesh_cfg_mod_pub_get(¶m, get->model_pub_get.element_addr, get->model_pub_get.model_id, get->model_pub_get.company_id); case ESP_BLE_MESH_MODEL_OP_HEARTBEAT_PUB_GET: - return bt_mesh_cfg_hb_pub_get(&ctx); + return bt_mesh_cfg_hb_pub_get(¶m); case ESP_BLE_MESH_MODEL_OP_HEARTBEAT_SUB_GET: - return bt_mesh_cfg_hb_sub_get(&ctx); + return bt_mesh_cfg_hb_sub_get(¶m); case ESP_BLE_MESH_MODEL_OP_COMPOSITION_DATA_GET: - return bt_mesh_cfg_comp_data_get(&ctx, get->comp_data_get.page); + return bt_mesh_cfg_comp_data_get(¶m, get->comp_data_get.page); case ESP_BLE_MESH_MODEL_OP_SIG_MODEL_SUB_GET: - return bt_mesh_cfg_mod_sub_get(&ctx, get->sig_model_sub_get.element_addr, + return bt_mesh_cfg_mod_sub_get(¶m, get->sig_model_sub_get.element_addr, get->sig_model_sub_get.model_id); case ESP_BLE_MESH_MODEL_OP_VENDOR_MODEL_SUB_GET: - return bt_mesh_cfg_mod_sub_get_vnd(&ctx, get->vnd_model_sub_get.element_addr, + return bt_mesh_cfg_mod_sub_get_vnd(¶m, get->vnd_model_sub_get.element_addr, get->vnd_model_sub_get.model_id, get->vnd_model_sub_get.company_id); case ESP_BLE_MESH_MODEL_OP_NET_KEY_GET: - return bt_mesh_cfg_net_key_get(&ctx); + return bt_mesh_cfg_net_key_get(¶m); case ESP_BLE_MESH_MODEL_OP_APP_KEY_GET: - return bt_mesh_cfg_app_key_get(&ctx, get->app_key_get.net_idx); + return bt_mesh_cfg_app_key_get(¶m, get->app_key_get.net_idx); case ESP_BLE_MESH_MODEL_OP_NODE_IDENTITY_GET: - return bt_mesh_cfg_node_identity_get(&ctx, get->node_identity_get.net_idx); + return bt_mesh_cfg_node_identity_get(¶m, get->node_identity_get.net_idx); case ESP_BLE_MESH_MODEL_OP_SIG_MODEL_APP_GET: - return bt_mesh_cfg_mod_app_get(&ctx, get->sig_model_app_get.element_addr, + return bt_mesh_cfg_mod_app_get(¶m, get->sig_model_app_get.element_addr, get->sig_model_app_get.model_id); case ESP_BLE_MESH_MODEL_OP_VENDOR_MODEL_APP_GET: - return bt_mesh_cfg_mod_app_get_vnd(&ctx, get->vnd_model_app_get.element_addr, + return bt_mesh_cfg_mod_app_get_vnd(¶m, get->vnd_model_app_get.element_addr, get->vnd_model_app_get.model_id, get->vnd_model_app_get.company_id); case ESP_BLE_MESH_MODEL_OP_KEY_REFRESH_PHASE_GET: - return bt_mesh_cfg_kr_phase_get(&ctx, get->kr_phase_get.net_idx); + return bt_mesh_cfg_kr_phase_get(¶m, get->kr_phase_get.net_idx); case ESP_BLE_MESH_MODEL_OP_LPN_POLLTIMEOUT_GET: - return bt_mesh_cfg_lpn_timeout_get(&ctx, get->lpn_pollto_get.lpn_addr); + return bt_mesh_cfg_lpn_timeout_get(¶m, get->lpn_pollto_get.lpn_addr); case ESP_BLE_MESH_MODEL_OP_NETWORK_TRANSMIT_GET: - return bt_mesh_cfg_net_transmit_get(&ctx); + return bt_mesh_cfg_net_transmit_get(¶m); default: - BT_ERR("Invalid Configuration Get opcode 0x%04x", params->opcode); + BT_ERR("Invalid Configuration Get opcode 0x%04x", param.opcode); return -EINVAL; } @@ -476,7 +475,7 @@ static int btc_ble_mesh_config_client_get_state(esp_ble_mesh_client_common_param static int btc_ble_mesh_config_client_set_state(esp_ble_mesh_client_common_param_t *params, esp_ble_mesh_cfg_client_set_state_t *set) { - struct bt_mesh_msg_ctx ctx = {0}; + bt_mesh_client_common_param_t param = {0}; if (params == NULL) { BT_ERR("%s, Invalid parameter", __func__); @@ -488,35 +487,36 @@ static int btc_ble_mesh_config_client_set_state(esp_ble_mesh_client_common_param return -EINVAL; } - ctx.net_idx = params->ctx.net_idx; - ctx.app_idx = BLE_MESH_KEY_DEV; - ctx.addr = params->ctx.addr; - ctx.send_rel = params->ctx.send_rel; - ctx.send_ttl = params->ctx.send_ttl; + param.opcode = params->opcode; + param.model = (struct bt_mesh_model *)params->model; + param.ctx.net_idx = params->ctx.net_idx; + param.ctx.app_idx = BLE_MESH_KEY_DEV; + param.ctx.addr = params->ctx.addr; + param.ctx.send_rel = params->ctx.send_rel; + param.ctx.send_ttl = params->ctx.send_ttl; + param.msg_timeout = params->msg_timeout; - config_msg_timeout = params->msg_timeout; - - switch (params->opcode) { + switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_BEACON_SET: - return bt_mesh_cfg_beacon_set(&ctx, set->beacon_set.beacon); + return bt_mesh_cfg_beacon_set(¶m, set->beacon_set.beacon); case ESP_BLE_MESH_MODEL_OP_DEFAULT_TTL_SET: - return bt_mesh_cfg_ttl_set(&ctx, set->default_ttl_set.ttl); + return bt_mesh_cfg_ttl_set(¶m, set->default_ttl_set.ttl); case ESP_BLE_MESH_MODEL_OP_FRIEND_SET: - return bt_mesh_cfg_friend_set(&ctx, set->friend_set.friend_state); + return bt_mesh_cfg_friend_set(¶m, set->friend_set.friend_state); case ESP_BLE_MESH_MODEL_OP_GATT_PROXY_SET: - return bt_mesh_cfg_gatt_proxy_set(&ctx, set->gatt_proxy_set.gatt_proxy); + return bt_mesh_cfg_gatt_proxy_set(¶m, set->gatt_proxy_set.gatt_proxy); case ESP_BLE_MESH_MODEL_OP_RELAY_SET: - return bt_mesh_cfg_relay_set(&ctx, set->relay_set.relay, + return bt_mesh_cfg_relay_set(¶m, set->relay_set.relay, set->relay_set.relay_retransmit); case ESP_BLE_MESH_MODEL_OP_NET_KEY_ADD: - return bt_mesh_cfg_net_key_add(&ctx, set->net_key_add.net_idx, + return bt_mesh_cfg_net_key_add(¶m, set->net_key_add.net_idx, &set->net_key_add.net_key[0]); case ESP_BLE_MESH_MODEL_OP_APP_KEY_ADD: - return bt_mesh_cfg_app_key_add(&ctx, set->app_key_add.net_idx, + return bt_mesh_cfg_app_key_add(¶m, set->app_key_add.net_idx, set->app_key_add.app_idx, &set->app_key_add.app_key[0]); case ESP_BLE_MESH_MODEL_OP_MODEL_APP_BIND: - return bt_mesh_cfg_mod_app_bind(&ctx, set->model_app_bind.element_addr, + return bt_mesh_cfg_mod_app_bind(¶m, set->model_app_bind.element_addr, set->model_app_bind.model_app_idx, set->model_app_bind.model_id, set->model_app_bind.company_id); @@ -529,46 +529,46 @@ static int btc_ble_mesh_config_client_set_state(esp_ble_mesh_client_common_param .period = set->model_pub_set.publish_period, .transmit = set->model_pub_set.publish_retransmit, }; - return bt_mesh_cfg_mod_pub_set(&ctx, set->model_pub_set.element_addr, + return bt_mesh_cfg_mod_pub_set(¶m, set->model_pub_set.element_addr, set->model_pub_set.model_id, set->model_pub_set.company_id, &model_pub); } case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_ADD: - return bt_mesh_cfg_mod_sub_add(&ctx, set->model_sub_add.element_addr, + return bt_mesh_cfg_mod_sub_add(¶m, set->model_sub_add.element_addr, set->model_sub_add.sub_addr, set->model_sub_add.model_id, set->model_sub_add.company_id); case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_DELETE: - return bt_mesh_cfg_mod_sub_del(&ctx, set->model_sub_delete.element_addr, + return bt_mesh_cfg_mod_sub_del(¶m, set->model_sub_delete.element_addr, set->model_sub_delete.sub_addr, set->model_sub_delete.model_id, set->model_sub_delete.company_id); case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_OVERWRITE: - return bt_mesh_cfg_mod_sub_overwrite(&ctx, set->model_sub_overwrite.element_addr, + return bt_mesh_cfg_mod_sub_overwrite(¶m, set->model_sub_overwrite.element_addr, set->model_sub_overwrite.sub_addr, set->model_sub_overwrite.model_id, set->model_sub_overwrite.company_id); case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_VIRTUAL_ADDR_ADD: - return bt_mesh_cfg_mod_sub_va_add(&ctx, set->model_sub_va_add.element_addr, + return bt_mesh_cfg_mod_sub_va_add(¶m, set->model_sub_va_add.element_addr, &set->model_sub_va_add.label_uuid[0], set->model_sub_va_add.model_id, set->model_sub_va_add.company_id); case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_VIRTUAL_ADDR_OVERWRITE: - return bt_mesh_cfg_mod_sub_va_overwrite(&ctx, set->model_sub_va_overwrite.element_addr, + return bt_mesh_cfg_mod_sub_va_overwrite(¶m, set->model_sub_va_overwrite.element_addr, &set->model_sub_va_overwrite.label_uuid[0], set->model_sub_va_overwrite.model_id, set->model_sub_va_overwrite.company_id); case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_VIRTUAL_ADDR_DELETE: - return bt_mesh_cfg_mod_sub_va_del(&ctx, set->model_sub_va_delete.element_addr, + return bt_mesh_cfg_mod_sub_va_del(¶m, set->model_sub_va_delete.element_addr, &set->model_sub_va_delete.label_uuid[0], set->model_sub_va_delete.model_id, set->model_sub_va_delete.company_id); case ESP_BLE_MESH_MODEL_OP_HEARTBEAT_SUB_SET: - return bt_mesh_cfg_hb_sub_set(&ctx, (struct bt_mesh_cfg_hb_sub *)&set->heartbeat_sub_set); + return bt_mesh_cfg_hb_sub_set(¶m, (struct bt_mesh_cfg_hb_sub *)&set->heartbeat_sub_set); case ESP_BLE_MESH_MODEL_OP_HEARTBEAT_PUB_SET: - return bt_mesh_cfg_hb_pub_set(&ctx, (const struct bt_mesh_cfg_hb_pub *)&set->heartbeat_pub_set); + return bt_mesh_cfg_hb_pub_set(¶m, (struct bt_mesh_cfg_hb_pub *)&set->heartbeat_pub_set); case ESP_BLE_MESH_MODEL_OP_NODE_RESET: - return bt_mesh_cfg_node_reset(&ctx); + return bt_mesh_cfg_node_reset(¶m); case ESP_BLE_MESH_MODEL_OP_MODEL_PUB_VIRTUAL_ADDR_SET: { struct bt_mesh_cfg_mod_pub model_pub = { .app_idx = set->model_pub_va_set.publish_app_idx, @@ -577,42 +577,42 @@ static int btc_ble_mesh_config_client_set_state(esp_ble_mesh_client_common_param .period = set->model_pub_va_set.publish_period, .transmit = set->model_pub_va_set.publish_retransmit, }; - return bt_mesh_cfg_mod_pub_va_set(&ctx, set->model_pub_va_set.element_addr, + return bt_mesh_cfg_mod_pub_va_set(¶m, set->model_pub_va_set.element_addr, set->model_pub_va_set.model_id, set->model_pub_va_set.company_id, set->model_pub_va_set.label_uuid, &model_pub); } case ESP_BLE_MESH_MODEL_OP_MODEL_SUB_DELETE_ALL: - return bt_mesh_cfg_mod_sub_del_all(&ctx, set->model_sub_delete_all.element_addr, + return bt_mesh_cfg_mod_sub_del_all(¶m, set->model_sub_delete_all.element_addr, set->model_sub_delete_all.model_id, set->model_sub_delete_all.company_id); case ESP_BLE_MESH_MODEL_OP_NET_KEY_UPDATE: - return bt_mesh_cfg_net_key_update(&ctx, set->net_key_update.net_idx, + return bt_mesh_cfg_net_key_update(¶m, set->net_key_update.net_idx, set->net_key_update.net_key); case ESP_BLE_MESH_MODEL_OP_NET_KEY_DELETE: - return bt_mesh_cfg_net_key_delete(&ctx, set->net_key_delete.net_idx); + return bt_mesh_cfg_net_key_delete(¶m, set->net_key_delete.net_idx); case ESP_BLE_MESH_MODEL_OP_APP_KEY_UPDATE: - return bt_mesh_cfg_app_key_update(&ctx, set->app_key_update.net_idx, + return bt_mesh_cfg_app_key_update(¶m, set->app_key_update.net_idx, set->app_key_update.app_idx, set->app_key_update.app_key); case ESP_BLE_MESH_MODEL_OP_APP_KEY_DELETE: - return bt_mesh_cfg_app_key_delete(&ctx, set->app_key_delete.net_idx, + return bt_mesh_cfg_app_key_delete(¶m, set->app_key_delete.net_idx, set->app_key_delete.app_idx); case ESP_BLE_MESH_MODEL_OP_NODE_IDENTITY_SET: - return bt_mesh_cfg_node_identity_set(&ctx, set->node_identity_set.net_idx, + return bt_mesh_cfg_node_identity_set(¶m, set->node_identity_set.net_idx, set->node_identity_set.identity); case ESP_BLE_MESH_MODEL_OP_MODEL_APP_UNBIND: - return bt_mesh_cfg_mod_app_unbind(&ctx, set->model_app_unbind.element_addr, + return bt_mesh_cfg_mod_app_unbind(¶m, set->model_app_unbind.element_addr, set->model_app_unbind.model_app_idx, set->model_app_unbind.model_id, set->model_app_unbind.company_id); case ESP_BLE_MESH_MODEL_OP_KEY_REFRESH_PHASE_SET: - return bt_mesh_cfg_kr_phase_set(&ctx, set->kr_phase_set.net_idx, + return bt_mesh_cfg_kr_phase_set(¶m, set->kr_phase_set.net_idx, set->kr_phase_set.transition); case ESP_BLE_MESH_MODEL_OP_NETWORK_TRANSMIT_SET: - return bt_mesh_cfg_net_transmit_set(&ctx, set->net_transmit_set.net_transmit); + return bt_mesh_cfg_net_transmit_set(¶m, set->net_transmit_set.net_transmit); default: - BT_ERR("Invalid Configuration Set opcode 0x%04x", params->opcode); + BT_ERR("Invalid Configuration Set opcode 0x%04x", param.opcode); return -EINVAL; } diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c index 41aa9c9e57..240f318aa1 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c @@ -21,8 +21,6 @@ #include "health_cli.h" #include "esp_ble_mesh_health_model_api.h" -extern s32_t health_msg_timeout; - /* Health Client Model related functions */ static inline void btc_ble_mesh_health_client_cb_to_app(esp_ble_mesh_health_client_cb_event_t event, @@ -317,7 +315,7 @@ void btc_ble_mesh_health_publish_callback(u32_t opcode, struct bt_mesh_model *mo static int btc_ble_mesh_health_client_get_state(esp_ble_mesh_client_common_param_t *params, esp_ble_mesh_health_client_get_state_t *get) { - struct bt_mesh_msg_ctx ctx = {0}; + bt_mesh_client_common_param_t param = {0}; if (params == NULL) { BT_ERR("%s, Invalid parameter", __func__); @@ -329,23 +327,24 @@ static int btc_ble_mesh_health_client_get_state(esp_ble_mesh_client_common_param return -EINVAL; } - ctx.net_idx = params->ctx.net_idx; - ctx.app_idx = params->ctx.app_idx; - ctx.addr = params->ctx.addr; - ctx.send_rel = params->ctx.send_rel; - ctx.send_ttl = params->ctx.send_ttl; + param.opcode = params->opcode; + param.model = (struct bt_mesh_model *)params->model; + param.ctx.net_idx = params->ctx.net_idx; + param.ctx.app_idx = params->ctx.app_idx; + param.ctx.addr = params->ctx.addr; + param.ctx.send_rel = params->ctx.send_rel; + param.ctx.send_ttl = params->ctx.send_ttl; + param.msg_timeout = params->msg_timeout; - health_msg_timeout = params->msg_timeout; - - switch (params->opcode) { + switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_ATTENTION_GET: - return bt_mesh_health_attention_get(&ctx); + return bt_mesh_health_attention_get(¶m); case ESP_BLE_MESH_MODEL_OP_HEALTH_PERIOD_GET: - return bt_mesh_health_period_get(&ctx); + return bt_mesh_health_period_get(¶m); case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_GET: - return bt_mesh_health_fault_get(&ctx, get->fault_get.company_id); + return bt_mesh_health_fault_get(¶m, get->fault_get.company_id); default: - BT_ERR("Invalid Health Get opcode 0x%04x", params->opcode); + BT_ERR("Invalid Health Get opcode 0x%04x", param.opcode); return -EINVAL; } @@ -355,40 +354,41 @@ static int btc_ble_mesh_health_client_get_state(esp_ble_mesh_client_common_param static int btc_ble_mesh_health_client_set_state(esp_ble_mesh_client_common_param_t *params, esp_ble_mesh_health_client_set_state_t *set) { - struct bt_mesh_msg_ctx ctx = {0}; + bt_mesh_client_common_param_t param = {0}; if (params == NULL || set == NULL) { BT_ERR("%s, Invalid parameter", __func__); return -EINVAL; } - ctx.net_idx = params->ctx.net_idx; - ctx.app_idx = params->ctx.app_idx; - ctx.addr = params->ctx.addr; - ctx.send_rel = params->ctx.send_rel; - ctx.send_ttl = params->ctx.send_ttl; + param.opcode = params->opcode; + param.model = (struct bt_mesh_model *)params->model; + param.ctx.net_idx = params->ctx.net_idx; + param.ctx.app_idx = params->ctx.app_idx; + param.ctx.addr = params->ctx.addr; + param.ctx.send_rel = params->ctx.send_rel; + param.ctx.send_ttl = params->ctx.send_ttl; + param.msg_timeout = params->msg_timeout; - health_msg_timeout = params->msg_timeout; - - switch (params->opcode) { + switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_ATTENTION_SET: - return bt_mesh_health_attention_set(&ctx, set->attention_set.attention, true); + return bt_mesh_health_attention_set(¶m, set->attention_set.attention, true); case ESP_BLE_MESH_MODEL_OP_ATTENTION_SET_UNACK: - return bt_mesh_health_attention_set(&ctx, set->attention_set.attention, false); + return bt_mesh_health_attention_set(¶m, set->attention_set.attention, false); case ESP_BLE_MESH_MODEL_OP_HEALTH_PERIOD_SET: - return bt_mesh_health_period_set(&ctx, set->period_set.fast_period_divisor, true); + return bt_mesh_health_period_set(¶m, set->period_set.fast_period_divisor, true); case ESP_BLE_MESH_MODEL_OP_HEALTH_PERIOD_SET_UNACK: - return bt_mesh_health_period_set(&ctx, set->period_set.fast_period_divisor, false); + return bt_mesh_health_period_set(¶m, set->period_set.fast_period_divisor, false); case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_TEST: - return bt_mesh_health_fault_test(&ctx, set->fault_test.company_id, set->fault_test.test_id, true); + return bt_mesh_health_fault_test(¶m, set->fault_test.company_id, set->fault_test.test_id, true); case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_TEST_UNACK: - return bt_mesh_health_fault_test(&ctx, set->fault_test.company_id, set->fault_test.test_id, false); + return bt_mesh_health_fault_test(¶m, set->fault_test.company_id, set->fault_test.test_id, false); case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_CLEAR: - return bt_mesh_health_fault_clear(&ctx, set->fault_clear.company_id, true); + return bt_mesh_health_fault_clear(¶m, set->fault_clear.company_id, true); case ESP_BLE_MESH_MODEL_OP_HEALTH_FAULT_CLEAR_UNACK: - return bt_mesh_health_fault_clear(&ctx, set->fault_clear.company_id, false); + return bt_mesh_health_fault_clear(¶m, set->fault_clear.company_id, false); default: - BT_ERR("Invalid Health Set opcode 0x%04x", params->opcode); + BT_ERR("Invalid Health Set opcode 0x%04x", param.opcode); return -EINVAL; } diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c index ab1aba5877..87026a62e4 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c @@ -2016,18 +2016,25 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) break; } net_buf_simple_add_mem(buf, arg->model_send.data, arg->model_send.length); - arg->model_send.ctx->srv_send = false; common.model = (struct bt_mesh_model *)(arg->model_send.model); common.role = arg->model_send.device_role; if (bt_mesh_set_client_model_role(&common)) { BT_ERR("Failed to set model role"); break; } - err = bt_mesh_client_send_msg((struct bt_mesh_model *)arg->model_send.model, - arg->model_send.opcode, - (struct bt_mesh_msg_ctx *)arg->model_send.ctx, buf, - btc_ble_mesh_client_model_timeout_cb, arg->model_send.msg_timeout, - arg->model_send.need_rsp, NULL, NULL); + bt_mesh_client_common_param_t param = { + .opcode = arg->model_send.opcode, + .model = (struct bt_mesh_model *)arg->model_send.model, + .ctx.net_idx = arg->model_send.ctx->net_idx, + .ctx.app_idx = arg->model_send.ctx->app_idx, + .ctx.addr = arg->model_send.ctx->addr, + .ctx.send_rel = arg->model_send.ctx->send_rel, + .ctx.send_ttl = arg->model_send.ctx->send_ttl, + .ctx.srv_send = false, + .msg_timeout = arg->model_send.msg_timeout, + }; + err = bt_mesh_client_send_msg(¶m, buf, arg->model_send.need_rsp, + btc_ble_mesh_client_model_timeout_cb); bt_mesh_free_buf(buf); btc_ble_mesh_model_send_comp_cb(arg->model_send.model, arg->model_send.ctx, arg->model_send.opcode, err); diff --git a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c index 628d501d9b..4e0c9f1dc8 100644 --- a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c @@ -20,9 +20,6 @@ #include "mesh_common.h" #include "cfg_cli.h" -/* 2 byte dummy opcode for getting compile time buffer sizes. */ -#define DUMMY_2_BYTE_OP BLE_MESH_MODEL_OP_2(0xff, 0xff) - s32_t config_msg_timeout; static bt_mesh_config_client_t *cli; @@ -681,37 +678,14 @@ const struct bt_mesh_model_op bt_mesh_cfg_cli_op[] = { BLE_MESH_MODEL_OP_END, }; -int bt_mesh_cfg_comp_data_get(struct bt_mesh_msg_ctx *ctx, u8_t page) +static int send_msg_with_none(bt_mesh_client_common_param_t *param, u32_t op) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_DEV_COMP_DATA_GET, 1); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_DEV_COMP_DATA_GET); - net_buf_simple_add_u8(&msg, page); - - err = bt_mesh_client_send_msg(cli->model, OP_DEV_COMP_DATA_GET, ctx, - &msg, timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; -} - -static int get_state_u8(struct bt_mesh_msg_ctx *ctx, u32_t op) -{ - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 0); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 0); int err = 0; bt_mesh_model_msg_init(&msg, op); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -719,16 +693,15 @@ static int get_state_u8(struct bt_mesh_msg_ctx *ctx, u32_t op) return err; } -static int set_state_u8(struct bt_mesh_msg_ctx *ctx, u32_t op, u8_t new_val) +static int send_msg_with_u8(bt_mesh_client_common_param_t *param, u32_t op, u8_t val) { - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 1); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 1); int err = 0; bt_mesh_model_msg_init(&msg, op); - net_buf_simple_add_u8(&msg, new_val); + net_buf_simple_add_u8(&msg, val); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -736,84 +709,15 @@ static int set_state_u8(struct bt_mesh_msg_ctx *ctx, u32_t op, u8_t new_val) return err; } -int bt_mesh_cfg_beacon_get(struct bt_mesh_msg_ctx *ctx) +static int send_msg_with_le16(bt_mesh_client_common_param_t *param, u32_t op, u16_t val) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return get_state_u8(ctx, OP_BEACON_GET); -} - -int bt_mesh_cfg_beacon_set(struct bt_mesh_msg_ctx *ctx, u8_t val) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return set_state_u8(ctx, OP_BEACON_SET, val); -} - -int bt_mesh_cfg_ttl_get(struct bt_mesh_msg_ctx *ctx) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return get_state_u8(ctx, OP_DEFAULT_TTL_GET); -} - -int bt_mesh_cfg_ttl_set(struct bt_mesh_msg_ctx *ctx, u8_t val) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return set_state_u8(ctx, OP_DEFAULT_TTL_SET, val); -} - -int bt_mesh_cfg_friend_get(struct bt_mesh_msg_ctx *ctx) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return get_state_u8(ctx, OP_FRIEND_GET); -} - -int bt_mesh_cfg_friend_set(struct bt_mesh_msg_ctx *ctx, u8_t val) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return set_state_u8(ctx, OP_FRIEND_SET, val); -} - -int bt_mesh_cfg_gatt_proxy_get(struct bt_mesh_msg_ctx *ctx) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return get_state_u8(ctx, OP_GATT_PROXY_GET); -} - -int bt_mesh_cfg_gatt_proxy_set(struct bt_mesh_msg_ctx *ctx, u8_t val) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return set_state_u8(ctx, OP_GATT_PROXY_SET, val); -} - -int bt_mesh_cfg_relay_get(struct bt_mesh_msg_ctx *ctx) -{ - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_RELAY_GET, 0); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 2); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } + bt_mesh_model_msg_init(&msg, op); + net_buf_simple_add_le16(&msg, val); - bt_mesh_model_msg_init(&msg, OP_RELAY_GET); - - err = bt_mesh_client_send_msg(cli->model, OP_RELAY_GET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -821,23 +725,71 @@ int bt_mesh_cfg_relay_get(struct bt_mesh_msg_ctx *ctx) return err; } -int bt_mesh_cfg_relay_set(struct bt_mesh_msg_ctx *ctx, u8_t new_relay, - u8_t new_transmit) +int bt_mesh_cfg_comp_data_get(bt_mesh_client_common_param_t *param, u8_t page) +{ + return send_msg_with_u8(param, OP_DEV_COMP_DATA_GET, page); +} + +int bt_mesh_cfg_beacon_get(bt_mesh_client_common_param_t *param) +{ + return send_msg_with_none(param, OP_BEACON_GET); +} + +int bt_mesh_cfg_beacon_set(bt_mesh_client_common_param_t *param, u8_t val) +{ + if (val > 0x01) { + BT_ERR("Invalid beacon state 0x%02x", val); + return -EINVAL; + } + return send_msg_with_u8(param, OP_BEACON_SET, val); +} + +int bt_mesh_cfg_ttl_get(bt_mesh_client_common_param_t *param) +{ + return send_msg_with_none(param, OP_DEFAULT_TTL_GET); +} + +int bt_mesh_cfg_ttl_set(bt_mesh_client_common_param_t *param, u8_t val) +{ + return send_msg_with_u8(param, OP_DEFAULT_TTL_SET, val); +} + +int bt_mesh_cfg_friend_get(bt_mesh_client_common_param_t *param) +{ + return send_msg_with_none(param, OP_FRIEND_GET); +} + +int bt_mesh_cfg_friend_set(bt_mesh_client_common_param_t *param, u8_t val) +{ + return send_msg_with_u8(param, OP_FRIEND_SET, val); +} + +int bt_mesh_cfg_gatt_proxy_get(bt_mesh_client_common_param_t *param) +{ + return send_msg_with_none(param, OP_GATT_PROXY_GET); +} + +int bt_mesh_cfg_gatt_proxy_set(bt_mesh_client_common_param_t *param, u8_t val) +{ + return send_msg_with_u8(param, OP_GATT_PROXY_SET, val); +} + +int bt_mesh_cfg_relay_get(bt_mesh_client_common_param_t *param) +{ + return send_msg_with_none(param, OP_RELAY_GET); +} + +int bt_mesh_cfg_relay_set(bt_mesh_client_common_param_t *param, + u8_t relay, u8_t retransmit) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_RELAY_SET, 2); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_RELAY_SET); - net_buf_simple_add_u8(&msg, new_relay); - net_buf_simple_add_u8(&msg, new_transmit); + net_buf_simple_add_u8(&msg, relay); + net_buf_simple_add_u8(&msg, retransmit); - err = bt_mesh_client_send_msg(cli->model, OP_RELAY_SET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -845,23 +797,22 @@ int bt_mesh_cfg_relay_set(struct bt_mesh_msg_ctx *ctx, u8_t new_relay, return err; } -int bt_mesh_cfg_net_key_add(struct bt_mesh_msg_ctx *ctx, u16_t key_net_idx, - const u8_t net_key[16]) +int bt_mesh_cfg_net_key_add(bt_mesh_client_common_param_t *param, + u16_t net_idx, const u8_t net_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NET_KEY_ADD, 18); int err = 0; - if (!ctx || !ctx->addr || !net_key) { + if (!net_key) { + BT_ERR("Invalid NetKey"); return -EINVAL; } bt_mesh_model_msg_init(&msg, OP_NET_KEY_ADD); - net_buf_simple_add_le16(&msg, key_net_idx); + net_buf_simple_add_le16(&msg, net_idx); net_buf_simple_add_mem(&msg, net_key, 16); - err = bt_mesh_client_send_msg(cli->model, OP_NET_KEY_ADD, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -869,23 +820,23 @@ int bt_mesh_cfg_net_key_add(struct bt_mesh_msg_ctx *ctx, u16_t key_net_idx, return err; } -int bt_mesh_cfg_app_key_add(struct bt_mesh_msg_ctx *ctx, u16_t key_net_idx, - u16_t key_app_idx, const u8_t app_key[16]) +int bt_mesh_cfg_app_key_add(bt_mesh_client_common_param_t *param, + u16_t net_idx, u16_t app_idx, + const u8_t app_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_ADD, 19); int err = 0; - if (!ctx || !ctx->addr || !app_key) { + if (!app_key) { + BT_ERR("Invalid AppKey"); return -EINVAL; } bt_mesh_model_msg_init(&msg, OP_APP_KEY_ADD); - key_idx_pack(&msg, key_net_idx, key_app_idx); + key_idx_pack(&msg, net_idx, app_idx); net_buf_simple_add_mem(&msg, app_key, 16); - err = bt_mesh_client_send_msg(cli->model, OP_APP_KEY_ADD, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -893,27 +844,22 @@ int bt_mesh_cfg_app_key_add(struct bt_mesh_msg_ctx *ctx, u16_t key_net_idx, return err; } -int bt_mesh_cfg_mod_app_bind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_app_idx, u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_app_bind(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t app_idx, + u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_APP_BIND, 8); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_MOD_APP_BIND); net_buf_simple_add_le16(&msg, elem_addr); - net_buf_simple_add_le16(&msg, mod_app_idx); + net_buf_simple_add_le16(&msg, app_idx); if (cid != BLE_MESH_CID_NVAL) { net_buf_simple_add_le16(&msg, cid); } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, OP_MOD_APP_BIND, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -921,10 +867,11 @@ int bt_mesh_cfg_mod_app_bind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -static int mod_sub(u32_t op, struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid) +static int mod_sub(bt_mesh_client_common_param_t *param, u32_t op, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid) { - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 8); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 8); int err = 0; bt_mesh_model_msg_init(&msg, op); @@ -935,8 +882,7 @@ static int mod_sub(u32_t op, struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -944,41 +890,40 @@ static int mod_sub(u32_t op, struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -int bt_mesh_cfg_mod_sub_add(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_add(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return mod_sub(OP_MOD_SUB_ADD, ctx, elem_addr, sub_addr, mod_id, cid); + return mod_sub(param, OP_MOD_SUB_ADD, elem_addr, sub_addr, mod_id, cid); } -int bt_mesh_cfg_mod_sub_del(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_del(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return mod_sub(OP_MOD_SUB_DEL, ctx, elem_addr, sub_addr, mod_id, cid); + return mod_sub(param, OP_MOD_SUB_DEL, elem_addr, sub_addr, mod_id, cid); } -int bt_mesh_cfg_mod_sub_overwrite(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_overwrite(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return mod_sub(OP_MOD_SUB_OVERWRITE, ctx, elem_addr, sub_addr, mod_id, cid); + return mod_sub(param, OP_MOD_SUB_OVERWRITE, elem_addr, sub_addr, mod_id, cid); } -static int mod_sub_va(u32_t op, struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid) +static int mod_sub_va(bt_mesh_client_common_param_t *param, u32_t op, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid) { - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 22); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 22); int err = 0; - BT_DBG("net_idx 0x%04x addr 0x%04x elem_addr 0x%04x label %s", - ctx->net_idx, ctx->addr, elem_addr, label); + if (!label) { + BT_ERR("Invalid label uuid"); + return -EINVAL; + } + + BT_DBG("elem_addr 0x%04x label %s", elem_addr, bt_hex(label, 16)); BT_DBG("mod_id 0x%04x cid 0x%04x", mod_id, cid); bt_mesh_model_msg_init(&msg, op); @@ -989,8 +934,7 @@ static int mod_sub_va(u32_t op, struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -998,43 +942,33 @@ static int mod_sub_va(u32_t op, struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -int bt_mesh_cfg_mod_sub_va_add(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_va_add(bt_mesh_client_common_param_t *param, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr || !label) { - return -EINVAL; - } - return mod_sub_va(OP_MOD_SUB_VA_ADD, ctx, elem_addr, label, mod_id, cid); + return mod_sub_va(param, OP_MOD_SUB_VA_ADD, elem_addr, label, mod_id, cid); } -int bt_mesh_cfg_mod_sub_va_del(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_va_del(bt_mesh_client_common_param_t *param, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr || !label) { - return -EINVAL; - } - return mod_sub_va(OP_MOD_SUB_VA_DEL, ctx, elem_addr, label, mod_id, cid); + return mod_sub_va(param, OP_MOD_SUB_VA_DEL, elem_addr, label, mod_id, cid); } -int bt_mesh_cfg_mod_sub_va_overwrite(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_va_overwrite(bt_mesh_client_common_param_t *param, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr || !label) { - return -EINVAL; - } - return mod_sub_va(OP_MOD_SUB_VA_OVERWRITE, ctx, elem_addr, label, mod_id, cid); + return mod_sub_va(param, OP_MOD_SUB_VA_OVERWRITE, elem_addr, label, mod_id, cid); } -int bt_mesh_cfg_mod_pub_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_pub_get(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_PUB_GET, 6); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_MOD_PUB_GET); net_buf_simple_add_le16(&msg, elem_addr); if (cid != BLE_MESH_CID_NVAL) { @@ -1042,9 +976,7 @@ int bt_mesh_cfg_mod_pub_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, OP_MOD_PUB_GET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1052,14 +984,15 @@ int bt_mesh_cfg_mod_pub_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -int bt_mesh_cfg_mod_pub_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid, +int bt_mesh_cfg_mod_pub_set(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid, struct bt_mesh_cfg_mod_pub *pub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_PUB_SET, 13); int err = 0; - if (!ctx || !ctx->addr || !pub) { + if (!pub) { + BT_ERR("Invalid model pub set"); return -EINVAL; } @@ -1075,9 +1008,7 @@ int bt_mesh_cfg_mod_pub_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, OP_MOD_PUB_SET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1085,13 +1016,14 @@ int bt_mesh_cfg_mod_pub_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -int bt_mesh_cfg_hb_sub_set(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_cfg_hb_sub_set(bt_mesh_client_common_param_t *param, struct bt_mesh_cfg_hb_sub *sub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEARTBEAT_SUB_SET, 5); int err = 0; - if (!ctx || !ctx->addr || !sub) { + if (!sub) { + BT_ERR("Invalid heartbeat sub set"); return -EINVAL; } @@ -1100,9 +1032,7 @@ int bt_mesh_cfg_hb_sub_set(struct bt_mesh_msg_ctx *ctx, net_buf_simple_add_le16(&msg, sub->dst); net_buf_simple_add_u8(&msg, sub->period); - err = bt_mesh_client_send_msg(cli->model, OP_HEARTBEAT_SUB_SET, ctx, - &msg, timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1110,34 +1040,19 @@ int bt_mesh_cfg_hb_sub_set(struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_cfg_hb_sub_get(struct bt_mesh_msg_ctx *ctx) +int bt_mesh_cfg_hb_sub_get(bt_mesh_client_common_param_t *param) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEARTBEAT_SUB_GET, 0); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_HEARTBEAT_SUB_GET); - - err = bt_mesh_client_send_msg(cli->model, OP_HEARTBEAT_SUB_GET, ctx, - &msg, timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return send_msg_with_none(param, OP_HEARTBEAT_SUB_GET); } -int bt_mesh_cfg_hb_pub_set(struct bt_mesh_msg_ctx *ctx, - const struct bt_mesh_cfg_hb_pub *pub) +int bt_mesh_cfg_hb_pub_set(bt_mesh_client_common_param_t *param, + struct bt_mesh_cfg_hb_pub *pub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEARTBEAT_PUB_SET, 9); int err = 0; - if (!ctx || !ctx->addr || !pub) { + if (!pub) { + BT_ERR("Invalid heartbeat pub set"); return -EINVAL; } @@ -1149,9 +1064,7 @@ int bt_mesh_cfg_hb_pub_set(struct bt_mesh_msg_ctx *ctx, net_buf_simple_add_le16(&msg, pub->feat); net_buf_simple_add_le16(&msg, pub->net_idx); - err = bt_mesh_client_send_msg(cli->model, OP_HEARTBEAT_PUB_SET, ctx, - &msg, timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1159,56 +1072,26 @@ int bt_mesh_cfg_hb_pub_set(struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_cfg_hb_pub_get(struct bt_mesh_msg_ctx *ctx) +int bt_mesh_cfg_hb_pub_get(bt_mesh_client_common_param_t *param) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEARTBEAT_PUB_GET, 0); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_HEARTBEAT_PUB_GET); - - err = bt_mesh_client_send_msg(cli->model, OP_HEARTBEAT_PUB_GET, ctx, - &msg, timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return send_msg_with_none(param, OP_HEARTBEAT_PUB_GET); } -int bt_mesh_cfg_node_reset(struct bt_mesh_msg_ctx *ctx) +int bt_mesh_cfg_node_reset(bt_mesh_client_common_param_t *param) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NODE_RESET, 0); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_NODE_RESET); - - err = bt_mesh_client_send_msg(cli->model, OP_NODE_RESET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return send_msg_with_none(param, OP_NODE_RESET); } -int bt_mesh_cfg_mod_pub_va_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid, const u8_t label[16], +int bt_mesh_cfg_mod_pub_va_set(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, + u16_t cid, const u8_t label[16], struct bt_mesh_cfg_mod_pub *pub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_PUB_VA_SET, 27); int err = 0; - if (!ctx || !ctx->addr || !label || !pub) { + if (!label || !pub) { + BT_ERR("%s, Invalid parameter", __func__); return -EINVAL; } @@ -1224,9 +1107,7 @@ int bt_mesh_cfg_mod_pub_va_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, OP_MOD_PUB_VA_SET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1234,16 +1115,12 @@ int bt_mesh_cfg_mod_pub_va_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -int bt_mesh_cfg_mod_sub_del_all(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_del_all(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_SUB_DEL_ALL, 6); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_MOD_SUB_DEL_ALL); net_buf_simple_add_le16(&msg, elem_addr); if (cid != BLE_MESH_CID_NVAL) { @@ -1251,9 +1128,7 @@ int bt_mesh_cfg_mod_sub_del_all(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, OP_MOD_SUB_DEL_ALL, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1261,10 +1136,10 @@ int bt_mesh_cfg_mod_sub_del_all(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -static int mod_sub_get(u32_t op, struct bt_mesh_msg_ctx *ctx, +static int mod_sub_get(bt_mesh_client_common_param_t *param, u32_t op, u16_t elem_addr, u16_t mod_id, u16_t cid) { - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 6); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 6); int err = 0; bt_mesh_model_msg_init(&msg, op); @@ -1274,8 +1149,7 @@ static int mod_sub_get(u32_t op, struct bt_mesh_msg_ctx *ctx, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1283,30 +1157,30 @@ static int mod_sub_get(u32_t op, struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_cfg_mod_sub_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, u16_t mod_id) +int bt_mesh_cfg_mod_sub_get(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return mod_sub_get(OP_MOD_SUB_GET, ctx, elem_addr, mod_id, BLE_MESH_CID_NVAL); + return mod_sub_get(param, OP_MOD_SUB_GET, elem_addr, mod_id, BLE_MESH_CID_NVAL); } -int bt_mesh_cfg_mod_sub_get_vnd(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_sub_get_vnd(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr || cid == BLE_MESH_CID_NVAL) { + if (cid == BLE_MESH_CID_NVAL) { + BT_ERR("Invalid company id"); return -EINVAL; } - return mod_sub_get(OP_MOD_SUB_GET_VND, ctx, elem_addr, mod_id, cid); + return mod_sub_get(param, OP_MOD_SUB_GET_VND, elem_addr, mod_id, cid); } -int bt_mesh_cfg_net_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, - const u8_t net_key[16]) +int bt_mesh_cfg_net_key_update(bt_mesh_client_common_param_t *param, + u16_t net_idx, const u8_t net_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NET_KEY_UPDATE, 18); int err = 0; - if (!ctx || !ctx->addr || !net_key) { + if (!net_key) { + BT_ERR("Invalid NetKey"); return -EINVAL; } @@ -1314,9 +1188,7 @@ int bt_mesh_cfg_net_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, net_buf_simple_add_le16(&msg, net_idx); net_buf_simple_add_mem(&msg, net_key, 16); - err = bt_mesh_client_send_msg(cli->model, OP_NET_KEY_UPDATE, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1324,56 +1196,25 @@ int bt_mesh_cfg_net_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, return err; } -int bt_mesh_cfg_net_key_delete(struct bt_mesh_msg_ctx *ctx, u16_t net_idx) +int bt_mesh_cfg_net_key_delete(bt_mesh_client_common_param_t *param, u16_t net_idx) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NET_KEY_DEL, 2); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_NET_KEY_DEL); - net_buf_simple_add_le16(&msg, net_idx); - - err = bt_mesh_client_send_msg(cli->model, OP_NET_KEY_DEL, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return send_msg_with_le16(param, OP_NET_KEY_DEL, net_idx); } -int bt_mesh_cfg_net_key_get(struct bt_mesh_msg_ctx *ctx) +int bt_mesh_cfg_net_key_get(bt_mesh_client_common_param_t *param) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NET_KEY_GET, 0); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_NET_KEY_GET); - - err = bt_mesh_client_send_msg(cli->model, OP_NET_KEY_GET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return send_msg_with_none(param, OP_NET_KEY_GET); } -int bt_mesh_cfg_app_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, - u16_t app_idx, const u8_t app_key[16]) +int bt_mesh_cfg_app_key_update(bt_mesh_client_common_param_t *param, + u16_t net_idx, u16_t app_idx, + const u8_t app_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_UPDATE, 19); int err = 0; - if (!ctx || !ctx->addr || !app_key) { + if (!app_key) { + BT_ERR("Invalid AppKey"); return -EINVAL; } @@ -1381,9 +1222,7 @@ int bt_mesh_cfg_app_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, key_idx_pack(&msg, net_idx, app_idx); net_buf_simple_add_mem(&msg, app_key, 16); - err = bt_mesh_client_send_msg(cli->model, OP_APP_KEY_UPDATE, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1391,21 +1230,16 @@ int bt_mesh_cfg_app_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, return err; } -int bt_mesh_cfg_app_key_delete(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u16_t app_idx) +int bt_mesh_cfg_app_key_delete(bt_mesh_client_common_param_t *param, + u16_t net_idx, u16_t app_idx) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_DEL, 3); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_APP_KEY_DEL); key_idx_pack(&msg, net_idx, app_idx); - err = bt_mesh_client_send_msg(cli->model, OP_APP_KEY_DEL, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1413,21 +1247,32 @@ int bt_mesh_cfg_app_key_delete(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u16_t return err; } -int bt_mesh_cfg_app_key_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx) +int bt_mesh_cfg_app_key_get(bt_mesh_client_common_param_t *param, u16_t net_idx) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_GET, 2); + return send_msg_with_le16(param, OP_APP_KEY_GET, net_idx); +} + +int bt_mesh_cfg_node_identity_get(bt_mesh_client_common_param_t *param, u16_t net_idx) +{ + return send_msg_with_le16(param, OP_NODE_IDENTITY_GET, net_idx); +} + +int bt_mesh_cfg_node_identity_set(bt_mesh_client_common_param_t *param, + u16_t net_idx, u8_t identity) +{ + BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NODE_IDENTITY_SET, 3); int err = 0; - if (!ctx || !ctx->addr) { + if (identity > 0x02) { + BT_ERR("Invalid node identity 0x%02x", identity); return -EINVAL; } - bt_mesh_model_msg_init(&msg, OP_APP_KEY_GET); + bt_mesh_model_msg_init(&msg, OP_NODE_IDENTITY_SET); net_buf_simple_add_le16(&msg, net_idx); + net_buf_simple_add_u8(&msg, identity); - err = bt_mesh_client_send_msg(cli->model, OP_APP_KEY_GET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1435,53 +1280,13 @@ int bt_mesh_cfg_app_key_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx) return err; } -static int node_identity_op(u32_t op, struct bt_mesh_msg_ctx *ctx, - u16_t net_idx, u8_t identity) -{ - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 3); - int err = 0; - - bt_mesh_model_msg_init(&msg, op); - net_buf_simple_add_le16(&msg, net_idx); - if (op == OP_NODE_IDENTITY_SET) { - net_buf_simple_add_u8(&msg, identity); - } - - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; -} - -int bt_mesh_cfg_node_identity_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return node_identity_op(OP_NODE_IDENTITY_GET, ctx, net_idx, 0xFF); -} - -int bt_mesh_cfg_node_identity_set(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u8_t identity) -{ - if (!ctx || !ctx->addr || identity > 0x01) { - return -EINVAL; - } - return node_identity_op(OP_NODE_IDENTITY_SET, ctx, net_idx, identity); -} - -int bt_mesh_cfg_mod_app_unbind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t app_idx, u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_app_unbind(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t app_idx, + u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_APP_UNBIND, 8); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_MOD_APP_UNBIND); net_buf_simple_add_le16(&msg, elem_addr); net_buf_simple_add_le16(&msg, app_idx); @@ -1490,9 +1295,7 @@ int bt_mesh_cfg_mod_app_unbind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, OP_MOD_APP_UNBIND, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1500,10 +1303,10 @@ int bt_mesh_cfg_mod_app_unbind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, return err; } -static int mod_app_get(u32_t op, struct bt_mesh_msg_ctx *ctx, +static int mod_app_get(bt_mesh_client_common_param_t *param, u32_t op, u16_t elem_addr, u16_t mod_id, u16_t cid) { - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 6); + BLE_MESH_MODEL_BUF_DEFINE(msg, op, 6); int err = 0; bt_mesh_model_msg_init(&msg, op); @@ -1513,8 +1316,7 @@ static int mod_app_get(u32_t op, struct bt_mesh_msg_ctx *ctx, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1522,37 +1324,43 @@ static int mod_app_get(u32_t op, struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_cfg_mod_app_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, u16_t mod_id) +int bt_mesh_cfg_mod_app_get(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return mod_app_get(OP_SIG_MOD_APP_GET, ctx, elem_addr, mod_id, BLE_MESH_CID_NVAL); + return mod_app_get(param, OP_SIG_MOD_APP_GET, elem_addr, mod_id, BLE_MESH_CID_NVAL); } -int bt_mesh_cfg_mod_app_get_vnd(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid) +int bt_mesh_cfg_mod_app_get_vnd(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid) { - if (!ctx || !ctx->addr || cid == BLE_MESH_CID_NVAL) { + if (cid == BLE_MESH_CID_NVAL) { + BT_ERR("Invalid company id"); return -EINVAL; } - return mod_app_get(OP_VND_MOD_APP_GET, ctx, elem_addr, mod_id, cid); + return mod_app_get(param, OP_VND_MOD_APP_GET, elem_addr, mod_id, cid); } -static int kr_phase_op(u32_t op, struct bt_mesh_msg_ctx *ctx, - u16_t net_idx, u8_t transition) +int bt_mesh_cfg_kr_phase_get(bt_mesh_client_common_param_t *param, u16_t net_idx) { - BLE_MESH_MODEL_BUF_DEFINE(msg, DUMMY_2_BYTE_OP, 3); + return send_msg_with_le16(param, OP_KRP_GET, net_idx); +} + +int bt_mesh_cfg_kr_phase_set(bt_mesh_client_common_param_t *param, + u16_t net_idx, u8_t transition) +{ + BLE_MESH_MODEL_BUF_DEFINE(msg, OP_KRP_SET, 3); int err = 0; - bt_mesh_model_msg_init(&msg, op); + if (transition > 0x03) { + BT_ERR("Invalid kr phase transition 0x%02x", transition); + return -EINVAL; + } + + bt_mesh_model_msg_init(&msg, OP_KRP_SET); net_buf_simple_add_le16(&msg, net_idx); - if (op == OP_KRP_SET) { - net_buf_simple_add_u8(&msg, transition); - } + net_buf_simple_add_u8(&msg, transition); - err = bt_mesh_client_send_msg(cli->model, op, ctx, &msg, timeout_handler, - config_msg_timeout, true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -1560,58 +1368,19 @@ static int kr_phase_op(u32_t op, struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_cfg_kr_phase_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx) +int bt_mesh_cfg_lpn_timeout_get(bt_mesh_client_common_param_t *param, u16_t lpn_addr) { - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return kr_phase_op(OP_KRP_GET, ctx, net_idx, 0xFF); + return send_msg_with_le16(param, OP_LPN_TIMEOUT_GET, lpn_addr); } -int bt_mesh_cfg_kr_phase_set(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u8_t transition) +int bt_mesh_cfg_net_transmit_get(bt_mesh_client_common_param_t *param) { - if (!ctx || !ctx->addr || transition > 0x03) { - return -EINVAL; - } - return kr_phase_op(OP_KRP_SET, ctx, net_idx, transition);; + return send_msg_with_none(param, OP_NET_TRANSMIT_GET); } -int bt_mesh_cfg_lpn_timeout_get(struct bt_mesh_msg_ctx *ctx, u16_t lpn_addr) +int bt_mesh_cfg_net_transmit_set(bt_mesh_client_common_param_t *param, u8_t transmit) { - BLE_MESH_MODEL_BUF_DEFINE(msg, OP_LPN_TIMEOUT_GET, 2); - int err = 0; - - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - bt_mesh_model_msg_init(&msg, OP_LPN_TIMEOUT_GET); - net_buf_simple_add_le16(&msg, lpn_addr); - - err = bt_mesh_client_send_msg(cli->model, OP_LPN_TIMEOUT_GET, ctx, &msg, - timeout_handler, config_msg_timeout, - true, NULL, NULL); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; -} - -int bt_mesh_cfg_net_transmit_get(struct bt_mesh_msg_ctx *ctx) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return get_state_u8(ctx, OP_NET_TRANSMIT_GET); -} - -int bt_mesh_cfg_net_transmit_set(struct bt_mesh_msg_ctx *ctx, u8_t transmit) -{ - if (!ctx || !ctx->addr) { - return -EINVAL; - } - return set_state_u8(ctx, OP_NET_TRANSMIT_SET, transmit); + return send_msg_with_u8(param, OP_NET_TRANSMIT_SET, transmit); } s32_t bt_mesh_cfg_cli_timeout_get(void) diff --git a/components/bt/esp_ble_mesh/mesh_core/health_cli.c b/components/bt/esp_ble_mesh/mesh_core/health_cli.c index 5ff4f0c778..acf56eef2d 100644 --- a/components/bt/esp_ble_mesh/mesh_core/health_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/health_cli.c @@ -235,20 +235,14 @@ const struct bt_mesh_model_op bt_mesh_health_cli_op[] = { BLE_MESH_MODEL_OP_END, }; -int bt_mesh_health_attention_get(struct bt_mesh_msg_ctx *ctx) +int bt_mesh_health_attention_get(bt_mesh_client_common_param_t *param) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_ATTENTION_GET, 0); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_ATTENTION_GET); - err = bt_mesh_client_send_msg(health_cli->model, OP_ATTENTION_GET, ctx, - &msg, timeout_handler, health_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -256,28 +250,16 @@ int bt_mesh_health_attention_get(struct bt_mesh_msg_ctx *ctx) return err; } -int bt_mesh_health_attention_set(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_attention_set(bt_mesh_client_common_param_t *param, u8_t attention, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_ATTENTION_SET, 1); - u32_t opcode = 0U; int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - if (need_ack) { - opcode = OP_ATTENTION_SET; - } else { - opcode = OP_ATTENTION_SET_UNREL; - } - bt_mesh_model_msg_init(&msg, opcode); + bt_mesh_model_msg_init(&msg, need_ack ? OP_ATTENTION_SET : OP_ATTENTION_SET_UNREL); net_buf_simple_add_u8(&msg, attention); - err = bt_mesh_client_send_msg(health_cli->model, opcode, ctx, &msg, - timeout_handler, health_msg_timeout, - need_ack, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -285,20 +267,14 @@ int bt_mesh_health_attention_set(struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_health_period_get(struct bt_mesh_msg_ctx *ctx) +int bt_mesh_health_period_get(bt_mesh_client_common_param_t *param) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_PERIOD_GET, 0); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_HEALTH_PERIOD_GET); - err = bt_mesh_client_send_msg(health_cli->model, OP_HEALTH_PERIOD_GET, - ctx, &msg, timeout_handler, health_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -306,28 +282,16 @@ int bt_mesh_health_period_get(struct bt_mesh_msg_ctx *ctx) return err; } -int bt_mesh_health_period_set(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_period_set(bt_mesh_client_common_param_t *param, u8_t divisor, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_PERIOD_SET, 1); - u32_t opcode = 0U; int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - if (need_ack) { - opcode = OP_HEALTH_PERIOD_SET; - } else { - opcode = OP_HEALTH_PERIOD_SET_UNREL; - } - bt_mesh_model_msg_init(&msg, opcode); + bt_mesh_model_msg_init(&msg, need_ack ? OP_HEALTH_PERIOD_SET : OP_HEALTH_PERIOD_SET_UNREL); net_buf_simple_add_u8(&msg, divisor); - err = bt_mesh_client_send_msg(health_cli->model, opcode, ctx, &msg, - timeout_handler, health_msg_timeout, - need_ack, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -335,29 +299,17 @@ int bt_mesh_health_period_set(struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_health_fault_test(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_fault_test(bt_mesh_client_common_param_t *param, u16_t cid, u8_t test_id, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_FAULT_TEST, 3); - u32_t opcode = 0U; int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - if (need_ack) { - opcode = OP_HEALTH_FAULT_TEST; - } else { - opcode = OP_HEALTH_FAULT_TEST_UNREL; - } - bt_mesh_model_msg_init(&msg, opcode); + bt_mesh_model_msg_init(&msg, need_ack ? OP_HEALTH_FAULT_TEST : OP_HEALTH_FAULT_TEST_UNREL); net_buf_simple_add_u8(&msg, test_id); net_buf_simple_add_le16(&msg, cid); - err = bt_mesh_client_send_msg(health_cli->model, opcode, ctx, &msg, - timeout_handler, health_msg_timeout, - need_ack, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -365,28 +317,16 @@ int bt_mesh_health_fault_test(struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_health_fault_clear(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_fault_clear(bt_mesh_client_common_param_t *param, u16_t cid, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_FAULT_CLEAR, 2); - u32_t opcode = 0U; int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - - if (need_ack) { - opcode = OP_HEALTH_FAULT_CLEAR; - } else { - opcode = OP_HEALTH_FAULT_CLEAR_UNREL; - } - bt_mesh_model_msg_init(&msg, opcode); + bt_mesh_model_msg_init(&msg, need_ack ? OP_HEALTH_FAULT_CLEAR : OP_HEALTH_FAULT_CLEAR_UNREL); net_buf_simple_add_le16(&msg, cid); - err = bt_mesh_client_send_msg(health_cli->model, opcode, ctx, &msg, - timeout_handler, health_msg_timeout, - need_ack, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } @@ -394,21 +334,15 @@ int bt_mesh_health_fault_clear(struct bt_mesh_msg_ctx *ctx, return err; } -int bt_mesh_health_fault_get(struct bt_mesh_msg_ctx *ctx, u16_t cid) +int bt_mesh_health_fault_get(bt_mesh_client_common_param_t *param, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_FAULT_GET, 2); int err = 0; - if (!ctx || !ctx->addr) { - return -EINVAL; - } - bt_mesh_model_msg_init(&msg, OP_HEALTH_FAULT_GET); net_buf_simple_add_le16(&msg, cid); - err = bt_mesh_client_send_msg(health_cli->model, OP_HEALTH_FAULT_GET, ctx, - &msg, timeout_handler, health_msg_timeout, - true, NULL, NULL); + err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); if (err) { BT_ERR("%s, send failed (err %d)", __func__, err); } diff --git a/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h b/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h index 873d989858..c33a7d977f 100644 --- a/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h +++ b/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h @@ -34,36 +34,39 @@ extern const struct bt_mesh_model_op bt_mesh_cfg_cli_op[]; BLE_MESH_MODEL(BLE_MESH_MODEL_ID_CFG_CLI, \ bt_mesh_cfg_cli_op, NULL, cli_data) -int bt_mesh_cfg_comp_data_get(struct bt_mesh_msg_ctx *ctx, u8_t page); +int bt_mesh_cfg_comp_data_get(bt_mesh_client_common_param_t *param, u8_t page); -int bt_mesh_cfg_beacon_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_beacon_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_beacon_set(struct bt_mesh_msg_ctx *ctx, u8_t val); +int bt_mesh_cfg_beacon_set(bt_mesh_client_common_param_t *param, u8_t val); -int bt_mesh_cfg_ttl_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_ttl_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_ttl_set(struct bt_mesh_msg_ctx *ctx, u8_t val); +int bt_mesh_cfg_ttl_set(bt_mesh_client_common_param_t *param, u8_t val); -int bt_mesh_cfg_friend_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_friend_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_friend_set(struct bt_mesh_msg_ctx *ctx, u8_t val); +int bt_mesh_cfg_friend_set(bt_mesh_client_common_param_t *param, u8_t val); -int bt_mesh_cfg_gatt_proxy_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_gatt_proxy_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_gatt_proxy_set(struct bt_mesh_msg_ctx *ctx, u8_t val); +int bt_mesh_cfg_gatt_proxy_set(bt_mesh_client_common_param_t *param, u8_t val); -int bt_mesh_cfg_relay_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_relay_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_relay_set(struct bt_mesh_msg_ctx *ctx, u8_t new_relay, u8_t new_transmit); +int bt_mesh_cfg_relay_set(bt_mesh_client_common_param_t *param, + u8_t relay, u8_t retransmit); -int bt_mesh_cfg_net_key_add(struct bt_mesh_msg_ctx *ctx, u16_t key_net_idx, - const u8_t net_key[16]); +int bt_mesh_cfg_net_key_add(bt_mesh_client_common_param_t *param, + u16_t net_idx, const u8_t net_key[16]); -int bt_mesh_cfg_app_key_add(struct bt_mesh_msg_ctx *ctx, u16_t key_net_idx, - u16_t key_app_idx, const u8_t app_key[16]); +int bt_mesh_cfg_app_key_add(bt_mesh_client_common_param_t *param, + u16_t net_idx, u16_t app_idx, + const u8_t app_key[16]); -int bt_mesh_cfg_mod_app_bind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_app_idx, u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_app_bind(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t app_idx, + u16_t mod_id, u16_t cid); struct bt_mesh_cfg_mod_pub { u16_t addr; @@ -74,30 +77,36 @@ struct bt_mesh_cfg_mod_pub { u8_t transmit; }; -int bt_mesh_cfg_mod_pub_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_pub_get(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_pub_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid, +int bt_mesh_cfg_mod_pub_set(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid, struct bt_mesh_cfg_mod_pub *pub); -int bt_mesh_cfg_mod_sub_add(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_add(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_sub_del(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_del(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_sub_overwrite(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t sub_addr, u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_overwrite(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t sub_addr, + u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_sub_va_add(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_va_add(bt_mesh_client_common_param_t *param, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_sub_va_del(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_va_del(bt_mesh_client_common_param_t *param, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_sub_va_overwrite(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - const u8_t label[16], u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_va_overwrite(bt_mesh_client_common_param_t *param, + u16_t elem_addr, const u8_t label[16], + u16_t mod_id, u16_t cid); struct bt_mesh_cfg_hb_sub { u16_t src; @@ -105,10 +114,10 @@ struct bt_mesh_cfg_hb_sub { u8_t period; }; -int bt_mesh_cfg_hb_sub_set(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_cfg_hb_sub_set(bt_mesh_client_common_param_t *param, struct bt_mesh_cfg_hb_sub *sub); -int bt_mesh_cfg_hb_sub_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_hb_sub_get(bt_mesh_client_common_param_t *param); struct bt_mesh_cfg_hb_pub { u16_t dst; @@ -119,12 +128,12 @@ struct bt_mesh_cfg_hb_pub { u16_t net_idx; }; -int bt_mesh_cfg_hb_pub_set(struct bt_mesh_msg_ctx *ctx, - const struct bt_mesh_cfg_hb_pub *pub); +int bt_mesh_cfg_hb_pub_set(bt_mesh_client_common_param_t *param, + struct bt_mesh_cfg_hb_pub *pub); -int bt_mesh_cfg_hb_pub_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_hb_pub_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_node_reset(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_node_reset(bt_mesh_client_common_param_t *param); s32_t bt_mesh_cfg_cli_timeout_get(void); void bt_mesh_cfg_cli_timeout_set(s32_t timeout); @@ -244,53 +253,61 @@ struct bt_mesh_cfg_lpn_pollto_status { s32_t timeout; }; -int bt_mesh_cfg_mod_pub_va_set(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid, const u8_t label[16], +int bt_mesh_cfg_mod_pub_va_set(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, + u16_t cid, const u8_t label[16], struct bt_mesh_cfg_mod_pub *pub); -int bt_mesh_cfg_mod_sub_del_all(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_del_all(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_sub_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, u16_t mod_id); +int bt_mesh_cfg_mod_sub_get(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id); -int bt_mesh_cfg_mod_sub_get_vnd(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_sub_get_vnd(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid); -int bt_mesh_cfg_net_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, - const u8_t net_key[16]); +int bt_mesh_cfg_net_key_update(bt_mesh_client_common_param_t *param, + u16_t net_idx, const u8_t net_key[16]); -int bt_mesh_cfg_net_key_delete(struct bt_mesh_msg_ctx *ctx, u16_t net_idx); +int bt_mesh_cfg_net_key_delete(bt_mesh_client_common_param_t *param, u16_t net_idx); -int bt_mesh_cfg_net_key_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_net_key_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_app_key_update(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, - u16_t app_idx, const u8_t app_key[16]); +int bt_mesh_cfg_app_key_update(bt_mesh_client_common_param_t *param, + u16_t net_idx, u16_t app_idx, + const u8_t app_key[16]); -int bt_mesh_cfg_app_key_delete(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u16_t app_idx); +int bt_mesh_cfg_app_key_delete(bt_mesh_client_common_param_t *param, + u16_t net_idx, u16_t app_idx); -int bt_mesh_cfg_app_key_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx); +int bt_mesh_cfg_app_key_get(bt_mesh_client_common_param_t *param, u16_t net_idx); -int bt_mesh_cfg_node_identity_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx); +int bt_mesh_cfg_node_identity_get(bt_mesh_client_common_param_t *param, u16_t net_idx); -int bt_mesh_cfg_node_identity_set(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u8_t identity); +int bt_mesh_cfg_node_identity_set(bt_mesh_client_common_param_t *param, + u16_t net_idx, u8_t identity); -int bt_mesh_cfg_mod_app_unbind(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t app_idx, u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_app_unbind(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t app_idx, + u16_t mod_id, u16_t cid); -int bt_mesh_cfg_mod_app_get(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, u16_t mod_id); +int bt_mesh_cfg_mod_app_get(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id); -int bt_mesh_cfg_mod_app_get_vnd(struct bt_mesh_msg_ctx *ctx, u16_t elem_addr, - u16_t mod_id, u16_t cid); +int bt_mesh_cfg_mod_app_get_vnd(bt_mesh_client_common_param_t *param, + u16_t elem_addr, u16_t mod_id, u16_t cid); -int bt_mesh_cfg_kr_phase_get(struct bt_mesh_msg_ctx *ctx, u16_t net_idx); +int bt_mesh_cfg_kr_phase_get(bt_mesh_client_common_param_t *param, u16_t net_idx); -int bt_mesh_cfg_kr_phase_set(struct bt_mesh_msg_ctx *ctx, u16_t net_idx, u8_t transition); +int bt_mesh_cfg_kr_phase_set(bt_mesh_client_common_param_t *param, + u16_t net_idx, u8_t transition); -int bt_mesh_cfg_lpn_timeout_get(struct bt_mesh_msg_ctx *ctx, u16_t lpn_addr); +int bt_mesh_cfg_lpn_timeout_get(bt_mesh_client_common_param_t *param, u16_t lpn_addr); -int bt_mesh_cfg_net_transmit_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_cfg_net_transmit_get(bt_mesh_client_common_param_t *param); -int bt_mesh_cfg_net_transmit_set(struct bt_mesh_msg_ctx *ctx, u8_t transmit); +int bt_mesh_cfg_net_transmit_set(bt_mesh_client_common_param_t *param, u8_t transmit); #ifdef __cplusplus } diff --git a/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h b/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h index 52982eced3..8d38cf3d3d 100644 --- a/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h +++ b/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h @@ -36,22 +36,22 @@ extern const struct bt_mesh_model_op bt_mesh_health_cli_op[]; int bt_mesh_health_cli_set(struct bt_mesh_model *model); -int bt_mesh_health_fault_get(struct bt_mesh_msg_ctx *ctx, u16_t cid); +int bt_mesh_health_fault_get(bt_mesh_client_common_param_t *param, u16_t cid); -int bt_mesh_health_fault_clear(struct bt_mesh_msg_ctx *ctx, u16_t cid, - bool need_ack); +int bt_mesh_health_fault_clear(bt_mesh_client_common_param_t *param, + u16_t cid, bool need_ack); -int bt_mesh_health_fault_test(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_fault_test(bt_mesh_client_common_param_t *param, u16_t cid, u8_t test_id, bool need_ack); -int bt_mesh_health_period_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_health_period_get(bt_mesh_client_common_param_t *param); -int bt_mesh_health_period_set(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_period_set(bt_mesh_client_common_param_t *param, u8_t divisor, bool need_ack); -int bt_mesh_health_attention_get(struct bt_mesh_msg_ctx *ctx); +int bt_mesh_health_attention_get(bt_mesh_client_common_param_t *param); -int bt_mesh_health_attention_set(struct bt_mesh_msg_ctx *ctx, +int bt_mesh_health_attention_set(bt_mesh_client_common_param_t *param, u8_t attention, bool need_ack); s32_t bt_mesh_health_cli_timeout_get(void); diff --git a/components/bt/esp_ble_mesh/mesh_models/client/client_common.c b/components/bt/esp_ble_mesh/mesh_models/client/client_common.c index 66e128d431..658c3c4a8a 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/client_common.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/client_common.c @@ -251,26 +251,21 @@ static const struct bt_mesh_send_cb send_cb = { .end = NULL, }; -int bt_mesh_client_send_msg(struct bt_mesh_model *model, - u32_t opcode, - struct bt_mesh_msg_ctx *ctx, - struct net_buf_simple *msg, - k_work_handler_t timer_handler, - s32_t timeout, bool need_ack, - const struct bt_mesh_send_cb *cb, - void *cb_data) +int bt_mesh_client_send_msg(bt_mesh_client_common_param_t *param, + struct net_buf_simple *msg, bool need_ack, + k_work_handler_t timer_handler) { bt_mesh_client_internal_data_t *internal = NULL; bt_mesh_client_user_data_t *client = NULL; bt_mesh_client_node_t *node = NULL; int err = 0; - if (!model || !ctx || !msg) { + if (!param || !param->model || !msg) { BT_ERR("%s, Invalid parameter", __func__); return -EINVAL; } - client = (bt_mesh_client_user_data_t *)model->user_data; + client = (bt_mesh_client_user_data_t *)param->model->user_data; if (!client) { BT_ERR("Invalid client user data"); return -EINVAL; @@ -282,23 +277,23 @@ int bt_mesh_client_send_msg(struct bt_mesh_model *model, return -EINVAL; } - if (ctx->addr == BLE_MESH_ADDR_UNASSIGNED) { - BT_ERR("Invalid DST 0x%04x", ctx->addr); + if (param->ctx.addr == BLE_MESH_ADDR_UNASSIGNED) { + BT_ERR("Invalid DST 0x%04x", param->ctx.addr); return -EINVAL; } if (!need_ack) { /* If this is an unack message, send it directly. */ - return bt_mesh_model_send(model, ctx, msg, cb, cb_data); + return bt_mesh_model_send(param->model, ¶m->ctx, msg, param->cb, param->cb_data); } - if (!BLE_MESH_ADDR_IS_UNICAST(ctx->addr)) { + if (!BLE_MESH_ADDR_IS_UNICAST(param->ctx.addr)) { /* If an acknowledged message is not sent to a unicast address, * for example to a group/virtual address, then all the * corresponding responses will be treated as publish messages. * And no timeout will be used for the message. */ - return bt_mesh_model_send(model, ctx, msg, cb, cb_data); + return bt_mesh_model_send(param->model, ¶m->ctx, msg, param->cb, param->cb_data); } if (!timer_handler) { @@ -306,8 +301,8 @@ int bt_mesh_client_send_msg(struct bt_mesh_model *model, return -EINVAL; } - if (bt_mesh_client_check_node_in_list(&internal->queue, ctx->addr)) { - BT_ERR("Busy sending message to DST 0x%04x", ctx->addr); + if (bt_mesh_client_check_node_in_list(&internal->queue, param->ctx.addr)) { + BT_ERR("Busy sending message to DST 0x%04x", param->ctx.addr); return -EBUSY; } @@ -318,16 +313,17 @@ int bt_mesh_client_send_msg(struct bt_mesh_model *model, return -ENOMEM; } - memcpy(&node->ctx, ctx, sizeof(struct bt_mesh_msg_ctx)); - node->ctx.model = model; - node->opcode = opcode; - node->op_pending = bt_mesh_client_get_status_op(client->op_pair, client->op_pair_size, opcode); + memcpy(&node->ctx, ¶m->ctx, sizeof(struct bt_mesh_msg_ctx)); + node->ctx.model = param->model; + node->opcode = param->opcode; + node->op_pending = bt_mesh_client_get_status_op(client->op_pair, client->op_pair_size, param->opcode); if (node->op_pending == 0U) { BT_ERR("Not found the status opcode in op_pair list"); bt_mesh_free(node); return -EINVAL; } - node->timeout = bt_mesh_client_calc_timeout(ctx, msg, opcode, timeout ? timeout : CONFIG_BLE_MESH_CLIENT_MSG_TIMEOUT); + node->timeout = bt_mesh_client_calc_timeout(¶m->ctx, msg, param->opcode, + param->msg_timeout ? param->msg_timeout : CONFIG_BLE_MESH_CLIENT_MSG_TIMEOUT); if (k_delayed_work_init(&node->timer, timer_handler)) { BT_ERR("Failed to create a timer"); @@ -343,7 +339,7 @@ int bt_mesh_client_send_msg(struct bt_mesh_model *model, * Due to the higher priority of adv_thread (than btc task), we need to * send the packet after the list item "node" is initialized properly. */ - err = bt_mesh_model_send(model, ctx, msg, &send_cb, node); + err = bt_mesh_model_send(param->model, ¶m->ctx, msg, &send_cb, node); if (err) { BT_ERR("Failed to send client message 0x%08x", node->opcode); k_delayed_work_free(&node->timer); diff --git a/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c b/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c index bee29cf451..99d13c7912 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c @@ -725,9 +725,7 @@ static int gen_get_state(bt_mesh_client_common_param_t *common, void *value) } } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, &msg, - timeout_handler, common->msg_timeout, true, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, &msg, true, timeout_handler); if (err) { BT_ERR("Failed to send Generic Get message (err %d)", err); } @@ -904,9 +902,7 @@ static int gen_set_state(bt_mesh_client_common_param_t *common, goto end; } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, msg, - timeout_handler, common->msg_timeout, need_ack, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); if (err) { BT_ERR("Failed to send Generic Set message (err %d)", err); } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h b/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h index 78e87a24e1..c6fc892348 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h +++ b/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h @@ -104,13 +104,9 @@ bt_mesh_client_node_t *bt_mesh_is_client_recv_publish_msg(struct bt_mesh_model * struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf, bool need_pub); -int bt_mesh_client_send_msg(struct bt_mesh_model *model, - u32_t opcode, - struct bt_mesh_msg_ctx *ctx, - struct net_buf_simple *msg, - k_work_handler_t timer_handler, - s32_t timeout, bool need_ack, - const struct bt_mesh_send_cb *cb, void *cb_data); +int bt_mesh_client_send_msg(bt_mesh_client_common_param_t *param, + struct net_buf_simple *msg, bool need_ack, + k_work_handler_t timer_handler); int bt_mesh_client_free_node(bt_mesh_client_node_t *node); diff --git a/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c b/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c index 77ed506213..18e5072e11 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c @@ -790,9 +790,7 @@ static int light_get_state(bt_mesh_client_common_param_t *common, void *value) } } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, &msg, - timeout_handler, common->msg_timeout, true, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, &msg, true, timeout_handler); if (err) { BT_ERR("Failed to send Lighting Get message (err %d)", err); } @@ -1028,9 +1026,7 @@ static int light_set_state(bt_mesh_client_common_param_t *common, goto end; } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, msg, - timeout_handler, common->msg_timeout, need_ack, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); if (err) { BT_ERR("Failed to send Lighting Set message (err %d)", err); } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c b/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c index 860c50a8bc..34a597d853 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c @@ -447,9 +447,7 @@ static int sensor_act_state(bt_mesh_client_common_param_t *common, goto end; } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, msg, - timeout_handler, common->msg_timeout, need_ack, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); if (err) { BT_ERR("Failed to send Sensor client message (err %d)", err); } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c b/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c index 9357cdbc75..b39ed24ffa 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c @@ -390,9 +390,7 @@ static int time_scene_get_state(bt_mesh_client_common_param_t *common, void *val } } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, &msg, - timeout_handler, common->msg_timeout, true, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, &msg, true, timeout_handler); if (err) { BT_ERR("Failed to send Time Scene Get message (err %d)", err); } @@ -485,9 +483,7 @@ static int time_scene_set_state(bt_mesh_client_common_param_t *common, goto end; } - err = bt_mesh_client_send_msg(common->model, common->opcode, &common->ctx, msg, - timeout_handler, common->msg_timeout, need_ack, - common->cb, common->cb_data); + err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); if (err) { BT_ERR("Failed to send Time Scene Set message (err %d)", err); } From 1d6f6536402e8529b546268cca5aa814e0c8e129 Mon Sep 17 00:00:00 2001 From: lly Date: Sun, 28 Jun 2020 15:56:34 +0800 Subject: [PATCH 2/8] ble_mesh: stack: Remove some not used variables & functions --- .../bt/esp_ble_mesh/mesh_core/cfg_cli.c | 20 +---------- .../bt/esp_ble_mesh/mesh_core/health_cli.c | 35 ------------------- .../esp_ble_mesh/mesh_core/include/cfg_cli.h | 3 -- .../mesh_core/include/health_cli.h | 5 --- 4 files changed, 1 insertion(+), 62 deletions(-) diff --git a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c index 4e0c9f1dc8..cd4bdde6ac 100644 --- a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c @@ -20,10 +20,6 @@ #include "mesh_common.h" #include "cfg_cli.h" -s32_t config_msg_timeout; - -static bt_mesh_config_client_t *cli; - static const bt_mesh_client_op_pair_t cfg_op_pair[] = { { OP_BEACON_GET, OP_BEACON_STATUS }, { OP_BEACON_SET, OP_BEACON_STATUS }, @@ -1383,16 +1379,6 @@ int bt_mesh_cfg_net_transmit_set(bt_mesh_client_common_param_t *param, u8_t tran return send_msg_with_u8(param, OP_NET_TRANSMIT_SET, transmit); } -s32_t bt_mesh_cfg_cli_timeout_get(void) -{ - return config_msg_timeout; -} - -void bt_mesh_cfg_cli_timeout_set(s32_t timeout) -{ - config_msg_timeout = timeout; -} - int bt_mesh_cfg_cli_init(struct bt_mesh_model *model, bool primary) { config_internal_data_t *internal = NULL; @@ -1433,8 +1419,6 @@ int bt_mesh_cfg_cli_init(struct bt_mesh_model *model, bool primary) bt_mesh_client_clear_list(client->internal_data); } - cli = client; - /* Configuration Model security is device-key based */ model->keys[0] = BLE_MESH_KEY_DEV; @@ -1469,11 +1453,9 @@ int bt_mesh_cfg_cli_deinit(struct bt_mesh_model *model, bool primary) /* Free the allocated internal data */ bt_mesh_free(client->internal_data); - cli->internal_data = NULL; + client->internal_data = NULL; } - client = NULL; - bt_mesh_cfg_client_mutex_free(); return 0; diff --git a/components/bt/esp_ble_mesh/mesh_core/health_cli.c b/components/bt/esp_ble_mesh/mesh_core/health_cli.c index acf56eef2d..1c8475154d 100644 --- a/components/bt/esp_ble_mesh/mesh_core/health_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/health_cli.c @@ -18,10 +18,6 @@ #include "mesh_common.h" #include "health_cli.h" -s32_t health_msg_timeout; - -static bt_mesh_health_client_t *health_cli; - static const bt_mesh_client_op_pair_t health_op_pair[] = { { OP_HEALTH_FAULT_GET, OP_HEALTH_FAULT_STATUS }, { OP_HEALTH_FAULT_CLEAR, OP_HEALTH_FAULT_STATUS }, @@ -350,28 +346,6 @@ int bt_mesh_health_fault_get(bt_mesh_client_common_param_t *param, u16_t cid) return err; } -s32_t bt_mesh_health_cli_timeout_get(void) -{ - return health_msg_timeout; -} - -void bt_mesh_health_cli_timeout_set(s32_t timeout) -{ - health_msg_timeout = timeout; -} - -int bt_mesh_health_cli_set(struct bt_mesh_model *model) -{ - if (!model || !model->user_data) { - BT_ERR("No Health Client context for given model"); - return -EINVAL; - } - - health_cli = model->user_data; - - return 0; -} - int bt_mesh_health_cli_init(struct bt_mesh_model *model, bool primary) { health_internal_data_t *internal = NULL; @@ -409,11 +383,6 @@ int bt_mesh_health_cli_init(struct bt_mesh_model *model, bool primary) bt_mesh_health_client_mutex_new(); - /* Set the default health client pointer */ - if (!health_cli) { - health_cli = client; - } - return 0; } @@ -443,9 +412,5 @@ int bt_mesh_health_cli_deinit(struct bt_mesh_model *model, bool primary) bt_mesh_health_client_mutex_free(); - if (health_cli) { - health_cli = NULL; - } - return 0; } diff --git a/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h b/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h index c33a7d977f..e04b7b3ad3 100644 --- a/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h +++ b/components/bt/esp_ble_mesh/mesh_core/include/cfg_cli.h @@ -135,9 +135,6 @@ int bt_mesh_cfg_hb_pub_get(bt_mesh_client_common_param_t *param); int bt_mesh_cfg_node_reset(bt_mesh_client_common_param_t *param); -s32_t bt_mesh_cfg_cli_timeout_get(void); -void bt_mesh_cfg_cli_timeout_set(s32_t timeout); - /* Configuration Client Status Message Context */ struct bt_mesh_cfg_comp_data_status { diff --git a/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h b/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h index 8d38cf3d3d..6bb7a42852 100644 --- a/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h +++ b/components/bt/esp_ble_mesh/mesh_core/include/health_cli.h @@ -34,8 +34,6 @@ extern const struct bt_mesh_model_op bt_mesh_health_cli_op[]; BLE_MESH_MODEL(BLE_MESH_MODEL_ID_HEALTH_CLI, \ bt_mesh_health_cli_op, NULL, cli_data) -int bt_mesh_health_cli_set(struct bt_mesh_model *model); - int bt_mesh_health_fault_get(bt_mesh_client_common_param_t *param, u16_t cid); int bt_mesh_health_fault_clear(bt_mesh_client_common_param_t *param, @@ -54,9 +52,6 @@ int bt_mesh_health_attention_get(bt_mesh_client_common_param_t *param); int bt_mesh_health_attention_set(bt_mesh_client_common_param_t *param, u8_t attention, bool need_ack); -s32_t bt_mesh_health_cli_timeout_get(void); -void bt_mesh_health_cli_timeout_set(s32_t timeout); - /* Health Client Status Message Context */ struct bt_mesh_health_current_status { From ad39479804cac01f6d5f351b0da526b569855ac4 Mon Sep 17 00:00:00 2001 From: lly Date: Sun, 28 Jun 2020 16:18:24 +0800 Subject: [PATCH 3/8] ble_mesh: stack: Remove some not used client parameters --- .../bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c | 4 ++++ .../bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c | 10 ++++++---- .../bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c | 4 ++++ .../bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c | 10 ++++++---- .../bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c | 10 ++++++---- .../esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c | 10 ++++++---- .../esp_ble_mesh/mesh_models/client/generic_client.c | 6 ++---- .../mesh_models/client/include/generic_client.h | 8 ++------ .../mesh_models/client/include/lighting_client.h | 8 ++------ .../mesh_models/client/include/sensor_client.h | 8 ++------ .../mesh_models/client/include/time_scene_client.h | 8 ++------ .../esp_ble_mesh/mesh_models/client/lighting_client.c | 6 ++---- .../bt/esp_ble_mesh/mesh_models/client/sensor_client.c | 6 ++---- .../mesh_models/client/time_scene_client.c | 6 ++---- 14 files changed, 48 insertions(+), 56 deletions(-) diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c index 1d18f4fb65..c8807a3535 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c @@ -635,12 +635,14 @@ void btc_ble_mesh_config_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_CONFIG_CLIENT_GET_STATE: { cb.params = arg->cfg_client_get_state.params; + role_param.model = (struct bt_mesh_model *)cb.params->model; role_param.role = cb.params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + cb.error_code = btc_ble_mesh_config_client_get_state(arg->cfg_client_get_state.params, arg->cfg_client_get_state.get_state); if (cb.error_code) { @@ -650,12 +652,14 @@ void btc_ble_mesh_config_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_CONFIG_CLIENT_SET_STATE: { cb.params = arg->cfg_client_set_state.params; + role_param.model = (struct bt_mesh_model *)cb.params->model; role_param.role = cb.params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + cb.error_code = btc_ble_mesh_config_client_set_state(arg->cfg_client_set_state.params, arg->cfg_client_set_state.set_state); if (cb.error_code) { diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c index 4f267b3f63..7b813fc090 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c @@ -466,12 +466,14 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_GENERIC_CLIENT_GET_STATE: { params = arg->generic_client_get_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -482,8 +484,7 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->generic_client_get_state.params; - cb.error_code = bt_mesh_generic_client_get_state(&common, - (void *)arg->generic_client_get_state.get_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_generic_client_get_state(&common, arg->generic_client_get_state.get_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_generic_client_callback(&cb, ESP_BLE_MESH_GENERIC_CLIENT_GET_STATE_EVT); @@ -492,12 +493,14 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_GENERIC_CLIENT_SET_STATE: { params = arg->generic_client_set_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -508,8 +511,7 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->generic_client_set_state.params; - cb.error_code = bt_mesh_generic_client_set_state(&common, - (void *)arg->generic_client_set_state.set_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_generic_client_set_state(&common, arg->generic_client_set_state.set_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_generic_client_callback(&cb, ESP_BLE_MESH_GENERIC_CLIENT_SET_STATE_EVT); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c index 240f318aa1..c956be5b0d 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c @@ -411,12 +411,14 @@ void btc_ble_mesh_health_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_HEALTH_CLIENT_GET_STATE: { cb.params = arg->health_client_get_state.params; + role_param.model = (struct bt_mesh_model *)cb.params->model; role_param.role = cb.params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + cb.error_code = btc_ble_mesh_health_client_get_state(arg->health_client_get_state.params, arg->health_client_get_state.get_state); if (cb.error_code) { @@ -427,12 +429,14 @@ void btc_ble_mesh_health_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_HEALTH_CLIENT_SET_STATE: { cb.params = arg->health_client_set_state.params; + role_param.model = (struct bt_mesh_model *)cb.params->model; role_param.role = cb.params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + cb.error_code = btc_ble_mesh_health_client_set_state(arg->health_client_set_state.params, arg->health_client_set_state.set_state); if (cb.error_code) { diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c index 3687d20fd4..89e576ebfc 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c @@ -310,12 +310,14 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_LIGHTING_CLIENT_GET_STATE: { params = arg->light_client_get_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -326,8 +328,7 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->light_client_get_state.params; - cb.error_code = bt_mesh_light_client_get_state(&common, - (void *)arg->light_client_get_state.get_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_light_client_get_state(&common, arg->light_client_get_state.get_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_lighting_client_callback(&cb, ESP_BLE_MESH_LIGHT_CLIENT_GET_STATE_EVT); @@ -336,12 +337,14 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_LIGHTING_CLIENT_SET_STATE: { params = arg->light_client_set_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -352,8 +355,7 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->light_client_set_state.params; - cb.error_code = bt_mesh_light_client_set_state(&common, - (void *)arg->light_client_set_state.set_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_light_client_set_state(&common, arg->light_client_set_state.set_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_lighting_client_callback(&cb, ESP_BLE_MESH_LIGHT_CLIENT_SET_STATE_EVT); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c index 98c9069391..100de98335 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c @@ -548,12 +548,14 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_SENSOR_CLIENT_GET_STATE: { params = arg->sensor_client_get_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -564,8 +566,7 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->sensor_client_get_state.params; - cb.error_code = bt_mesh_sensor_client_get_state(&common, - (void *)arg->sensor_client_get_state.get_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_sensor_client_get_state(&common, arg->sensor_client_get_state.get_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_sensor_client_callback(&cb, ESP_BLE_MESH_SENSOR_CLIENT_GET_STATE_EVT); @@ -574,12 +575,14 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_SENSOR_CLIENT_SET_STATE: { params = arg->sensor_client_set_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -590,8 +593,7 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->sensor_client_set_state.params; - cb.error_code = bt_mesh_sensor_client_set_state(&common, - (void *)arg->sensor_client_set_state.set_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_sensor_client_set_state(&common, arg->sensor_client_set_state.set_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_sensor_client_callback(&cb, ESP_BLE_MESH_SENSOR_CLIENT_SET_STATE_EVT); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c index ac30384465..ce3318cc83 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c @@ -312,12 +312,14 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_TIME_SCENE_CLIENT_GET_STATE: { params = arg->time_scene_client_get_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -328,8 +330,7 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->time_scene_client_get_state.params; - cb.error_code = bt_mesh_time_scene_client_get_state(&common, - (void *)arg->time_scene_client_get_state.get_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_time_scene_client_get_state(&common, arg->time_scene_client_get_state.get_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_time_scene_client_callback(&cb, ESP_BLE_MESH_TIME_SCENE_CLIENT_GET_STATE_EVT); @@ -338,12 +339,14 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_TIME_SCENE_CLIENT_SET_STATE: { params = arg->time_scene_client_set_state.params; + role_param.model = (struct bt_mesh_model *)params->model; role_param.role = params->msg_role; if (bt_mesh_set_client_model_role(&role_param)) { BT_ERR("Failed to set model role"); break; } + common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -354,8 +357,7 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) common.msg_timeout = params->msg_timeout; cb.params = arg->time_scene_client_set_state.params; - cb.error_code = bt_mesh_time_scene_client_set_state(&common, - (void *)arg->time_scene_client_set_state.set_state, (void *)&cb.status_cb); + cb.error_code = bt_mesh_time_scene_client_set_state(&common, arg->time_scene_client_set_state.set_state); if (cb.error_code) { /* If send failed, callback error_code to app layer immediately */ btc_ble_mesh_time_scene_client_callback(&cb, ESP_BLE_MESH_TIME_SCENE_CLIENT_SET_STATE_EVT); diff --git a/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c b/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c index 99d13c7912..6f11f60049 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c @@ -913,8 +913,7 @@ end: return err; } -int bt_mesh_generic_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status) +int bt_mesh_generic_client_get_state(bt_mesh_client_common_param_t *common, void *get) { bt_mesh_generic_client_t *client = NULL; @@ -977,8 +976,7 @@ int bt_mesh_generic_client_get_state(bt_mesh_client_common_param_t *common, return gen_get_state(common, get); } -int bt_mesh_generic_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status) +int bt_mesh_generic_client_set_state(bt_mesh_client_common_param_t *common, void *set) { bt_mesh_generic_client_t *client = NULL; u16_t length = 0U; diff --git a/components/bt/esp_ble_mesh/mesh_models/client/include/generic_client.h b/components/bt/esp_ble_mesh/mesh_models/client/include/generic_client.h index c0b9af97f2..53bea97434 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/include/generic_client.h +++ b/components/bt/esp_ble_mesh/mesh_models/client/include/generic_client.h @@ -553,24 +553,20 @@ int bt_mesh_gen_property_cli_deinit(struct bt_mesh_model *model, bool primary); * * @param[in] common: Message common information structure * @param[in] get: Pointer of generic get message value - * @param[out] status: Pointer of generic status message value * * @return Zero-success, other-fail */ -int bt_mesh_generic_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status); +int bt_mesh_generic_client_get_state(bt_mesh_client_common_param_t *common, void *get); /** * @brief This function is called to set generic states. * * @param[in] common: Message common information structure * @param[in] set: Pointer of generic set message value - * @param[out] status: Pointer of generic status message value * * @return Zero-success, other-fail */ -int bt_mesh_generic_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status); +int bt_mesh_generic_client_set_state(bt_mesh_client_common_param_t *common, void *set); #ifdef __cplusplus } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/include/lighting_client.h b/components/bt/esp_ble_mesh/mesh_models/client/include/lighting_client.h index f623cfb8a8..7a7e62c305 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/include/lighting_client.h +++ b/components/bt/esp_ble_mesh/mesh_models/client/include/lighting_client.h @@ -523,24 +523,20 @@ int bt_mesh_light_lc_cli_deinit(struct bt_mesh_model *model, bool primary); * * @param[in] common: Message common information structure * @param[in] get: Pointer of light get message value - * @param[out] status: Pointer of light status message value * * @return Zero-success, other-fail */ -int bt_mesh_light_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status); +int bt_mesh_light_client_get_state(bt_mesh_client_common_param_t *common, void *get); /** * @brief This function is called to set light states. * * @param[in] common: Message common information structure * @param[in] set: Pointer of light set message value - * @param[out] status: Pointer of light status message value * * @return Zero-success, other-fail */ -int bt_mesh_light_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status); +int bt_mesh_light_client_set_state(bt_mesh_client_common_param_t *common, void *set); #ifdef __cplusplus } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/include/sensor_client.h b/components/bt/esp_ble_mesh/mesh_models/client/include/sensor_client.h index 2f798c69f1..47448547ff 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/include/sensor_client.h +++ b/components/bt/esp_ble_mesh/mesh_models/client/include/sensor_client.h @@ -158,24 +158,20 @@ int bt_mesh_sensor_cli_deinit(struct bt_mesh_model *model, bool primary); * * @param[in] common: Message common information structure * @param[in] get: Pointer of sensor get message value - * @param[out] status: Pointer of sensor status message value * * @return Zero-success, other-fail */ -int bt_mesh_sensor_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status); +int bt_mesh_sensor_client_get_state(bt_mesh_client_common_param_t *common, void *get); /** * @brief This function is called to set sensor states. * * @param[in] common: Message common information structure * @param[in] set: Pointer of sensor set message value - * @param[out] status: Pointer of sensor status message value * * @return Zero-success, other-fail */ -int bt_mesh_sensor_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status); +int bt_mesh_sensor_client_set_state(bt_mesh_client_common_param_t *common, void *set); #ifdef __cplusplus } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/include/time_scene_client.h b/components/bt/esp_ble_mesh/mesh_models/client/include/time_scene_client.h index 4d400776b0..ee741c5306 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/include/time_scene_client.h +++ b/components/bt/esp_ble_mesh/mesh_models/client/include/time_scene_client.h @@ -268,24 +268,20 @@ int bt_mesh_scheduler_cli_deinit(struct bt_mesh_model *model, bool primary); * * @param[in] common: Message common information structure * @param[in] get: Pointer of time scene get message value - * @param[out] status: Pointer of time scene status message value * * @return Zero-success, other-fail */ -int bt_mesh_time_scene_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status); +int bt_mesh_time_scene_client_get_state(bt_mesh_client_common_param_t *common, void *get); /** * @brief This function is called to set scene states. * * @param[in] common: Message common information structure * @param[in] set: Pointer of time scene set message value - * @param[out] status: Pointer of time scene status message value * * @return Zero-success, other-fail */ -int bt_mesh_time_scene_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status); +int bt_mesh_time_scene_client_set_state(bt_mesh_client_common_param_t *common, void *set); #ifdef __cplusplus } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c b/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c index 18e5072e11..f89161de52 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c @@ -1037,8 +1037,7 @@ end: return err; } -int bt_mesh_light_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status) +int bt_mesh_light_client_get_state(bt_mesh_client_common_param_t *common, void *get) { bt_mesh_light_client_t *client = NULL; @@ -1091,8 +1090,7 @@ int bt_mesh_light_client_get_state(bt_mesh_client_common_param_t *common, return light_get_state(common, get); } -int bt_mesh_light_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status) +int bt_mesh_light_client_set_state(bt_mesh_client_common_param_t *common, void *set) { bt_mesh_light_client_t *client = NULL; u16_t length = 0U; diff --git a/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c b/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c index 34a597d853..9ef7694e59 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c @@ -458,8 +458,7 @@ end: return err; } -int bt_mesh_sensor_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status) +int bt_mesh_sensor_client_get_state(bt_mesh_client_common_param_t *common, void *get) { bt_mesh_sensor_client_t *client = NULL; u16_t length = 0U; @@ -524,8 +523,7 @@ int bt_mesh_sensor_client_get_state(bt_mesh_client_common_param_t *common, return sensor_act_state(common, get, length, true); } -int bt_mesh_sensor_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status) +int bt_mesh_sensor_client_set_state(bt_mesh_client_common_param_t *common, void *set) { bt_mesh_sensor_client_t *client = NULL; u16_t length = 0U; diff --git a/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c b/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c index b39ed24ffa..8d416ba032 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c @@ -493,8 +493,7 @@ end: return err; } -int bt_mesh_time_scene_client_get_state(bt_mesh_client_common_param_t *common, - void *get, void *status) +int bt_mesh_time_scene_client_get_state(bt_mesh_client_common_param_t *common, void *get) { bt_mesh_time_scene_client_t *client = NULL; @@ -532,8 +531,7 @@ int bt_mesh_time_scene_client_get_state(bt_mesh_client_common_param_t *common, return time_scene_get_state(common, get); } -int bt_mesh_time_scene_client_set_state(bt_mesh_client_common_param_t *common, - void *set, void *status) +int bt_mesh_time_scene_client_set_state(bt_mesh_client_common_param_t *common, void *set) { bt_mesh_time_scene_client_t *client = NULL; u16_t length = 0U; From 5f6f61f63495d2fd70bce4b2171ede30a9758b23 Mon Sep 17 00:00:00 2001 From: lly Date: Sun, 28 Jun 2020 16:53:02 +0800 Subject: [PATCH 4/8] ble_mesh: stack: Move client role set to the msg function --- .../btc/btc_ble_mesh_config_model.c | 19 +------- .../btc/btc_ble_mesh_generic_model.c | 19 +------- .../btc/btc_ble_mesh_health_model.c | 19 +------- .../btc/btc_ble_mesh_lighting_model.c | 19 +------- .../bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c | 18 +++----- .../btc/btc_ble_mesh_sensor_model.c | 19 +------- .../btc/btc_ble_mesh_time_scene_model.c | 19 +------- .../mesh_models/client/client_common.c | 46 +++++++------------ .../client/include/client_common.h | 13 ++---- 9 files changed, 40 insertions(+), 151 deletions(-) diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c index c8807a3535..8e34d47fc6 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c @@ -416,6 +416,7 @@ static int btc_ble_mesh_config_client_get_state(esp_ble_mesh_client_common_param param.ctx.send_rel = params->ctx.send_rel; param.ctx.send_ttl = params->ctx.send_ttl; param.msg_timeout = params->msg_timeout; + param.msg_role = params->msg_role; switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_BEACON_GET: @@ -495,6 +496,7 @@ static int btc_ble_mesh_config_client_set_state(esp_ble_mesh_client_common_param param.ctx.send_rel = params->ctx.send_rel; param.ctx.send_ttl = params->ctx.send_ttl; param.msg_timeout = params->msg_timeout; + param.msg_role = params->msg_role; switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_BEACON_SET: @@ -623,7 +625,6 @@ void btc_ble_mesh_config_client_call_handler(btc_msg_t *msg) { btc_ble_mesh_config_client_args_t *arg = NULL; esp_ble_mesh_cfg_client_cb_param_t cb = {0}; - bt_mesh_role_param_t role_param = {0}; if (!msg || !msg->arg) { BT_ERR("%s, Invalid parameter", __func__); @@ -635,14 +636,6 @@ void btc_ble_mesh_config_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_CONFIG_CLIENT_GET_STATE: { cb.params = arg->cfg_client_get_state.params; - - role_param.model = (struct bt_mesh_model *)cb.params->model; - role_param.role = cb.params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - cb.error_code = btc_ble_mesh_config_client_get_state(arg->cfg_client_get_state.params, arg->cfg_client_get_state.get_state); if (cb.error_code) { @@ -652,14 +645,6 @@ void btc_ble_mesh_config_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_CONFIG_CLIENT_SET_STATE: { cb.params = arg->cfg_client_set_state.params; - - role_param.model = (struct bt_mesh_model *)cb.params->model; - role_param.role = cb.params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - cb.error_code = btc_ble_mesh_config_client_set_state(arg->cfg_client_set_state.params, arg->cfg_client_set_state.set_state); if (cb.error_code) { diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c index 7b813fc090..ec959964a7 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c @@ -454,7 +454,6 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) btc_ble_mesh_generic_client_args_t *arg = NULL; esp_ble_mesh_generic_client_cb_param_t cb = {0}; bt_mesh_client_common_param_t common = {0}; - bt_mesh_role_param_t role_param = {0}; if (!msg || !msg->arg) { BT_ERR("%s, Invalid parameter", __func__); @@ -466,14 +465,6 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_GENERIC_CLIENT_GET_STATE: { params = arg->generic_client_get_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -482,6 +473,7 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->generic_client_get_state.params; cb.error_code = bt_mesh_generic_client_get_state(&common, arg->generic_client_get_state.get_state); @@ -493,14 +485,6 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_GENERIC_CLIENT_SET_STATE: { params = arg->generic_client_set_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -509,6 +493,7 @@ void btc_ble_mesh_generic_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->generic_client_set_state.params; cb.error_code = bt_mesh_generic_client_set_state(&common, arg->generic_client_set_state.set_state); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c index c956be5b0d..9ed378906b 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c @@ -335,6 +335,7 @@ static int btc_ble_mesh_health_client_get_state(esp_ble_mesh_client_common_param param.ctx.send_rel = params->ctx.send_rel; param.ctx.send_ttl = params->ctx.send_ttl; param.msg_timeout = params->msg_timeout; + param.msg_role = params->msg_role; switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_ATTENTION_GET: @@ -369,6 +370,7 @@ static int btc_ble_mesh_health_client_set_state(esp_ble_mesh_client_common_param param.ctx.send_rel = params->ctx.send_rel; param.ctx.send_ttl = params->ctx.send_ttl; param.msg_timeout = params->msg_timeout; + param.msg_role = params->msg_role; switch (param.opcode) { case ESP_BLE_MESH_MODEL_OP_ATTENTION_SET: @@ -399,7 +401,6 @@ void btc_ble_mesh_health_client_call_handler(btc_msg_t *msg) { btc_ble_mesh_health_client_args_t *arg = NULL; esp_ble_mesh_health_client_cb_param_t cb = {0}; - bt_mesh_role_param_t role_param = {0}; if (!msg || !msg->arg) { BT_ERR("%s, Invalid parameter", __func__); @@ -411,14 +412,6 @@ void btc_ble_mesh_health_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_HEALTH_CLIENT_GET_STATE: { cb.params = arg->health_client_get_state.params; - - role_param.model = (struct bt_mesh_model *)cb.params->model; - role_param.role = cb.params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - cb.error_code = btc_ble_mesh_health_client_get_state(arg->health_client_get_state.params, arg->health_client_get_state.get_state); if (cb.error_code) { @@ -429,14 +422,6 @@ void btc_ble_mesh_health_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_HEALTH_CLIENT_SET_STATE: { cb.params = arg->health_client_set_state.params; - - role_param.model = (struct bt_mesh_model *)cb.params->model; - role_param.role = cb.params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - cb.error_code = btc_ble_mesh_health_client_set_state(arg->health_client_set_state.params, arg->health_client_set_state.set_state); if (cb.error_code) { diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c index 89e576ebfc..013b661c85 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c @@ -298,7 +298,6 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) btc_ble_mesh_lighting_client_args_t *arg = NULL; esp_ble_mesh_light_client_cb_param_t cb = {0}; bt_mesh_client_common_param_t common = {0}; - bt_mesh_role_param_t role_param = {0}; if (!msg || !msg->arg) { BT_ERR("%s, Invalid parameter", __func__); @@ -310,14 +309,6 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_LIGHTING_CLIENT_GET_STATE: { params = arg->light_client_get_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -326,6 +317,7 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->light_client_get_state.params; cb.error_code = bt_mesh_light_client_get_state(&common, arg->light_client_get_state.get_state); @@ -337,14 +329,6 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_LIGHTING_CLIENT_SET_STATE: { params = arg->light_client_set_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -353,6 +337,7 @@ void btc_ble_mesh_lighting_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->light_client_set_state.params; cb.error_code = bt_mesh_light_client_set_state(&common, arg->light_client_set_state.set_state); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c index 87026a62e4..d0b2517bfa 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c @@ -1978,11 +1978,11 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_MODEL_PUBLISH: { if (arg->model_publish.device_role == PROVISIONER) { - bt_mesh_role_param_t common = {0}; - common.model = (struct bt_mesh_model *)(arg->model_publish.model); - common.role = arg->model_publish.device_role; - if (bt_mesh_set_client_model_role(&common)) { - BT_ERR("Failed to set model role"); + /* Currently Provisioner only supports client model */ + err = bt_mesh_set_client_model_role((struct bt_mesh_model *)arg->model_publish.model, + arg->model_publish.device_role); + if (err) { + BT_ERR("Failed to set client role"); break; } } @@ -2008,7 +2008,6 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) break; } case BTC_BLE_MESH_ACT_CLIENT_MODEL_SEND: { - bt_mesh_role_param_t common = {0}; /* arg->model_send.length contains opcode & message, plus extra 4-bytes TransMIC */ struct net_buf_simple *buf = bt_mesh_alloc_buf(arg->model_send.length + BLE_MESH_MIC_SHORT); if (!buf) { @@ -2016,12 +2015,6 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) break; } net_buf_simple_add_mem(buf, arg->model_send.data, arg->model_send.length); - common.model = (struct bt_mesh_model *)(arg->model_send.model); - common.role = arg->model_send.device_role; - if (bt_mesh_set_client_model_role(&common)) { - BT_ERR("Failed to set model role"); - break; - } bt_mesh_client_common_param_t param = { .opcode = arg->model_send.opcode, .model = (struct bt_mesh_model *)arg->model_send.model, @@ -2032,6 +2025,7 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) .ctx.send_ttl = arg->model_send.ctx->send_ttl, .ctx.srv_send = false, .msg_timeout = arg->model_send.msg_timeout, + .msg_role = arg->model_send.device_role, }; err = bt_mesh_client_send_msg(¶m, buf, arg->model_send.need_rsp, btc_ble_mesh_client_model_timeout_cb); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c index 100de98335..af05ac4f55 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c @@ -536,7 +536,6 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) btc_ble_mesh_sensor_client_args_t *arg = NULL; esp_ble_mesh_sensor_client_cb_param_t cb = {0}; bt_mesh_client_common_param_t common = {0}; - bt_mesh_role_param_t role_param = {0}; if (!msg || !msg->arg) { BT_ERR("%s, Invalid parameter", __func__); @@ -548,14 +547,6 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_SENSOR_CLIENT_GET_STATE: { params = arg->sensor_client_get_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -564,6 +555,7 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->sensor_client_get_state.params; cb.error_code = bt_mesh_sensor_client_get_state(&common, arg->sensor_client_get_state.get_state); @@ -575,14 +567,6 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_SENSOR_CLIENT_SET_STATE: { params = arg->sensor_client_set_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -591,6 +575,7 @@ void btc_ble_mesh_sensor_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->sensor_client_set_state.params; cb.error_code = bt_mesh_sensor_client_set_state(&common, arg->sensor_client_set_state.set_state); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c index ce3318cc83..1609a4591a 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c @@ -300,7 +300,6 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) esp_ble_mesh_client_common_param_t *params = NULL; esp_ble_mesh_time_scene_client_cb_param_t cb = {0}; bt_mesh_client_common_param_t common = {0}; - bt_mesh_role_param_t role_param = {0}; if (!msg || !msg->arg) { BT_ERR("%s, Invalid parameter", __func__); @@ -312,14 +311,6 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) switch (msg->act) { case BTC_BLE_MESH_ACT_TIME_SCENE_CLIENT_GET_STATE: { params = arg->time_scene_client_get_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -328,6 +319,7 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->time_scene_client_get_state.params; cb.error_code = bt_mesh_time_scene_client_get_state(&common, arg->time_scene_client_get_state.get_state); @@ -339,14 +331,6 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) } case BTC_BLE_MESH_ACT_TIME_SCENE_CLIENT_SET_STATE: { params = arg->time_scene_client_set_state.params; - - role_param.model = (struct bt_mesh_model *)params->model; - role_param.role = params->msg_role; - if (bt_mesh_set_client_model_role(&role_param)) { - BT_ERR("Failed to set model role"); - break; - } - common.opcode = params->opcode; common.model = (struct bt_mesh_model *)params->model; common.ctx.net_idx = params->ctx.net_idx; @@ -355,6 +339,7 @@ void btc_ble_mesh_time_scene_client_call_handler(btc_msg_t *msg) common.ctx.send_rel = params->ctx.send_rel; common.ctx.send_ttl = params->ctx.send_ttl; common.msg_timeout = params->msg_timeout; + common.msg_role = params->msg_role; cb.params = arg->time_scene_client_set_state.params; cb.error_code = bt_mesh_time_scene_client_set_state(&common, arg->time_scene_client_set_state.set_state); diff --git a/components/bt/esp_ble_mesh/mesh_models/client/client_common.c b/components/bt/esp_ble_mesh/mesh_models/client/client_common.c index 658c3c4a8a..20ee9cbb39 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/client_common.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/client_common.c @@ -282,6 +282,11 @@ int bt_mesh_client_send_msg(bt_mesh_client_common_param_t *param, return -EINVAL; } + if (bt_mesh_set_client_model_role(param->model, param->msg_role)) { + BT_ERR("Failed to set client role"); + return -EIO; + } + if (!need_ack) { /* If this is an unack message, send it directly. */ return bt_mesh_model_send(param->model, ¶m->ctx, msg, param->cb, param->cb_data); @@ -499,43 +504,26 @@ int bt_mesh_client_clear_list(void *data) return 0; } -int bt_mesh_set_client_model_role(bt_mesh_role_param_t *common) +int bt_mesh_set_client_model_role(struct bt_mesh_model *model, u8_t role) { bt_mesh_client_user_data_t *client = NULL; - if (!common || !common->model || !common->model->user_data) { - BT_ERR("%s, Invalid parameter", __func__); + if (!model) { + BT_ERR("Invalid client model"); return -EINVAL; } - client = (bt_mesh_client_user_data_t *)common->model->user_data; - - switch (common->role) { -#if CONFIG_BLE_MESH_NODE - case NODE: - /* no matter if provisioner is enabled/disabled , node role can be used to send messages */ - client->msg_role = NODE; - break; -#endif -#if CONFIG_BLE_MESH_PROVISIONER - case PROVISIONER: - /* if provisioner is not enabled, provisioner role can't be used to send messages */ - if (!bt_mesh_is_provisioner_en()) { - BT_ERR("Provisioner is disabled"); - return -EINVAL; - } - client->msg_role = PROVISIONER; - break; -#endif -#if CONFIG_BLE_MESH_FAST_PROV - case FAST_PROV: - client->msg_role = FAST_PROV; - break; -#endif - default: - BT_WARN("Unknown model role 0x%02x", common->role); + client = (bt_mesh_client_user_data_t *)model->user_data; + if (!client) { + BT_ERR("Invalid client user data"); return -EINVAL; } + if (role >= ROLE_NVAL) { + BT_ERR("Invalid client role 0x%02x", role); + return -EINVAL; + } + + client->msg_role = role; return 0; } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h b/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h index c6fc892348..9883efe208 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h +++ b/components/bt/esp_ble_mesh/mesh_models/client/include/client_common.h @@ -79,6 +79,7 @@ typedef struct { struct bt_mesh_model *model; /* Pointer to the client model */ struct bt_mesh_msg_ctx ctx; /* Message context */ s32_t msg_timeout; /* Time to get corresponding response */ + u8_t msg_role; /* Role (Node/Provisioner) of the device */ const struct bt_mesh_send_cb *cb; /* User defined callback function */ void *cb_data; /* User defined callback value */ } bt_mesh_client_common_param_t; @@ -112,19 +113,15 @@ int bt_mesh_client_free_node(bt_mesh_client_node_t *node); int bt_mesh_client_clear_list(void *data); -typedef struct { - struct bt_mesh_model *model; /* The client model structure */ - u8_t role; /* Role of the device - Node/Provisioner */ -} bt_mesh_role_param_t; - /** - * @brief This function copies node_index for stack internal use. + * @brief Set role of the client model for internal use. * - * @param[in] common: Pointer to the bt_mesh_role_param_t structure + * @param[in] model: Pointer to the client model + * @param[in] role: Role of the device * * @return Zero - success, otherwise - fail */ -int bt_mesh_set_client_model_role(bt_mesh_role_param_t *common); +int bt_mesh_set_client_model_role(struct bt_mesh_model *model, u8_t role); #ifdef __cplusplus } From 02eaaca3d65a8f3d6a605c0af14cc309fd932f2c Mon Sep 17 00:00:00 2001 From: lly Date: Sun, 28 Jun 2020 17:03:17 +0800 Subject: [PATCH 5/8] ble_mesh: stack: Fix no events for some error conditions --- components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c index d0b2517bfa..f2bf7f7803 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c @@ -1983,6 +1983,7 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) arg->model_publish.device_role); if (err) { BT_ERR("Failed to set client role"); + btc_ble_mesh_model_publish_comp_cb(arg->model_publish.model, err); break; } } @@ -1995,10 +1996,14 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) struct net_buf_simple *buf = bt_mesh_alloc_buf(arg->model_send.length + BLE_MESH_MIC_SHORT); if (!buf) { BT_ERR("%s, Out of memory", __func__); + btc_ble_mesh_model_send_comp_cb(arg->model_send.model, arg->model_send.ctx, + arg->model_send.opcode, -ENOMEM); break; } + net_buf_simple_add_mem(buf, arg->model_send.data, arg->model_send.length); arg->model_send.ctx->srv_send = true; + err = bt_mesh_model_send((struct bt_mesh_model *)arg->model_send.model, (struct bt_mesh_msg_ctx *)arg->model_send.ctx, buf, NULL, NULL); @@ -2012,8 +2017,11 @@ void btc_ble_mesh_model_call_handler(btc_msg_t *msg) struct net_buf_simple *buf = bt_mesh_alloc_buf(arg->model_send.length + BLE_MESH_MIC_SHORT); if (!buf) { BT_ERR("%s, Out of memory", __func__); + btc_ble_mesh_model_send_comp_cb(arg->model_send.model, arg->model_send.ctx, + arg->model_send.opcode, -ENOMEM); break; } + net_buf_simple_add_mem(buf, arg->model_send.data, arg->model_send.length); bt_mesh_client_common_param_t param = { .opcode = arg->model_send.opcode, From 36d714ec59bbc694c5978135f9577e4dbe859cf2 Mon Sep 17 00:00:00 2001 From: lly Date: Wed, 8 Jul 2020 09:35:31 +0800 Subject: [PATCH 6/8] ble_mesh: stack: Check client msg result in common func --- .../bt/esp_ble_mesh/mesh_core/cfg_cli.c | 184 +++--------------- .../bt/esp_ble_mesh/mesh_core/health_cli.c | 56 +----- .../mesh_models/client/client_common.c | 22 +-- .../mesh_models/client/generic_client.c | 12 +- .../mesh_models/client/lighting_client.c | 12 +- .../mesh_models/client/sensor_client.c | 4 - .../mesh_models/client/time_scene_client.c | 11 +- 7 files changed, 44 insertions(+), 257 deletions(-) diff --git a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c index cd4bdde6ac..6168051b8a 100644 --- a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c @@ -677,48 +677,30 @@ const struct bt_mesh_model_op bt_mesh_cfg_cli_op[] = { static int send_msg_with_none(bt_mesh_client_common_param_t *param, u32_t op) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 0); - int err = 0; bt_mesh_model_msg_init(&msg, op); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } static int send_msg_with_u8(bt_mesh_client_common_param_t *param, u32_t op, u8_t val) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 1); - int err = 0; bt_mesh_model_msg_init(&msg, op); net_buf_simple_add_u8(&msg, val); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } static int send_msg_with_le16(bt_mesh_client_common_param_t *param, u32_t op, u16_t val) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 2); - int err = 0; bt_mesh_model_msg_init(&msg, op); net_buf_simple_add_le16(&msg, val); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_comp_data_get(bt_mesh_client_common_param_t *param, u8_t page) @@ -779,25 +761,18 @@ int bt_mesh_cfg_relay_set(bt_mesh_client_common_param_t *param, u8_t relay, u8_t retransmit) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_RELAY_SET, 2); - int err = 0; bt_mesh_model_msg_init(&msg, OP_RELAY_SET); net_buf_simple_add_u8(&msg, relay); net_buf_simple_add_u8(&msg, retransmit); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_net_key_add(bt_mesh_client_common_param_t *param, u16_t net_idx, const u8_t net_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NET_KEY_ADD, 18); - int err = 0; if (!net_key) { BT_ERR("Invalid NetKey"); @@ -808,12 +783,7 @@ int bt_mesh_cfg_net_key_add(bt_mesh_client_common_param_t *param, net_buf_simple_add_le16(&msg, net_idx); net_buf_simple_add_mem(&msg, net_key, 16); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_app_key_add(bt_mesh_client_common_param_t *param, @@ -821,7 +791,6 @@ int bt_mesh_cfg_app_key_add(bt_mesh_client_common_param_t *param, const u8_t app_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_ADD, 19); - int err = 0; if (!app_key) { BT_ERR("Invalid AppKey"); @@ -832,12 +801,7 @@ int bt_mesh_cfg_app_key_add(bt_mesh_client_common_param_t *param, key_idx_pack(&msg, net_idx, app_idx); net_buf_simple_add_mem(&msg, app_key, 16); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_app_bind(bt_mesh_client_common_param_t *param, @@ -845,7 +809,6 @@ int bt_mesh_cfg_mod_app_bind(bt_mesh_client_common_param_t *param, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_APP_BIND, 8); - int err = 0; bt_mesh_model_msg_init(&msg, OP_MOD_APP_BIND); net_buf_simple_add_le16(&msg, elem_addr); @@ -855,12 +818,7 @@ int bt_mesh_cfg_mod_app_bind(bt_mesh_client_common_param_t *param, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } static int mod_sub(bt_mesh_client_common_param_t *param, u32_t op, @@ -868,7 +826,6 @@ static int mod_sub(bt_mesh_client_common_param_t *param, u32_t op, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 8); - int err = 0; bt_mesh_model_msg_init(&msg, op); net_buf_simple_add_le16(&msg, elem_addr); @@ -878,12 +835,7 @@ static int mod_sub(bt_mesh_client_common_param_t *param, u32_t op, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_sub_add(bt_mesh_client_common_param_t *param, @@ -912,7 +864,6 @@ static int mod_sub_va(bt_mesh_client_common_param_t *param, u32_t op, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 22); - int err = 0; if (!label) { BT_ERR("Invalid label uuid"); @@ -930,12 +881,7 @@ static int mod_sub_va(bt_mesh_client_common_param_t *param, u32_t op, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_sub_va_add(bt_mesh_client_common_param_t *param, @@ -963,7 +909,6 @@ int bt_mesh_cfg_mod_pub_get(bt_mesh_client_common_param_t *param, u16_t elem_addr, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_PUB_GET, 6); - int err = 0; bt_mesh_model_msg_init(&msg, OP_MOD_PUB_GET); net_buf_simple_add_le16(&msg, elem_addr); @@ -972,12 +917,7 @@ int bt_mesh_cfg_mod_pub_get(bt_mesh_client_common_param_t *param, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_pub_set(bt_mesh_client_common_param_t *param, @@ -985,7 +925,6 @@ int bt_mesh_cfg_mod_pub_set(bt_mesh_client_common_param_t *param, struct bt_mesh_cfg_mod_pub *pub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_PUB_SET, 13); - int err = 0; if (!pub) { BT_ERR("Invalid model pub set"); @@ -1004,19 +943,13 @@ int bt_mesh_cfg_mod_pub_set(bt_mesh_client_common_param_t *param, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_hb_sub_set(bt_mesh_client_common_param_t *param, struct bt_mesh_cfg_hb_sub *sub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEARTBEAT_SUB_SET, 5); - int err = 0; if (!sub) { BT_ERR("Invalid heartbeat sub set"); @@ -1028,12 +961,7 @@ int bt_mesh_cfg_hb_sub_set(bt_mesh_client_common_param_t *param, net_buf_simple_add_le16(&msg, sub->dst); net_buf_simple_add_u8(&msg, sub->period); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_hb_sub_get(bt_mesh_client_common_param_t *param) @@ -1045,7 +973,6 @@ int bt_mesh_cfg_hb_pub_set(bt_mesh_client_common_param_t *param, struct bt_mesh_cfg_hb_pub *pub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEARTBEAT_PUB_SET, 9); - int err = 0; if (!pub) { BT_ERR("Invalid heartbeat pub set"); @@ -1060,12 +987,7 @@ int bt_mesh_cfg_hb_pub_set(bt_mesh_client_common_param_t *param, net_buf_simple_add_le16(&msg, pub->feat); net_buf_simple_add_le16(&msg, pub->net_idx); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_hb_pub_get(bt_mesh_client_common_param_t *param) @@ -1084,7 +1006,6 @@ int bt_mesh_cfg_mod_pub_va_set(bt_mesh_client_common_param_t *param, struct bt_mesh_cfg_mod_pub *pub) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_PUB_VA_SET, 27); - int err = 0; if (!label || !pub) { BT_ERR("%s, Invalid parameter", __func__); @@ -1103,19 +1024,13 @@ int bt_mesh_cfg_mod_pub_va_set(bt_mesh_client_common_param_t *param, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_sub_del_all(bt_mesh_client_common_param_t *param, u16_t elem_addr, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_SUB_DEL_ALL, 6); - int err = 0; bt_mesh_model_msg_init(&msg, OP_MOD_SUB_DEL_ALL); net_buf_simple_add_le16(&msg, elem_addr); @@ -1124,19 +1039,13 @@ int bt_mesh_cfg_mod_sub_del_all(bt_mesh_client_common_param_t *param, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } static int mod_sub_get(bt_mesh_client_common_param_t *param, u32_t op, u16_t elem_addr, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 6); - int err = 0; bt_mesh_model_msg_init(&msg, op); net_buf_simple_add_le16(&msg, elem_addr); @@ -1145,12 +1054,7 @@ static int mod_sub_get(bt_mesh_client_common_param_t *param, u32_t op, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_sub_get(bt_mesh_client_common_param_t *param, @@ -1173,7 +1077,6 @@ int bt_mesh_cfg_net_key_update(bt_mesh_client_common_param_t *param, u16_t net_idx, const u8_t net_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NET_KEY_UPDATE, 18); - int err = 0; if (!net_key) { BT_ERR("Invalid NetKey"); @@ -1184,12 +1087,7 @@ int bt_mesh_cfg_net_key_update(bt_mesh_client_common_param_t *param, net_buf_simple_add_le16(&msg, net_idx); net_buf_simple_add_mem(&msg, net_key, 16); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_net_key_delete(bt_mesh_client_common_param_t *param, u16_t net_idx) @@ -1207,7 +1105,6 @@ int bt_mesh_cfg_app_key_update(bt_mesh_client_common_param_t *param, const u8_t app_key[16]) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_UPDATE, 19); - int err = 0; if (!app_key) { BT_ERR("Invalid AppKey"); @@ -1218,29 +1115,18 @@ int bt_mesh_cfg_app_key_update(bt_mesh_client_common_param_t *param, key_idx_pack(&msg, net_idx, app_idx); net_buf_simple_add_mem(&msg, app_key, 16); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_app_key_delete(bt_mesh_client_common_param_t *param, u16_t net_idx, u16_t app_idx) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_APP_KEY_DEL, 3); - int err = 0; bt_mesh_model_msg_init(&msg, OP_APP_KEY_DEL); key_idx_pack(&msg, net_idx, app_idx); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_app_key_get(bt_mesh_client_common_param_t *param, u16_t net_idx) @@ -1257,7 +1143,6 @@ int bt_mesh_cfg_node_identity_set(bt_mesh_client_common_param_t *param, u16_t net_idx, u8_t identity) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_NODE_IDENTITY_SET, 3); - int err = 0; if (identity > 0x02) { BT_ERR("Invalid node identity 0x%02x", identity); @@ -1268,12 +1153,7 @@ int bt_mesh_cfg_node_identity_set(bt_mesh_client_common_param_t *param, net_buf_simple_add_le16(&msg, net_idx); net_buf_simple_add_u8(&msg, identity); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_app_unbind(bt_mesh_client_common_param_t *param, @@ -1281,7 +1161,6 @@ int bt_mesh_cfg_mod_app_unbind(bt_mesh_client_common_param_t *param, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_MOD_APP_UNBIND, 8); - int err = 0; bt_mesh_model_msg_init(&msg, OP_MOD_APP_UNBIND); net_buf_simple_add_le16(&msg, elem_addr); @@ -1291,19 +1170,13 @@ int bt_mesh_cfg_mod_app_unbind(bt_mesh_client_common_param_t *param, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } static int mod_app_get(bt_mesh_client_common_param_t *param, u32_t op, u16_t elem_addr, u16_t mod_id, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, op, 6); - int err = 0; bt_mesh_model_msg_init(&msg, op); net_buf_simple_add_le16(&msg, elem_addr); @@ -1312,12 +1185,7 @@ static int mod_app_get(bt_mesh_client_common_param_t *param, u32_t op, } net_buf_simple_add_le16(&msg, mod_id); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_mod_app_get(bt_mesh_client_common_param_t *param, @@ -1345,7 +1213,6 @@ int bt_mesh_cfg_kr_phase_set(bt_mesh_client_common_param_t *param, u16_t net_idx, u8_t transition) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_KRP_SET, 3); - int err = 0; if (transition > 0x03) { BT_ERR("Invalid kr phase transition 0x%02x", transition); @@ -1356,12 +1223,7 @@ int bt_mesh_cfg_kr_phase_set(bt_mesh_client_common_param_t *param, net_buf_simple_add_le16(&msg, net_idx); net_buf_simple_add_u8(&msg, transition); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_cfg_lpn_timeout_get(bt_mesh_client_common_param_t *param, u16_t lpn_addr) diff --git a/components/bt/esp_ble_mesh/mesh_core/health_cli.c b/components/bt/esp_ble_mesh/mesh_core/health_cli.c index 1c8475154d..68f8e828e2 100644 --- a/components/bt/esp_ble_mesh/mesh_core/health_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/health_cli.c @@ -234,116 +234,74 @@ const struct bt_mesh_model_op bt_mesh_health_cli_op[] = { int bt_mesh_health_attention_get(bt_mesh_client_common_param_t *param) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_ATTENTION_GET, 0); - int err = 0; bt_mesh_model_msg_init(&msg, OP_ATTENTION_GET); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_health_attention_set(bt_mesh_client_common_param_t *param, u8_t attention, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_ATTENTION_SET, 1); - int err = 0; bt_mesh_model_msg_init(&msg, need_ack ? OP_ATTENTION_SET : OP_ATTENTION_SET_UNREL); net_buf_simple_add_u8(&msg, attention); - err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); } int bt_mesh_health_period_get(bt_mesh_client_common_param_t *param) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_PERIOD_GET, 0); - int err = 0; bt_mesh_model_msg_init(&msg, OP_HEALTH_PERIOD_GET); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_health_period_set(bt_mesh_client_common_param_t *param, u8_t divisor, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_PERIOD_SET, 1); - int err = 0; bt_mesh_model_msg_init(&msg, need_ack ? OP_HEALTH_PERIOD_SET : OP_HEALTH_PERIOD_SET_UNREL); net_buf_simple_add_u8(&msg, divisor); - err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); } int bt_mesh_health_fault_test(bt_mesh_client_common_param_t *param, u16_t cid, u8_t test_id, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_FAULT_TEST, 3); - int err = 0; bt_mesh_model_msg_init(&msg, need_ack ? OP_HEALTH_FAULT_TEST : OP_HEALTH_FAULT_TEST_UNREL); net_buf_simple_add_u8(&msg, test_id); net_buf_simple_add_le16(&msg, cid); - err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); } int bt_mesh_health_fault_clear(bt_mesh_client_common_param_t *param, u16_t cid, bool need_ack) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_FAULT_CLEAR, 2); - int err = 0; bt_mesh_model_msg_init(&msg, need_ack ? OP_HEALTH_FAULT_CLEAR : OP_HEALTH_FAULT_CLEAR_UNREL); net_buf_simple_add_le16(&msg, cid); - err = bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, need_ack, timeout_handler); } int bt_mesh_health_fault_get(bt_mesh_client_common_param_t *param, u16_t cid) { BLE_MESH_MODEL_BUF_DEFINE(msg, OP_HEALTH_FAULT_GET, 2); - int err = 0; bt_mesh_model_msg_init(&msg, OP_HEALTH_FAULT_GET); net_buf_simple_add_le16(&msg, cid); - err = bt_mesh_client_send_msg(param, &msg, true, timeout_handler); - if (err) { - BT_ERR("%s, send failed (err %d)", __func__, err); - } - - return err; + return bt_mesh_client_send_msg(param, &msg, true, timeout_handler); } int bt_mesh_health_cli_init(struct bt_mesh_model *model, bool primary) diff --git a/components/bt/esp_ble_mesh/mesh_models/client/client_common.c b/components/bt/esp_ble_mesh/mesh_models/client/client_common.c index 20ee9cbb39..857028628d 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/client_common.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/client_common.c @@ -287,18 +287,18 @@ int bt_mesh_client_send_msg(bt_mesh_client_common_param_t *param, return -EIO; } - if (!need_ack) { - /* If this is an unack message, send it directly. */ - return bt_mesh_model_send(param->model, ¶m->ctx, msg, param->cb, param->cb_data); - } - - if (!BLE_MESH_ADDR_IS_UNICAST(param->ctx.addr)) { - /* If an acknowledged message is not sent to a unicast address, - * for example to a group/virtual address, then all the - * corresponding responses will be treated as publish messages. - * And no timeout will be used for the message. + if (need_ack == false || !BLE_MESH_ADDR_IS_UNICAST(param->ctx.addr)) { + /* 1. If this is an unacknowledged message, send it directly. + * 2. If this is an acknowledged message, but the destination + * is not a unicast address, e.g. a group/virtual address, + * then all the corresponding responses will be treated as + * publish messages, and no timeout will be used. */ - return bt_mesh_model_send(param->model, ¶m->ctx, msg, param->cb, param->cb_data); + err = bt_mesh_model_send(param->model, ¶m->ctx, msg, param->cb, param->cb_data); + if (err) { + BT_ERR("Failed to send client message 0x%08x", param->opcode); + } + return err; } if (!timer_handler) { diff --git a/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c b/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c index 6f11f60049..62a1ea626c 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/generic_client.c @@ -689,7 +689,6 @@ const struct bt_mesh_model_op gen_property_cli_op[] = { static int gen_get_state(bt_mesh_client_common_param_t *common, void *value) { NET_BUF_SIMPLE_DEFINE(msg, BLE_MESH_GEN_GET_STATE_MSG_LEN); - int err = 0; bt_mesh_model_msg_init(&msg, common->opcode); @@ -725,12 +724,7 @@ static int gen_get_state(bt_mesh_client_common_param_t *common, void *value) } } - err = bt_mesh_client_send_msg(common, &msg, true, timeout_handler); - if (err) { - BT_ERR("Failed to send Generic Get message (err %d)", err); - } - - return err; + return bt_mesh_client_send_msg(common, &msg, true, timeout_handler); } static int gen_set_state(bt_mesh_client_common_param_t *common, @@ -903,13 +897,9 @@ static int gen_set_state(bt_mesh_client_common_param_t *common, } err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); - if (err) { - BT_ERR("Failed to send Generic Set message (err %d)", err); - } end: bt_mesh_free_buf(msg); - return err; } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c b/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c index f89161de52..45454afbf6 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c @@ -772,7 +772,6 @@ const struct bt_mesh_model_op light_lc_cli_op[] = { static int light_get_state(bt_mesh_client_common_param_t *common, void *value) { NET_BUF_SIMPLE_DEFINE(msg, BLE_MESH_LIGHT_GET_STATE_MSG_LEN); - int err = 0; bt_mesh_model_msg_init(&msg, common->opcode); @@ -790,12 +789,7 @@ static int light_get_state(bt_mesh_client_common_param_t *common, void *value) } } - err = bt_mesh_client_send_msg(common, &msg, true, timeout_handler); - if (err) { - BT_ERR("Failed to send Lighting Get message (err %d)", err); - } - - return err; + return bt_mesh_client_send_msg(common, &msg, true, timeout_handler); } static int light_set_state(bt_mesh_client_common_param_t *common, @@ -1027,13 +1021,9 @@ static int light_set_state(bt_mesh_client_common_param_t *common, } err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); - if (err) { - BT_ERR("Failed to send Lighting Set message (err %d)", err); - } end: bt_mesh_free_buf(msg); - return err; } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c b/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c index 9ef7694e59..c003c01833 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c @@ -448,13 +448,9 @@ static int sensor_act_state(bt_mesh_client_common_param_t *common, } err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); - if (err) { - BT_ERR("Failed to send Sensor client message (err %d)", err); - } end: bt_mesh_free_buf(msg); - return err; } diff --git a/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c b/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c index 8d416ba032..201d8b51f7 100644 --- a/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c +++ b/components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c @@ -372,7 +372,6 @@ const struct bt_mesh_model_op scheduler_cli_op[] = { static int time_scene_get_state(bt_mesh_client_common_param_t *common, void *value) { NET_BUF_SIMPLE_DEFINE(msg, BLE_MESH_SCENE_GET_STATE_MSG_LEN); - int err = 0; bt_mesh_model_msg_init(&msg, common->opcode); @@ -390,12 +389,7 @@ static int time_scene_get_state(bt_mesh_client_common_param_t *common, void *val } } - err = bt_mesh_client_send_msg(common, &msg, true, timeout_handler); - if (err) { - BT_ERR("Failed to send Time Scene Get message (err %d)", err); - } - - return err; + return bt_mesh_client_send_msg(common, &msg, true, timeout_handler); } static int time_scene_set_state(bt_mesh_client_common_param_t *common, @@ -484,9 +478,6 @@ static int time_scene_set_state(bt_mesh_client_common_param_t *common, } err = bt_mesh_client_send_msg(common, msg, need_ack, timeout_handler); - if (err) { - BT_ERR("Failed to send Time Scene Set message (err %d)", err); - } end: bt_mesh_free_buf(msg); From e924e5f2f4b737dbd7fb00c2dd80c16a2ae00b1d Mon Sep 17 00:00:00 2001 From: lly Date: Thu, 16 Jul 2020 15:20:45 +0800 Subject: [PATCH 7/8] ble_mesh: stack: Rename cfg & health client status recv func --- .../bt/esp_ble_mesh/mesh_core/cfg_cli.c | 42 +++++++++---------- .../bt/esp_ble_mesh/mesh_core/health_cli.c | 14 +++---- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c index 6168051b8a..4da7b8b236 100644 --- a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c @@ -123,9 +123,9 @@ static void timeout_handler(struct k_work *work) return; } -static void cfg_client_cancel(struct bt_mesh_model *model, - struct bt_mesh_msg_ctx *ctx, - void *status, size_t len) +static void cfg_client_recv_status(struct bt_mesh_model *model, + struct bt_mesh_msg_ctx *ctx, + void *status, size_t len) { bt_mesh_client_node_t *node = NULL; struct net_buf_simple buf = {0}; @@ -265,7 +265,7 @@ static void comp_data_status(struct bt_mesh_model *model, net_buf_simple_add_mem(status.comp_data, buf->data, buf->len); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_comp_data_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_comp_data_status)); } static void state_status_u8(struct bt_mesh_model *model, @@ -280,7 +280,7 @@ static void state_status_u8(struct bt_mesh_model *model, status = net_buf_simple_pull_u8(buf); - cfg_client_cancel(model, ctx, &status, sizeof(u8_t)); + cfg_client_recv_status(model, ctx, &status, sizeof(u8_t)); } static void beacon_status(struct bt_mesh_model *model, @@ -324,7 +324,7 @@ static void relay_status(struct bt_mesh_model *model, status.relay = net_buf_simple_pull_u8(buf); status.retransmit = net_buf_simple_pull_u8(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_relay_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_relay_status)); } static void net_key_status(struct bt_mesh_model *model, @@ -340,7 +340,7 @@ static void net_key_status(struct bt_mesh_model *model, status.status = net_buf_simple_pull_u8(buf); status.net_idx = net_buf_simple_pull_le16(buf) & 0xfff; - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_netkey_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_netkey_status)); } static void app_key_status(struct bt_mesh_model *model, @@ -356,7 +356,7 @@ static void app_key_status(struct bt_mesh_model *model, status.status = net_buf_simple_pull_u8(buf); key_idx_unpack(buf, &status.net_idx, &status.app_idx); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_appkey_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_appkey_status)); } static void mod_app_status(struct bt_mesh_model *model, @@ -379,7 +379,7 @@ static void mod_app_status(struct bt_mesh_model *model, } status.mod_id = net_buf_simple_pull_le16(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_mod_app_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_mod_app_status)); } static void mod_pub_status(struct bt_mesh_model *model, @@ -408,7 +408,7 @@ static void mod_pub_status(struct bt_mesh_model *model, } status.mod_id = net_buf_simple_pull_le16(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_mod_pub_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_mod_pub_status)); } static void mod_sub_status(struct bt_mesh_model *model, @@ -431,7 +431,7 @@ static void mod_sub_status(struct bt_mesh_model *model, } status.mod_id = net_buf_simple_pull_le16(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_mod_sub_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_mod_sub_status)); } static void hb_sub_status(struct bt_mesh_model *model, @@ -452,7 +452,7 @@ static void hb_sub_status(struct bt_mesh_model *model, status.min = net_buf_simple_pull_u8(buf); status.max = net_buf_simple_pull_u8(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_hb_sub_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_hb_sub_status)); } static void hb_pub_status(struct bt_mesh_model *model, @@ -473,7 +473,7 @@ static void hb_pub_status(struct bt_mesh_model *model, status.feat = net_buf_simple_pull_u8(buf); status.net_idx = net_buf_simple_pull_u8(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_hb_sub_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_hb_sub_status)); } static void node_reset_status(struct bt_mesh_model *model, @@ -484,7 +484,7 @@ static void node_reset_status(struct bt_mesh_model *model, ctx->net_idx, ctx->app_idx, ctx->addr, buf->len, bt_hex(buf->data, buf->len)); - cfg_client_cancel(model, ctx, NULL, 0); + cfg_client_recv_status(model, ctx, NULL, 0); } static void mod_sub_list(struct bt_mesh_model *model, @@ -513,7 +513,7 @@ static void mod_sub_list(struct bt_mesh_model *model, } net_buf_simple_add_mem(list.addr, buf->data, buf->len); - cfg_client_cancel(model, ctx, &list, sizeof(struct bt_mesh_cfg_mod_sub_list)); + cfg_client_recv_status(model, ctx, &list, sizeof(struct bt_mesh_cfg_mod_sub_list)); } static void net_key_list(struct bt_mesh_model *model, @@ -533,7 +533,7 @@ static void net_key_list(struct bt_mesh_model *model, } net_buf_simple_add_mem(list.net_idx, buf->data, buf->len); - cfg_client_cancel(model, ctx, &list, sizeof(struct bt_mesh_cfg_net_key_list)); + cfg_client_recv_status(model, ctx, &list, sizeof(struct bt_mesh_cfg_net_key_list)); } static void app_key_list(struct bt_mesh_model *model, @@ -555,7 +555,7 @@ static void app_key_list(struct bt_mesh_model *model, } net_buf_simple_add_mem(list.app_idx, buf->data, buf->len); - cfg_client_cancel(model, ctx, &list, sizeof(struct bt_mesh_cfg_app_key_list)); + cfg_client_recv_status(model, ctx, &list, sizeof(struct bt_mesh_cfg_app_key_list)); } static void node_id_status(struct bt_mesh_model *model, @@ -572,7 +572,7 @@ static void node_id_status(struct bt_mesh_model *model, status.net_idx = net_buf_simple_pull_le16(buf); status.identity = net_buf_simple_pull_u8(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_node_id_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_node_id_status)); } static void mod_app_list(struct bt_mesh_model *model, @@ -601,7 +601,7 @@ static void mod_app_list(struct bt_mesh_model *model, } net_buf_simple_add_mem(list.app_idx, buf->data, buf->len); - cfg_client_cancel(model, ctx, &list, sizeof(struct bt_mesh_cfg_mod_app_list)); + cfg_client_recv_status(model, ctx, &list, sizeof(struct bt_mesh_cfg_mod_app_list)); } static void kr_phase_status(struct bt_mesh_model *model, @@ -618,7 +618,7 @@ static void kr_phase_status(struct bt_mesh_model *model, status.net_idx = net_buf_simple_pull_le16(buf); status.phase = net_buf_simple_pull_u8(buf); - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_key_refresh_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_key_refresh_status)); } static void lpn_pollto_status(struct bt_mesh_model *model, @@ -636,7 +636,7 @@ static void lpn_pollto_status(struct bt_mesh_model *model, status.timeout |= net_buf_simple_pull_u8(buf) << 8; status.timeout |= net_buf_simple_pull_u8(buf) << 16; - cfg_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_cfg_lpn_pollto_status)); + cfg_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_cfg_lpn_pollto_status)); } static void net_trans_status(struct bt_mesh_model *model, diff --git a/components/bt/esp_ble_mesh/mesh_core/health_cli.c b/components/bt/esp_ble_mesh/mesh_core/health_cli.c index 68f8e828e2..58a4acc44a 100644 --- a/components/bt/esp_ble_mesh/mesh_core/health_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/health_cli.c @@ -81,9 +81,9 @@ static void timeout_handler(struct k_work *work) return; } -static void health_client_cancel(struct bt_mesh_model *model, - struct bt_mesh_msg_ctx *ctx, - void *status, size_t len) +static void health_client_recv_status(struct bt_mesh_model *model, + struct bt_mesh_msg_ctx *ctx, + void *status, size_t len) { bt_mesh_client_node_t *node = NULL; struct net_buf_simple buf = {0}; @@ -167,7 +167,7 @@ static void health_fault_status(struct bt_mesh_model *model, net_buf_simple_add_mem(status.fault_array, buf->data, buf->len); - health_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_health_fault_status)); + health_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_health_fault_status)); } static void health_current_status(struct bt_mesh_model *model, @@ -190,7 +190,7 @@ static void health_current_status(struct bt_mesh_model *model, net_buf_simple_add_mem(status.fault_array, buf->data, buf->len); - health_client_cancel(model, ctx, &status, sizeof(struct bt_mesh_health_current_status)); + health_client_recv_status(model, ctx, &status, sizeof(struct bt_mesh_health_current_status)); } static void health_period_status(struct bt_mesh_model *model, @@ -205,7 +205,7 @@ static void health_period_status(struct bt_mesh_model *model, status = net_buf_simple_pull_u8(buf); - health_client_cancel(model, ctx, &status, sizeof(u8_t)); + health_client_recv_status(model, ctx, &status, sizeof(u8_t)); } static void health_attention_status(struct bt_mesh_model *model, @@ -220,7 +220,7 @@ static void health_attention_status(struct bt_mesh_model *model, status = net_buf_simple_pull_u8(buf); - health_client_cancel(model, ctx, &status, sizeof(u8_t)); + health_client_recv_status(model, ctx, &status, sizeof(u8_t)); } const struct bt_mesh_model_op bt_mesh_health_cli_op[] = { From 0fcd0bb6b857f81a9e390c85ae4ee7f0d1a72729 Mon Sep 17 00:00:00 2001 From: lly Date: Thu, 16 Jul 2020 15:40:48 +0800 Subject: [PATCH 8/8] ble_mesh: stack: Client model related code clean --- .../bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c | 8 ++------ .../bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c | 8 ++------ .../bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c | 4 +--- .../bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c | 8 ++------ .../bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c | 8 ++------ .../bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c | 8 ++------ components/bt/esp_ble_mesh/mesh_core/cfg_cli.c | 3 +-- components/bt/esp_ble_mesh/mesh_core/health_cli.c | 3 +-- 8 files changed, 13 insertions(+), 37 deletions(-) diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c index 8e34d47fc6..170ed4ff18 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c @@ -315,7 +315,6 @@ void bt_mesh_config_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, { esp_ble_mesh_cfg_client_cb_param_t cb_params = {0}; esp_ble_mesh_client_common_param_t params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -356,8 +355,7 @@ void bt_mesh_config_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, cb_params.params = ¶ms; if (val && len) { - length = (len <= sizeof(cb_params.status_cb)) ? len : sizeof(cb_params.status_cb); - memcpy(&cb_params.status_cb, val, length); + memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb))); } btc_ble_mesh_config_client_callback(&cb_params, act); @@ -716,7 +714,6 @@ void bt_mesh_config_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model *mo const u8_t *val, size_t len) { esp_ble_mesh_cfg_server_cb_param_t cb_params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -744,8 +741,7 @@ void bt_mesh_config_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model *mo cb_params.ctx.send_ttl = ctx->send_ttl; if (val && len) { - length = (len <= sizeof(cb_params.value)) ? len : sizeof(cb_params.value); - memcpy(&cb_params.value, val, length); + memcpy(&cb_params.value, val, MIN(len, sizeof(cb_params.value))); } btc_ble_mesh_config_server_callback(&cb_params, act); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c index ec959964a7..15b729a5a4 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c @@ -385,7 +385,6 @@ void bt_mesh_generic_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, { esp_ble_mesh_generic_client_cb_param_t cb_params = {0}; esp_ble_mesh_client_common_param_t params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -426,8 +425,7 @@ void bt_mesh_generic_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, cb_params.params = ¶ms; if (val && len) { - length = (len <= sizeof(cb_params.status_cb)) ? len : sizeof(cb_params.status_cb); - memcpy(&cb_params.status_cb, val, length); + memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb))); } btc_ble_mesh_generic_client_callback(&cb_params, act); @@ -698,7 +696,6 @@ void bt_mesh_generic_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model *m const u8_t *val, size_t len) { esp_ble_mesh_generic_server_cb_param_t cb_params = {0}; - size_t length = 0U; uint8_t act = 0U; if (model == NULL || ctx == NULL) { @@ -732,8 +729,7 @@ void bt_mesh_generic_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model *m cb_params.ctx.send_ttl = ctx->send_ttl; if (val && len) { - length = (len <= sizeof(cb_params.value)) ? len : sizeof(cb_params.value); - memcpy(&cb_params.value, val, length); + memcpy(&cb_params.value, val, MIN(len, sizeof(cb_params.value))); } btc_ble_mesh_generic_server_callback(&cb_params, act); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c index 9ed378906b..9e401446c8 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c @@ -249,7 +249,6 @@ void bt_mesh_health_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, { esp_ble_mesh_health_client_cb_param_t cb_params = {0}; esp_ble_mesh_client_common_param_t params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -290,8 +289,7 @@ void bt_mesh_health_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, cb_params.params = ¶ms; if (val && len) { - length = (len <= sizeof(cb_params.status_cb)) ? len : sizeof(cb_params.status_cb); - memcpy(&cb_params.status_cb, val, length); + memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb))); } btc_ble_mesh_health_client_callback(&cb_params, act); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c index 013b661c85..bd34808050 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c @@ -229,7 +229,6 @@ void bt_mesh_lighting_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, { esp_ble_mesh_light_client_cb_param_t cb_params = {0}; esp_ble_mesh_client_common_param_t params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -270,8 +269,7 @@ void bt_mesh_lighting_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, cb_params.params = ¶ms; if (val && len) { - length = (len <= sizeof(cb_params.status_cb)) ? len : sizeof(cb_params.status_cb); - memcpy(&cb_params.status_cb, val, length); + memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb))); } btc_ble_mesh_lighting_client_callback(&cb_params, act); @@ -510,7 +508,6 @@ void bt_mesh_lighting_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model * const u8_t *val, size_t len) { esp_ble_mesh_lighting_server_cb_param_t cb_params = {0}; - size_t length = 0U; uint8_t act = 0U; if (model == NULL || ctx == NULL) { @@ -547,8 +544,7 @@ void bt_mesh_lighting_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model * cb_params.ctx.send_ttl = ctx->send_ttl; if (val && len) { - length = (len <= sizeof(cb_params.value)) ? len : sizeof(cb_params.value); - memcpy(&cb_params.value, val, length); + memcpy(&cb_params.value, val, MIN(len, sizeof(cb_params.value))); } btc_ble_mesh_lighting_server_callback(&cb_params, act); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c index af05ac4f55..048d9ddb6c 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c @@ -467,7 +467,6 @@ void bt_mesh_sensor_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, { esp_ble_mesh_sensor_client_cb_param_t cb_params = {0}; esp_ble_mesh_client_common_param_t params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -508,8 +507,7 @@ void bt_mesh_sensor_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, cb_params.params = ¶ms; if (val && len) { - length = (len <= sizeof(cb_params.status_cb)) ? len : sizeof(cb_params.status_cb); - memcpy(&cb_params.status_cb, val, length); + memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb))); } btc_ble_mesh_sensor_client_callback(&cb_params, act); @@ -830,7 +828,6 @@ void bt_mesh_sensor_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model *mo const u8_t *val, size_t len) { esp_ble_mesh_sensor_server_cb_param_t cb_params = {0}; - size_t length = 0U; uint8_t act = 0U; if (model == NULL || ctx == NULL) { @@ -864,8 +861,7 @@ void bt_mesh_sensor_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model *mo cb_params.ctx.send_ttl = ctx->send_ttl; if (val && len) { - length = (len <= sizeof(cb_params.value)) ? len : sizeof(cb_params.value); - memcpy(&cb_params.value, val, length); + memcpy(&cb_params.value, val, MIN(len, sizeof(cb_params.value))); } btc_ble_mesh_sensor_server_callback(&cb_params, act); diff --git a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c index 1609a4591a..8fd1b4810c 100644 --- a/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c +++ b/components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c @@ -231,7 +231,6 @@ void bt_mesh_time_scene_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, { esp_ble_mesh_time_scene_client_cb_param_t cb_params = {0}; esp_ble_mesh_client_common_param_t params = {0}; - size_t length = 0U; uint8_t act = 0U; if (!model || !ctx) { @@ -272,8 +271,7 @@ void bt_mesh_time_scene_client_cb_evt_to_btc(u32_t opcode, u8_t evt_type, cb_params.params = ¶ms; if (val && len) { - length = (len <= sizeof(cb_params.status_cb)) ? len : sizeof(cb_params.status_cb); - memcpy(&cb_params.status_cb, val, length); + memcpy(&cb_params.status_cb, val, MIN(len, sizeof(cb_params.status_cb))); } btc_ble_mesh_time_scene_client_callback(&cb_params, act); @@ -413,7 +411,6 @@ void bt_mesh_time_scene_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model const u8_t *val, size_t len) { esp_ble_mesh_time_scene_server_cb_param_t cb_params = {0}; - size_t length = 0U; uint8_t act = 0U; if (model == NULL || ctx == NULL) { @@ -450,8 +447,7 @@ void bt_mesh_time_scene_server_cb_evt_to_btc(u8_t evt_type, struct bt_mesh_model cb_params.ctx.send_ttl = ctx->send_ttl; if (val && len) { - length = (len <= sizeof(cb_params.value)) ? len : sizeof(cb_params.value); - memcpy(&cb_params.value, val, length); + memcpy(&cb_params.value, val, MIN(len, sizeof(cb_params.value))); } btc_ble_mesh_time_scene_server_callback(&cb_params, act); diff --git a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c index 4da7b8b236..61bcc541d1 100644 --- a/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/cfg_cli.c @@ -214,8 +214,7 @@ static void cfg_client_recv_status(struct bt_mesh_model *model, switch (ctx->recv_op) { case OP_DEV_COMP_DATA_STATUS: { - struct bt_mesh_cfg_comp_data_status *val; - val = (struct bt_mesh_cfg_comp_data_status *)status; + struct bt_mesh_cfg_comp_data_status *val = status; bt_mesh_free_buf(val->comp_data); break; } diff --git a/components/bt/esp_ble_mesh/mesh_core/health_cli.c b/components/bt/esp_ble_mesh/mesh_core/health_cli.c index 58a4acc44a..2af6dbad2a 100644 --- a/components/bt/esp_ble_mesh/mesh_core/health_cli.c +++ b/components/bt/esp_ble_mesh/mesh_core/health_cli.c @@ -132,8 +132,7 @@ static void health_client_recv_status(struct bt_mesh_model *model, switch (ctx->recv_op) { case OP_HEALTH_FAULT_STATUS: { - struct bt_mesh_health_fault_status *val; - val = (struct bt_mesh_health_fault_status *)status; + struct bt_mesh_health_fault_status *val = status; bt_mesh_free_buf(val->fault_array); break; }