h2zero/esp-nimble-cpp
1
0
Fork 1
mirror of https://github.com/h2zero/esp-nimble-cpp.git synced 2025-09-25 05:21:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

Convert NIMBLE_CPP macros to MYNEWT.

Browse Source
This commit is contained in:
h2zero
2025-09-06 12:13:39 -06:00
committed by Ryan Powell
parent 8f9e85a46a
commit 6f0b9ddf5d
11 changed files with 123 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/NimBLEAddress.cpp
View File

@@ -22,13 +22,29 @@
# include <algorithm> # include <algorithm>
# ifdef CONFIG_NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER # ifndef MYNEWT_VAL_NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER
# ifndef CONFIG_NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER
# define MYNEWT_VAL_NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER (0)
# else
# define MYNEWT_VAL_NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER CONFIG_NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER
# endif
# endif
# ifndef MYNEWT_VAL_NIMBLE_CPP_ADDR_FMT_UPPERCASE
# ifndef CONFIG_NIMBLE_CPP_ADDR_FMT_UPPERCASE
# define MYNEWT_VAL_NIMBLE_CPP_ADDR_FMT_UPPERCASE (1)
# else
# define MYNEWT_VAL_NIMBLE_CPP_ADDR_FMT_UPPERCASE CONFIG_NIMBLE_CPP_ADDR_FMT_UPPERCASE
# endif
# endif
# if MYNEWT_VAL(NIMBLE_CPP_ADDR_FMT_EXCLUDE_DELIMITER)
# define NIMBLE_CPP_ADDR_DELIMITER "" # define NIMBLE_CPP_ADDR_DELIMITER ""
# else # else
# define NIMBLE_CPP_ADDR_DELIMITER ":" # define NIMBLE_CPP_ADDR_DELIMITER ":"
# endif # endif
# ifdef CONFIG_NIMBLE_CPP_ADDR_FMT_UPPERCASE # if MYNEWT_VAL(NIMBLE_CPP_ADDR_FMT_UPPERCASE)
# define NIMBLE_CPP_ADDR_FMT "%02X%s%02X%s%02X%s%02X%s%02X%s%02X" # define NIMBLE_CPP_ADDR_FMT "%02X%s%02X%s%02X%s%02X%s%02X%s%02X"
# else # else
# define NIMBLE_CPP_ADDR_FMT "%02x%s%02x%s%02x%s%02x%s%02x%s%02x" # define NIMBLE_CPP_ADDR_FMT "%02x%s%02x%s%02x%s%02x%s%02x%s%02x"

4
src/NimBLEAttValue.cpp
View File

@@ -35,7 +35,7 @@ NimBLEAttValue::NimBLEAttValue(uint16_t init_len, uint16_t max_len)
m_attr_max_len{std::min<uint16_t>(BLE_ATT_ATTR_MAX_LEN, max_len)}, m_attr_max_len{std::min<uint16_t>(BLE_ATT_ATTR_MAX_LEN, max_len)},
m_attr_len{}, m_attr_len{},
m_capacity{init_len} m_capacity{init_len}
# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
, ,
m_timestamp{} m_timestamp{}
# endif # endif
@@ -134,7 +134,7 @@ NimBLEAttValue& NimBLEAttValue::append(const uint8_t* value, uint16_t len) {
return *this; return *this;
} }
# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
time_t t = time(nullptr); time_t t = time(nullptr);
# else # else
time_t t = 0; time_t t = 0;

34
src/NimBLEAttValue.h
View File

@@ -31,20 +31,30 @@
# include <cstring> # include <cstring>
# include <cstdint> # include <cstdint>
# ifndef MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
# ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
# define CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED 0 # define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED 0
# else
# define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
# endif
# endif # endif
# ifndef BLE_ATT_ATTR_MAX_LEN # ifndef BLE_ATT_ATTR_MAX_LEN
# define BLE_ATT_ATTR_MAX_LEN 512 # define BLE_ATT_ATTR_MAX_LEN 512
# endif # endif
# if !defined(CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) # ifndef MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
# define CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20 # ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
# elif CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH > BLE_ATT_ATTR_MAX_LEN # define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20
# error CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be larger than 512 (BLE_ATT_ATTR_MAX_LEN) # else
# elif CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH < 1 # define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
# error CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be less than 1; Range = 1 : 512 # endif
# endif
# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) > BLE_ATT_ATTR_MAX_LEN
# error NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be larger than 512 (BLE_ATT_ATTR_MAX_LEN)
# elif MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) < 1
# error NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be less than 1; Range = 1 : 512
# endif # endif
/* Used to determine if the type passed to a template has a data() and size() method. */ /* Used to determine if the type passed to a template has a data() and size() method. */
@@ -74,7 +84,7 @@ class NimBLEAttValue {
uint16_t m_attr_max_len{}; uint16_t m_attr_max_len{};
uint16_t m_attr_len{}; uint16_t m_attr_len{};
uint16_t m_capacity{}; uint16_t m_capacity{};
# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
time_t m_timestamp{}; time_t m_timestamp{};
# endif # endif
void deepCopy(const NimBLEAttValue& source); void deepCopy(const NimBLEAttValue& source);
@@ -85,7 +95,7 @@ class NimBLEAttValue {
* @param[in] init_len The initial size in bytes. * @param[in] init_len The initial size in bytes.
* @param[in] max_len The max size in bytes that the value can be. * @param[in] max_len The max size in bytes that the value can be.
*/ */
NimBLEAttValue(uint16_t init_len = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN); NimBLEAttValue(uint16_t init_len = MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH), uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
/** /**
* @brief Construct with an initial value from a buffer. * @brief Construct with an initial value from a buffer.
@@ -170,7 +180,7 @@ class NimBLEAttValue {
/** @brief Iterator end */ /** @brief Iterator end */
const uint8_t* end() const { return m_attr_value + m_attr_len; } const uint8_t* end() const { return m_attr_value + m_attr_len; }
# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
/** @brief Returns a timestamp of when the value was last updated */ /** @brief Returns a timestamp of when the value was last updated */
time_t getTimeStamp() const { return m_timestamp; } time_t getTimeStamp() const { return m_timestamp; }
@@ -210,7 +220,7 @@ class NimBLEAttValue {
const NimBLEAttValue& getValue(time_t* timestamp = nullptr) const { const NimBLEAttValue& getValue(time_t* timestamp = nullptr) const {
if (timestamp != nullptr) { if (timestamp != nullptr) {
# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
*timestamp = m_timestamp; *timestamp = m_timestamp;
# else # else
*timestamp = 0; *timestamp = 0;
@@ -307,7 +317,7 @@ class NimBLEAttValue {
template <typename T> template <typename T>
T getValue(time_t* timestamp = nullptr, bool skipSizeCheck = false) const { T getValue(time_t* timestamp = nullptr, bool skipSizeCheck = false) const {
if (timestamp != nullptr) { if (timestamp != nullptr) {
# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED # if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
*timestamp = m_timestamp; *timestamp = m_timestamp;
# else # else
*timestamp = 0; *timestamp = 0;

4
src/NimBLEDevice.cpp
View File

@@ -1325,7 +1325,7 @@ std::string NimBLEDevice::toString() {
return getAddress().toString(); return getAddress().toString();
} // toString } // toString
# if CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED || __DOXYGEN__ # if MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED) || __DOXYGEN__
/** /**
* @brief Debug assert - weak function. * @brief Debug assert - weak function.
* @param [in] file The file where the assert occurred. * @param [in] file The file where the assert occurred.
@@ -1336,7 +1336,7 @@ void nimble_cpp_assert(const char* file, unsigned line) {
ble_npl_time_delay(10); ble_npl_time_delay(10);
abort(); abort();
} }
# endif // CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED # endif // MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED)
void NimBLEDevice::setDeviceCallbacks(NimBLEDeviceCallbacks* cb) { void NimBLEDevice::setDeviceCallbacks(NimBLEDeviceCallbacks* cb) {
m_pDeviceCallbacks = cb ? cb : &defaultDeviceCallbacks; m_pDeviceCallbacks = cb ? cb : &defaultDeviceCallbacks;

2
src/NimBLELocalValueAttribute.h
View File

@@ -101,7 +101,7 @@ class NimBLELocalValueAttribute : public NimBLELocalAttribute, public NimBLEValu
NimBLELocalValueAttribute(const NimBLEUUID& uuid, NimBLELocalValueAttribute(const NimBLEUUID& uuid,
uint16_t handle, uint16_t handle,
uint16_t maxLen, uint16_t maxLen,
uint16_t initLen = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) uint16_t initLen = MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH))
: NimBLELocalAttribute(uuid, handle), NimBLEValueAttribute(maxLen, initLen) {} : NimBLELocalAttribute(uuid, handle), NimBLEValueAttribute(maxLen, initLen) {}
/** /**
* @brief Destroy the NimBLELocalValueAttribute object. * @brief Destroy the NimBLELocalValueAttribute object.

35
src/NimBLELog.h
View File

@@ -21,12 +21,21 @@
#include "syscfg/syscfg.h" #include "syscfg/syscfg.h"
#if CONFIG_BT_NIMBLE_ENABLED #if CONFIG_BT_NIMBLE_ENABLED
# ifndef MYNEWT_VAL_NIMBLE_CPP_LOG_LEVEL
# ifndef CONFIG_NIMBLE_CPP_LOG_LEVEL
# if defined(ARDUINO_ARCH_ESP32) && defined(CORE_DEBUG_LEVEL)
# define MYNEWT_VAL_NIMBLE_CPP_LOG_LEVEL CORE_DEBUG_LEVEL
# else
# define MYNEWT_VAL_NIMBLE_CPP_LOG_LEVEL 0
# endif
# else
# define MYNEWT_VAL_NIMBLE_CPP_LOG_LEVEL CONFIG_NIMBLE_CPP_LOG_LEVEL
# endif
# endif
# if defined(CONFIG_NIMBLE_CPP_IDF) # if defined(CONFIG_NIMBLE_CPP_IDF)
# include "esp_log.h" # include "esp_log.h"
# include "console/console.h" # include "console/console.h"
# ifndef CONFIG_NIMBLE_CPP_LOG_LEVEL
# define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
# endif
# if defined(CONFIG_NIMBLE_CPP_LOG_OVERRIDE_COLOR) # if defined(CONFIG_NIMBLE_CPP_LOG_OVERRIDE_COLOR)
# if CONFIG_LOG_COLORS # if CONFIG_LOG_COLORS
@@ -120,13 +129,13 @@
# define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) \ # define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) \
do { \ do { \
if (CONFIG_NIMBLE_CPP_LOG_LEVEL >= level) NIMBLE_CPP_LOG_LEVEL_LOCAL(level, tag, format, ##__VA_ARGS__); \ if (MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= level) NIMBLE_CPP_LOG_LEVEL_LOCAL(level, tag, format, ##__VA_ARGS__); \
} while (0) } while (0)
# else # else
# define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) \ # define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) \
do { \ do { \
if (CONFIG_NIMBLE_CPP_LOG_LEVEL >= level) ESP_LOG_LEVEL_LOCAL(level, tag, format, ##__VA_ARGS__); \ if (MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= level) ESP_LOG_LEVEL_LOCAL(level, tag, format, ##__VA_ARGS__); \
} while (0) } while (0)
# endif /* CONFIG_NIMBLE_CPP_LOG_OVERRIDE_COLOR */ # endif /* CONFIG_NIMBLE_CPP_LOG_OVERRIDE_COLOR */
@@ -137,35 +146,27 @@
# define NIMBLE_LOGE(tag, format, ...) NIMBLE_CPP_LOG_PRINT(ESP_LOG_ERROR, tag, format, ##__VA_ARGS__) # define NIMBLE_LOGE(tag, format, ...) NIMBLE_CPP_LOG_PRINT(ESP_LOG_ERROR, tag, format, ##__VA_ARGS__)
# else # else
# include "syscfg/syscfg.h"
# include "nimble/console/console.h" # include "nimble/console/console.h"
# ifndef CONFIG_NIMBLE_CPP_LOG_LEVEL
# if defined(ARDUINO_ARCH_ESP32) && defined(CORE_DEBUG_LEVEL)
# define CONFIG_NIMBLE_CPP_LOG_LEVEL CORE_DEBUG_LEVEL
# else
# define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
# endif
# endif
# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 4
# define NIMBLE_LOGD(tag, format, ...) console_printf("D %s: " format "\n", tag, ##__VA_ARGS__) # define NIMBLE_LOGD(tag, format, ...) console_printf("D %s: " format "\n", tag, ##__VA_ARGS__)
# else # else
# define NIMBLE_LOGD(tag, format, ...) (void)tag # define NIMBLE_LOGD(tag, format, ...) (void)tag
# endif # endif
# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 3 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 3
# define NIMBLE_LOGI(tag, format, ...) console_printf("I %s: " format "\n", tag, ##__VA_ARGS__) # define NIMBLE_LOGI(tag, format, ...) console_printf("I %s: " format "\n", tag, ##__VA_ARGS__)
# else # else
# define NIMBLE_LOGI(tag, format, ...) (void)tag # define NIMBLE_LOGI(tag, format, ...) (void)tag
# endif # endif
# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 2 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 2
# define NIMBLE_LOGW(tag, format, ...) console_printf("W %s: " format "\n", tag, ##__VA_ARGS__) # define NIMBLE_LOGW(tag, format, ...) console_printf("W %s: " format "\n", tag, ##__VA_ARGS__)
# else # else
# define NIMBLE_LOGW(tag, format, ...) (void)tag # define NIMBLE_LOGW(tag, format, ...) (void)tag
# endif # endif
# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 1 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 1
# define NIMBLE_LOGE(tag, format, ...) console_printf("E %s: " format "\n", tag, ##__VA_ARGS__) # define NIMBLE_LOGE(tag, format, ...) console_printf("E %s: " format "\n", tag, ##__VA_ARGS__)
# else # else
# define NIMBLE_LOGE(tag, format, ...) (void)tag # define NIMBLE_LOGE(tag, format, ...) (void)tag

4
src/NimBLEScan.cpp
View File

@@ -126,7 +126,7 @@ int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
} }
} }
#if MYNEWT_VAL(BLE_EXT_ADV) # if MYNEWT_VAL(BLE_EXT_ADV)
if (advertisedDevice->getDataStatus() == BLE_GAP_EXT_ADV_DATA_STATUS_INCOMPLETE) { if (advertisedDevice->getDataStatus() == BLE_GAP_EXT_ADV_DATA_STATUS_INCOMPLETE) {
NIMBLE_LOGD(LOG_TAG, "EXT ADV data incomplete, waiting for more"); NIMBLE_LOGD(LOG_TAG, "EXT ADV data incomplete, waiting for more");
return 0; return 0;
@@ -498,7 +498,7 @@ void NimBLEScan::clearResults() {
* @brief Dump the scan results to the log. * @brief Dump the scan results to the log.
*/ */
void NimBLEScanResults::dump() const { void NimBLEScanResults::dump() const {
# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 3 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 3
for (const auto& dev : m_deviceVec) { for (const auto& dev : m_deviceVec) {
NIMBLE_LOGI(LOG_TAG, "- %s", dev->toString().c_str()); NIMBLE_LOGI(LOG_TAG, "- %s", dev->toString().c_str());
} }

2
src/NimBLEServer.cpp
View File

@@ -189,7 +189,7 @@ void NimBLEServer::start() {
return; return;
} }
# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4 # if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 4
ble_gatts_show_local(); ble_gatts_show_local();
# endif # endif

62
src/NimBLEUtils.cpp
View File

@@ -35,13 +35,41 @@
# include <stdlib.h> # include <stdlib.h>
# include <climits> # include <climits>
# if defined INC_FREERTOS_H # ifndef MYNEWT_VAL_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
# ifndef CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT # ifdef CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
# define CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT 31 # define MYNEWT_VAL_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
# else
# define MYNEWT_VAL_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT (0)
# endif # endif
constexpr uint32_t TASK_BLOCK_BIT = (1 << CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT);
# endif # endif
# ifndef MYNEWT_VAL_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
# ifdef CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
# define MYNEWT_VAL_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
# else
# define MYNEWT_VAL_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT (0)
# endif
# endif
# ifndef MYNEWT_VAL_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT
# ifdef CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT
# define MYNEWT_VAL_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT
# else
# define MYNEWT_VAL_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT (0)
# endif
# endif
# if defined INC_FREERTOS_H
# ifndef MYNEWT_VAL_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT
# ifndef CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT
# define MYNEWT_VAL_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT 31
# else
# define MYNEWT_VAL_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT
# endif
# endif
# endif
constexpr uint32_t TASK_BLOCK_BIT = (1 << MYNEWT_VAL(NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT));
static const char* LOG_TAG = "NimBLEUtils"; static const char* LOG_TAG = "NimBLEUtils";
/** /**
@@ -54,7 +82,7 @@ NimBLETaskData::NimBLETaskData(void* pInstance, int flags, void* buf)
: m_pInstance{pInstance}, : m_pInstance{pInstance},
m_flags{flags}, m_flags{flags},
m_pBuf{buf} m_pBuf{buf}
# if defined INC_FREERTOS_H # ifdef INC_FREERTOS_H
, ,
m_pHandle{xTaskGetCurrentTaskHandle()} { m_pHandle{xTaskGetCurrentTaskHandle()} {
} }
@@ -75,7 +103,7 @@ NimBLETaskData::NimBLETaskData(void* pInstance, int flags, void* buf)
* @brief Destructor. * @brief Destructor.
*/ */
NimBLETaskData::~NimBLETaskData() { NimBLETaskData::~NimBLETaskData() {
# if !defined INC_FREERTOS_H # ifndef INC_FREERTOS_H
if (m_pHandle != nullptr) { if (m_pHandle != nullptr) {
ble_npl_sem_deinit(static_cast<ble_npl_sem*>(m_pHandle)); ble_npl_sem_deinit(static_cast<ble_npl_sem*>(m_pHandle));
delete static_cast<ble_npl_sem*>(m_pHandle); delete static_cast<ble_npl_sem*>(m_pHandle);
@@ -97,7 +125,7 @@ bool NimBLEUtils::taskWait(const NimBLETaskData& taskData, uint32_t timeout) {
ble_npl_time_ms_to_ticks(timeout, &ticks); ble_npl_time_ms_to_ticks(timeout, &ticks);
} }
# if defined INC_FREERTOS_H # ifdef INC_FREERTOS_H
uint32_t notificationValue; uint32_t notificationValue;
xTaskNotifyWait(0, TASK_BLOCK_BIT, &notificationValue, 0); xTaskNotifyWait(0, TASK_BLOCK_BIT, &notificationValue, 0);
if (notificationValue & TASK_BLOCK_BIT) { if (notificationValue & TASK_BLOCK_BIT) {
@@ -119,7 +147,7 @@ bool NimBLEUtils::taskWait(const NimBLETaskData& taskData, uint32_t timeout) {
void NimBLEUtils::taskRelease(const NimBLETaskData& taskData, int flags) { void NimBLEUtils::taskRelease(const NimBLETaskData& taskData, int flags) {
taskData.m_flags = flags; taskData.m_flags = flags;
if (taskData.m_pHandle != nullptr) { if (taskData.m_pHandle != nullptr) {
# if defined INC_FREERTOS_H # ifdef INC_FREERTOS_H
xTaskNotify(static_cast<TaskHandle_t>(taskData.m_pHandle), TASK_BLOCK_BIT, eSetBits); xTaskNotify(static_cast<TaskHandle_t>(taskData.m_pHandle), TASK_BLOCK_BIT, eSetBits);
# else # else
ble_npl_sem_release(static_cast<ble_npl_sem*>(taskData.m_pHandle)); ble_npl_sem_release(static_cast<ble_npl_sem*>(taskData.m_pHandle));
@@ -133,7 +161,7 @@ void NimBLEUtils::taskRelease(const NimBLETaskData& taskData, int flags) {
* @return A string representation of the return code. * @return A string representation of the return code.
*/ */
const char* NimBLEUtils::returnCodeToString(int rc) { const char* NimBLEUtils::returnCodeToString(int rc) {
# if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT) # if MYNEWT_VAL(NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
switch (rc) { switch (rc) {
case 0: case 0:
return "SUCCESS"; return "SUCCESS";
@@ -416,10 +444,10 @@ const char* NimBLEUtils::returnCodeToString(int rc) {
default: default:
return "Unknown"; return "Unknown";
} }
# else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT) # else // MYNEWT_VAL(NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
(void)rc; (void)rc;
return ""; return "";
# endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT) # endif // MYNEWT_VAL(NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
} }
/** /**
@@ -428,7 +456,7 @@ const char* NimBLEUtils::returnCodeToString(int rc) {
* @return A string representation of the advertising flags. * @return A string representation of the advertising flags.
*/ */
const char* NimBLEUtils::advTypeToString(uint8_t advType) { const char* NimBLEUtils::advTypeToString(uint8_t advType) {
# if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT) # if MYNEWT_VAL(NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
switch (advType) { switch (advType) {
case BLE_HCI_ADV_TYPE_ADV_IND: // 0 case BLE_HCI_ADV_TYPE_ADV_IND: // 0
return "Undirected - Connectable / Scannable"; return "Undirected - Connectable / Scannable";
@@ -443,10 +471,10 @@ const char* NimBLEUtils::advTypeToString(uint8_t advType) {
default: default:
return "Unknown flag"; return "Unknown flag";
} }
# else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT) # else // MYNEWT_VAL(NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
(void)advType; (void)advType;
return ""; return "";
# endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT) # endif // MYNEWT_VAL(NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
} // adFlagsToString } // adFlagsToString
/** /**
@@ -455,7 +483,7 @@ const char* NimBLEUtils::advTypeToString(uint8_t advType) {
* @return A string representation of the event type. * @return A string representation of the event type.
*/ */
const char* NimBLEUtils::gapEventToString(uint8_t eventType) { const char* NimBLEUtils::gapEventToString(uint8_t eventType) {
# if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT) # if MYNEWT_VAL(NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
switch (eventType) { switch (eventType) {
case BLE_GAP_EVENT_CONNECT: // 0 case BLE_GAP_EVENT_CONNECT: // 0
return "BLE_GAP_EVENT_CONNECT "; return "BLE_GAP_EVENT_CONNECT ";
@@ -535,10 +563,10 @@ const char* NimBLEUtils::gapEventToString(uint8_t eventType) {
NIMBLE_LOGD(LOG_TAG, "Unknown event type %d 0x%.2x", eventType, eventType); NIMBLE_LOGD(LOG_TAG, "Unknown event type %d 0x%.2x", eventType, eventType);
return "Unknown event type"; return "Unknown event type";
} }
# else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT) # else // MYNEWT_VAL(NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
(void)eventType; (void)eventType;
return ""; return "";
# endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT) # endif // MYNEWT_VAL(NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
} // gapEventToString } // gapEventToString
/** /**

10
src/NimBLEUtils.h
View File

@@ -21,7 +21,15 @@
#include "syscfg/syscfg.h" #include "syscfg/syscfg.h"
#if CONFIG_BT_NIMBLE_ENABLED #if CONFIG_BT_NIMBLE_ENABLED
#if CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED && !defined NDEBUG # ifndef MYNEWT_VAL_NIMBLE_CPP_DEBUG_ASSERT_ENABLED
# if defined(CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED)
# define MYNEWT_VAL_NIMBLE_CPP_DEBUG_ASSERT_ENABLED CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED
# else
# define MYNEWT_VAL_NIMBLE_CPP_DEBUG_ASSERT_ENABLED (0)
# endif
# endif
#if MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED) && !defined NDEBUG
void nimble_cpp_assert(const char *file, unsigned line) __attribute((weak, noreturn)); void nimble_cpp_assert(const char *file, unsigned line) __attribute((weak, noreturn));
# define NIMBLE_ATT_VAL_FILE (__builtin_strrchr(__FILE__, '/') ? \ # define NIMBLE_ATT_VAL_FILE (__builtin_strrchr(__FILE__, '/') ? \
__builtin_strrchr (__FILE__, '/') + 1 : __FILE__) __builtin_strrchr (__FILE__, '/') + 1 : __FILE__)

2
src/NimBLEValueAttribute.h
View File

@@ -26,7 +26,7 @@
class NimBLEValueAttribute { class NimBLEValueAttribute {
public: public:
NimBLEValueAttribute(uint16_t maxLen = BLE_ATT_ATTR_MAX_LEN, uint16_t initLen = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) NimBLEValueAttribute(uint16_t maxLen = BLE_ATT_ATTR_MAX_LEN, uint16_t initLen = MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH))
: m_value(initLen, maxLen) {} : m_value(initLen, maxLen) {}
/** /**