mirror of https://github.com/ARMmbed/mbed-os.git
Add tracing to BLE GAP (#14117)
* Add traces to GapImpl.cpp
* Add helpers and param logs
* Update GapImpl.cpp
* Move helpers to ble_trace_helpers.h
* Add traces to whitelist setter & getter functions
* Prepend parent dir. to ble_trace_helpers.h include line
* Resolve portability issue by using PRI* macro in place of %lu
* Add traces to PalGapImpl.cpp
* Complete PAL GAP traces
* Remove stray include
* Make 'echo' traces in PAL configurable
Some of the tr_info traces at the beginning of PAL functions are duplicates ('echoes') of those in GAP functions. This commit enables including/excluding of these traces in mbed_app.json by writing 1/0, respectively to the MBED_CONF_CORDIO_TRACE_PAL_ECHOES config macro. The default is to exclude 'echo' traces.
* Add missing spaces in tr_info traces
* Clean-up param log for set_extended_advertising_parameters
* Remove "Failed: " from every tr_error trace
* Apply changes from PalGapImpl.cpp review
* Apply changes from GapImpl.cpp review
* Use binary for channel map trace
B0: ADVERTISING_CHANNEL_37
B1: ADVERTISING_CHANNEL_38
B2: ADVERTISING_CHANNEL_39
We're assuming that the user understands the above. This could be documented somewhere.
* Replace more %lu w/PRIu32
* Add tr_info to terminateSync for user call
* Make trace group for PAL traces BLDM
* Remove [PAL] prefix from every PAL trace
* Add trace to setPeripheralPrivacyConfiguration
* Make set scan params tr_info dependent on selected PHY
* Add trace to GAP events
* Other GAP events required traces
pull/14198/head
Abbas Bracken Ziad
Paul Szczepanek
parent
91d4b48989
commit
f4febdcb9d
|
|
@ -21,6 +21,7 @@
|
|||
#include "ble/SecurityManager.h"
|
||||
#include "mbed-trace/mbed_trace.h"
|
||||
#include "pal/GapTypes.h"
|
||||
#include "pal/GapEvents.h"
|
||||
#include "ble-host/include/dm_api.h"
|
||||
#include "common/UUID.h"
|
||||
|
||||
|
|
@ -226,6 +227,471 @@ static inline const char *to_string(privacy_mode_t mode)
|
|||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::advertising_type_t advType)
|
||||
{
|
||||
switch (advType.value()) {
|
||||
case ble::advertising_type_t::CONNECTABLE_UNDIRECTED:
|
||||
return "CONNECTABLE_UNDIRECTED";
|
||||
case ble::advertising_type_t::CONNECTABLE_DIRECTED:
|
||||
return "CONNECTABLE_DIRECTED";
|
||||
case ble::advertising_type_t::SCANNABLE_UNDIRECTED:
|
||||
return "SCANNABLE_UNDIRECTED";
|
||||
case ble::advertising_type_t::NON_CONNECTABLE_UNDIRECTED:
|
||||
return "NON_CONNECTABLE_UNDIRECTED";
|
||||
case ble::advertising_type_t::CONNECTABLE_DIRECTED_LOW_DUTY:
|
||||
return "CONNECTABLE_DIRECTED_LOW_DUTY";
|
||||
case ble::advertising_type_t::CONNECTABLE_NON_SCANNABLE_UNDIRECTED:
|
||||
return "CONNECTABLE_NON_SCANNABLE_UNDIRECTED";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::own_address_type_t addressType)
|
||||
{
|
||||
switch (addressType.value()) {
|
||||
case ble::own_address_type_t::PUBLIC:
|
||||
return "PUBLIC";
|
||||
case ble::own_address_type_t::RANDOM:
|
||||
return "RANDOM";
|
||||
case ble::own_address_type_t::RESOLVABLE_PRIVATE_ADDRESS_PUBLIC_FALLBACK:
|
||||
return "RESOLVABLE_PRIVATE_ADDRESS_PUBLIC_FALLBACK";
|
||||
case ble::own_address_type_t::RESOLVABLE_PRIVATE_ADDRESS_RANDOM_FALLBACK:
|
||||
return "RESOLVABLE_PRIVATE_ADDRESS_RANDOM_FALLBACK";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::advertising_filter_policy_t policy)
|
||||
{
|
||||
switch (policy.value()) {
|
||||
case ble::advertising_filter_policy_t::NO_FILTER:
|
||||
return "NO_FILTER";
|
||||
case ble::advertising_filter_policy_t::FILTER_SCAN_REQUESTS:
|
||||
return "FILTER_SCAN_REQUESTS";
|
||||
case ble::advertising_filter_policy_t::FILTER_CONNECTION_REQUEST:
|
||||
return "FILTER_CONNECTION_REQUEST";
|
||||
case ble::advertising_filter_policy_t::FILTER_SCAN_AND_CONNECTION_REQUESTS:
|
||||
return "FILTER_SCAN_AND_CONNECTION_REQUESTS";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::phy_t phy)
|
||||
{
|
||||
switch (phy.value()) {
|
||||
case ble::phy_t::NONE:
|
||||
return "NONE";
|
||||
case ble::phy_t::LE_1M:
|
||||
return "LE_1M";
|
||||
case ble::phy_t::LE_2M:
|
||||
return "LE_2M";
|
||||
case ble::phy_t::LE_CODED:
|
||||
return "LE_CODED";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::scanning_filter_policy_t policy)
|
||||
{
|
||||
switch (policy.value()) {
|
||||
case ble::scanning_filter_policy_t::NO_FILTER:
|
||||
return "NO_FILTER";
|
||||
case ble::scanning_filter_policy_t::FILTER_ADVERTISING:
|
||||
return "FILTER_ADVERTISING";
|
||||
case ble::scanning_filter_policy_t::NO_FILTER_INCLUDE_UNRESOLVABLE_DIRECTED:
|
||||
return "NO_FILTER_INCLUDE_UNRESOLVABLE_DIRECTED";
|
||||
case ble::scanning_filter_policy_t::FILTER_ADVERTISING_INCLUDE_UNRESOLVABLE_DIRECTED:
|
||||
return "FILTER_ADVERTISING_INCLUDE_UNRESOLVABLE_DIRECTED";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::duplicates_filter_t filtering)
|
||||
{
|
||||
switch (filtering.value()) {
|
||||
case ble::duplicates_filter_t::ENABLE:
|
||||
return "ENABLE";
|
||||
case ble::duplicates_filter_t::DISABLE:
|
||||
return "DISABLE";
|
||||
case ble::duplicates_filter_t::PERIODIC_RESET:
|
||||
return "PERIODIC_RESET";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::peer_address_type_t addressType)
|
||||
{
|
||||
switch (addressType.value()) {
|
||||
case ble::peer_address_type_t::PUBLIC:
|
||||
return "PUBLIC";
|
||||
case ble::peer_address_type_t::RANDOM:
|
||||
return "RANDOM";
|
||||
case ble::peer_address_type_t::PUBLIC_IDENTITY:
|
||||
return "PUBLIC_IDENTITY";
|
||||
case ble::peer_address_type_t::RANDOM_STATIC_IDENTITY:
|
||||
return "RANDOM_STATIC_IDENTITY";
|
||||
case ble::peer_address_type_t::ANONYMOUS:
|
||||
return "ANONYMOUS";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::initiator_filter_policy_t policy)
|
||||
{
|
||||
switch(policy.value()) {
|
||||
case ble::initiator_filter_policy_t::NO_FILTER:
|
||||
return "NO_FILTER";
|
||||
case ble::initiator_filter_policy_t::USE_WHITE_LIST:
|
||||
return "USE_WHITE_LIST";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::coded_symbol_per_bit_t sym)
|
||||
{
|
||||
switch (sym.value()) {
|
||||
case ble::coded_symbol_per_bit_t::UNDEFINED:
|
||||
return "UNDEFINED";
|
||||
case ble::coded_symbol_per_bit_t::S2:
|
||||
return "S2";
|
||||
case ble::coded_symbol_per_bit_t::S8:
|
||||
return "S8";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::local_disconnection_reason_t reason)
|
||||
{
|
||||
switch (reason.value()) {
|
||||
case ble::local_disconnection_reason_t::AUTHENTICATION_FAILURE:
|
||||
return "AUTHENTICATION_FAILURE";
|
||||
case ble::local_disconnection_reason_t::USER_TERMINATION:
|
||||
return "USER_TERMINATION";
|
||||
case ble::local_disconnection_reason_t::LOW_RESOURCES:
|
||||
return "LOW_RESOURCES";
|
||||
case ble::local_disconnection_reason_t::POWER_OFF:
|
||||
return "POWER OFF";
|
||||
case ble::local_disconnection_reason_t::UNSUPPORTED_REMOTE_FEATURE:
|
||||
return "UNSUPPORTED_REMOTE_FEATURE";
|
||||
case ble::local_disconnection_reason_t::PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
|
||||
return "PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED";
|
||||
case ble::local_disconnection_reason_t::UNACCEPTABLE_CONNECTION_PARAMETERS:
|
||||
return "UNACCEPTABLE_CONNECTION_PARAMETERS";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::advertising_channel_map_t map)
|
||||
{
|
||||
switch (map.value()) {
|
||||
case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_37:
|
||||
return "[001]";
|
||||
case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_38:
|
||||
return "[010]";
|
||||
case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_37_AND_38:
|
||||
return "[011]";
|
||||
case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_39:
|
||||
return "[100]";
|
||||
case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_37_AND_39:
|
||||
return "[101]";
|
||||
case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_38_AND_39:
|
||||
return "[110]";
|
||||
case ble::advertising_channel_map_t::ALL_ADVERTISING_CHANNELS:
|
||||
return "[111]";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::connection_peer_address_type_t connection_peer_address_type)
|
||||
{
|
||||
switch (connection_peer_address_type.value()) {
|
||||
case ble::connection_peer_address_type_t::PUBLIC_ADDRESS:
|
||||
return "PUBLIC_ADDRESS";
|
||||
case ble::connection_peer_address_type_t::RANDOM_ADDRESS:
|
||||
return "RANDOM_ADDRESS";
|
||||
case ble::connection_peer_address_type_t::PUBLIC_IDENTITY_ADDRESS:
|
||||
return "PUBLIC_IDENTITY_ADDRESS";
|
||||
case ble::connection_peer_address_type_t::RANDOM_IDENTITY_ADDRESS:
|
||||
return "RANDOM_IDENTITY_ADDRESS";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::whitelist_address_type_t whitelist_address_type)
|
||||
{
|
||||
if (whitelist_address_type.value() == ble::whitelist_address_type_t::PUBLIC_DEVICE_ADDRESS) {
|
||||
return "PUBLIC_DEVICE_ADDRESS";
|
||||
} else {
|
||||
return "RANDOM_DEVICE_ADDRESS";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::hci_error_code_t error)
|
||||
{
|
||||
switch (error.value()) {
|
||||
case ble::hci_error_code_t::SUCCESS:
|
||||
return "SUCCESS";
|
||||
case ble::hci_error_code_t::UNKNOWN_HCI_COMMAND:
|
||||
return "UNKNOWN_HCI_COMMAND";
|
||||
case ble::hci_error_code_t::UNKNOWN_CONNECTION_IDENTIFIER:
|
||||
return "UNKNOWN_CONNECTION_IDENTIFIER";
|
||||
case ble::hci_error_code_t::HARDWARE_FAILLURE:
|
||||
return "HARDWARE_FAILLURE";
|
||||
case ble::hci_error_code_t::PAGE_TIMEOUT:
|
||||
return "PAGE_TIMEOUT";
|
||||
case ble::hci_error_code_t::AUTHENTICATION_FAILLURE:
|
||||
return "AUTHENTICATION_FAILLURE";
|
||||
case ble::hci_error_code_t::PIN_OR_KEY_MISSING:
|
||||
return "PIN_OR_KEY_MISSING";
|
||||
case ble::hci_error_code_t::MEMORY_CAPACITY_EXCEEDED:
|
||||
return "MEMORY_CAPACITY_EXCEEDED";
|
||||
case ble::hci_error_code_t::CONNECTION_TIMEOUT:
|
||||
return "CONNECTION_TIMEOUT";
|
||||
case ble::hci_error_code_t::CONNECTION_LIMIT_EXCEEDED:
|
||||
return "CONNECTION_LIMIT_EXCEEDED";
|
||||
case ble::hci_error_code_t::SYNCHRONOUS_CONNECTION_LIMIT_TO_A_DEVICE_EXCEEDED:
|
||||
return "SYNCHRONOUS_CONNECTION_LIMIT_TO_A_DEVICE_EXCEEDED";
|
||||
case ble::hci_error_code_t::CONNECTION_ALREADY_EXIST:
|
||||
return "CONNECTION_ALREADY_EXIST";
|
||||
case ble::hci_error_code_t::COMMAND_DISALLOWED:
|
||||
return "COMMAND_DISALLOWED";
|
||||
case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES:
|
||||
return "CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES";
|
||||
case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_SECURITY_REASONS:
|
||||
return "CONNECTION_REJECTED_DUE_TO_SECURITY_REASONS";
|
||||
case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR:
|
||||
return "CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR";
|
||||
case ble::hci_error_code_t::CONNECTION_ACCEPT_TIMEOUT_EXCEEDED:
|
||||
return "CONNECTION_ACCEPT_TIMEOUT_EXCEEDED";
|
||||
case ble::hci_error_code_t::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE:
|
||||
return "UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE";
|
||||
case ble::hci_error_code_t::INVALID_HCI_COMMAND_PARAMETERS:
|
||||
return "INVALID_HCI_COMMAND_PARAMETERS";
|
||||
case ble::hci_error_code_t::REMOTE_USER_TERMINATED_CONNECTION:
|
||||
return "REMOTE_USER_TERMINATED_CONNECTION";
|
||||
case ble::hci_error_code_t::REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES:
|
||||
return "REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES";
|
||||
case ble::hci_error_code_t::REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_POWER_OFF:
|
||||
return "REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_POWER_OFF";
|
||||
case ble::hci_error_code_t::CONNECTION_TERMINATED_BY_LOCAL_HOST:
|
||||
return "CONNECTION_TERMINATED_BY_LOCAL_HOST";
|
||||
case ble::hci_error_code_t::REPEATED_ATTEMPTS:
|
||||
return "REPEATED_ATTEMPTS";
|
||||
case ble::hci_error_code_t::PAIRING_NOT_ALLOWED:
|
||||
return "PAIRING_NOT_ALLOWED";
|
||||
case ble::hci_error_code_t::UNKNOWN_LMP_PDU:
|
||||
return "UNKNOWN_LMP_PDU";
|
||||
case ble::hci_error_code_t::UNSUPPORTED_REMOTE_FEATURE | ble::hci_error_code_t::UNSUPPORTED_LMP_FEATURE:
|
||||
return "UNSUPPORTED_REMOTE_FEATURE/UNSUPPORTED_LMP_FEATURE";
|
||||
case ble::hci_error_code_t::SCO_OFFSET_REJECTED:
|
||||
return "SCO_OFFSET_REJECTED";
|
||||
case ble::hci_error_code_t::SCO_INTERVAL_REJECTED:
|
||||
return "SCO_INTERVAL_REJECTED";
|
||||
case ble::hci_error_code_t::SCO_AIR_MODE_REJECTED:
|
||||
return "SCO_AIR_MODE_REJECTED";
|
||||
case ble::hci_error_code_t::INVALID_LMP_PARAMETERS | ble::hci_error_code_t::INVALID_LL_PARAMETERS:
|
||||
return "INVALID_LMP_PARAMETERS/INVALID_LL_PARAMETERS";
|
||||
case ble::hci_error_code_t::UNSPECIFIED_ERROR:
|
||||
return "UNSPECIFIED_ERROR";
|
||||
case ble::hci_error_code_t::UNSUPPORTED_LMP_PARAMETER_VALUE | ble::hci_error_code_t::UNSUPPORTED_LL_PARAMETER_VALUE:
|
||||
return "UNSUPPORTED_LMP_PARAMETER_VALUE/UNSUPPORTED_LL_PARAMETER_VALUE";
|
||||
case ble::hci_error_code_t::ROLE_CHANGE_NOT_ALLOWED:
|
||||
return "ROLE_CHANGE_NOT_ALLOWED";
|
||||
case ble::hci_error_code_t::LMP_RESPONSE_TIMEOUT | ble::hci_error_code_t::LL_RESPONSE_TIMEOUT:
|
||||
return "LMP_RESPONSE_TIMEOUT/LL_RESPONSE_TIMEOUT";
|
||||
case ble::hci_error_code_t::LMP_ERROR_TRANSACTION_COLLISION | ble::hci_error_code_t::LL_PROCEDURE_COLLISION:
|
||||
return "LMP_ERROR_TRANSACTION_COLLISION/LL_PROCEDURE_COLLISION";
|
||||
case ble::hci_error_code_t::LMP_PDU_NOT_ALLOWED:
|
||||
return "LMP_PDU_NOT_ALLOWED";
|
||||
case ble::hci_error_code_t::ENCRYPTION_MODE_NOT_ACCEPTABLE:
|
||||
return "ENCRYPTION_MODE_NOT_ACCEPTABLE";
|
||||
case ble::hci_error_code_t::LINK_KEY_CANNOT_BE_CHANGED:
|
||||
return "LINK_KEY_CANNOT_BE_CHANGED";
|
||||
case ble::hci_error_code_t::REQUESTED_QOS_NOT_SUPPORTED:
|
||||
return "REQUESTED_QOS_NOT_SUPPORTED";
|
||||
case ble::hci_error_code_t::INSTANT_PASSED:
|
||||
return "INSTANT_PASSED";
|
||||
case ble::hci_error_code_t::PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
|
||||
return "PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED";
|
||||
case ble::hci_error_code_t::DIFFERENT_TRANSACTION_COLLISION:
|
||||
return "DIFFERENT_TRANSACTION_COLLISION";
|
||||
case ble::hci_error_code_t::RESERVED_FOR_FUTURE_USE:
|
||||
return "RESERVED_FOR_FUTURE_USE";
|
||||
case ble::hci_error_code_t::QOS_UNACCEPTABLE_PARAMETER:
|
||||
return "QOS_UNACCEPTABLE_PARAMETER";
|
||||
case ble::hci_error_code_t::QOS_REJECTED:
|
||||
return "QOS_REJECTED";
|
||||
case ble::hci_error_code_t::CHANNEL_CLASSIFICATION_NOT_SUPPORTED:
|
||||
return "CHANNEL_CLASSIFICATION_NOT_SUPPORTED";
|
||||
case ble::hci_error_code_t::INSUFFICIENT_SECURITY:
|
||||
return "INSUFFICIENT_SECURITY";
|
||||
case ble::hci_error_code_t::PARAMETER_OUT_OF_MANDATORY_RANGE:
|
||||
return "PARAMETER_OUT_OF_MANDATORY_RANGE";
|
||||
case ble::hci_error_code_t::ROLE_SWITCH_PENDING:
|
||||
return "ROLE_SWITCH_PENDING";
|
||||
case ble::hci_error_code_t::RESERVED_SLOT_VIOLATION:
|
||||
return "RESERVED_SLOT_VIOLATION";
|
||||
case ble::hci_error_code_t::ROLE_SWITCH_FAILED:
|
||||
return "ROLE_SWITCH_FAILED";
|
||||
case ble::hci_error_code_t::EXTENDED_INQUIRY_RESPONSE_TOO_LARGE:
|
||||
return "EXTENDED_INQUIRY_RESPONSE_TOO_LARGE";
|
||||
case ble::hci_error_code_t::SECURE_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOST:
|
||||
return "SECURE_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOST";
|
||||
case ble::hci_error_code_t::HOST_BUSY_PAIRING:
|
||||
return "HOST_BUSY_PAIRING";
|
||||
case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND:
|
||||
return "CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND";
|
||||
case ble::hci_error_code_t::CONTROLLER_BUSY:
|
||||
return "CONTROLLER_BUSY";
|
||||
case ble::hci_error_code_t::UNACCEPTABLE_CONNECTION_PARAMETERS:
|
||||
return "UNACCEPTABLE_CONNECTION_PARAMETERS";
|
||||
case ble::hci_error_code_t::ADVERTISING_TIMEOUT:
|
||||
return "ADVERTISING_TIMEOUT";
|
||||
case ble::hci_error_code_t::CONNECTION_TERMINATED_DUE_TO_MIC_FAILURE:
|
||||
return "CONNECTION_TERMINATED_DUE_TO_MIC_FAILURE";
|
||||
case ble::hci_error_code_t::CONNECTION_FAILED_TO_BE_ESTABLISHED:
|
||||
return "CONNECTION_FAILED_TO_BE_ESTABLISHED";
|
||||
case ble::hci_error_code_t::MAC_CONNECTION_FAILED:
|
||||
return "MAC_CONNECTION_FAILED";
|
||||
case ble::hci_error_code_t::COARSE_CLOCK_ADJUSTMENT_REJECTED_BUT_WILL_TRY_TO_ADJUST_USING_CLOCK_DRAGGING:
|
||||
return "COARSE_CLOCK_ADJUSTMENT_REJECTED_BUT_WILL_TRY_TO_ADJUST_USING_CLOCK_DRAGGING";
|
||||
case ble::hci_error_code_t::TYPE0_SUBMAP_NOT_DEFINED:
|
||||
return "TYPE0_SUBMAP_NOT_DEFINED";
|
||||
case ble::hci_error_code_t::UNKNOWN_ADVERTISING_IDENTIFIER:
|
||||
return "UNKNOWN_ADVERTISING_IDENTIFIER";
|
||||
case ble::hci_error_code_t::LIMIT_REACHED:
|
||||
return "LIMIT_REACHED";
|
||||
case ble::hci_error_code_t::OPERATION_CANCELLED_BY_HOST:
|
||||
return "OPERATION_CANCELLED_BY_HOST";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::advertising_fragment_description_t fragment_description)
|
||||
{
|
||||
switch (fragment_description.value()) {
|
||||
case ble::advertising_fragment_description_t::INTERMEDIATE_FRAGMENT:
|
||||
return "INTERMEDIATE_FRAGMENT";
|
||||
case ble::advertising_fragment_description_t::FIRST_FRAGMENT:
|
||||
return "FIRST_FRAGMENT";
|
||||
case ble::advertising_fragment_description_t::LAST_FRAGMENT:
|
||||
return "LAST_FRAGMENT";
|
||||
case ble::advertising_fragment_description_t::COMPLETE_FRAGMENT:
|
||||
return "COMPLETE_FRAGMENT";
|
||||
case ble::advertising_fragment_description_t::UNCHANGED_DATA:
|
||||
return "UNCHANGED_DATA";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::peripheral_privacy_configuration_t::resolution_strategy_t resolution_strategy)
|
||||
{
|
||||
switch (resolution_strategy) {
|
||||
case ble::peripheral_privacy_configuration_t::resolution_strategy_t::DO_NOT_RESOLVE:
|
||||
return "DO_NOT_RESOLVE";
|
||||
case ble::peripheral_privacy_configuration_t::resolution_strategy_t::REJECT_NON_RESOLVED_ADDRESS:
|
||||
return "REJECT_NON_RESOLVED_ADDRESS";
|
||||
case ble::peripheral_privacy_configuration_t::resolution_strategy_t::PERFORM_PAIRING_PROCEDURE:
|
||||
return "PERFORM_PAIRING_PROCEDURE";
|
||||
case ble::peripheral_privacy_configuration_t::resolution_strategy_t::PERFORM_AUTHENTICATION_PROCEDURE:
|
||||
return "PERFORM_AUTHENTICATION_PROCEDURE";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::GapEventType event_type)
|
||||
{
|
||||
switch (event_type.value()) {
|
||||
case ble::GapEventType::type::UNEXPECTED_ERROR:
|
||||
return "UNEXPECTED_ERROR";
|
||||
case ble::GapEventType::type::CONNECTION_COMPLETE:
|
||||
return "CONNECTION_COMPLETE";
|
||||
case ble::GapEventType::type::ADVERTISING_REPORT:
|
||||
return "ADVERTISING_REPORT";
|
||||
case ble::GapEventType::type::CONNECTION_UPDATE:
|
||||
return "CONNECTION_UPDATE";
|
||||
case ble::GapEventType::type::REMOTE_CONNECTION_PARAMETER_REQUEST:
|
||||
return "REMOTE_CONNECTION_PARAMETER_REQUEST";
|
||||
case ble::GapEventType::type::DISCONNECTION_COMPLETE:
|
||||
return "DISCONNECTION_COMPLETE";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::received_advertising_type_t type)
|
||||
{
|
||||
switch (type.value()) {
|
||||
case ble::received_advertising_type_t::ADV_IND:
|
||||
return "ADV_IND";
|
||||
case ble::received_advertising_type_t::ADV_DIRECT_IND:
|
||||
return "ADV_DIRECT_IND";
|
||||
case ble::received_advertising_type_t::ADV_SCAN_IND:
|
||||
return "ADV_SCAN_IND";
|
||||
case ble::received_advertising_type_t::ADV_NONCONN_IND:
|
||||
return "ADV_NONCONN_IND";
|
||||
case ble::received_advertising_type_t::SCAN_RESPONSE:
|
||||
return "SCAN_RESPONSE";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::connection_role_t role)
|
||||
{
|
||||
if (role.value() == ble::connection_role_t::CENTRAL) {
|
||||
return "CENTRAL";
|
||||
} else {
|
||||
return "PERIPHERAL";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::direct_address_type_t direct_address_type)
|
||||
{
|
||||
switch (direct_address_type.value()) {
|
||||
case ble::direct_address_type_t::PUBLIC_ADDRESS:
|
||||
return "PUBLIC_ADDRESS";
|
||||
case ble::direct_address_type_t::RANDOM_ADDRESS:
|
||||
return "RANDOM_ADDRESS";
|
||||
case ble::direct_address_type_t::PUBLIC_IDENTITY_ADDRESS:
|
||||
return "PUBLIC_IDENTITY_ADDRESS";
|
||||
case ble::direct_address_type_t::RANDOM_IDENTITY_ADDRESS:
|
||||
return "RANDOM_IDENTITY_ADDRESS";
|
||||
case ble::direct_address_type_t::RANDOM_DEVICE_ADDRESS:
|
||||
return "RANDOM_DEVICE_ADDRESS";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
static inline const char* to_string(ble::advertising_data_status_t data_status)
|
||||
{
|
||||
switch (data_status.value()) {
|
||||
case ble::advertising_data_status_t::COMPLETE:
|
||||
return "COMPLETE";
|
||||
case ble::advertising_data_status_t::INCOMPLETE_MORE_DATA:
|
||||
return "INCOMPLETE_MORE_DATA";
|
||||
case ble::advertising_data_status_t::INCOMPLETE_DATA_TRUNCATED:
|
||||
return "INCOMPLETE_DATA_TRUNCATED";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace ble
|
||||
|
||||
|
|
|
|||
|
|
@ -82,6 +82,10 @@
|
|||
"value": null,
|
||||
"macro_name": "CORDIO_RPA_SWAP_WORKAROUND"
|
||||
},
|
||||
"trace-pal-echoes": {
|
||||
"help": "Include 'echo' traces in PAL, i.e. function signature and argument prints",
|
||||
"value": 0
|
||||
},
|
||||
"trace-hci-packets": {
|
||||
"help": "If tracing is enabled at level DEBUG traces will include HCI packet traces.",
|
||||
"value": false
|
||||
|
|
|
|||
|
|
@ -22,10 +22,16 @@
|
|||
#include "dm_main.h"
|
||||
#include "dm_conn.h"
|
||||
|
||||
#include "mbed-trace/mbed_trace.h"
|
||||
#include "common/ble_trace_helpers.h"
|
||||
|
||||
#define TRACE_GROUP "BLDM"
|
||||
|
||||
namespace ble {
|
||||
namespace impl {
|
||||
|
||||
namespace {
|
||||
|
||||
bool dummy_gap_event_handler(const wsfMsgHdr_t *msg)
|
||||
{
|
||||
return false;
|
||||
|
|
@ -102,6 +108,10 @@ address_t PalGap::get_random_address()
|
|||
|
||||
ble_error_t PalGap::set_random_address(const address_t &address)
|
||||
{
|
||||
tr_info("Set random address - "
|
||||
"address=%s",
|
||||
to_string(address));
|
||||
|
||||
device_random_address = address;
|
||||
DmDevSetRandAddr(const_cast<uint8_t *>(address.data()));
|
||||
return BLE_ERROR_NONE;
|
||||
|
|
@ -119,6 +129,26 @@ ble_error_t PalGap::set_advertising_parameters(
|
|||
advertising_filter_policy_t advertising_filter_policy
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Set advertising parameters - "
|
||||
"advertising_interval_min=%d, "
|
||||
"advertising_interval_max=%d, "
|
||||
"advertising_type=%s, "
|
||||
"own_address_type=%s, "
|
||||
"peer_address_type=%s, "
|
||||
"peer_address=%s, "
|
||||
"advertising_channel_map=%s, "
|
||||
"advertising_filter_policy_t=%s",
|
||||
advertising_interval_min,
|
||||
advertising_interval_max,
|
||||
to_string(advertising_type),
|
||||
to_string(own_address_type),
|
||||
to_string(peer_address_type),
|
||||
to_string(peer_address),
|
||||
to_string(advertising_channel_map),
|
||||
to_string(advertising_filter_policy));
|
||||
#endif
|
||||
|
||||
DmAdvSetInterval(
|
||||
DM_ADV_HANDLE_DEFAULT,
|
||||
advertising_interval_min,
|
||||
|
|
@ -160,6 +190,14 @@ ble_error_t PalGap::set_advertising_data(
|
|||
const advertising_data_t &advertising_data
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Set advertising data - "
|
||||
"advertising_data_length=%d, "
|
||||
"advertising_data=%s",
|
||||
advertising_data_length,
|
||||
mbed_trace_array(advertising_data.data(), advertising_data_length));
|
||||
#endif
|
||||
|
||||
DmAdvSetData(
|
||||
DM_ADV_HANDLE_DEFAULT,
|
||||
HCI_ADV_DATA_OP_COMP_FRAG,
|
||||
|
|
@ -170,12 +208,19 @@ ble_error_t PalGap::set_advertising_data(
|
|||
return BLE_ERROR_NONE;
|
||||
}
|
||||
|
||||
|
||||
ble_error_t PalGap::set_scan_response_data(
|
||||
uint8_t scan_response_data_length,
|
||||
const advertising_data_t &scan_response_data
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Set scan response data - "
|
||||
"scan_response_data_length=%d, "
|
||||
"scan_response_data=%s",
|
||||
scan_response_data_length,
|
||||
mbed_trace_array(scan_response_data.data(), scan_response_data_length));
|
||||
#endif
|
||||
|
||||
DmAdvSetData(
|
||||
DM_ADV_HANDLE_DEFAULT,
|
||||
HCI_ADV_DATA_OP_COMP_FRAG,
|
||||
|
|
@ -189,6 +234,10 @@ ble_error_t PalGap::set_scan_response_data(
|
|||
|
||||
ble_error_t PalGap::advertising_enable(bool enable)
|
||||
{
|
||||
tr_info("Advertising enable - "
|
||||
"enable=%s",
|
||||
to_string(enable));
|
||||
|
||||
if (enable) {
|
||||
// The Cordio stack requires to start direct advertising with
|
||||
// the function DmConnAccept instead of the function DmAdvStart.
|
||||
|
|
@ -206,6 +255,7 @@ ble_error_t PalGap::advertising_enable(bool enable)
|
|||
direct_adv_cb->peer_address.data()
|
||||
);
|
||||
if (direct_adv_cb->connection_handle == DM_CONN_ID_NONE) {
|
||||
tr_error("unknown ID for pending callback");
|
||||
return BLE_ERROR_INTERNAL_STACK_FAILURE;
|
||||
} else {
|
||||
direct_adv_cb->state = direct_adv_cb_t::running;
|
||||
|
|
@ -247,6 +297,20 @@ ble_error_t PalGap::set_scan_parameters(
|
|||
scanning_filter_policy_t filter_policy
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Set scan parameters - "
|
||||
"active_scanning=%s, "
|
||||
"scan_interval=%d, "
|
||||
"scan_window=%d, "
|
||||
"own_address_type=%s, "
|
||||
"filter_policy=%s",
|
||||
to_string(active_scanning),
|
||||
scan_interval,
|
||||
scan_window,
|
||||
to_string(own_address_type),
|
||||
to_string(filter_policy));
|
||||
#endif
|
||||
|
||||
use_active_scanning = active_scanning;
|
||||
DmScanSetInterval(HCI_INIT_PHY_LE_1M_BIT, &scan_interval, &scan_window);
|
||||
DmScanSetAddrType(own_address_type.value());
|
||||
|
|
@ -265,6 +329,12 @@ ble_error_t PalGap::scan_enable(
|
|||
bool filter_duplicates
|
||||
)
|
||||
{
|
||||
tr_info("Scan enable - "
|
||||
"enable=%s, "
|
||||
"filter_duplicates=%s",
|
||||
to_string(enable),
|
||||
to_string(filter_duplicates));
|
||||
|
||||
if (enable) {
|
||||
uint8_t scanType = use_active_scanning ? DM_SCAN_TYPE_ACTIVE : DM_SCAN_TYPE_PASSIVE;
|
||||
DmScanStart(
|
||||
|
|
@ -298,6 +368,34 @@ ble_error_t PalGap::create_connection(
|
|||
uint16_t maximum_connection_event_length
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Create Connection - "
|
||||
"scan_interval=%d, "
|
||||
"scan_window=%d, "
|
||||
"initiator_policy=%s, "
|
||||
"peer_address_type=%s, "
|
||||
"peer_address=%s, "
|
||||
"own_address_type=%s, "
|
||||
"connection_interval_min=%d, "
|
||||
"connection_interval_max=%d, "
|
||||
"connection_latency=%d, "
|
||||
"supervision_timout=%d, "
|
||||
"minimum_connection_event_length=%d, "
|
||||
"maximum_connection_event_length=%d",
|
||||
scan_interval,
|
||||
scan_window,
|
||||
to_string(initiator_policy),
|
||||
to_string(peer_address_type),
|
||||
to_string(peer_address),
|
||||
to_string(own_address_type),
|
||||
connection_interval_min,
|
||||
connection_interval_max,
|
||||
connection_latency,
|
||||
supervision_timeout,
|
||||
minimum_connection_event_length,
|
||||
maximum_connection_event_length);
|
||||
#endif
|
||||
|
||||
DmConnSetScanInterval(scan_interval, scan_window);
|
||||
#if BLE_FEATURE_WHITELIST
|
||||
DmDevSetFilterPolicy(DM_FILT_POLICY_MODE_INIT, initiator_policy.value());
|
||||
|
|
@ -322,6 +420,7 @@ ble_error_t PalGap::create_connection(
|
|||
);
|
||||
|
||||
if (connection_id == DM_CONN_ID_NONE) {
|
||||
tr_error("unknown ID for open connection");
|
||||
return BLE_ERROR_INTERNAL_STACK_FAILURE;
|
||||
}
|
||||
|
||||
|
|
@ -368,6 +467,12 @@ ble_error_t PalGap::add_device_to_whitelist(
|
|||
address_t address
|
||||
)
|
||||
{
|
||||
tr_info("Add device to whitelist - "
|
||||
"address_type=%s,"
|
||||
"address=%s",
|
||||
to_string(address_type),
|
||||
to_string(address));
|
||||
|
||||
DmDevWhiteListAdd(
|
||||
address_type.value(),
|
||||
const_cast<uint8_t *>(address.data())
|
||||
|
|
@ -381,6 +486,12 @@ ble_error_t PalGap::remove_device_from_whitelist(
|
|||
address_t address
|
||||
)
|
||||
{
|
||||
tr_info("Remove device from whitelist - "
|
||||
"address_type=%s, "
|
||||
"address=%s",
|
||||
to_string(address_type),
|
||||
to_string(address));
|
||||
|
||||
DmDevWhiteListRemove(
|
||||
address_type.value(),
|
||||
const_cast<uint8_t *>(address.data())
|
||||
|
|
@ -400,7 +511,25 @@ ble_error_t PalGap::connection_parameters_update(
|
|||
uint16_t maximum_connection_event_length
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Connection %d: connection parameters update - "
|
||||
"connection_interval_min=%d, "
|
||||
"connection_interval_max=%d, "
|
||||
"connection_latency=%d, "
|
||||
"supervision_timeout=%d, "
|
||||
"minimum_connection_event_length=%d, "
|
||||
"maximum_connection_event_length=%d",
|
||||
connection,
|
||||
connection_interval_min,
|
||||
connection_interval_max,
|
||||
connection_latency,
|
||||
supervision_timeout,
|
||||
minimum_connection_event_length,
|
||||
maximum_connection_event_length);
|
||||
#endif
|
||||
|
||||
if (DmConnCheckIdle(connection) != 0) {
|
||||
tr_error("connection busy");
|
||||
return BLE_ERROR_INVALID_STATE;
|
||||
}
|
||||
|
||||
|
|
@ -431,6 +560,21 @@ ble_error_t PalGap::accept_connection_parameter_request(
|
|||
uint16_t maximum_connection_event_length
|
||||
)
|
||||
{
|
||||
tr_info("Connection %d: accept connection parameter request - "
|
||||
"interval_min=%d, "
|
||||
"interval_max=%d, "
|
||||
"latency=%d, "
|
||||
"supervision_timeout=%d, "
|
||||
"minimum_connection_event_length=%d, "
|
||||
"maximum_connection_event_length=%d",
|
||||
connection_handle,
|
||||
interval_min,
|
||||
interval_max,
|
||||
latency,
|
||||
supervision_timeout,
|
||||
minimum_connection_event_length,
|
||||
maximum_connection_event_length);
|
||||
|
||||
hciConnSpec_t connection_spec = {
|
||||
interval_min,
|
||||
interval_max,
|
||||
|
|
@ -449,6 +593,11 @@ ble_error_t PalGap::reject_connection_parameter_request(
|
|||
hci_error_code_t rejection_reason
|
||||
)
|
||||
{
|
||||
tr_info("Connection %d: reject_connection_parameter_request - "
|
||||
"rejection_reason=%s",
|
||||
connection_handle,
|
||||
to_string(rejection_reason));
|
||||
|
||||
DmRemoteConnParamReqNegReply(
|
||||
connection_handle,
|
||||
rejection_reason.value()
|
||||
|
|
@ -462,6 +611,13 @@ ble_error_t PalGap::disconnect(
|
|||
local_disconnection_reason_t disconnection_reason
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Connection %d: disconnect - "
|
||||
"disconnection_reason=%s",
|
||||
connection,
|
||||
to_string(disconnection_reason));
|
||||
#endif
|
||||
|
||||
DmConnClose(
|
||||
DM_CLIENT_ID_APP,
|
||||
connection,
|
||||
|
|
@ -475,11 +631,13 @@ ble_error_t PalGap::disconnect(
|
|||
#if BLE_FEATURE_PHY_MANAGEMENT
|
||||
ble_error_t PalGap::read_phy(connection_handle_t connection)
|
||||
{
|
||||
tr_info("Connection %d: read phy", connection);
|
||||
if (is_feature_supported(controller_supported_features_t::LE_2M_PHY)
|
||||
|| is_feature_supported(controller_supported_features_t::LE_CODED_PHY)) {
|
||||
DmReadPhy(connection);
|
||||
return BLE_ERROR_NONE;
|
||||
}
|
||||
tr_error("Only 1M PHY supported");
|
||||
return BLE_ERROR_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
|
|
@ -488,6 +646,14 @@ ble_error_t PalGap::set_preferred_phys(
|
|||
const phy_set_t &rx_phys
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Set preferred phys -"
|
||||
"tx_phys=%s, "
|
||||
"rx_phys=%s",
|
||||
to_string(tx_phys),
|
||||
to_string(rx_phys));
|
||||
#endif
|
||||
|
||||
DmSetDefaultPhy(
|
||||
create_all_phys_value(tx_phys, rx_phys),
|
||||
tx_phys.value(),
|
||||
|
|
@ -505,6 +671,17 @@ ble_error_t PalGap::set_phy(
|
|||
coded_symbol_per_bit_t coded_symbol
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Connection %d: set phy - "
|
||||
"tx_phys=%s, "
|
||||
"rx_phys=%s, "
|
||||
"coded_symbol=%s",
|
||||
connection,
|
||||
to_string(tx_phys),
|
||||
to_string(rx_phys),
|
||||
to_string(coded_symbol));
|
||||
#endif
|
||||
|
||||
/* if phy set is empty set corresponding all_phys bit to 1 */
|
||||
uint8_t all_phys = 0;
|
||||
if (tx_phys.value() == 0) {
|
||||
|
|
@ -869,6 +1046,11 @@ ble_error_t PalGap::set_advertising_set_random_address(
|
|||
const address_t &address
|
||||
)
|
||||
{
|
||||
tr_info("Advertising set %d: set random address - "
|
||||
"address=%s",
|
||||
advertising_handle,
|
||||
to_string(address));
|
||||
|
||||
DmAdvSetRandAddr(advertising_handle, address.data());
|
||||
return BLE_ERROR_NONE;
|
||||
}
|
||||
|
|
@ -891,15 +1073,57 @@ ble_error_t PalGap::set_extended_advertising_parameters(
|
|||
bool scan_request_notification
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Advertising set %d: set extended advertising parameters - "
|
||||
"event_properties:[%s%s%s%s%s%s%s ], "
|
||||
"primary_advertising_interval_min=%" PRIu32 ", "
|
||||
"primary_advertising_interval_max=%" PRIu32 ", "
|
||||
"primary_advertising_channel_map=%s, "
|
||||
"own_address_type=%s, "
|
||||
"peer_address_type=%s, "
|
||||
"peer_address=%s, "
|
||||
"advertising_filter_policy=%s, "
|
||||
"advertising_power=%d, "
|
||||
"primary_advertising_phy=%s, "
|
||||
"secondary_advertising_max_skip=%d, "
|
||||
"secondary_phy=%s, "
|
||||
"advertising_sid=%d, "
|
||||
"scan_request_notification=%s",
|
||||
advertising_handle,
|
||||
event_properties.connectable ? " connectable" : "",
|
||||
event_properties.scannable ? " scannable" : "",
|
||||
event_properties.directed ? " directed" : "",
|
||||
event_properties.high_duty_cycle ? " high_duty_cycle" : "",
|
||||
event_properties.use_legacy_pdu ? " use_legacy_pdu" : "",
|
||||
event_properties.omit_advertiser_address ? " omit_advertiser_address," : "",
|
||||
event_properties.include_tx_power ? " nclude_tx_power" : "",
|
||||
primary_advertising_interval_min,
|
||||
primary_advertising_interval_max,
|
||||
to_string(primary_advertising_channel_map),
|
||||
to_string(own_address_type),
|
||||
to_string(peer_address_type),
|
||||
to_string(peer_address),
|
||||
to_string(advertising_filter_policy),
|
||||
advertising_power,
|
||||
to_string(primary_advertising_phy),
|
||||
secondary_advertising_max_skip,
|
||||
to_string(secondary_phy),
|
||||
advertising_sid,
|
||||
to_string(scan_request_notification));
|
||||
#endif
|
||||
|
||||
uint8_t adv_type;
|
||||
|
||||
if (event_properties.use_legacy_pdu) {
|
||||
if (event_properties.directed == false) {
|
||||
tr_info("Legacy PDU w/undirected advertising event");
|
||||
if (event_properties.high_duty_cycle) {
|
||||
tr_error("cannot use high duty cycle");
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
if (event_properties.connectable && event_properties.scannable == false) {
|
||||
tr_error("must be scannable if connectable");
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
|
|
@ -911,11 +1135,14 @@ ble_error_t PalGap::set_extended_advertising_parameters(
|
|||
adv_type = DM_ADV_NONCONN_UNDIRECT;
|
||||
}
|
||||
} else {
|
||||
tr_info("Legacy PDU w/directed advertising event");
|
||||
if (event_properties.scannable) {
|
||||
tr_error("cannot be scannable");
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
if (event_properties.connectable == false) {
|
||||
tr_error("must be connectable");
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
|
|
@ -927,7 +1154,9 @@ ble_error_t PalGap::set_extended_advertising_parameters(
|
|||
}
|
||||
} else {
|
||||
if (event_properties.directed == false) {
|
||||
tr_info("Extended PDU w/undirected advertising event");
|
||||
if (event_properties.high_duty_cycle) {
|
||||
tr_error("cannot use high duty cycle");
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
|
|
@ -946,6 +1175,7 @@ ble_error_t PalGap::set_extended_advertising_parameters(
|
|||
// standpoint
|
||||
|
||||
if (event_properties.connectable && event_properties.scannable) {
|
||||
tr_error("cannot be scannable if connectable");
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
} else if (event_properties.connectable) {
|
||||
if (event_properties.high_duty_cycle) {
|
||||
|
|
@ -1022,6 +1252,17 @@ ble_error_t PalGap::set_periodic_advertising_parameters(
|
|||
bool advertise_power
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Advertising set %d: set periodic advertising parameters - "
|
||||
"periodic_advertising_min=%s, "
|
||||
"periodic_advertising_max=%s, "
|
||||
"advertise_power=%s",
|
||||
advertising_handle,
|
||||
to_string(periodic_advertising_min),
|
||||
to_string(periodic_advertising_max),
|
||||
to_string(advertise_power));
|
||||
#endif
|
||||
|
||||
DmPerAdvIncTxPwr(advertising_handle, advertise_power);
|
||||
DmPerAdvSetInterval(
|
||||
advertising_handle,
|
||||
|
|
@ -1043,6 +1284,19 @@ ble_error_t PalGap::set_extended_advertising_data(
|
|||
const uint8_t *advertising_data
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Advertising set %d: set extended advertising data - "
|
||||
"operation=%s, "
|
||||
"minimize_fragmentation=%s, "
|
||||
"advertising_data_size=%d, "
|
||||
"advertising_data=%s",
|
||||
advertising_handle,
|
||||
to_string(operation),
|
||||
to_string(minimize_fragmentation),
|
||||
advertising_data_size,
|
||||
mbed_trace_array(advertising_data, advertising_data_size));
|
||||
#endif
|
||||
|
||||
uint8_t frag_pref = minimize_fragmentation ?
|
||||
HCI_ADV_DATA_FRAG_PREF_NO_FRAG :
|
||||
HCI_ADV_DATA_FRAG_PREF_FRAG;
|
||||
|
|
@ -1068,6 +1322,17 @@ ble_error_t PalGap::set_periodic_advertising_data(
|
|||
const uint8_t *advertising_data
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Advertising set %d: set periodic advertising data - "
|
||||
"fragment_description=%s, "
|
||||
"advertising_data_size=%d, "
|
||||
"advertising_data=%s",
|
||||
advertising_handle,
|
||||
to_string(fragment_description),
|
||||
advertising_data_size,
|
||||
mbed_trace_array(advertising_data, advertising_data_size));
|
||||
#endif
|
||||
|
||||
DmPerAdvSetData(
|
||||
advertising_handle,
|
||||
fragment_description.value(),
|
||||
|
|
@ -1087,6 +1352,19 @@ ble_error_t PalGap::set_extended_scan_response_data(
|
|||
const uint8_t *scan_response_data
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Advertising data %d: set extended scan response data - "
|
||||
"operation=%s, "
|
||||
"minimize_fragmentation=%s, "
|
||||
"scan_response_data_size=%d, "
|
||||
"scan_response_data=%s",
|
||||
advertising_handle,
|
||||
to_string(operation),
|
||||
to_string(minimize_fragmentation),
|
||||
scan_response_data_size,
|
||||
mbed_trace_array(scan_response_data, scan_response_data_size));
|
||||
#endif
|
||||
|
||||
uint8_t frag_pref = minimize_fragmentation ?
|
||||
HCI_ADV_DATA_FRAG_PREF_NO_FRAG :
|
||||
HCI_ADV_DATA_FRAG_PREF_FRAG;
|
||||
|
|
@ -1112,7 +1390,14 @@ ble_error_t PalGap::extended_advertising_enable(
|
|||
const uint8_t *in_max_extended_advertising_events
|
||||
)
|
||||
{
|
||||
tr_info("Extended advertising enable - "
|
||||
"enable=%s, "
|
||||
"number_of_sets=%d",
|
||||
to_string(enable),
|
||||
number_of_sets);
|
||||
|
||||
if (number_of_sets > DM_NUM_ADV_SETS) {
|
||||
tr_error("number of sets cannot be greater than %d", DM_NUM_ADV_SETS);
|
||||
return BLE_ERROR_INVALID_PARAM;
|
||||
}
|
||||
|
||||
|
|
@ -1143,6 +1428,7 @@ ble_error_t PalGap::extended_advertising_enable(
|
|||
direct_adv_cb->peer_address.data()
|
||||
);
|
||||
if (direct_adv_cb->connection_handle == DM_CONN_ID_NONE) {
|
||||
tr_error("unknown connection ID %d", direct_adv_cb->connection_handle);
|
||||
return BLE_ERROR_INTERNAL_STACK_FAILURE;
|
||||
} else {
|
||||
direct_adv_cb->state = direct_adv_cb_t::running;
|
||||
|
|
@ -1201,6 +1487,11 @@ ble_error_t PalGap::periodic_advertising_enable(
|
|||
advertising_handle_t advertising_handle
|
||||
)
|
||||
{
|
||||
tr_info("Advertising set %d: periodic advertsing enable - "
|
||||
"enable=%s",
|
||||
advertising_handle,
|
||||
to_string(enable));
|
||||
|
||||
if (enable) {
|
||||
DmPerAdvStart(advertising_handle);
|
||||
} else {
|
||||
|
|
@ -1265,6 +1556,16 @@ ble_error_t PalGap::set_extended_scan_parameters(
|
|||
const uint16_t *scan_window
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Set extended scan parameters - "
|
||||
"own_address_type=%s, "
|
||||
"filter_policy=%s, "
|
||||
"scanning_phys=%s",
|
||||
to_string(own_address_type),
|
||||
to_string(filter_policy),
|
||||
to_string(scanning_phys));
|
||||
#endif
|
||||
|
||||
DmScanSetAddrType(own_address_type.value());
|
||||
|
||||
for (size_t i = 0, count = scanning_phys.count(); i < count; ++i) {
|
||||
|
|
@ -1299,6 +1600,16 @@ ble_error_t PalGap::extended_scan_enable(
|
|||
uint16_t period
|
||||
)
|
||||
{
|
||||
tr_info("Extended scan enable - "
|
||||
"enable=%s, "
|
||||
"filter_duplicates=%s, "
|
||||
"duration=%d, "
|
||||
"period=%d",
|
||||
to_string(enable),
|
||||
to_string(filter_duplicates),
|
||||
duration,
|
||||
period);
|
||||
|
||||
if (enable) {
|
||||
uint32_t duration_ms = duration * 10;
|
||||
|
||||
|
|
@ -1330,6 +1641,20 @@ ble_error_t PalGap::periodic_advertising_create_sync(
|
|||
uint16_t sync_timeout
|
||||
)
|
||||
{
|
||||
tr_info("Periodic advertising create sync - "
|
||||
"use_periodic_advertiser_list=%s, "
|
||||
"advertising_sid=%d, "
|
||||
"peer_address_type=%s, "
|
||||
"peer_address=%s, "
|
||||
"allowed_skip=%d, "
|
||||
"sync_timeout=%d",
|
||||
to_string(use_periodic_advertiser_list),
|
||||
advertising_sid,
|
||||
to_string(peer_address_type),
|
||||
to_string(peer_address),
|
||||
allowed_skip,
|
||||
sync_timeout);
|
||||
|
||||
DmDevSetExtFilterPolicy(
|
||||
DM_ADV_HANDLE_DEFAULT,
|
||||
DM_FILT_POLICY_MODE_SYNC,
|
||||
|
|
@ -1345,6 +1670,7 @@ ble_error_t PalGap::periodic_advertising_create_sync(
|
|||
);
|
||||
|
||||
if (sync_id == DM_SYNC_ID_NONE) {
|
||||
tr_error("unknown sync ID %d", sync_id);
|
||||
return BLE_ERROR_INTERNAL_STACK_FAILURE;
|
||||
} else {
|
||||
/* this is not the real handle, this is CORDIO internal handle but the user doesn't need to know that */
|
||||
|
|
@ -1375,6 +1701,16 @@ ble_error_t PalGap::add_device_to_periodic_advertiser_list(
|
|||
uint8_t advertising_sid
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Add device to periodic advertiser list - "
|
||||
"advertiser_address_type=%s, "
|
||||
"advertiser_address=%s, "
|
||||
"advertiser_sid=%d",
|
||||
to_string(advertiser_address_type),
|
||||
to_string(advertiser_address),
|
||||
advertising_sid);
|
||||
#endif
|
||||
|
||||
DmAddDeviceToPerAdvList(
|
||||
advertiser_address_type.value(),
|
||||
const_cast<uint8_t *>(advertiser_address.data()),
|
||||
|
|
@ -1390,6 +1726,16 @@ ble_error_t PalGap::remove_device_from_periodic_advertiser_list(
|
|||
uint8_t advertising_sid
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Remove device from periodic advertiser list - "
|
||||
"advertiser_address_type=%s, "
|
||||
"advertiser_address=%s, "
|
||||
"advertiser_sid=%d",
|
||||
to_string(advertiser_address_type),
|
||||
to_string(advertiser_address),
|
||||
advertising_sid);
|
||||
#endif
|
||||
|
||||
DmRemoveDeviceFromPerAdvList(
|
||||
advertiser_address_type.value(),
|
||||
const_cast<uint8_t *>(advertiser_address.data()),
|
||||
|
|
@ -1430,6 +1776,20 @@ ble_error_t PalGap::extended_create_connection(
|
|||
const uint16_t *maximum_connection_event_lengths
|
||||
)
|
||||
{
|
||||
#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
|
||||
tr_info("Extended create connection - "
|
||||
"initiator_policy=%s, "
|
||||
"own_address_type=%s, "
|
||||
"peer_address_type=%s, "
|
||||
"peer_address=%s, "
|
||||
"initiating_phys=%s",
|
||||
to_string(initiator_policy),
|
||||
to_string(own_address_type),
|
||||
to_string(peer_address_type),
|
||||
to_string(peer_address),
|
||||
to_string(initiating_phys));
|
||||
#endif
|
||||
|
||||
DmExtConnSetScanInterval(
|
||||
initiating_phys.value(),
|
||||
const_cast<uint16_t *>(scan_intervals),
|
||||
|
|
@ -1476,10 +1836,20 @@ ble_error_t PalGap::update_direct_advertising_parameters(
|
|||
advertising_peer_address_type_t peer_address_type
|
||||
)
|
||||
{
|
||||
tr_info("Advertising set %d: update direct advertising parameters - "
|
||||
"advertising_type=%d, "
|
||||
"peer_address=%s, "
|
||||
"peer_address_type=%s",
|
||||
advertising_handle,
|
||||
advertising_type,
|
||||
to_string(peer_address),
|
||||
to_string(peer_address_type));
|
||||
|
||||
// The case where a direct advertising is running and parameters are updated
|
||||
// is considered to be a programming error. User should stop advertising first.
|
||||
direct_adv_cb_t *running = get_running_direct_adv_cb(advertising_handle);
|
||||
if (running) {
|
||||
tr_error("trying to update parameters but direct advertising is running");
|
||||
return BLE_ERROR_INVALID_STATE;
|
||||
}
|
||||
|
||||
|
|
@ -1506,6 +1876,7 @@ ble_error_t PalGap::update_direct_advertising_parameters(
|
|||
advertising_type == DM_ADV_CONN_DIRECT_LO_DUTY) {
|
||||
direct_adv_cb_t *adv_cb = get_free_direct_adv_cb();
|
||||
if (!adv_cb) {
|
||||
tr_error("failed to acquire a cb");
|
||||
return BLE_ERROR_INTERNAL_STACK_FAILURE;
|
||||
}
|
||||
adv_cb->state = direct_adv_cb_t::pending;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue