Convert NIMBLE_CPP macros to MYNEWT.

2025-09-25 05:21:13 +02:00 · 2025-09-06 12:13:39 -06:00
parent 8f9e85a46a
commit 6f0b9ddf5d
11 changed files with 123 additions and 60 deletions
--- a/src/NimBLEAddress.cpp
+++ b/src/NimBLEAddress.cpp
@@ -22,13 +22,29 @@

 # 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 ""
 # else
 #  define NIMBLE_CPP_ADDR_DELIMITER ":"
 # 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"
 # else
 #  define NIMBLE_CPP_ADDR_FMT "%02x%s%02x%s%02x%s%02x%s%02x%s%02x"
--- a/src/NimBLEAttValue.cpp
+++ b/src/NimBLEAttValue.cpp
@@ -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_len{},
      m_capacity{init_len}
-# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
      ,
      m_timestamp{}
 # endif
@@ -134,7 +134,7 @@ NimBLEAttValue& NimBLEAttValue::append(const uint8_t* value, uint16_t len) {
        return *this;
    }

-# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
    time_t t = time(nullptr);
 # else
    time_t t = 0;
--- a/src/NimBLEAttValue.h
+++ b/src/NimBLEAttValue.h
@@ -31,20 +31,30 @@
 # include <cstring>
 # include <cstdint>

-# ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
-#  define CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED 0
+# ifndef MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+#  ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+#   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

 # ifndef BLE_ATT_ATTR_MAX_LEN
 #  define BLE_ATT_ATTR_MAX_LEN 512
 # endif

-# if !defined(CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH)
-#  define CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20
-# elif CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH > BLE_ATT_ATTR_MAX_LEN
-#  error CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be larger than 512 (BLE_ATT_ATTR_MAX_LEN)
-# elif CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH < 1
-#  error CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be less than 1; Range = 1 : 512
+# ifndef MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
+#  ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
+#   define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20
+#  else
+#   define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
+#  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

 /* 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_len{};
    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{};
 # endif
    void deepCopy(const NimBLEAttValue& source);
@@ -85,7 +95,7 @@ class NimBLEAttValue {
     * @param[in] init_len The initial size in bytes.
     * @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.
@@ -170,7 +180,7 @@ class NimBLEAttValue {
    /** @brief Iterator end */
    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 */
    time_t getTimeStamp() const { return m_timestamp; }

@@ -210,7 +220,7 @@ class NimBLEAttValue {

    const NimBLEAttValue& getValue(time_t* timestamp = nullptr) const {
        if (timestamp != nullptr) {
-# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
            *timestamp = m_timestamp;
 # else
            *timestamp = 0;
@@ -307,7 +317,7 @@ class NimBLEAttValue {
    template <typename T>
    T getValue(time_t* timestamp = nullptr, bool skipSizeCheck = false) const {
        if (timestamp != nullptr) {
-# if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
            *timestamp = m_timestamp;
 # else
            *timestamp = 0;
--- a/src/NimBLEDevice.cpp
+++ b/src/NimBLEDevice.cpp
@@ -1325,7 +1325,7 @@ std::string NimBLEDevice::toString() {
    return getAddress().toString();
 } // toString

-# if CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED || __DOXYGEN__
+# if MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED) || __DOXYGEN__
 /**
 * @brief Debug assert - weak function.
 * @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);
    abort();
 }
-# endif // CONFIG_NIMBLE_CPP_DEBUG_ASSERT_ENABLED
+# endif // MYNEWT_VAL(NIMBLE_CPP_DEBUG_ASSERT_ENABLED)

 void NimBLEDevice::setDeviceCallbacks(NimBLEDeviceCallbacks* cb) {
    m_pDeviceCallbacks = cb ? cb : &defaultDeviceCallbacks;
--- a/src/NimBLELocalValueAttribute.h
+++ b/src/NimBLELocalValueAttribute.h
@@ -101,7 +101,7 @@ class NimBLELocalValueAttribute : public NimBLELocalAttribute, public NimBLEValu
    NimBLELocalValueAttribute(const NimBLEUUID& uuid,
                              uint16_t          handle,
                              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) {}
    /**
     * @brief Destroy the NimBLELocalValueAttribute object.
--- a/src/NimBLELog.h
+++ b/src/NimBLELog.h
@@ -21,12 +21,21 @@
 #include "syscfg/syscfg.h"
 #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)
 #  include "esp_log.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 CONFIG_LOG_COLORS
@@ -120,13 +129,13 @@

 #   define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...)                                                            \
      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)

 #  else
 #   define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...)                                                    \
      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)

 #  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__)

 # else
-#  include "syscfg/syscfg.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__)
 #  else
 #   define NIMBLE_LOGD(tag, format, ...) (void)tag
 #  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__)
 #  else
 #   define NIMBLE_LOGI(tag, format, ...) (void)tag
 #  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__)
 #  else
 #   define NIMBLE_LOGW(tag, format, ...) (void)tag
 #  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__)
 #  else
 #   define NIMBLE_LOGE(tag, format, ...) (void)tag
--- a/src/NimBLEScan.cpp
+++ b/src/NimBLEScan.cpp
@@ -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) {
                NIMBLE_LOGD(LOG_TAG, "EXT ADV data incomplete, waiting for more");
                return 0;
@@ -498,7 +498,7 @@ void NimBLEScan::clearResults() {
 * @brief Dump the scan results to the log.
 */
 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) {
        NIMBLE_LOGI(LOG_TAG, "- %s", dev->toString().c_str());
    }
--- a/src/NimBLEServer.cpp
+++ b/src/NimBLEServer.cpp
@@ -189,7 +189,7 @@ void NimBLEServer::start() {
        return;
    }

-# if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4
+# if MYNEWT_VAL(NIMBLE_CPP_LOG_LEVEL) >= 4
    ble_gatts_show_local();
 # endif

--- a/src/NimBLEUtils.cpp
+++ b/src/NimBLEUtils.cpp
@@ -35,14 +35,42 @@
 # include <stdlib.h>
 # include <climits>

-# if defined INC_FREERTOS_H
-#  ifndef CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT
-#   define CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT 31
+# ifndef MYNEWT_VAL_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
+#  ifdef CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
+#   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
-constexpr uint32_t TASK_BLOCK_BIT = (1 << CONFIG_NIMBLE_CPP_FREERTOS_TASK_BLOCK_BIT);
 # endif

-static const char* LOG_TAG = "NimBLEUtils";
+# 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";

 /**
 * @brief Construct a NimBLETaskData instance.
@@ -54,7 +82,7 @@ NimBLETaskData::NimBLETaskData(void* pInstance, int flags, void* buf)
    : m_pInstance{pInstance},
      m_flags{flags},
      m_pBuf{buf}
-# if defined INC_FREERTOS_H
+# ifdef INC_FREERTOS_H
      ,
      m_pHandle{xTaskGetCurrentTaskHandle()} {
 }
@@ -75,7 +103,7 @@ NimBLETaskData::NimBLETaskData(void* pInstance, int flags, void* buf)
 * @brief Destructor.
 */
 NimBLETaskData::~NimBLETaskData() {
-# if !defined INC_FREERTOS_H
+# ifndef INC_FREERTOS_H
    if (m_pHandle != nullptr) {
        ble_npl_sem_deinit(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);
    }

-# if defined INC_FREERTOS_H
+# ifdef INC_FREERTOS_H
    uint32_t notificationValue;
    xTaskNotifyWait(0, TASK_BLOCK_BIT, &notificationValue, 0);
    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) {
    taskData.m_flags = flags;
    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);
 # else
        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.
 */
 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) {
        case 0:
            return "SUCCESS";
@@ -416,10 +444,10 @@ const char* NimBLEUtils::returnCodeToString(int rc) {
        default:
            return "Unknown";
    }
-# else  // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
+# else  // MYNEWT_VAL(NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
    (void)rc;
    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.
 */
 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) {
        case BLE_HCI_ADV_TYPE_ADV_IND: // 0
            return "Undirected - Connectable / Scannable";
@@ -443,10 +471,10 @@ const char* NimBLEUtils::advTypeToString(uint8_t advType) {
        default:
            return "Unknown flag";
    }
-# else  // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
+# else  // MYNEWT_VAL(NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
    (void)advType;
    return "";
-# endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
+# endif // MYNEWT_VAL(NIMBLE_CPP_ENABLE_ADVERTISEMENT_TYPE_TEXT)
 } // adFlagsToString

 /**
@@ -455,7 +483,7 @@ const char* NimBLEUtils::advTypeToString(uint8_t advType) {
 * @return A string representation of the event type.
 */
 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) {
        case BLE_GAP_EVENT_CONNECT: // 0
            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);
            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;
    return "";
-# endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
+# endif // MYNEWT_VAL(NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
 } // gapEventToString

 /**
--- a/src/NimBLEUtils.h
+++ b/src/NimBLEUtils.h
@@ -21,7 +21,15 @@
 #include "syscfg/syscfg.h"
 #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));
 # define NIMBLE_ATT_VAL_FILE  (__builtin_strrchr(__FILE__, '/') ? \
                            __builtin_strrchr (__FILE__, '/') + 1 : __FILE__)
--- a/src/NimBLEValueAttribute.h
+++ b/src/NimBLEValueAttribute.h
@@ -26,7 +26,7 @@

 class NimBLEValueAttribute {
  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) {}

    /**