mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-03-29 22:20:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

mesh: use mesh_message_t for unsegmented access messages

Browse Source
This commit is contained in:
Matthias Ringwald 2020-03-09 15:56:32 +01:00
parent 1e6c9225b9
commit e41a4a086c
6 changed files with 183 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
src/mesh/mesh_access.c
View File

@ -688,11 +688,72 @@ void mesh_access_network_add_model_identifier(mesh_network_pdu_t * pdu, uint32_t
}
}
// access message template
// mesh_message_t builder
mesh_message_pdu_t * mesh_access_message_init(uint32_t opcode, bool segmented, uint8_t num_segments){
btstack_assert(num_segments > 0);
btstack_assert(segmented || (num_segments == 1));
mesh_network_pdu_t * mesh_access_setup_unsegmented_message(const mesh_access_message_t *message_template, ...){
mesh_network_pdu_t * network_pdu = mesh_access_network_init(message_template->opcode);
if (!network_pdu) return NULL;
mesh_message_pdu_t * pdu = mesh_message_pdu_get();
if (!pdu) return NULL;
// TODO: handle segmented messages
btstack_assert(segmented == false);
// use mesh_network_t as before
mesh_network_pdu_t * segment = mesh_network_pdu_get();
if (segment == NULL){
mesh_message_pdu_free(pdu);
return NULL;
}
btstack_linked_list_add(&pdu->segments, (btstack_linked_item_t *) segment);
pdu->len = mesh_access_setup_opcode(&segment->data[10], opcode) + 10;
pdu->pdu_header.ack_opcode = MESH_ACCESS_OPCODE_NOT_SET;
return pdu;
}
void mesh_access_message_add_uint8(mesh_message_pdu_t * pdu, uint8_t value){
// TODO: handle segmented messages
mesh_network_pdu_t * segment = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&pdu->segments);
segment->data[pdu->len++] = value;
}
void mesh_access_message_add_uint16(mesh_message_pdu_t * pdu, uint16_t value){
// TODO: handle segmented messages
mesh_network_pdu_t * segment = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&pdu->segments);
little_endian_store_16(segment->data, pdu->len, value);
pdu->len += 2;
}
void mesh_access_message_add_uint24(mesh_message_pdu_t * pdu, uint16_t value){
// TODO: handle segmented messages
mesh_network_pdu_t * segment = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&pdu->segments);
little_endian_store_24(segment->data, pdu->len, value);
pdu->len += 3;
}
void mesh_access_message_add_uint32(mesh_message_pdu_t * pdu, uint16_t value){
// TODO: handle segmented messages
mesh_network_pdu_t * segment = (mesh_network_pdu_t *) btstack_linked_list_get_first_item(&pdu->segments);
little_endian_store_32(segment->data, pdu->len, value);
pdu->len += 4;
}
void mesh_access_message_add_model_identifier(mesh_message_pdu_t * pdu, uint32_t model_identifier){
if (mesh_model_is_bluetooth_sig(model_identifier)){
mesh_access_message_add_uint16( pdu, mesh_model_get_model_id(model_identifier) );
} else {
mesh_access_message_add_uint32( pdu, model_identifier );
}
}
// access message template
mesh_message_pdu_t * mesh_access_setup_message(bool segmented, const mesh_access_message_t *message_template, ...){
btstack_assert(segmented == false);
// TODO: handle segmented messages
mesh_message_pdu_t * message_pdu = mesh_access_message_init(message_template->opcode, segmented, 1);
if (!message_pdu) return NULL;
va_list argptr;
va_start(argptr, message_template);
@ -705,23 +766,24 @@ mesh_network_pdu_t * mesh_access_setup_unsegmented_message(const mesh_access_mes
switch (*format){
case '1':
word = va_arg(argptr, int); // minimal va_arg is int: 2 bytes on 8+16 bit CPUs
mesh_access_network_add_uint8( network_pdu, word);
mesh_access_message_add_uint8( message_pdu, word);
break;
case '2':
word = va_arg(argptr, int); // minimal va_arg is int: 2 bytes on 8+16 bit CPUs
mesh_access_network_add_uint16( network_pdu, word);
mesh_access_message_add_uint16( message_pdu, word);
break;
case '3':
longword = va_arg(argptr, uint32_t);
mesh_access_network_add_uint24( network_pdu, longword);
mesh_access_message_add_uint24( message_pdu, longword);
break;
case '4':
longword = va_arg(argptr, uint32_t);
mesh_access_network_add_uint32( network_pdu, longword);
mesh_access_message_add_uint32( message_pdu, longword);
mesh_access_message_add_uint32( message_pdu, longword);
break;
case 'm':
longword = va_arg(argptr, uint32_t);
mesh_access_network_add_model_identifier( network_pdu, longword);
mesh_access_message_add_model_identifier( message_pdu, longword);
break;
default:
log_error("Unsupported mesh message format specifier '%c", *format);
@ -732,7 +794,7 @@ mesh_network_pdu_t * mesh_access_setup_unsegmented_message(const mesh_access_mes
va_end(argptr);
return network_pdu;
return message_pdu;
}
mesh_transport_pdu_t * mesh_access_setup_segmented_message(const mesh_access_message_t *message_template, ...){
@ -783,6 +845,7 @@ mesh_transport_pdu_t * mesh_access_setup_segmented_message(const mesh_access_mes
return transport_pdu;
}
static const mesh_operation_t * mesh_model_lookup_operation_by_opcode(mesh_model_t * model, uint32_t opcode){
// find opcode in table
const mesh_operation_t * operation = model->operations;

9
src/mesh/mesh_access.h
View File

@ -264,9 +264,16 @@ void mesh_access_network_add_uint24(mesh_network_pdu_t * pdu, uint16_t value);
void mesh_access_network_add_uint32(mesh_network_pdu_t * pdu, uint16_t value);
void mesh_access_network_add_model_identifier(mesh_network_pdu_t * pdu, uint32_t model_identifier);
mesh_message_pdu_t mesh_access_pdu_init(uint32_t opcode, bool segmented, uint8_t num_segments);
void mesh_access_message_add_uint8(mesh_message_pdu_t * pdu, uint8_t value);
void mesh_access_message_add_uint16(mesh_message_pdu_t * pdu, uint16_t value);
void mesh_access_message_add_uint24(mesh_message_pdu_t * pdu, uint16_t value);
void mesh_access_message_add_uint32(mesh_message_pdu_t * pdu, uint16_t value);
void mesh_access_message_add_model_identifier(mesh_message_pdu_t * pdu, uint32_t model_identifier);
// message builder using template
mesh_network_pdu_t * mesh_access_setup_unsegmented_message(const mesh_access_message_t *message_template, ...);
mesh_transport_pdu_t * mesh_access_setup_segmented_message(const mesh_access_message_t *message_template, ...);
mesh_message_pdu_t * mesh_access_setup_message(bool segmented, const mesh_access_message_t *message_template, ...);
#ifdef __cplusplus
} /* end of extern "C" */

186
src/mesh/mesh_configuration_client.c
View File

@ -342,10 +342,10 @@ uint8_t mesh_configuration_client_send_beacon_get(mesh_model_t * mesh_model, uin
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_beacon_get);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_beacon_get);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_BEACON_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_BEACON_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -355,10 +355,10 @@ uint8_t mesh_configuration_client_send_beacon_set(mesh_model_t * mesh_model, uin
if (beacon > 1) return ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_beacon_set, beacon);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_beacon_set, beacon);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_BEACON_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_BEACON_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -366,10 +366,10 @@ uint8_t mesh_configuration_client_send_composition_data_get(mesh_model_t * mesh_
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_composition_data_get, page);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_composition_data_get, page);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_COMPOSITION_DATA_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_COMPOSITION_DATA_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -377,10 +377,10 @@ uint8_t mesh_configuration_client_send_default_ttl_get(mesh_model_t * mesh_model
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_default_ttl_get);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_default_ttl_get);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_DEFAULT_TTL_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_DEFAULT_TTL_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -390,10 +390,10 @@ uint8_t mesh_configuration_client_send_default_ttl_set(mesh_model_t * mesh_model
if (ttl == 0x01 || ttl >= 0x80) return ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_default_ttl_set, ttl);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_default_ttl_set, ttl);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_DEFAULT_TTL_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_DEFAULT_TTL_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -401,10 +401,10 @@ uint8_t mesh_configuration_client_send_gatt_proxy_get(mesh_model_t * mesh_model,
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_gatt_proxy_get);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_gatt_proxy_get);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_GATT_PROXY_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_GATT_PROXY_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -414,10 +414,10 @@ uint8_t mesh_configuration_client_send_gatt_proxy_set(mesh_model_t * mesh_model,
if (gatt_proxy_state > 2) return ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_gatt_proxy_set, gatt_proxy_state);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_gatt_proxy_set, gatt_proxy_state);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_GATT_PROXY_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_GATT_PROXY_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -425,10 +425,10 @@ uint8_t mesh_configuration_client_send_relay_get(mesh_model_t * mesh_model, uint
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_relay_get);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_relay_get);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_RELAY_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_RELAY_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -439,10 +439,10 @@ uint8_t mesh_configuration_client_send_relay_set(mesh_model_t * mesh_model, uint
if (relay_retransmit_count > 0x07) return ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE;
if (relay_retransmit_interval_steps > 0x1F) return ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_relay_set, relay, (relay_retransmit_count << 5) | relay_retransmit_interval_steps);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_relay_set, relay, (relay_retransmit_count << 5) | relay_retransmit_interval_steps);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_RELAY_SET);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_RELAY_SET);
return ERROR_CODE_SUCCESS;
}
@ -450,10 +450,10 @@ uint8_t mesh_configuration_client_send_model_publication_get(mesh_model_t * mesh
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_publication_get, dest, model_id);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_publication_get, dest, model_id);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -475,7 +475,7 @@ uint8_t mesh_configuration_client_send_model_publication_set(mesh_model_t * mesh
return ERROR_CODE_PARAMETER_OUT_OF_MANDATORY_RANGE;
}
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_publication_set,
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_publication_set,
dest,
publication_config->publish_address_unicast,
(publication_config->credential_flag << 12) | publication_config->appkey_index,
@ -483,9 +483,9 @@ uint8_t mesh_configuration_client_send_model_publication_set(mesh_model_t * mesh
publication_config->publish_period,
(publication_config->publish_retransmit_interval_steps << 3) | publication_config->publish_retransmit_count,
model_id);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -518,10 +518,10 @@ uint8_t mesh_configuration_client_send_model_subscription_add(mesh_model_t * mes
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_subscription_add, dest, address, model_id);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_subscription_add, dest, address, model_id);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -540,10 +540,10 @@ uint8_t mesh_configuration_client_send_model_subscription_delete(mesh_model_t *
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_subscription_delete, dest, address, model_id);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_subscription_delete, dest, address, model_id);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -562,10 +562,10 @@ uint8_t mesh_configuration_client_send_model_subscription_overwrite(mesh_model_t
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_subscription_overwrite, dest, address, model_id);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_subscription_overwrite, dest, address, model_id);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -584,10 +584,10 @@ uint8_t mesh_configuration_client_send_model_subscription_delete_all(mesh_model_
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_subscription_delete_all, dest, address, model_id);
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_subscription_delete_all, dest, address, model_id);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -595,19 +595,19 @@ uint8_t mesh_configuration_client_send_model_subscription_get(mesh_model_t * mes
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * network_pdu = NULL;
mesh_message_pdu_t * message_pdu = NULL;
uint32_t ack_opcode = MESH_FOUNDATION_OPERATION_SIG_MODEL_SUBSCRIPTION_LIST;
if (mesh_model_is_bluetooth_sig(model_id)){
network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_sig_model_subscription_get, dest, model_id);
message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_sig_model_subscription_get, dest, model_id);
} else {
network_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_vendor_model_subscription_get, dest, model_id);
message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_vendor_model_subscription_get, dest, model_id);
ack_opcode = MESH_FOUNDATION_OPERATION_VENDOR_MODEL_SUBSCRIPTION_LIST;
}
if (!network_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) network_pdu, ack_opcode);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, ack_opcode);
return ERROR_CODE_SUCCESS;
}
@ -736,10 +736,10 @@ uint8_t mesh_configuration_client_send_model_app_unbind_set(mesh_model_t * mesh_
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_model_app_unbind, dest, appk_index, model_identifier);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_model_app_unbind, dest, appk_index, model_identifier);
if (!message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_MODEL_APP_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_MODEL_APP_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -747,17 +747,17 @@ uint8_t mesh_configuration_client_send_model_app_get(mesh_model_t * mesh_model,
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu;
mesh_message_pdu_t * message_pdu;
uint32_t ack_opcode = MESH_FOUNDATION_OPERATION_SIG_MODEL_APP_LIST;
if (mesh_model_is_bluetooth_sig(model_identifier)){
transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_sig_model_app_get, dest, model_identifier);
message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_sig_model_app_get, dest, model_identifier);
} else {
transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_vendor_model_app_get, dest, model_identifier);
message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_vendor_model_app_get, dest, model_identifier);
ack_opcode = MESH_FOUNDATION_OPERATION_VENDOR_MODEL_APP_LIST;
}
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, ack_opcode);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, ack_opcode);
return ERROR_CODE_SUCCESS;
}
@ -765,10 +765,10 @@ uint8_t mesh_configuration_client_send_node_reset(mesh_model_t * mesh_model, uin
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_node_reset);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_node_reset);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_NODE_RESET_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_NODE_RESET_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -776,10 +776,10 @@ uint8_t mesh_configuration_client_send_friend_get(mesh_model_t * mesh_model, uin
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_friend_get);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_friend_get);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_FRIEND_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_FRIEND_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -787,10 +787,10 @@ uint8_t mesh_configuration_client_send_friend_set(mesh_model_t * mesh_model, uin
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_friend_set, friend_state);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_friend_set, friend_state);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_FRIEND_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_FRIEND_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -798,10 +798,10 @@ uint8_t mesh_configuration_client_send_key_refresh_phase_get(mesh_model_t * mesh
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_key_refresh_phase_get, netk_index);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_key_refresh_phase_get, netk_index);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_KEY_REFRESH_PHASE_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_KEY_REFRESH_PHASE_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -809,10 +809,10 @@ uint8_t mesh_configuration_client_send_key_refresh_phase_set(mesh_model_t * mesh
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_key_refresh_phase_set, netk_index, transition);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_key_refresh_phase_set, netk_index, transition);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_KEY_REFRESH_PHASE_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_KEY_REFRESH_PHASE_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -820,10 +820,10 @@ uint8_t mesh_configuration_client_send_heartbeat_publication_get(mesh_model_t *
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_heartbeat_publication_get);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_heartbeat_publication_get);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_PUBLICATION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_PUBLICATION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -831,7 +831,7 @@ uint8_t mesh_configuration_client_send_heartbeat_publication_set(mesh_model_t *
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_heartbeat_publication_set,
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_heartbeat_publication_set,
publication_state.destination,
mesh_heartbeat_period_log(publication_state.count),
mesh_heartbeat_period_log(publication_state.period_s),
@ -839,9 +839,9 @@ uint8_t mesh_configuration_client_send_heartbeat_publication_set(mesh_model_t *
publication_state.features,
publication_state.netkey_index);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_PUBLICATION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_PUBLICATION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -849,10 +849,10 @@ uint8_t mesh_configuration_client_send_heartbeat_subscription_get(mesh_model_t *
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_heartbeat_subscription_get);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_heartbeat_subscription_get);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_SUBSCRIPTION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_SUBSCRIPTION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -860,10 +860,10 @@ uint8_t mesh_configuration_client_send_heartbeat_subscription_set(mesh_model_t *
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_heartbeat_subscription_set, heartbeat_source, heartbeat_destination, mesh_heartbeat_period_log(period_s));
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_heartbeat_subscription_set, heartbeat_source, heartbeat_destination, mesh_heartbeat_period_log(period_s));
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_SUBSCRIPTION_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_HEARTBEAT_SUBSCRIPTION_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -871,10 +871,10 @@ uint8_t mesh_configuration_client_send_low_power_node_poll_timeout_get(mesh_mode
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_client_low_power_node_poll_timeout_get);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_client_low_power_node_poll_timeout_get);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_LOW_POWER_NODE_POLL_TIMEOUT_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_LOW_POWER_NODE_POLL_TIMEOUT_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -882,10 +882,10 @@ uint8_t mesh_configuration_client_send_network_transmit_get(mesh_model_t * mesh_
uint8_t status = mesh_access_validate_envelop_params(mesh_model, dest, netkey_index, appkey_index);
if (status != ERROR_CODE_SUCCESS) return status;
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_network_transmit_get);
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_network_transmit_get);
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_NETWORK_TRANSMIT_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_NETWORK_TRANSMIT_STATUS);
return ERROR_CODE_SUCCESS;
}
@ -898,10 +898,10 @@ uint8_t mesh_configuration_client_send_network_transmit_set(mesh_model_t * mesh_
transmit_interval_steps_10ms -= 1;
}
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_configuration_network_transmit_set, (transmit_count << 5) | (transmit_interval_steps_10ms & 0x1F));
if (!transport_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_configuration_network_transmit_set, (transmit_count << 5) | (transmit_interval_steps_10ms & 0x1F));
if (message_pdu) return BTSTACK_MEMORY_ALLOC_FAILED;
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) transport_pdu, MESH_FOUNDATION_OPERATION_NETWORK_TRANSMIT_STATUS);
mesh_configuration_client_send_acknowledged(mesh_access_get_element_address(mesh_model), dest, netkey_index, appkey_index, (mesh_pdu_t *) message_pdu, MESH_FOUNDATION_OPERATION_NETWORK_TRANSMIT_STATUS);
return ERROR_CODE_SUCCESS;
}

8
src/mesh/mesh_health_server.c
View File

@ -108,14 +108,14 @@ const mesh_access_message_t mesh_foundation_health_attention_status = {
static mesh_pdu_t * health_period_status(mesh_model_t * mesh_model){
mesh_health_state_t * state = (mesh_health_state_t *) mesh_model->model_data;
// setup message
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_foundation_health_period_status, state->fast_period_divisor);
return (mesh_pdu_t *) transport_pdu;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_foundation_health_period_status, state->fast_period_divisor);
return (mesh_pdu_t *) message_pdu;
}
static mesh_pdu_t * health_attention_status(void){
// setup message
mesh_network_pdu_t * transport_pdu = mesh_access_setup_unsegmented_message(&mesh_foundation_health_attention_status, mesh_attention_timer_get());
return (mesh_pdu_t *) transport_pdu;
mesh_message_pdu_t * message_pdu = mesh_access_setup_message(false, &mesh_foundation_health_attention_status, mesh_attention_timer_get());
return (mesh_pdu_t *) message_pdu;
}
// report fault status - used for both current as well as registered faults, see registered_faults param

2
src/mesh/mesh_upper_transport.c
View File

@ -556,7 +556,7 @@ void mesh_upper_transport_pdu_free(mesh_pdu_t * pdu){
break;
case MESH_PDU_TYPE_MESSAGE:
message_pdu = (mesh_message_pdu_t *) pdu;
mesh_message_pdu_free(pdu);
mesh_message_pdu_free(message_pdu);
default:
break;
}

5
test/mesh/mesh_message_test.cpp
View File

@ -427,7 +427,10 @@ void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index, uin
mesh_pdu_t * pdu;
if (count == 1 ){
// send as unsegmented access pdu
pdu = (mesh_pdu_t*) mesh_network_pdu_get();
mesh_message_pdu_t * message_pdu = mesh_message_pdu_get();
mesh_network_pdu_t * segment = mesh_network_pdu_get();
btstack_linked_list_add(&message_pdu->segments, (btstack_linked_item_t *) segment);
pdu = (mesh_pdu_t*) message_pdu;
} else {
// send as segmented access pdu
pdu = (mesh_pdu_t*) mesh_transport_pdu_get();