ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

BLE: add traces to gatt client (#14165) 

* add traces to gatt client

* add files to cmakelists

Co-Authored-By: Vincent Coubard <vincent.coubard@arm.com>

* fixed tracing variable name

Co-Authored-By: Vincent Coubard <vincent.coubard@arm.com>

* add pal tracing

* add more traces for successfull actions

* put write and read as tr_debug in pal

Co-authored-by: Vincent Coubard <vincent.coubard@arm.com>
pull/14198/head
Paul Szczepanek 2021-01-21 10:12:53 +00:00 committed by Paul Szczepanek
parent 7b08388be6
commit 91d4b48989
5 changed files with 322 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
connectivity/FEATURE_BLE/source/CMakeLists.txt
View File

@ -7,6 +7,11 @@ add_subdirectory(gatt)
add_subdirectory(generic) add_subdirectory(generic)
add_subdirectory(pal) add_subdirectory(pal)
target_include_directories(mbed-ble
INTERFACE
.
)
target_sources(mbed-ble target_sources(mbed-ble
INTERFACE INTERFACE
BLE.cpp BLE.cpp
@ -14,6 +19,7 @@ target_sources(mbed-ble
GattClient.cpp GattClient.cpp
GattServer.cpp GattServer.cpp
SecurityManager.cpp SecurityManager.cpp
common/ble_trace_helpers.cpp
) )
target_link_libraries(mbed-ble target_link_libraries(mbed-ble

186
connectivity/FEATURE_BLE/source/common/ble_trace_helpers.cpp
View File

@ -16,10 +16,192 @@
*/ */
#include "ble_trace_helpers.h" #include "ble_trace_helpers.h"
#include "pal/AttServerMessage.h"
#include "ble-host/include/att_api.h"
#define TRACE_GROUP "BLE " #define TRACE_GROUP "BLE "
namespace ble { namespace ble {
#if MBED_CONF_MBED_TRACE_ENABLE #if MBED_CONF_MBED_TRACE_ENABLE
const char* ble_error_to_string(ble_error_t error_code)
{
#if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
const char* ret = "INVALID ENUM VALUE";
switch(error_code)
{
case BLE_ERROR_NONE: ret = "BLE_ERROR_NONE"; break;
case BLE_ERROR_BUFFER_OVERFLOW: ret = "BLE_ERROR_BUFFER_OVERFLOW"; break;
case BLE_ERROR_NOT_IMPLEMENTED: ret = "BLE_ERROR_NOT_IMPLEMENTED"; break;
case BLE_ERROR_PARAM_OUT_OF_RANGE: ret = "BLE_ERROR_PARAM_OUT_OF_RANGE"; break;
case BLE_ERROR_INVALID_PARAM: ret = "BLE_ERROR_INVALID_PARAM"; break;
case BLE_STACK_BUSY: ret = "BLE_STACK_BUSY"; break;
case BLE_ERROR_INVALID_STATE: ret = "BLE_ERROR_INVALID_STATE"; break;
case BLE_ERROR_NO_MEM: ret = "BLE_ERROR_NO_MEM"; break;
case BLE_ERROR_OPERATION_NOT_PERMITTED: ret = "BLE_ERROR_OPERATION_NOT_PERMITTED"; break;
case BLE_ERROR_INITIALIZATION_INCOMPLETE: ret = "BLE_ERROR_INITIALIZATION_INCOMPLETE"; break;
case BLE_ERROR_ALREADY_INITIALIZED: ret = "BLE_ERROR_ALREADY_INITIALIZED"; break;
case BLE_ERROR_UNSPECIFIED: ret = "BLE_ERROR_UNSPECIFIED"; break;
case BLE_ERROR_INTERNAL_STACK_FAILURE: ret = "BLE_ERROR_INTERNAL_STACK_FAILURE"; break;
case BLE_ERROR_NOT_FOUND: ret = "BLE_ERROR_NOT_FOUND"; break;
}
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00";
sprintf(ret, "0x%02x", (int)error_code);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret;
}
const char* attribute_error_code_to_string(uint8_t error_code)
{
#if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
const char* ret = "INVALID ENUM VALUE";
switch(error_code)
{
case AttErrorResponse::INVALID_HANDLE: ret = "INVALID_HANDLE"; break;
case AttErrorResponse::READ_NOT_PERMITTED: ret = "READ_NOT_PERMITTED"; break;
case AttErrorResponse::WRITE_NOT_PERMITTED: ret = "WRITE_NOT_PERMITTED"; break;
case AttErrorResponse::INVALID_PDU: ret = "INVALID_PDU"; break;
case AttErrorResponse::INSUFFICIENT_AUTHENTICATION: ret = "INSUFFICIENT_AUTHENTICATION"; break;
case AttErrorResponse::REQUEST_NOT_SUPPORTED: ret = "REQUEST_NOT_SUPPORTED"; break;
case AttErrorResponse::INVALID_OFFSET: ret = "INVALID_OFFSET"; break;
case AttErrorResponse::INSUFFICIENT_AUTHORIZATION: ret = "INSUFFICIENT_AUTHORIZATION"; break;
case AttErrorResponse::PREPARE_QUEUE_FULL: ret = "PREPARE_QUEUE_FULL"; break;
case AttErrorResponse::ATTRIBUTE_NOT_FOUND: ret = "ATTRIBUTE_NOT_FOUND"; break;
case AttErrorResponse::ATTRIBUTE_NOT_LONG: ret = "ATTRIBUTE_NOT_LONG"; break;
case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE: ret = "INSUFFICIENT_ENCRYPTION_KEY_SIZE"; break;
case AttErrorResponse::INVALID_ATTRIBUTE_VALUE_LENGTH: ret = "INVALID_ATTRIBUTE_VALUE_LENGTH"; break;
case AttErrorResponse::UNLIKELY_ERROR: ret = "UNLIKELY_ERROR"; break;
case AttErrorResponse::INSUFFICIENT_ENCRYPTION: ret = "INSUFFICIENT_ENCRYPTION"; break;
case AttErrorResponse::UNSUPPORTED_GROUP_TYPE: ret = "UNSUPPORTED_GROUP_TYPE"; break;
case AttErrorResponse::INSUFFICIENT_RESOURCES: ret = "INSUFFICIENT_RESOURCES"; break;
case AttErrorResponse::WRITE_REQUEST_REJECTED: ret = "WRITE_REQUEST_REJECTED"; break;
case AttErrorResponse::CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_IMPROPERLY_CONFIGURED:
ret = "CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_IMPROPERLY_CONFIGURED"; break;
case AttErrorResponse::PROCEDURE_ALREADY_IN_PROGRESS: ret = "PROCEDURE_ALREADY_IN_PROGRESS"; break;
case AttErrorResponse::OUT_OF_RANGE: ret = "OUT_OF_RANGE"; break;
}
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00";
sprintf(ret, "0x%02x", (int)error_code);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret;
}
const char* att_client_callback_event_to_string(uint8_t code)
{
#if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
const char* ret = "INVALID EVENT";
switch(code)
{
case ATTC_FIND_INFO_RSP: ret = "ATTC_FIND_INFO_RSP"; break;
case ATTC_FIND_BY_TYPE_VALUE_RSP: ret = "ATTC_FIND_BY_TYPE_VALUE_RSP"; break;
case ATTC_READ_BY_TYPE_RSP: ret = "ATTC_READ_BY_TYPE_RSP"; break;
case ATTC_READ_RSP: ret = "ATTC_READ_RSP"; break;
case ATTC_READ_LONG_RSP: ret = "ATTC_READ_LONG_RSP"; break;
case ATTC_READ_MULTIPLE_RSP: ret = "ATTC_READ_MULTIPLE_RSP"; break;
case ATTC_READ_BY_GROUP_TYPE_RSP: ret = "ATTC_READ_BY_GROUP_TYPE_RSP"; break;
case ATTC_WRITE_RSP: ret = "ATTC_WRITE_RSP"; break;
case ATTC_WRITE_CMD_RSP: ret = "ATTC_WRITE_CMD_RSP"; break;
case ATTC_PREPARE_WRITE_RSP: ret = "ATTC_PREPARE_WRITE_RSP"; break;
case ATTC_EXECUTE_WRITE_RSP: ret = "ATTC_EXECUTE_WRITE_RSP"; break;
case ATTC_HANDLE_VALUE_NTF: ret = "ATTC_HANDLE_VALUE_NTF"; break;
case ATTC_HANDLE_VALUE_IND: ret = "ATTC_HANDLE_VALUE_IND"; break;
case ATTC_READ_MULT_VAR_RSP: ret = "ATTC_READ_MULT_VAR_RSP"; break;
case ATTC_MULT_VALUE_NTF: ret = "ATTC_MULT_VALUE_NTF"; break;
case ATTS_HANDLE_VALUE_CNF: ret = "ATTS_HANDLE_VALUE_CNF"; break;
case ATTS_MULT_VALUE_CNF: ret = "ATTS_MULT_VALUE_CNF"; break;
case ATTS_CCC_STATE_IND: ret = "ATTS_CCC_STATE_IND"; break;
case ATTS_DB_HASH_CALC_CMPL_IND: ret = "ATTS_DB_HASH_CALC_CMPL_IND"; break;
case ATT_MTU_UPDATE_IND: ret = "ATT_MTU_UPDATE_IND"; break;
case ATT_EATT_CONN_CMPL_IND: ret = "ATT_EATT_CONN_CMPL_IND"; break;
case ATT_EATT_RECONFIG_CMPL_IND: ret = "ATT_EATT_RECONFIG_CMPL_IND"; break;
}
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00";
sprintf(ret, "0x%02x", (int)code);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret;
}
const char* att_error_code_to_string(uint8_t error_code)
{
#if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
const char* ret = "INVALID EVENT";
switch(error_code)
{
case ATT_SUCCESS: ret = "ATT_SUCCESS"; break;
case ATT_ERR_HANDLE: ret = "ATT_ERR_HANDLE"; break;
case ATT_ERR_READ: ret = "ATT_ERR_READ"; break;
case ATT_ERR_WRITE: ret = "ATT_ERR_WRITE"; break;
case ATT_ERR_INVALID_PDU: ret = "ATT_ERR_INVALID_PDU"; break;
case ATT_ERR_AUTH: ret = "ATT_ERR_AUTH"; break;
case ATT_ERR_NOT_SUP: ret = "ATT_ERR_NOT_SUP"; break;
case ATT_ERR_OFFSET: ret = "ATT_ERR_OFFSET"; break;
case ATT_ERR_AUTHOR: ret = "ATT_ERR_AUTHOR"; break;
case ATT_ERR_QUEUE_FULL: ret = "ATT_ERR_QUEUE_FULL"; break;
case ATT_ERR_NOT_FOUND: ret = "ATT_ERR_NOT_FOUND"; break;
case ATT_ERR_NOT_LONG: ret = "ATT_ERR_NOT_LONG"; break;
case ATT_ERR_KEY_SIZE: ret = "ATT_ERR_KEY_SIZE"; break;
case ATT_ERR_LENGTH: ret = "ATT_ERR_LENGTH"; break;
case ATT_ERR_UNLIKELY: ret = "ATT_ERR_UNLIKELY"; break;
case ATT_ERR_ENC: ret = "ATT_ERR_ENC"; break;
case ATT_ERR_GROUP_TYPE: ret = "ATT_ERR_GROUP_TYPE"; break;
case ATT_ERR_RESOURCES: ret = "ATT_ERR_RESOURCES"; break;
case ATT_ERR_DATABASE_OUT_OF_SYNC: ret = "ATT_ERR_DATABASE_OUT_OF_SYNC"; break;
case ATT_ERR_VALUE_NOT_ALLOWED: ret = "ATT_ERR_VALUE_NOT_ALLOWED"; break;
case ATT_ERR_WRITE_REJ: ret = "ATT_ERR_WRITE_REJ"; break;
case ATT_ERR_CCCD: ret = "ATT_ERR_CCCD"; break;
case ATT_ERR_IN_PROGRESS: ret = "ATT_ERR_IN_PROGRESS"; break;
case ATT_ERR_RANGE: ret = "ATT_ERR_RANGE"; break;
}
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00";
sprintf(ret, "0x%02x", (int)error_code);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret;
}
const char* attribute_opcode_to_string(uint8_t error_code)
{
#if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
const char* ret = "INVALID OPCODE";
switch(error_code)
{
case AttributeOpcode::ERROR_RESPONSE: ret = "ERROR_RESPONSE"; break;
case AttributeOpcode::EXCHANGE_MTU_REQUEST: ret = "EXCHANGE_MTU_REQUEST"; break;
case AttributeOpcode::EXCHANGE_MTU_RESPONSE: ret = "EXCHANGE_MTU_RESPONSE"; break;
case AttributeOpcode::FIND_INFORMATION_REQUEST: ret = "FIND_INFORMATION_REQUEST"; break;
case AttributeOpcode::FIND_INFORMATION_RESPONSE: ret = "FIND_INFORMATION_RESPONSE"; break;
case AttributeOpcode::FIND_BY_TYPE_VALUE_REQUEST: ret = "FIND_BY_TYPE_VALUE_REQUEST"; break;
case AttributeOpcode::FIND_BY_VALUE_TYPE_RESPONSE: ret = "FIND_BY_VALUE_TYPE_RESPONSE"; break;
case AttributeOpcode::READ_BY_TYPE_REQUEST: ret = "READ_BY_TYPE_REQUEST"; break;
case AttributeOpcode::READ_BY_TYPE_RESPONSE: ret = "READ_BY_TYPE_RESPONSE"; break;
case AttributeOpcode::READ_REQUEST: ret = "READ_REQUEST"; break;
case AttributeOpcode::READ_RESPONSE: ret = "READ_RESPONSE"; break;
case AttributeOpcode::READ_BLOB_REQUEST: ret = "READ_BLOB_REQUEST"; break;
case AttributeOpcode::READ_BLOB_RESPONSE: ret = "READ_BLOB_RESPONSE"; break;
case AttributeOpcode::READ_MULTIPLE_REQUEST: ret = "READ_MULTIPLE_REQUEST"; break;
case AttributeOpcode::READ_MULTIPLE_RESPONSE: ret = "READ_MULTIPLE_RESPONSE"; break;
case AttributeOpcode::READ_BY_GROUP_TYPE_REQUEST: ret = "READ_BY_GROUP_TYPE_REQUEST"; break;
case AttributeOpcode::READ_BY_GROUP_TYPE_RESPONSE: ret = "READ_BY_GROUP_TYPE_RESPONSE"; break;
case AttributeOpcode::WRITE_REQUEST: ret = "WRITE_REQUEST"; break;
case AttributeOpcode::WRITE_RESPONSE: ret = "WRITE_RESPONSE"; break;
case AttributeOpcode::WRITE_COMMAND: ret = "WRITE_COMMAND"; break;
case AttributeOpcode::SIGNED_WRITE_COMMAND: ret = "SIGNED_WRITE_COMMAND"; break;
case AttributeOpcode::PREPARE_WRITE_REQUEST: ret = "PREPARE_WRITE_REQUEST"; break;
case AttributeOpcode::PREPARE_WRITE_RESPONSE: ret = "PREPARE_WRITE_RESPONSE"; break;
case AttributeOpcode::EXECUTE_WRITE_REQUEST: ret = "EXECUTE_WRITE_REQUEST"; break;
case AttributeOpcode::EXECUTE_WRITE_RESPONSE: ret = "EXECUTE_WRITE_RESPONSE"; break;
case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: ret = "HANDLE_VALUE_NOTIFICATION"; break;
case AttributeOpcode::HANDLE_VALUE_INDICATION: ret = "HANDLE_VALUE_INDICATION"; break;
}
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00";
sprintf(ret, "0x%02x", (int)error_code);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret;
}
const char* dm_callback_event_to_string(uint8_t event) { const char* dm_callback_event_to_string(uint8_t event) {
#if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS #if MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
const char* ret = "INVALID"; const char* ret = "INVALID";
@ -121,7 +303,7 @@ const char* dm_callback_event_to_string(uint8_t event) {
} }
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS #else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00"; static char ret[3] = "00";
sprintf(ret, "%02x", (int)event); sprintf(ret, "0x%02x", (int)event);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS #endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret; return ret;
} }
@ -328,7 +510,7 @@ const char* hci_opcode_to_string(uint16_t opcode)
} }
#else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS #else // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
static char ret[3] = "00"; static char ret[3] = "00";
sprintf(ret, "%02x", (int)opcode); sprintf(ret, "0x%02x", (int)opcode);
#endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS #endif // MBED_CONF_BLE_TRACE_HUMAN_READABLE_ENUMS
return ret; return ret;
} }

14
connectivity/FEATURE_BLE/source/common/ble_trace_helpers.h
View File

@ -22,13 +22,20 @@
#include "mbed-trace/mbed_trace.h" #include "mbed-trace/mbed_trace.h"
#include "pal/GapTypes.h" #include "pal/GapTypes.h"
#include "ble-host/include/dm_api.h" #include "ble-host/include/dm_api.h"
#include "common/UUID.h"
namespace ble { namespace ble {
#if MBED_CONF_MBED_TRACE_ENABLE #if MBED_CONF_MBED_TRACE_ENABLE
const char* dm_callback_event_to_string(uint8_t event);
void trace_le_supported_features(uint64_t feat); void trace_le_supported_features(uint64_t feat);
const char* dm_callback_event_to_string(uint8_t event);
const char* hci_opcode_to_string(uint16_t opcode); const char* hci_opcode_to_string(uint16_t opcode);
const char* attribute_error_code_to_string(uint8_t error);
const char* attribute_opcode_to_string(uint8_t error);
const char* ble_error_to_string(ble_error_t error);
const char* att_client_callback_event_to_string(uint8_t code);
const char* att_error_code_to_string(uint8_t code);
#endif //MBED_CONF_MBED_TRACE_ENABLE #endif //MBED_CONF_MBED_TRACE_ENABLE
template<typename T> template<typename T>
@ -37,6 +44,11 @@ static inline const char* tr_as_array(T item)
return (mbed_trace_array)((const uint8_t*)&item, sizeof(item)); return (mbed_trace_array)((const uint8_t*)&item, sizeof(item));
} }
static inline const char* to_string(UUID uuid)
{
return (mbed_trace_array)(uuid.getBaseUUID(), uuid.getLen());
}
static inline constexpr const char* to_string(bool v) static inline constexpr const char* to_string(bool v)
{ {
if (v) { if (v) {

26
connectivity/FEATURE_BLE/source/cordio/source/PalAttClientImpl.cpp
View File

@ -27,6 +27,8 @@
#include "att_api.h" #include "att_api.h"
#include "att_defs.h" #include "att_defs.h"
#define TRACE_GROUP "BLAT"
namespace ble { namespace ble {
namespace impl { namespace impl {
@ -41,6 +43,7 @@ PalAttClient::~PalAttClient() = default;
*/ */
ble_error_t PalAttClient::exchange_mtu_request(connection_handle_t connection) ble_error_t PalAttClient::exchange_mtu_request(connection_handle_t connection)
{ {
tr_info("Connection %d - AttcMtuReq mtu=%d", connection, pAttCfg->mtu);
AttcMtuReq(connection, pAttCfg->mtu); AttcMtuReq(connection, pAttCfg->mtu);
return BLE_ERROR_NONE; return BLE_ERROR_NONE;
} }
@ -65,6 +68,7 @@ ble_error_t PalAttClient::find_information_request(
attribute_handle_range_t discovery_range attribute_handle_range_t discovery_range
) )
{ {
tr_info("Connection %d - AttcFindInfoReq handles=[%d:%d]", connection_handle, discovery_range.begin, discovery_range.end);
AttcFindInfoReq( AttcFindInfoReq(
connection_handle, connection_handle,
discovery_range.begin, discovery_range.begin,
@ -84,6 +88,8 @@ ble_error_t PalAttClient::find_by_type_value_request(
const Span<const uint8_t> &value const Span<const uint8_t> &value
) )
{ {
tr_debug("Connection %d - AttcFindByTypeValueReq handles=[%d:%d] type=%d value=%s",
connection_handle, discovery_range.begin, discovery_range.end, type, tr_array(value.data(), value.size()));
AttcFindByTypeValueReq( AttcFindByTypeValueReq(
connection_handle, connection_handle,
discovery_range.begin, discovery_range.begin,
@ -105,6 +111,8 @@ ble_error_t PalAttClient::read_by_type_request(
const UUID &type const UUID &type
) )
{ {
tr_debug("Connection %d - AttcReadByTypeReq handles=[%d:%d] uuid=%s",
connection_handle, read_range.begin, read_range.end, to_string(type));
AttcReadByTypeReq( AttcReadByTypeReq(
connection_handle, connection_handle,
read_range.begin, read_range.begin,
@ -124,6 +132,7 @@ ble_error_t PalAttClient::read_request(
attribute_handle_t attribute_handle attribute_handle_t attribute_handle
) )
{ {
tr_debug("Connection %d - AttcReadReq handle=%d", connection_handle, attribute_handle);
AttcReadReq(connection_handle, attribute_handle); AttcReadReq(connection_handle, attribute_handle);
return BLE_ERROR_NONE; return BLE_ERROR_NONE;
} }
@ -137,6 +146,7 @@ ble_error_t PalAttClient::read_blob_request(
uint16_t offset uint16_t offset
) )
{ {
tr_debug("Connection %d - AttcReadLongReq handle=%d offset=%d", connection_handle, attribute_handle, offset);
AttcReadLongReq( AttcReadLongReq(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -154,6 +164,8 @@ ble_error_t PalAttClient::read_multiple_request(
const Span<const attribute_handle_t> &attribute_handles const Span<const attribute_handle_t> &attribute_handles
) )
{ {
tr_debug("Connection %d - AttcReadMultipleReq handles=%s",
connection_handle, tr_array((uint8_t*)attribute_handles.data(), attribute_handles.size()));
AttcReadMultipleReq( AttcReadMultipleReq(
connection_handle, connection_handle,
attribute_handles.size(), attribute_handles.size(),
@ -171,6 +183,8 @@ ble_error_t PalAttClient::read_by_group_type_request(
const UUID &group_type const UUID &group_type
) )
{ {
tr_debug("Connection %d - AttcReadByGroupTypeReq handles=[%d:%d] uuid=%s",
connection_handle, read_range.begin, read_range.end, to_string(group_type));
AttcReadByGroupTypeReq( AttcReadByGroupTypeReq(
connection_handle, connection_handle,
read_range.begin, read_range.begin,
@ -191,6 +205,8 @@ ble_error_t PalAttClient::write_request(
const Span<const uint8_t> &value const Span<const uint8_t> &value
) )
{ {
tr_debug("Connection %d - AttcWriteReq handle=%d value=%s",
connection_handle, attribute_handle, tr_array(value.data(), value.size()));
AttcWriteReq( AttcWriteReq(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -209,6 +225,8 @@ ble_error_t PalAttClient::write_command(
const Span<const uint8_t> &value const Span<const uint8_t> &value
) )
{ {
tr_debug("Connection %d - AttcWriteCmd handle=%d value=%s",
connection_handle, attribute_handle, tr_array(value.data(), value.size()));
AttcWriteCmd( AttcWriteCmd(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -227,6 +245,8 @@ ble_error_t PalAttClient::signed_write_command(
const Span<const uint8_t> &value const Span<const uint8_t> &value
) )
{ {
tr_debug("Connection %d - AttcSignedWriteCmd handle=%d sign_counter=&d value=%s",
connection_handle, attribute_handle, _local_sign_counter, tr_array(value.data(), value.size()));
AttcSignedWriteCmd( AttcSignedWriteCmd(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -261,6 +281,8 @@ ble_error_t PalAttClient::prepare_write_request(
const Span<const uint8_t> &value const Span<const uint8_t> &value
) )
{ {
tr_debug("Connection %d - AttcPrepareWriteReq handle=%d offset=%d value=%s",
connection_handle, attribute_handle, offset, tr_array(value.data(), value.size()));
AttcPrepareWriteReq( AttcPrepareWriteReq(
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -281,6 +303,8 @@ ble_error_t PalAttClient::execute_write_request(
bool execute bool execute
) )
{ {
tr_debug("AttcExecuteWriteReq %d - execute=%s",
connection_handle, to_string(execute));
AttcExecuteWriteReq( AttcExecuteWriteReq(
connection_handle, connection_handle,
execute execute
@ -396,6 +420,7 @@ void PalAttClient::on_transaction_timeout(
connection_handle_t connection_handle connection_handle_t connection_handle
) )
{ {
tr_info("Connection %d - transaction timed out", connection_handle);
if (_transaction_timeout_cb) { if (_transaction_timeout_cb) {
_transaction_timeout_cb(connection_handle); _transaction_timeout_cb(connection_handle);
} }
@ -404,6 +429,7 @@ void PalAttClient::on_transaction_timeout(
#if BLE_FEATURE_GATT_CLIENT #if BLE_FEATURE_GATT_CLIENT
void PalAttClient::att_client_handler(const attEvt_t *event) void PalAttClient::att_client_handler(const attEvt_t *event)
{ {
tr_debug("ATT event: %s status: %s", att_client_callback_event_to_string(event->hdr.event), att_error_code_to_string(event->hdr.status));
if (event->hdr.status == ATT_SUCCESS && event->hdr.event == ATT_MTU_UPDATE_IND) { if (event->hdr.status == ATT_SUCCESS && event->hdr.event == ATT_MTU_UPDATE_IND) {
ble::impl::BLEInstanceBase &ble = BLEInstanceBase::deviceInstance(); ble::impl::BLEInstanceBase &ble = BLEInstanceBase::deviceInstance();
PalGattClientEventHandler *handler = ble.getPalGattClient().get_event_handler(); PalGattClientEventHandler *handler = ble.getPalGattClient().get_event_handler();

97
connectivity/FEATURE_BLE/source/generic/GattClientImpl.cpp
View File

@ -33,6 +33,10 @@
#include "source/pal/AttServerMessage.h" #include "source/pal/AttServerMessage.h"
#include "source/BLEInstanceBase.h" #include "source/BLEInstanceBase.h"
#include "common/ble_trace_helpers.h"
#define TRACE_GROUP "BLGC"
using ble::AttServerMessage; using ble::AttServerMessage;
using ble::AttReadResponse; using ble::AttReadResponse;
using ble::AttReadBlobResponse; using ble::AttReadBlobResponse;
@ -113,7 +117,7 @@ struct GattClient::ProcedureControlBlock {
/* /*
* Procedure control block for the discovery process. * Procedure control block for the discovery process.
*/ */
#define TRACE_CLASS "DiscoveryControlBlock"
struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock { struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
@ -144,11 +148,13 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
void handle_timeout_error(GattClient *client) final void handle_timeout_error(GattClient *client) final
{ {
tr_warning("%s timed out", TRACE_CLASS);
terminate(client); terminate(client);
} }
void abort(GattClient *client) final void abort(GattClient *client) final
{ {
tr_warning("%s aborted", TRACE_CLASS);
terminate(client); terminate(client);
} }
@ -179,6 +185,7 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
case AttributeOpcode::ERROR_RESPONSE: { case AttributeOpcode::ERROR_RESPONSE: {
const auto &error = static_cast<const AttErrorResponse &>(message); const auto &error = static_cast<const AttErrorResponse &>(message);
if (error.error_code != AttErrorResponse::ATTRIBUTE_NOT_FOUND) { if (error.error_code != AttErrorResponse::ATTRIBUTE_NOT_FOUND) {
tr_warning("%s terminating early due to %s", TRACE_CLASS, attribute_error_code_to_string(error.error_code));
terminate(client); terminate(client);
return; return;
} }
@ -206,6 +213,7 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
void handle_service_discovered(GattClient *client, const Response &response) void handle_service_discovered(GattClient *client, const Response &response)
{ {
if (!response.size()) { if (!response.size()) {
tr_error("%s terminating due to malformed message", TRACE_CLASS);
terminate(client); terminate(client);
return; return;
} }
@ -216,6 +224,8 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
end_handle = get_end_handle(response[i]); end_handle = get_end_handle(response[i]);
UUID uuid = get_uuid(response[i]); UUID uuid = get_uuid(response[i]);
tr_debug("Discovered service UUID: %s [0x%x:0x%x])", to_string(uuid), start_handle, end_handle);
if (!characteristic_callback) { if (!characteristic_callback) {
DiscoveredService discovered_service; DiscoveredService discovered_service;
discovered_service.setup(uuid, start_handle, end_handle); discovered_service.setup(uuid, start_handle, end_handle);
@ -250,11 +260,13 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
void start_characteristic_discovery(GattClient *client) void start_characteristic_discovery(GattClient *client)
{ {
if (!services_discovered) { if (!services_discovered) {
tr_error("%s terminating due to services list structure null", TRACE_CLASS);
terminate(client); terminate(client);
return; return;
} }
if (!characteristic_callback) { if (!characteristic_callback) {
tr_error("%s terminating due missing characteristic callback", TRACE_CLASS);
terminate(client); terminate(client);
return; return;
} }
@ -293,6 +305,7 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
last_characteristic = characteristic_t( last_characteristic = characteristic_t(
client, connection_handle, response[i].handle, response[i].value client, connection_handle, response[i].handle, response[i].value
); );
tr_debug("Discovered char handle: 0x%x value: %s", response[i].handle, tr_array(response[i].value.data(), response[i].value.size()));
} }
// check if all the characteristics of the service has been discovered // check if all the characteristics of the service has been discovered
@ -308,6 +321,7 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
); );
if (err) { if (err) {
tr_error("%s terminating early due to %s", TRACE_CLASS, ble_error_to_string(err));
terminate(client); terminate(client);
} }
} }
@ -328,6 +342,7 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
delete old; delete old;
if (!services_discovered) { if (!services_discovered) {
tr_debug("Service discovery complete");
terminate(client); terminate(client);
} else { } else {
start_characteristic_discovery(client); start_characteristic_discovery(client);
@ -473,7 +488,7 @@ struct GattClient::DiscoveryControlBlock final : public ProcedureControlBlock {
bool done; bool done;
}; };
#define TRACE_CLASS "ReadControlBlock"
struct GattClient::ReadControlBlock final : public ProcedureControlBlock { struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
@ -494,6 +509,7 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
void handle_timeout_error(GattClient *client) final void handle_timeout_error(GattClient *client) final
{ {
tr_warning("%s timed out", TRACE_CLASS);
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -507,6 +523,7 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
void abort(GattClient *client) final void abort(GattClient *client) final
{ {
tr_warning("%s aborted", TRACE_CLASS);
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -543,6 +560,7 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
default: { default: {
// should not happen, terminate the procedure and notify client with an error // should not happen, terminate the procedure and notify client with an error
// in such case // in such case
tr_error("%s terminated unexpectedly due to unhandled opcode 0x%x", TRACE_CLASS, (int)message.opcode);
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -583,11 +601,13 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
response.len = (current_offset + read_response.size()) - offset; response.len = (current_offset + read_response.size()) - offset;
response.data = data; response.data = data;
} }
tr_info("Read response complete - received %d bytes", read_response.size());
terminate(client, response); terminate(client, response);
} else { } else {
// allocation which will contain the response data plus the next one. // allocation which will contain the response data plus the next one.
data = (uint8_t *) realloc(data, (current_offset - offset) + ((mtu_size - 1) * 2)); data = (uint8_t *) realloc(data, (current_offset - offset) + ((mtu_size - 1) * 2));
if (data == nullptr) { if (data == nullptr) {
tr_error("%s terminated due to OoM error", TRACE_CLASS);
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -601,6 +621,7 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
} }
memcpy(data + (current_offset - offset), read_response.data(), read_response.size()); memcpy(data + (current_offset - offset), read_response.data(), read_response.size());
tr_info("Read response partial - received %d bytes", read_response.size());
current_offset = current_offset + read_response.size(); current_offset = current_offset + read_response.size();
ble_error_t err = client->_pal_client.read_attribute_blob( ble_error_t err = client->_pal_client.read_attribute_blob(
connection_handle, connection_handle,
@ -609,6 +630,7 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
); );
if (err) { if (err) {
tr_error("%s terminated because reading attribute failed", TRACE_CLASS);
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -656,6 +678,8 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
break; break;
} }
tr_error("%s error: %s", TRACE_CLASS, attribute_error_code_to_string(error.error_code));
GattReadCallbackParams response = { GattReadCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -677,7 +701,7 @@ struct GattClient::ReadControlBlock final : public ProcedureControlBlock {
/* /*
* Control block for the write process * Control block for the write process
*/ */
#define TRACE_CLASS "WriteControlBlock"
struct GattClient::WriteControlBlock final : public ProcedureControlBlock { struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
@ -699,6 +723,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
void handle_timeout_error(GattClient *client) final void handle_timeout_error(GattClient *client) final
{ {
tr_warning("%s timed out", TRACE_CLASS);
GattWriteCallbackParams response = { GattWriteCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -711,6 +736,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
void abort(GattClient *client) final void abort(GattClient *client) final
{ {
tr_warning("%s aborted", TRACE_CLASS);
GattWriteCallbackParams response = { GattWriteCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -748,6 +774,8 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
break; break;
default: { default: {
tr_error("%s terminated due unhandled opcode 0x%x", TRACE_CLASS, (int)message.opcode);
GattWriteCallbackParams response = { GattWriteCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -763,6 +791,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
void handle_write_response(GattClient* client, const AttWriteResponse& write_response) void handle_write_response(GattClient* client, const AttWriteResponse& write_response)
{ {
tr_debug("write executed successfully");
GattWriteCallbackParams response = { GattWriteCallbackParams response = {
connection_handle, connection_handle,
attribute_handle, attribute_handle,
@ -778,6 +807,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
{ {
ble_error_t err = BLE_ERROR_UNSPECIFIED; ble_error_t err = BLE_ERROR_UNSPECIFIED;
offset += write_response.partial_value.size(); offset += write_response.partial_value.size();
tr_info("Prepared write partially complete offset=%d", offset);
uint16_t data_left = write_length - offset; /* offset is guaranteed to be less of equal to write_length */ uint16_t data_left = write_length - offset; /* offset is guaranteed to be less of equal to write_length */
if (data_left) { if (data_left) {
uint16_t chunk_size = client->get_mtu(connection_handle) - PREPARE_WRITE_HEADER_LENGTH; uint16_t chunk_size = client->get_mtu(connection_handle) - PREPARE_WRITE_HEADER_LENGTH;
@ -798,6 +828,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
} }
if (err) { if (err) {
tr_error("%s failed due to %s - clearing the queue", TRACE_CLASS, ble_error_to_string(err));
clear_prepare_queue(client, err, AttErrorResponse::UNLIKELY_ERROR); clear_prepare_queue(client, err, AttErrorResponse::UNLIKELY_ERROR);
} }
} }
@ -805,6 +836,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
void handle_execute_write_response(GattClient* client, const AttExecuteWriteResponse& execute_response) void handle_execute_write_response(GattClient* client, const AttExecuteWriteResponse& execute_response)
{ {
if (prepare_success) { if (prepare_success) {
tr_debug("Prepared write executed successfully");
status = BLE_ERROR_NONE; status = BLE_ERROR_NONE;
error_code = 0x00; error_code = 0x00;
} }
@ -865,6 +897,8 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
break; break;
} }
tr_error("%s error: %s", TRACE_CLASS, attribute_error_code_to_string(error.error_code));
if (error.request_opcode == AttributeOpcode(AttributeOpcode::PREPARE_WRITE_REQUEST)) { if (error.request_opcode == AttributeOpcode(AttributeOpcode::PREPARE_WRITE_REQUEST)) {
clear_prepare_queue(client, status, error.error_code); clear_prepare_queue(client, status, error.error_code);
} else { } else {
@ -892,7 +926,7 @@ struct GattClient::WriteControlBlock final : public ProcedureControlBlock {
/* /*
* Control block for the descriptor discovery process * Control block for the descriptor discovery process
*/ */
#define TRACE_CLASS "DescriptorDiscoveryControlBlock"
struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureControlBlock { struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureControlBlock {
using ProcedureControlBlock::connection_handle; using ProcedureControlBlock::connection_handle;
@ -913,6 +947,8 @@ struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureContr
ble_error_t start(GattClient *client) ble_error_t start(GattClient *client)
{ {
tr_info("Discover descriptor for char handle=%d",
characteristic.getDeclHandle());
return client->_pal_client.discover_characteristics_descriptors( return client->_pal_client.discover_characteristics_descriptors(
connection_handle, connection_handle,
attribute_handle_range( attribute_handle_range(
@ -924,11 +960,13 @@ struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureContr
void handle_timeout_error(GattClient *client) final void handle_timeout_error(GattClient *client) final
{ {
tr_warning("%s timed out", TRACE_CLASS);
terminate(client, BLE_ERROR_UNSPECIFIED); terminate(client, BLE_ERROR_UNSPECIFIED);
} }
void abort(GattClient *client) final void abort(GattClient *client) final
{ {
tr_warning("%s aborted", TRACE_CLASS);
terminate(client, BLE_ERROR_INVALID_STATE); terminate(client, BLE_ERROR_INVALID_STATE);
} }
@ -955,6 +993,7 @@ struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureContr
void handle_error(GattClient *client, const AttErrorResponse &error) void handle_error(GattClient *client, const AttErrorResponse &error)
{ {
tr_error("%s error: %s", TRACE_CLASS, attribute_error_code_to_string(error.error_code));
if (error.error_code == AttErrorResponse::ATTRIBUTE_NOT_FOUND) { if (error.error_code == AttErrorResponse::ATTRIBUTE_NOT_FOUND) {
terminate(client, BLE_ERROR_NONE); terminate(client, BLE_ERROR_NONE);
} else { } else {
@ -965,6 +1004,8 @@ struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureContr
void handle_response(GattClient *client, const AttFindInformationResponse &response) void handle_response(GattClient *client, const AttFindInformationResponse &response)
{ {
for (size_t i = 0; i < response.size(); ++i) { for (size_t i = 0; i < response.size(); ++i) {
tr_info("Discovered descriptor handle=%d uuid=%s for char handle=%d",
response[i].handle, to_string(response[i].uuid), characteristic.getDeclHandle());
DiscoveredCharacteristicDescriptor descriptor( DiscoveredCharacteristicDescriptor descriptor(
&ble::BLE::Instance().gattClient(), connection_handle, response[i].handle, response[i].uuid &ble::BLE::Instance().gattClient(), connection_handle, response[i].handle, response[i].uuid
); );
@ -993,6 +1034,10 @@ struct GattClient::DescriptorDiscoveryControlBlock final : public ProcedureContr
void terminate(GattClient *client, ble_error_t status, uint8_t error_code = 0x00) void terminate(GattClient *client, ble_error_t status, uint8_t error_code = 0x00)
{ {
if (status != BLE_ERROR_NONE) {
tr_warning("%s terminated due to %s %s", TRACE_CLASS, ble_error_to_string(status), attribute_error_code_to_string(error_code));
}
client->remove_control_block(this); client->remove_control_block(this);
CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = { CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = {
characteristic, characteristic,
@ -1039,8 +1084,10 @@ ble_error_t GattClient::launchServiceDiscovery(
const UUID &matching_characteristic_uuid const UUID &matching_characteristic_uuid
) )
{ {
tr_info("Launching service discovery (service: %s char: %s)", to_string(matching_service_uuid), to_string(matching_characteristic_uuid));
// verify that there is no other procedures going on this connection // verify that there is no other procedures going on this connection
if (_is_reseting || get_control_block(connection_handle)) { if (_is_reseting || get_control_block(connection_handle)) {
tr_error("cannot launch service discovery");
return BLE_ERROR_INVALID_STATE; return BLE_ERROR_INVALID_STATE;
} }
@ -1059,6 +1106,7 @@ ble_error_t GattClient::launchServiceDiscovery(
); );
if (discovery_pcb == nullptr) { if (discovery_pcb == nullptr) {
tr_error("Failed to allocate DiscoveryControlBlock");
return BLE_ERROR_NO_MEM; return BLE_ERROR_NO_MEM;
} }
@ -1082,6 +1130,7 @@ ble_error_t GattClient::launchServiceDiscovery(
} }
if (err) { if (err) {
tr_error("Discovery failed due to %s", ble_error_to_string(err));
remove_control_block(discovery_pcb); remove_control_block(discovery_pcb);
delete discovery_pcb; delete discovery_pcb;
} }
@ -1095,6 +1144,7 @@ ble_error_t GattClient::discoverServices(
const UUID &matchingServiceUUID const UUID &matchingServiceUUID
) )
{ {
tr_info("Discover services with uuid=%s", to_string(matchingServiceUUID));
/* We take advantage of the property /* We take advantage of the property
* that providing nullptr for the characteristic callback results in * that providing nullptr for the characteristic callback results in
* characteristic discovery being skipped for each matching * characteristic discovery being skipped for each matching
@ -1112,6 +1162,7 @@ ble_error_t GattClient::discoverServices(
GattAttribute::Handle_t endHandle GattAttribute::Handle_t endHandle
) )
{ {
tr_warning("discoverServices based on handle range not implemented");
return BLE_ERROR_NOT_IMPLEMENTED; return BLE_ERROR_NOT_IMPLEMENTED;
} }
@ -1132,6 +1183,7 @@ bool GattClient::isServiceDiscoveryActive() const
void GattClient::terminateServiceDiscovery() void GattClient::terminateServiceDiscovery()
{ {
tr_info("Terminate service discovery");
ProcedureControlBlock *pcb = control_blocks; ProcedureControlBlock *pcb = control_blocks;
while (pcb) { while (pcb) {
if (pcb->type == COMPLETE_DISCOVERY_PROCEDURE) { if (pcb->type == COMPLETE_DISCOVERY_PROCEDURE) {
@ -1150,6 +1202,7 @@ ble_error_t GattClient::read(
{ {
// verify that there is no other procedures going on this connection // verify that there is no other procedures going on this connection
if (_is_reseting || get_control_block(connection_handle)) { if (_is_reseting || get_control_block(connection_handle)) {
tr_error("cannot launch attribute read");
return BLE_ERROR_INVALID_STATE; return BLE_ERROR_INVALID_STATE;
} }
@ -1160,6 +1213,7 @@ ble_error_t GattClient::read(
); );
if (read_pcb == nullptr) { if (read_pcb == nullptr) {
tr_error("Attribute read failed due to allocation error");
return BLE_ERROR_NO_MEM; return BLE_ERROR_NO_MEM;
} }
@ -1167,6 +1221,8 @@ ble_error_t GattClient::read(
ble_error_t err = BLE_ERROR_NONE; ble_error_t err = BLE_ERROR_NONE;
tr_debug("Connection %d - read attribute %d offset %d", connection_handle, attribute_handle, offset);
if (offset == 0) { if (offset == 0) {
err = _pal_client.read_attribute_value( err = _pal_client.read_attribute_value(
connection_handle, attribute_handle connection_handle, attribute_handle
@ -1178,6 +1234,7 @@ ble_error_t GattClient::read(
} }
if (err) { if (err) {
tr_error("Attribute read failed due %s", ble_error_to_string(err));
remove_control_block(read_pcb); remove_control_block(read_pcb);
delete read_pcb; delete read_pcb;
} }
@ -1195,9 +1252,12 @@ ble_error_t GattClient::write(
) const ) const
{ {
if (_is_reseting || get_control_block(connection_handle)) { if (_is_reseting || get_control_block(connection_handle)) {
tr_error("cannot launch attibute write");
return BLE_ERROR_INVALID_STATE; return BLE_ERROR_INVALID_STATE;
} }
tr_debug("Connection %d - write attribute %d value %s", connection_handle, attribute_handle, tr_array(value, length));
uint16_t mtu = get_mtu(connection_handle); uint16_t mtu = get_mtu(connection_handle);
#if BLE_FEATURE_SIGNING #if BLE_FEATURE_SIGNING
@ -1218,6 +1278,7 @@ ble_error_t GattClient::write(
#endif // BLE_FEATURE_SIGNING #endif // BLE_FEATURE_SIGNING
if (cmd == GATT_OP_WRITE_CMD) { if (cmd == GATT_OP_WRITE_CMD) {
if (length > (uint16_t) (mtu - WRITE_HEADER_LENGTH)) { if (length > (uint16_t) (mtu - WRITE_HEADER_LENGTH)) {
tr_error("Writes need to fit in a single message");
return BLE_ERROR_PARAM_OUT_OF_RANGE; return BLE_ERROR_PARAM_OUT_OF_RANGE;
} }
return _pal_client.write_without_response( return _pal_client.write_without_response(
@ -1228,6 +1289,7 @@ ble_error_t GattClient::write(
#if BLE_FEATURE_SIGNING #if BLE_FEATURE_SIGNING
} else if (cmd == GATT_OP_SIGNED_WRITE_CMD) { } else if (cmd == GATT_OP_SIGNED_WRITE_CMD) {
if (length > (uint16_t) (mtu - WRITE_HEADER_LENGTH - CMAC_LENGTH - MAC_COUNTER_LENGTH)) { if (length > (uint16_t) (mtu - WRITE_HEADER_LENGTH - CMAC_LENGTH - MAC_COUNTER_LENGTH)) {
tr_error("Signed writes need to fit in single message");
return BLE_ERROR_PARAM_OUT_OF_RANGE; return BLE_ERROR_PARAM_OUT_OF_RANGE;
} }
ble_error_t status = _pal_client.signed_write_without_response( ble_error_t status = _pal_client.signed_write_without_response(
@ -1247,6 +1309,7 @@ ble_error_t GattClient::write(
if (length > (uint16_t) (mtu - WRITE_HEADER_LENGTH)) { if (length > (uint16_t) (mtu - WRITE_HEADER_LENGTH)) {
data = (uint8_t *) malloc(length); data = (uint8_t *) malloc(length);
if (data == nullptr) { if (data == nullptr) {
tr_err("Write failed due to allocation error");
return BLE_ERROR_NO_MEM; return BLE_ERROR_NO_MEM;
} }
memcpy(data, value, length); memcpy(data, value, length);
@ -1261,6 +1324,7 @@ ble_error_t GattClient::write(
if (write_pcb == nullptr) { if (write_pcb == nullptr) {
free(data); free(data);
tr_err("Write failed due to allocation error");
return BLE_ERROR_NO_MEM; return BLE_ERROR_NO_MEM;
} }
@ -1283,6 +1347,7 @@ ble_error_t GattClient::write(
} }
if (err) { if (err) {
tr_error("Write request failed due to %s", ble_error_to_string(err));
remove_control_block(write_pcb); remove_control_block(write_pcb);
delete write_pcb; delete write_pcb;
} }
@ -1298,6 +1363,7 @@ void GattClient::onServiceDiscoveryTermination(
ServiceDiscovery::TerminationCallback_t callback ServiceDiscovery::TerminationCallback_t callback
) )
{ {
tr_info("Service discovery ended");
_termination_callback = callback; _termination_callback = callback;
} }
@ -1308,6 +1374,8 @@ ble_error_t GattClient::discoverCharacteristicDescriptors(
const CharacteristicDescriptorDiscovery::TerminationCallback_t &terminationCallback const CharacteristicDescriptorDiscovery::TerminationCallback_t &terminationCallback
) )
{ {
tr_info("Discover char descriptors %d", characteristic.getDeclHandle());
// verify that there is no other procedures going on this connection // verify that there is no other procedures going on this connection
if (_is_reseting || get_control_block(characteristic.getConnectionHandle())) { if (_is_reseting || get_control_block(characteristic.getConnectionHandle())) {
return BLE_ERROR_INVALID_STATE; return BLE_ERROR_INVALID_STATE;
@ -1370,6 +1438,7 @@ void GattClient::terminateCharacteristicDescriptorDiscovery(
const DiscoveredCharacteristic &characteristic const DiscoveredCharacteristic &characteristic
) )
{ {
tr_info("terminate char descriptor discovery %d", characteristic.getDeclHandle());
ProcedureControlBlock *pcb = control_blocks; ProcedureControlBlock *pcb = control_blocks;
while (pcb) { while (pcb) {
@ -1397,6 +1466,7 @@ ble_error_t GattClient::negotiateAttMtu(
ble_error_t GattClient::reset() ble_error_t GattClient::reset()
{ {
tr_info("GattClient reset");
/* Notify that the instance is about to shut down. */ /* Notify that the instance is about to shut down. */
shutdownCallChain.call(&ble::BLE::Instance().gattClient()); shutdownCallChain.call(&ble::BLE::Instance().gattClient());
shutdownCallChain.clear(); shutdownCallChain.clear();
@ -1434,6 +1504,7 @@ void GattClient::on_att_mtu_change(
uint16_t att_mtu_size uint16_t att_mtu_size
) )
{ {
tr_info("MTU changed to %d", att_mtu_size);
if (eventHandler) { if (eventHandler) {
eventHandler->onAttMtuChange(connection_handle, att_mtu_size); eventHandler->onAttMtuChange(connection_handle, att_mtu_size);
} }
@ -1471,6 +1542,7 @@ void GattClient::on_server_message_received(
const AttServerMessage &message const AttServerMessage &message
) )
{ {
tr_debug("Received server message %s", attribute_opcode_to_string(message.opcode));
switch (message.opcode) { switch (message.opcode) {
case AttributeOpcode::ERROR_RESPONSE: case AttributeOpcode::ERROR_RESPONSE:
case AttributeOpcode::EXCHANGE_MTU_RESPONSE: case AttributeOpcode::EXCHANGE_MTU_RESPONSE:
@ -1493,6 +1565,7 @@ void GattClient::on_server_message_received(
} break; } break;
default: default:
tr_warning("Unhandled message in gatt client received from server");
// invalid message receive // invalid message receive
return; return;
} }
@ -1527,6 +1600,7 @@ void GattClient::on_server_event(connection_handle_t connection, const AttServer
callbacks_params.type = BLE_HVX_NOTIFICATION; callbacks_params.type = BLE_HVX_NOTIFICATION;
callbacks_params.len = notification.attribute_value.size(); callbacks_params.len = notification.attribute_value.size();
callbacks_params.data = notification.attribute_value.data(); callbacks_params.data = notification.attribute_value.data();
tr_debug("Notification for char: %d value: %s", notification.attribute_handle, tr_array(notification.attribute_value.data(), notification.attribute_value.size()));
} break; } break;
case AttributeOpcode::HANDLE_VALUE_INDICATION: { case AttributeOpcode::HANDLE_VALUE_INDICATION: {
@ -1536,9 +1610,11 @@ void GattClient::on_server_event(connection_handle_t connection, const AttServer
callbacks_params.type = BLE_HVX_INDICATION; callbacks_params.type = BLE_HVX_INDICATION;
callbacks_params.len = indication.attribute_value.size(); callbacks_params.len = indication.attribute_value.size();
callbacks_params.data = indication.attribute_value.data(); callbacks_params.data = indication.attribute_value.data();
tr_debug("Indication for char: %d value: %s", indication.attribute_handle, tr_array(indication.attribute_value.data(), indication.attribute_value.size()));
} break; } break;
default: default:
tr_warning("Unhandled event in gatt client received from server");
return; return;
} }
@ -1633,6 +1709,9 @@ uint16_t GattClient::get_mtu(connection_handle_t connection) const
*/ */
void GattClient::setEventHandler(EventHandler *handler) void GattClient::setEventHandler(EventHandler *handler)
{ {
if (!handler) {
tr_warning("Setting a null gatt event handler");
}
eventHandler = handler; eventHandler = handler;
} }
@ -1705,6 +1784,11 @@ GattClient::HVXCallbackChain_t &GattClient::onHVX()
*/ */
void GattClient::processReadResponse(const GattReadCallbackParams *params) void GattClient::processReadResponse(const GattReadCallbackParams *params)
{ {
if (params->status == BLE_ERROR_NONE) {
tr_debug("Att read complete handle 0x%x (offset %d), value %s", params->handle, params->offset, tr_array(params->data, params->len));
} else {
tr_info("Connection %d - Att read failed with error %s", params->connHandle, ble_error_to_string(params->status));
}
onDataReadCallbackChain(params); onDataReadCallbackChain(params);
} }
@ -1713,6 +1797,11 @@ void GattClient::processReadResponse(const GattReadCallbackParams *params)
*/ */
void GattClient::processWriteResponse(const GattWriteCallbackParams *params) void GattClient::processWriteResponse(const GattWriteCallbackParams *params)
{ {
if (params->status == BLE_ERROR_NONE) {
tr_debug("Att write complete handle 0x%x", params->handle);
} else {
tr_info("Connection %d - Att write failed with error %s", params->connHandle, ble_error_to_string(params->status));
}
onDataWriteCallbackChain(params); onDataWriteCallbackChain(params);
} }