esp_nimble_hci_and_controller_deinit() does not exist in idf anymore, I hope we never need it

New compiler new printf chars
2025-06-25 09:21:42 +02:00 · 2022-09-17 22:14:05 +02:00 · 2022-09-17 22:13:46 +02:00 · 2022-09-17 22:13:25 +02:00 · 2021-09-21 16:49:45 +02:00 · 2021-05-29 01:21:34 +02:00
57 changed files with 898 additions and 947 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,27 @@
+sudo: false
+
+before_install:
+ - cd ${TMPDIR-/tmp}
+ - wget -q http://doxygen.nl/files/doxygen-1.9.0.src.tar.gz
+ - tar -xzvf doxygen-1.9.0.src.tar.gz
+ - mkdir doxygen_build
+ - cd doxygen_build
+ - cmake ../doxygen-1.9.0/
+ - make
+ - export PATH="${TMPDIR-/tmp}/doxygen_build/bin:$PATH"
+ - cd ${TRAVIS_BUILD_DIR}
+ 
+branches:
+  only:
+    - master
+
+script:
+  - doxygen ./docs/Doxyfile
+
+deploy:
+  provider: pages
+  skip_cleanup: true
+  local_dir: docs/html
+  github_token: $GH_REPO_TOKEN
+  on:
+    branch: master
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,73 +1,6 @@
 # Changelog

-All notable changes to this project will be documented in this file.
-
-## [1.3.2] - 2022-01-15
-
-### Fixed
- Initialize advertising complete callback in NimBLEAdvertising constructor.
- Clear client disconnect timer in constructor before initializing.
- Fix missing data when reading large values.
- Fix missing data in notifications when using a large MTU size and more than 270 bytes of data are sent.
- Workaround fix added for cases when the task notification value is not cleared, causing various functions that should block not to block.
-
-### Added
- `NimBLEClient::getLastError` : Gets the error code of the last function call that produces a return code from the stack.
- `NimBLECharacteristic::notify` : Overload method to send notifications/indications with custom values.
- Added conditional checks for ESP32 specific functions/values to support use of the library on non-esp32 devices.
- Added an alias to use the callback name from the original library `onMtuChanged`.
- `NimBLEClient::setDataLen` and `NimBLEServer::setDataLen`:  Data length extension support (IDF version >= 4.3.2 only)
- Config option to set logging level for esp-nimble-cpp
-
-### Changed
- Critical section calls now use the NimBLE API instead of FreeRTOS directly. This removes the need for a `portMUX_TYPE` variable in the class definitions.
- Removed unnecessary variables in `NimBLEService` and changed the constructor no no longer accept `numHandles` and `inst_id` parameters.
-
-## [1.3.1] - 2021-08-04
-
-### Fixed
- Corrected a compiler/linker error when an application or a library uses bluetooth classic due to the redefinition of `btInUse`.
-
-## [1.3.0] - 2021-08-02
-
-### Added
- `NimBLECharacteristic::removeDescriptor`: Dynamically remove a descriptor from a characterisic. Takes effect after all connections are closed and sends a service changed indication.
- `NimBLEService::removeCharacteristic`: Dynamically remove a characteristic from a service. Takes effect after all connections are closed and sends a service changed indication
- `NimBLEServerCallbacks::onMTUChange`: This is callback is called when the MTU is updated after connection with a client.
- ESP32C3 support
-
- Whitelist API:
-  - `NimBLEDevice::whiteListAdd`: Add a device to the whitelist.
-  - `NimBLEDevice::whiteListRemove`: Remove a device from the whitelist.
-  - `NimBLEDevice::onWhiteList`: Check if the device is on the whitelist.
-  - `NimBLEDevice::getWhiteListCount`: Gets the size of the whitelist
-  - `NimBLEDevice::getWhiteListAddress`: Get the address of a device on the whitelist by index value.
-
- Bond management API:
-  - `NimBLEDevice::getNumBonds`: Gets the number of bonds stored.
-  - `NimBLEDevice::isBonded`: Checks if the device is bonded.
-  - `NimBLEDevice::deleteAllBonds`: Deletes all bonds.
-  - `NimBLEDevice::getBondedAddress`: Gets the address of a bonded device by the index value.
-
- `NimBLECharacteristic::getCallbacks` to retrieve the current callback handler.
- Connection Information class: `NimBLEConnInfo`.
- `NimBLEScan::clearDuplicateCache`: This can be used to reset the cache of advertised devices so they will be immediately discovered again.
-
-### Changed
- FreeRTOS files have been removed as they are not used by the library.
- Services, characteristics and descriptors can now be created statically and added after.
- Excess logging and some asserts removed.
- Use ESP_LOGx macros to enable using local log level filtering.
-
-### Fixed
- `NimBLECharacteristicCallbacks::onSubscribe` Is now called after the connection is added to the vector.
- Corrected bonding failure when reinitializing the BLE stack.
- Writing to a characterisic with a std::string value now correctly writes values with null characters.
- Retrieving remote descriptors now uses the characterisic end handle correctly.
- Missing data in long writes to remote descriptors.
- Hanging on task notification when sending an indication from the characteristic callback.
- BLE controller memory could be released when using Arduino as a component.
- Complile errors with NimBLE release 1.3.0.
+All notable changes to this project will be documented in this file.  

 ## [1.2.0] - 2021-02-08

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -14,11 +14,12 @@ elseif("nimble" IN_LIST BUILD_COMPONENTS OR "__nimble" IN_LIST __hack_component_
    )
 endif()

-if("arduino" IN_LIST BUILD_COMPONENTS OR __hack_component_targets MATCHES "__idf_arduino")
-    list(APPEND ESP_NIMBLE_PRIV_REQUIRES
-        arduino
-    )
-endif()
+# Dont use arduino bullshit
+#if("arduino" IN_LIST BUILD_COMPONENTS OR __hack_component_targets MATCHES "__idf_arduino")
+#    list(APPEND ESP_NIMBLE_PRIV_REQUIRES
+#        arduino
+#    )
+#endif()

 idf_component_register(
  REQUIRED_IDF_TARGETS
@ -28,6 +29,7 @@ idf_component_register(
  INCLUDE_DIRS
    "src"
  SRCS
+    "src/FreeRTOS.cpp"
    "src/NimBLE2904.cpp"
    "src/NimBLEAddress.cpp"
    "src/NimBLEAdvertisedDevice.cpp"
@ -52,7 +54,12 @@ idf_component_register(
  REQUIRES
    bt
    nvs_flash
+    esp_ringbuf
  PRIV_REQUIRES
    ${ESP_NIMBLE_PRIV_REQUIRES}
 )

+target_compile_options(${COMPONENT_TARGET}
+    PUBLIC
+        -DDONT_USE_ARDUINO_BULLSHIT
+)
--- a/CMakeLists.txt_idf3
+++ b/CMakeLists.txt_idf3
@ -5,6 +5,7 @@ cmake_minimum_required(VERSION 3.5)
 set(SUPPORTED_TARGETS esp32)

 set(COMPONENT_SRCS
+    "src/FreeRTOS.cpp"
    "src/NimBLE2904.cpp"
    "src/NimBLEAddress.cpp"
    "src/NimBLEAdvertisedDevice.cpp"
--- a/26
+++ b/26
@ -1,31 +1,5 @@
 menu "ESP-NimBLE-CPP configuration"

-choice NIMBLE_CPP_LOG_LEVEL
-    prompt "NimBLE CPP log verbosity"
-    default NIMBLE_CPP_LOG_LEVEL_NONE
-    help
-        Select NimBLE CPP log verbosity level.
-
-    config NIMBLE_CPP_LOG_LEVEL_NONE
-        bool "No logs"
-    config NIMBLE_CPP_LOG_LEVEL_ERROR
-        bool "Error logs"
-    config NIMBLE_CPP_LOG_LEVEL_WARNING
-        bool "Warning logs"
-    config NIMBLE_CPP_LOG_LEVEL_INFO
-        bool "Info logs"
-    config NIMBLE_CPP_LOG_LEVEL_DEBUG
-        bool "Debug logs"
-endchoice #NIMBLE_CPP_LOG_LEVEL
-
-config NIMBLE_CPP_LOG_LEVEL
-    int
-    default 0 if NIMBLE_CPP_LOG_LEVEL_NONE
-    default 1 if NIMBLE_CPP_LOG_LEVEL_ERROR
-    default 2 if NIMBLE_CPP_LOG_LEVEL_WARNING
-    default 3 if NIMBLE_CPP_LOG_LEVEL_INFO
-    default 4 if NIMBLE_CPP_LOG_LEVEL_DEBUG
-
 config NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
    bool "Show NimBLE return codes as text in debug log."
    default "n"
--- a/README.md
+++ b/README.md
@ -68,3 +68,9 @@ in your project/CMakeLists.txt after the line `include($ENV{IDF_PATH}/tools/cmak
 * [Jeroen88](https://github.com/Jeroen88) for the amazing help debugging and improving the client code.  
 <br/>  

+# Todo
+- Improve host reset handler
+- Implement random address handling
+- Implement bond management
+- Add Bluetooth Mesh
+<br/>  
--- a/docs/Doxyfile
+++ b/docs/Doxyfile
@ -38,7 +38,7 @@ PROJECT_NAME           = "esp-nimble-cpp / NimBLE-Arduino"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = 1.3.1
+PROJECT_NUMBER         = 1.2.0

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
--- a/docs/Migration_guide.md
+++ b/docs/Migration_guide.md
@ -69,6 +69,8 @@ For example `BLEServer::createService(SERVICE_UUID)` will work just as it did be

 <a name="characteristics"></a>
 ### Characteristics
+The constructor for `(Nim)BLECharacteristic` is now private, so if you currently subclass it to add logic you should switch to use `NimBLEService::createCharacteristic` instead.  Any custom processing logic previously in a `BLECharacteristic` subclass should be moved to a `NimBLECharacteristicCallbacks` subclass instead, and passed into `NimBLECharacteristic::setCallbacks`.
+
 `BLEService::createCharacteristic` (`NimBLEService::createCharacteristic`) is used the same way as originally except the properties parameter has changed.  

 When creating a characteristic the properties are now set with `NIMBLE_PROPERTY::XXXX` instead of `BLECharacteristic::XXXX`.
--- a/examples/Advanced/NimBLE_Server/main/main.cpp
+++ b/examples/Advanced/NimBLE_Server/main/main.cpp
@ -41,9 +41,6 @@ class ServerCallbacks: public NimBLEServerCallbacks {
        printf("Client disconnected - start advertising\n");
        NimBLEDevice::startAdvertising();
    };
-    void onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc) {
-        printf("MTU updated: %u for connection ID: %u\n", MTU, desc->conn_handle);
-    };
    
 /********************* Security handled here **********************
 ****** Note: these are the same return values as defaults ********/
--- a/src/FreeRTOS.cpp
+++ b/src/FreeRTOS.cpp
@ -0,0 +1,316 @@
+/*
+ * FreeRTOS.cpp
+ *
+ *  Created on: Feb 24, 2017
+ *      Author: kolban
+ */
+#include "sdkconfig.h"
+#include "FreeRTOS.h"
+#include "NimBLELog.h"
+
+#include <freertos/FreeRTOS.h>   // Include the base FreeRTOS definitions
+#include <freertos/task.h>       // Include the task definitions
+#include <freertos/semphr.h>     // Include the semaphore definitions
+#include <string>
+
+static const char* LOG_TAG = "FreeRTOS";
+
+
+/**
+ * Sleep for the specified number of milliseconds.
+ * @param[in] ms The period in milliseconds for which to sleep.
+ */
+void FreeRTOS::sleep(uint32_t ms) {
+    ::vTaskDelay(ms / portTICK_PERIOD_MS);
+} // sleep
+
+
+/**
+ * Start a new task.
+ * @param[in] task The function pointer to the function to be run in the task.
+ * @param[in] taskName A string identifier for the task.
+ * @param[in] param An optional parameter to be passed to the started task.
+ * @param[in] stackSize An optional paremeter supplying the size of the stack in which to run the task.
+ */
+void FreeRTOS::startTask(void task(void*), std::string taskName, void* param, uint32_t stackSize) {
+    ::xTaskCreate(task, taskName.data(), stackSize, param, 5, NULL);
+} // startTask
+
+
+/**
+ * Delete the task.
+ * @param[in] pTask An optional handle to the task to be deleted.  If not supplied the calling task will be deleted.
+ */
+void FreeRTOS::deleteTask(TaskHandle_t pTask) {
+    ::vTaskDelete(pTask);
+} // deleteTask
+
+
+/**
+ * Get the time in milliseconds since the %FreeRTOS scheduler started.
+ * @return The time in milliseconds since the %FreeRTOS scheduler started.
+ */
+uint32_t FreeRTOS::getTimeSinceStart() {
+    return (uint32_t) (xTaskGetTickCount() * portTICK_PERIOD_MS);
+} // getTimeSinceStart
+
+
+/**
+ * @brief Wait for a semaphore to be released by trying to take it and
+ * then releasing it again.
+ * @param [in] owner A debug tag.
+ * @return The value associated with the semaphore.
+ */
+uint32_t FreeRTOS::Semaphore::wait(std::string owner) {
+    NIMBLE_LOGD(LOG_TAG, ">> wait: Semaphore waiting: %s for %s", toString().c_str(), owner.c_str());
+
+    if (m_usePthreads) {
+        pthread_mutex_lock(&m_pthread_mutex);
+    } else {
+        xSemaphoreTake(m_semaphore, portMAX_DELAY);
+    }
+
+    if (m_usePthreads) {
+        pthread_mutex_unlock(&m_pthread_mutex);
+    } else {
+        xSemaphoreGive(m_semaphore);
+    }
+
+    NIMBLE_LOGD(LOG_TAG, "<< wait: Semaphore released: %s", toString().c_str());
+    return m_value;
+} // wait
+
+
+/**
+ * @brief Wait for a semaphore to be released in a given period of time by trying to take it and
+ * then releasing it again. The value associated with the semaphore can be taken by value() call after return
+ * @param [in] owner A debug tag.
+ * @param [in] timeoutMs timeout to wait in ms.
+ * @return True if we took the semaphore within timeframe.
+ */
+bool FreeRTOS::Semaphore::timedWait(std::string owner, uint32_t timeoutMs) {
+    NIMBLE_LOGD(LOG_TAG, ">> wait: Semaphore waiting: %s for %s", toString().c_str(), owner.c_str());
+
+    if (m_usePthreads && timeoutMs != portMAX_DELAY) {
+        assert(false);  // We apparently don't have a timed wait for pthreads.
+    }
+
+    auto ret = pdTRUE;
+
+    if (m_usePthreads) {
+        pthread_mutex_lock(&m_pthread_mutex);
+    } else {
+        ret = xSemaphoreTake(m_semaphore, timeoutMs);
+    }
+
+    if (m_usePthreads) {
+        pthread_mutex_unlock(&m_pthread_mutex);
+    } else {
+        xSemaphoreGive(m_semaphore);
+    }
+
+    NIMBLE_LOGD(LOG_TAG, "<< wait: Semaphore %s released: %d", toString().c_str(), ret);
+    return ret;
+} // wait
+
+
+/**
+ * @brief Construct a semaphore, the semaphore is given when created.
+ * @param [in] name A name string to provide debugging support.
+ */
+FreeRTOS::Semaphore::Semaphore(std::string name) {
+    m_usePthreads = false;      // Are we using pThreads or FreeRTOS?
+    if (m_usePthreads) {
+        pthread_mutex_init(&m_pthread_mutex, nullptr);
+    } else {
+        //m_semaphore = xSemaphoreCreateMutex();
+        m_semaphore = xSemaphoreCreateBinary();
+        xSemaphoreGive(m_semaphore);
+    }
+
+    m_name      = name;
+    m_owner     = std::string("<N/A>");
+    m_value     = 0;
+}
+
+
+FreeRTOS::Semaphore::~Semaphore() {
+    if (m_usePthreads) {
+        pthread_mutex_destroy(&m_pthread_mutex);
+    } else {
+        vSemaphoreDelete(m_semaphore);
+    }
+}
+
+
+/**
+ * @brief Give the semaphore.
+ */
+void FreeRTOS::Semaphore::give() {
+    NIMBLE_LOGD(LOG_TAG, "Semaphore giving: %s", toString().c_str());
+    m_owner = std::string("<N/A>");
+
+    if (m_usePthreads) {
+        pthread_mutex_unlock(&m_pthread_mutex);
+    } else {
+        xSemaphoreGive(m_semaphore);
+    }
+// #if defined(ARDUINO_ARCH_ESP32) && !defined(DONT_USE_ARDUINO_BULLSHIT)
+//  FreeRTOS::sleep(10);
+// #endif
+
+} // Semaphore::give
+
+
+/**
+ * @brief Give a semaphore.
+ * The Semaphore is given with an associated value.
+ * @param [in] value The value to associate with the semaphore.
+ */
+void FreeRTOS::Semaphore::give(uint32_t value) {
+    m_value = value;
+    give();
+} // give
+
+
+/**
+ * @brief Give a semaphore from an ISR.
+ */
+void FreeRTOS::Semaphore::giveFromISR() {
+    BaseType_t higherPriorityTaskWoken;
+    if (m_usePthreads) {
+        assert(false);
+    } else {
+        xSemaphoreGiveFromISR(m_semaphore, &higherPriorityTaskWoken);
+    }
+} // giveFromISR
+
+
+/**
+ * @brief Take a semaphore.
+ * Take a semaphore and wait indefinitely.
+ * @param [in] owner The new owner (for debugging)
+ * @return True if we took the semaphore.
+ */
+bool FreeRTOS::Semaphore::take(std::string owner) {
+    NIMBLE_LOGD(LOG_TAG, "Semaphore taking: %s for %s", toString().c_str(), owner.c_str());
+    bool rc = false;
+    if (m_usePthreads) {
+        pthread_mutex_lock(&m_pthread_mutex);
+    } else {
+        rc = ::xSemaphoreTake(m_semaphore, portMAX_DELAY) == pdTRUE;
+    }
+    m_owner = owner;
+    if (rc) {
+        NIMBLE_LOGD(LOG_TAG, "Semaphore taken:  %s", toString().c_str());
+    } else {
+        NIMBLE_LOGE(LOG_TAG, "Semaphore NOT taken:  %s", toString().c_str());
+    }
+    return rc;
+} // Semaphore::take
+
+
+/**
+ * @brief Take a semaphore.
+ * Take a semaphore but return if we haven't obtained it in the given period of milliseconds.
+ * @param [in] timeoutMs Timeout in milliseconds.
+ * @param [in] owner The new owner (for debugging)
+ * @return True if we took the semaphore.
+ */
+bool FreeRTOS::Semaphore::take(uint32_t timeoutMs, std::string owner) {
+    NIMBLE_LOGD(LOG_TAG, "Semaphore taking: %s for %s", toString().c_str(), owner.c_str());
+    bool rc = false;
+    if (m_usePthreads) {
+        assert(false);  // We apparently don't have a timed wait for pthreads.
+    } else {
+        rc = ::xSemaphoreTake(m_semaphore, timeoutMs / portTICK_PERIOD_MS) == pdTRUE;
+    }
+    m_owner = owner;
+    if (rc) {
+        NIMBLE_LOGD(LOG_TAG, "Semaphore taken:  %s", toString().c_str());
+    } else {
+        NIMBLE_LOGE(LOG_TAG, "Semaphore NOT taken:  %s", toString().c_str());
+    }
+    return rc;
+} // Semaphore::take
+
+
+
+/**
+ * @brief Create a string representation of the semaphore.
+ * @return A string representation of the semaphore.
+ */
+std::string FreeRTOS::Semaphore::toString() {
+    char hex[9];
+    std::string res = "name: " + m_name + " (0x";
+    snprintf(hex, sizeof(hex), "%08lx", (uint32_t)m_semaphore);
+    res += hex;
+    res += "), owner: " + m_owner;
+    return res;
+} // toString
+
+
+/**
+ * @brief Set the name of the semaphore.
+ * @param [in] name The name of the semaphore.
+ */
+void FreeRTOS::Semaphore::setName(std::string name) {
+    m_name = name;
+} // setName
+
+
+/**
+ * @brief Create a ring buffer.
+ * @param [in] length The amount of storage to allocate for the ring buffer.
+ * @param [in] type The type of buffer.  One of RINGBUF_TYPE_NOSPLIT, RINGBUF_TYPE_ALLOWSPLIT, RINGBUF_TYPE_BYTEBUF.
+ */
+#ifdef ESP_IDF_VERSION //Quick hack to detect if using IDF version that replaced ringbuf_type_t
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0)
+    Ringbuffer::Ringbuffer(size_t length, RingbufferType_t type) {
+#else
+    Ringbuffer::Ringbuffer(size_t length, ringbuf_type_t type) {
+#endif
+#else
+    Ringbuffer::Ringbuffer(size_t length, ringbuf_type_t type) {
+#endif
+    m_handle = ::xRingbufferCreate(length, type);
+} // Ringbuffer
+
+
+Ringbuffer::~Ringbuffer() {
+    ::vRingbufferDelete(m_handle);
+} // ~Ringbuffer
+
+
+/**
+ * @brief Receive data from the buffer.
+ * @param [out] size On return, the size of data returned.
+ * @param [in] wait How long to wait.
+ * @return A pointer to the storage retrieved.
+ */
+void* Ringbuffer::receive(size_t* size, TickType_t wait) {
+    return ::xRingbufferReceive(m_handle, size, wait);
+} // receive
+
+
+/**
+ * @brief Return an item.
+ * @param [in] item The item to be returned/released.
+ */
+void Ringbuffer::returnItem(void* item) {
+    ::vRingbufferReturnItem(m_handle, item);
+} // returnItem
+
+
+/**
+ * @brief Send data to the buffer.
+ * @param [in] data The data to place into the buffer.
+ * @param [in] length The length of data to place into the buffer.
+ * @param [in] wait How long to wait before giving up.  The default is to wait indefinitely.
+ * @return
+ */
+bool Ringbuffer::send(void* data, size_t length, TickType_t wait) {
+    return ::xRingbufferSend(m_handle, data, length, wait) == pdTRUE;
+} // send
+
+
--- a/src/FreeRTOS.h
+++ b/src/FreeRTOS.h
@ -0,0 +1,89 @@
+/*
+ * FreeRTOS.h
+ *
+ *  Created on: Feb 24, 2017
+ *      Author: kolban
+ */
+
+#ifndef MAIN_FREERTOS_H_
+#define MAIN_FREERTOS_H_
+
+#include <freertos/FreeRTOS.h>   // Include the base FreeRTOS definitions.
+#include <freertos/task.h>       // Include the task definitions.
+#include <freertos/semphr.h>     // Include the semaphore definitions.
+#include <freertos/ringbuf.h>    // Include the ringbuffer definitions.
+
+#include <stdint.h>
+#include <string>
+#include <pthread.h>
+
+
+/**
+ * @brief Interface to %FreeRTOS functions.
+ */
+class FreeRTOS {
+public:
+    static void sleep(uint32_t ms);
+    static void startTask(void task(void*), std::string taskName, void* param = nullptr, uint32_t stackSize = 2048);
+    static void deleteTask(TaskHandle_t pTask = nullptr);
+
+    static uint32_t getTimeSinceStart();
+
+/**
+ * @brief A binary semaphore class that operates like a mutex, it is already given when constructed.
+ */
+    class Semaphore {
+    public:
+        Semaphore(std::string owner = "<Unknown>");
+        ~Semaphore();
+        void        give();
+        void        give(uint32_t value);
+        void        giveFromISR();
+        void        setName(std::string name);
+        bool        take(std::string owner = "<Unknown>");
+        bool        take(uint32_t timeoutMs, std::string owner = "<Unknown>");
+        std::string toString();
+        bool        timedWait(std::string owner = "<Unknown>", uint32_t timeoutMs = portMAX_DELAY);
+        uint32_t    wait(std::string owner = "<Unknown>");
+        /**
+         * @brief Get the value of the semaphore.
+         * @return The value stored if the semaphore was given with give(value);
+         */
+        uint32_t    value(){ return m_value; };
+
+    private:
+        SemaphoreHandle_t m_semaphore;
+        pthread_mutex_t   m_pthread_mutex;
+        std::string       m_name;
+        std::string       m_owner;
+        uint32_t          m_value;
+        bool              m_usePthreads;
+
+    };
+};
+
+
+/**
+ * @brief A wrapper class for a freeRTOS ringbuffer.
+ */
+class Ringbuffer {
+public:
+#ifdef ESP_IDF_VERSION //Quick hack to detect if using IDF version that replaced ringbuf_type_t
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0)
+    Ringbuffer(size_t length, RingbufferType_t type = RINGBUF_TYPE_NOSPLIT);
+#else
+    Ringbuffer(size_t length, ringbuf_type_t type = RINGBUF_TYPE_NOSPLIT);
+#endif
+#else
+    Ringbuffer(size_t length, ringbuf_type_t type = RINGBUF_TYPE_NOSPLIT);
+#endif
+    ~Ringbuffer();
+
+    void*    receive(size_t* size, TickType_t wait = portMAX_DELAY);
+    void     returnItem(void* item);
+    bool     send(void* data, size_t length, TickType_t wait = portMAX_DELAY);
+private:
+    RingbufHandle_t m_handle;
+};
+
+#endif /* MAIN_FREERTOS_H_ */
--- a/src/HIDTypes.h
+++ b/src/HIDTypes.h
@ -45,7 +45,7 @@
 /* of data as per HID Class standard */

 /* Main items */
-#ifdef ARDUINO_ARCH_ESP32
+#if defined(ARDUINO_ARCH_ESP32) && !defined(DONT_USE_ARDUINO_BULLSHIT)
 #define HIDINPUT(size)             (0x80 | size)
 #define HIDOUTPUT(size)            (0x90 | size)
 #else
--- a/src/NimBLE2904.cpp
+++ b/src/NimBLE2904.cpp
@ -16,8 +16,11 @@
 * See also:
 * https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.characteristic_presentation_format.xml
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLE2904.h"

@ -83,4 +86,5 @@ void NimBLE2904::setUnit(uint16_t unit) {
    setValue((uint8_t*) &m_data, sizeof(m_data));
 } // setUnit

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif
--- a/src/NimBLE2904.h
+++ b/src/NimBLE2904.h
@ -14,8 +14,11 @@

 #ifndef MAIN_NIMBLE2904_H_
 #define MAIN_NIMBLE2904_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLEDescriptor.h"

@ -79,5 +82,6 @@ private:
    BLE2904_Data m_data;
 }; // BLE2904

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* MAIN_NIMBLE2904_H_ */
--- a/src/NimBLEAddress.cpp
+++ b/src/NimBLEAddress.cpp
@ -11,8 +11,8 @@
 *  Created on: Jul 2, 2017
 *      Author: kolban
 */
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include <algorithm>

--- a/src/NimBLEAddress.h
+++ b/src/NimBLEAddress.h
@ -14,15 +14,10 @@

 #ifndef COMPONENTS_NIMBLEADDRESS_H_
 #define COMPONENTS_NIMBLEADDRESS_H_
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "nimble/ble.h"
-#else
-#include "nimble/nimble/include/nimble/ble.h"
-#endif
-
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
--- a/src/NimBLEAdvertisedDevice.cpp
+++ b/src/NimBLEAdvertisedDevice.cpp
@ -11,9 +11,11 @@
 *  Created on: Jul 3, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)

 #include "NimBLEDevice.h"
 #include "NimBLEAdvertisedDevice.h"
@ -781,5 +783,7 @@ size_t NimBLEAdvertisedDevice::getPayloadLength() {
    return m_payload.size();
 } // getPayloadLength

-#endif /* CONFIG_BT_ENABLED  && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */

--- a/src/NimBLEAdvertisedDevice.h
+++ b/src/NimBLEAdvertisedDevice.h
@ -14,22 +14,20 @@

 #ifndef COMPONENTS_NIMBLEADVERTISEDDEVICE_H_
 #define COMPONENTS_NIMBLEADVERTISEDDEVICE_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)

 #include "NimBLEAddress.h"
 #include "NimBLEScan.h"
 #include "NimBLEUUID.h"

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_hs_adv.h"
-#else
-#include "nimble/nimble/host/include/host/ble_hs_adv.h"
-#endif

 #include <map>
 #include <vector>
-#include <time.h>


 class NimBLEScan;
@ -173,5 +171,6 @@ public:
    virtual void onResult(NimBLEAdvertisedDevice* advertisedDevice) = 0;
 };

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_NIMBLEADVERTISEDDEVICE_H_ */
--- a/src/NimBLEAdvertising.cpp
+++ b/src/NimBLEAdvertising.cpp
@ -13,14 +13,13 @@
 *      Author: kolban
 *
 */
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "services/gap/ble_svc_gap.h"
-#else
-#include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
-#endif
 #include "NimBLEAdvertising.h"
 #include "NimBLEDevice.h"
 #include "NimBLEServer.h"
@ -69,7 +68,6 @@ void NimBLEAdvertising::reset() {
    m_advDataSet                     = false;
    // Set this to non-zero to prevent auto start if host reset before started by app.
    m_duration                       = BLE_HS_FOREVER;
-    m_advCompCB                      = nullptr;
 } // reset


@ -385,7 +383,6 @@ void NimBLEAdvertising::setScanResponseData(NimBLEAdvertisementData& advertiseme
 * @brief Start advertising.
 * @param [in] duration The duration, in seconds, to advertise, 0 == advertise forever.
 * @param [in] advCompleteCB A pointer to a callback to be invoked when advertising ends.
- * @return True if advertising started successfully.
 */
 bool NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdvertising *pAdv)) {
    NIMBLE_LOGD(LOG_TAG, ">> Advertising start: customAdvData: %d, customScanResponseData: %d",
@ -655,8 +652,12 @@ bool NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdv
            break;
    }

+    if(rc != 0) {
+        return false;
+    }
+
    NIMBLE_LOGD(LOG_TAG, "<< Advertising start");
-    return (rc == 0);
+    return true;
 } // start


@ -1026,4 +1027,5 @@ std::string NimBLEAdvertisementData::getPayload() {
    return m_payload;
 } // getPayload

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLEAdvertising.h
+++ b/src/NimBLEAdvertising.h
@ -14,15 +14,13 @@

 #ifndef MAIN_BLEADVERTISING_H_
 #define MAIN_BLEADVERTISING_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
-#else
-#include "nimble/nimble/host/include/host/ble_gap.h"
-#endif
-
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
@ -134,5 +132,6 @@ private:
    std::vector<uint8_t>    m_uri;
 };

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* MAIN_BLEADVERTISING_H_ */
--- a/src/NimBLEBeacon.cpp
+++ b/src/NimBLEBeacon.cpp
@ -11,8 +11,8 @@
 *  Created on: Jan 4, 2018
 *      Author: kolban
 */
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include <string.h>
 #include <algorithm>
--- a/src/NimBLEBeacon.h
+++ b/src/NimBLEBeacon.h
@ -15,6 +15,7 @@
 #ifndef MAIN_NIMBLEBEACON_H_
 #define MAIN_NIMBLEBEACON_H_

+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 #include "NimBLEUUID.h"
 /**
 * @brief Representation of a beacon.
@ -48,4 +49,5 @@ public:
    void        setSignalPower(int8_t signalPower);
 }; // NimBLEBeacon

+#endif
 #endif /* MAIN_NIMBLEBEACON_H_ */
--- a/src/NimBLECharacteristic.cpp
+++ b/src/NimBLECharacteristic.cpp
@ -9,9 +9,11 @@
 *  Created on: Jun 22, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLECharacteristic.h"
 #include "NimBLE2904.h"
@ -43,14 +45,14 @@ NimBLECharacteristic::NimBLECharacteristic(const char* uuid, uint16_t properties
 * @param [in] pService - pointer to the service instance this characteristic belongs to.
 */
 NimBLECharacteristic::NimBLECharacteristic(const NimBLEUUID &uuid, uint16_t properties, NimBLEService* pService) {
-    m_uuid        = uuid;
-    m_handle      = NULL_HANDLE;
-    m_properties  = properties;
-    m_pCallbacks  = &defaultCallback;
-    m_pService    = pService;
-    m_value       = "";
-    m_timestamp   = 0;
-    m_removed     = 0;
+    m_uuid       = uuid;
+    m_handle     = NULL_HANDLE;
+    m_properties = properties;
+    m_pCallbacks = &defaultCallback;
+    m_pService   = pService;
+    m_value      = "";
+    m_valMux     = portMUX_INITIALIZER_UNLOCKED;
+    m_timestamp  = 0;
 } // NimBLECharacteristic

 /**
@ -93,63 +95,21 @@ NimBLEDescriptor* NimBLECharacteristic::createDescriptor(const NimBLEUUID &uuid,
    }

    addDescriptor(pDescriptor);
+
    return pDescriptor;
 } // createDescriptor


 /**
 * @brief Add a descriptor to the characteristic.
- * @param [in] pDescriptor A pointer to the descriptor to add.
+ * @param [in] A pointer to the descriptor to add.
 */
 void NimBLECharacteristic::addDescriptor(NimBLEDescriptor *pDescriptor) {
-    bool foundRemoved = false;
-
-    if(pDescriptor->m_removed > 0) {
-        for(auto& it : m_dscVec) {
-            if(it == pDescriptor) {
-                foundRemoved = true;
-                pDescriptor->m_removed = 0;
-            }
-        }
-    }
-
-    if(!foundRemoved) {
-        m_dscVec.push_back(pDescriptor);
-    }
-
    pDescriptor->setCharacteristic(this);
-    NimBLEDevice::getServer()->serviceChanged();
+    m_dscVec.push_back(pDescriptor);
 }


-/**
- * @brief Remove a descriptor from the characterisitc.
- * @param[in] pDescriptor A pointer to the descriptor instance to remove from the characterisitc.
- * @param[in] deleteDsc If true it will delete the descriptor instance and free it's resources.
- */
-void NimBLECharacteristic::removeDescriptor(NimBLEDescriptor *pDescriptor, bool deleteDsc) {
-    // Check if the descriptor was already removed and if so, check if this
-    // is being called to delete the object and do so if requested.
-    // Otherwise, ignore the call and return.
-    if(pDescriptor->m_removed > 0) {
-        if(deleteDsc) {
-            for(auto it = m_dscVec.begin(); it != m_dscVec.end(); ++it) {
-                if ((*it) == pDescriptor) {
-                    delete *it;
-                    m_dscVec.erase(it);
-                    break;
-                }
-            }
-        }
-
-        return;
-    }
-
-    pDescriptor->m_removed = deleteDsc ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE;
-    NimBLEDevice::getServer()->serviceChanged();
-} // removeDescriptor
-
-
 /**
 * @brief Return the BLE Descriptor for the given UUID.
 * @param [in] uuid The UUID of the descriptor.
@ -234,12 +194,12 @@ NimBLEUUID NimBLECharacteristic::getUUID() {
 * @return A std::string containing the current characteristic value.
 */
 std::string NimBLECharacteristic::getValue(time_t *timestamp) {
-    ble_npl_hw_enter_critical();
+    portENTER_CRITICAL(&m_valMux);
    std::string retVal = m_value;
    if(timestamp != nullptr) {
        *timestamp = m_timestamp;
    }
-    ble_npl_hw_exit_critical(0);
+    portEXIT_CRITICAL(&m_valMux);

    return retVal;
 } // getValue
@ -250,9 +210,10 @@ std::string NimBLECharacteristic::getValue(time_t *timestamp) {
 * @return The length of the current characteristic data.
 */
 size_t NimBLECharacteristic::getDataLength() {
-    ble_npl_hw_enter_critical();
+    portENTER_CRITICAL(&m_valMux);
    size_t len = m_value.length();
-    ble_npl_hw_exit_critical(0);
+    portEXIT_CRITICAL(&m_valMux);
+
    return len;
 }

@ -285,10 +246,11 @@ int NimBLECharacteristic::handleGapEvent(uint16_t conn_handle, uint16_t attr_han
                    pCharacteristic->m_pCallbacks->onRead(pCharacteristic, &desc);
                }

-                ble_npl_hw_enter_critical();
+                portENTER_CRITICAL(&pCharacteristic->m_valMux);
                rc = os_mbuf_append(ctxt->om, (uint8_t*)pCharacteristic->m_value.data(),
                                    pCharacteristic->m_value.length());
-                ble_npl_hw_exit_critical(0);
+                portEXIT_CRITICAL(&pCharacteristic->m_valMux);
+
                return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
            }

@ -394,7 +356,6 @@ void NimBLECharacteristic::indicate() {
    NIMBLE_LOGD(LOG_TAG, "<< indicate");
 } // indicate

-
 /**
 * @brief Send a notification.\n
 * A notification is a transmission of up to the first 20 bytes of the characteristic value.\n
@ -402,18 +363,8 @@ void NimBLECharacteristic::indicate() {
 * @param[in] is_notification if true sends a notification, false sends an indication.
 */
 void NimBLECharacteristic::notify(bool is_notification) {
-    notify(getValue(), is_notification);
-}
+    NIMBLE_LOGD(LOG_TAG, ">> notify: length: %d", getDataLength());

-/**
- * @brief Send a notification.\n
- * A notification is a transmission of up to the first 20 bytes of the characteristic value.\n
- * A notification will not block; it is a fire and forget.
- * @param[in] is_notification if true sends a notification, false sends an indication.
- */
-void NimBLECharacteristic::notify(std::string value, bool is_notification) {
-    size_t length = value.length();
-    NIMBLE_LOGD(LOG_TAG, ">> notify: length: %d", length);

    if(!(m_properties & NIMBLE_PROPERTY::NOTIFY) &&
       !(m_properties & NIMBLE_PROPERTY::INDICATE))
@ -430,13 +381,15 @@ void NimBLECharacteristic::notify(std::string value, bool is_notification) {

    m_pCallbacks->onNotify(this);

+    std::string value = getValue();
+    size_t length = value.length();
    bool reqSec = (m_properties & BLE_GATT_CHR_F_READ_AUTHEN) ||
                  (m_properties & BLE_GATT_CHR_F_READ_AUTHOR) ||
                  (m_properties & BLE_GATT_CHR_F_READ_ENC);
    int rc = 0;

    for (auto &it : m_subscribedVec) {
-        uint16_t _mtu = getService()->getServer()->getPeerMTU(it.first) - 3;
+        uint16_t _mtu = getService()->getServer()->getPeerMTU(it.first);

        // check if connected and subscribed
        if(_mtu == 0 || it.second == 0) {
@ -452,8 +405,8 @@ void NimBLECharacteristic::notify(std::string value, bool is_notification) {
            }
        }

-        if (length > _mtu) {
-            NIMBLE_LOGW(LOG_TAG, "- Truncating to %d bytes (maximum notify size)", _mtu);
+        if (length > _mtu - 3) {
+            NIMBLE_LOGW(LOG_TAG, "- Truncating to %d bytes (maximum notify size)", _mtu - 3);
        }

        if(is_notification && (!(it.second & NIMBLE_SUB_NOTIFY))) {
@ -520,7 +473,7 @@ NimBLECharacteristicCallbacks* NimBLECharacteristic::getCallbacks() {
 * @param [in] length The length of the data in bytes.
 */
 void NimBLECharacteristic::setValue(const uint8_t* data, size_t length) {
-#if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4
+#if CONFIG_LOG_DEFAULT_LEVEL > 3 || (ARDUINO_ARCH_ESP32 && !defined(DONT_USE_ARDUINO_BULLSHIT) && CORE_DEBUG_LEVEL >= 4)
    char* pHex = NimBLEUtils::buildHexData(nullptr, data, length);
    NIMBLE_LOGD(LOG_TAG, ">> setValue: length=%d, data=%s, characteristic UUID=%s", length, pHex, getUUID().toString().c_str());
    free(pHex);
@ -532,10 +485,10 @@ void NimBLECharacteristic::setValue(const uint8_t* data, size_t length) {
    }

    time_t t = time(nullptr);
-    ble_npl_hw_enter_critical();
+    portENTER_CRITICAL(&m_valMux);
    m_value = std::string((char*)data, length);
    m_timestamp = t;
-    ble_npl_hw_exit_critical(0);
+    portEXIT_CRITICAL(&m_valMux);

    NIMBLE_LOGD(LOG_TAG, "<< setValue");
 } // setValue
@ -645,4 +598,6 @@ void NimBLECharacteristicCallbacks::onSubscribe(NimBLECharacteristic* pCharacter
    NIMBLE_LOGD("NimBLECharacteristicCallbacks", "onSubscribe: default");
 }

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLECharacteristic.h
+++ b/src/NimBLECharacteristic.h
@ -13,15 +13,13 @@

 #ifndef MAIN_NIMBLECHARACTERISTIC_H_
 #define MAIN_NIMBLECHARACTERISTIC_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_hs.h"
-#else
-#include "nimble/nimble/host/include/host/ble_hs.h"
-#endif
-
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
@ -84,8 +82,6 @@ public:

    void              indicate();
    void              notify(bool is_notification = true);
-    void              notify(std::string value, bool is_notification = true);
-
    size_t            getSubscribedCount();

    NimBLEDescriptor* createDescriptor(const char* uuid,
@ -103,7 +99,6 @@ public:
    NimBLEDescriptor* getDescriptorByUUID(const char* uuid);
    NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID &uuid);
    NimBLEDescriptor* getDescriptorByHandle(uint16_t handle);
-    void              removeDescriptor(NimBLEDescriptor *pDescriptor, bool deleteDsc = false);

    std::string       getValue(time_t *timestamp = nullptr);
    size_t            getDataLength();
@ -155,8 +150,8 @@ private:
    NimBLEService*                 m_pService;
    std::string                    m_value;
    std::vector<NimBLEDescriptor*> m_dscVec;
+    portMUX_TYPE                   m_valMux;
    time_t                         m_timestamp;
-    uint8_t                        m_removed;

    std::vector<std::pair<uint16_t, uint16_t>>  m_subscribedVec;
 }; // NimBLECharacteristic
@ -198,5 +193,6 @@ public:
    virtual void onSubscribe(NimBLECharacteristic* pCharacteristic, ble_gap_conn_desc* desc, uint16_t subValue);
 };

-#endif /* CONFIG_BT_ENABLED  && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /*MAIN_NIMBLECHARACTERISTIC_H_*/
--- a/src/NimBLEClient.cpp
+++ b/src/NimBLEClient.cpp
@ -11,8 +11,11 @@
 *      Author: kolban
 */

+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLEClient.h"
 #include "NimBLEDevice.h"
@ -20,13 +23,9 @@

 #include <string>
 #include <unordered_set>
-#include <climits>

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "nimble/nimble_port.h"
-#else
-#include "nimble/porting/nimble/include/nimble/nimble_port.h"
-#endif
+

 static const char* LOG_TAG = "NimBLEClient";
 static NimBLEClientCallbacks defaultCallbacks;
@ -64,7 +63,6 @@ NimBLEClient::NimBLEClient(const NimBLEAddress &peerAddress) : m_peerAddress(pee
    m_deleteCallbacks  = false;
    m_pTaskData        = nullptr;
    m_connEstablished  = false;
-    m_lastErr          = 0;

    m_pConnParams.scan_itvl = 16;          // Scan interval in 0.625ms units (NimBLE Default)
    m_pConnParams.scan_window = 16;        // Scan window in 0.625ms units (NimBLE Default)
@ -75,7 +73,6 @@ NimBLEClient::NimBLEClient(const NimBLEAddress &peerAddress) : m_peerAddress(pee
    m_pConnParams.min_ce_len = BLE_GAP_INITIAL_CONN_MIN_CE_LEN; // Minimum length of connection event in 0.625ms units
    m_pConnParams.max_ce_len = BLE_GAP_INITIAL_CONN_MAX_CE_LEN; // Maximum length of connection event in 0.625ms units

-    memset(&m_dcTimer, 0, sizeof(m_dcTimer));
    ble_npl_callout_init(&m_dcTimer, nimble_port_get_dflt_eventq(),
                         NimBLEClient::dcTimerCb, this);
 } // NimBLEClient
@ -208,8 +205,7 @@ bool NimBLEClient::connect(const NimBLEAddress &address, bool deleteAttibutes) {
        m_peerAddress = address;
    }

-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
    m_pTaskData = &taskData;
    int rc = 0;

@ -255,17 +251,11 @@ bool NimBLEClient::connect(const NimBLEAddress &address, bool deleteAttibutes) {

    } while (rc == BLE_HS_EBUSY);

-    m_lastErr = rc;
-
    if(rc != 0) {
        m_pTaskData = nullptr;
        return false;
    }

-#ifdef ulTaskNotifyValueClear
-    // Clear the task notification value to ensure we block
-    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
    // Wait for the connect timeout time +1 second for the connection to complete
    if(ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(m_connectTimeout + 1000)) == pdFALSE) {
        m_pTaskData = nullptr;
@ -283,7 +273,6 @@ bool NimBLEClient::connect(const NimBLEAddress &address, bool deleteAttibutes) {
        return false;

    } else if(taskData.rc != 0){
-        m_lastErr = taskData.rc;
        NIMBLE_LOGE(LOG_TAG, "Connection failed; status=%d %s",
                    taskData.rc,
                    NimBLEUtils::returnCodeToString(taskData.rc));
@ -316,8 +305,7 @@ bool NimBLEClient::connect(const NimBLEAddress &address, bool deleteAttibutes) {
 * @return True on success.
 */
 bool NimBLEClient::secureConnection() {
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};

    int retryCount = 1;

@ -326,20 +314,14 @@ bool NimBLEClient::secureConnection() {

        int rc = NimBLEDevice::startSecurity(m_conn_id);
        if(rc != 0){
-            m_lastErr = rc;
            m_pTaskData = nullptr;
            return false;
        }

-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    } while (taskData.rc == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING) && retryCount--);

    if(taskData.rc != 0){
-        m_lastErr = taskData.rc;
        return false;
    }

@ -390,7 +372,6 @@ int NimBLEClient::disconnect(uint8_t reason) {
    }

    NIMBLE_LOGD(LOG_TAG, "<< disconnect()");
-    m_lastErr = rc;
    return rc;
 } // disconnect

@ -455,29 +436,6 @@ void NimBLEClient::updateConnParams(uint16_t minInterval, uint16_t maxInterval,
 } // updateConnParams


-/**
- * @brief Request an update of the data packet length.
- * * Can only be used after a connection has been established.
- * @details Sends a data length update request to the server the client is connected to.
- * The Data Length Extension (DLE) allows to increase the Data Channel Payload from 27 bytes to up to 251 bytes.
- * The server needs to support the Bluetooth 4.2 specifications, to be capable of DLE.
- * @param [in] tx_octets The preferred number of payload octets to use (Range 0x001B-0x00FB).
- */
-void NimBLEClient::setDataLen(uint16_t tx_octets) {
-#if defined(CONFIG_NIMBLE_CPP_IDF) && defined(ESP_IDF_VERSION) && \
-           ESP_IDF_VERSION <= ESP_IDF_VERSION_VAL(4,3,2)
-    return;
-#else
-    uint16_t tx_time = (tx_octets + 14) * 8;
-
-    int rc = ble_gap_set_data_len(m_conn_id, tx_octets, tx_time);
-    if(rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Set data length error: %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-    }
-#endif
-} // setDataLen
-
-
 /**
 * @brief Get detailed information about the current peer connection.
 */
@ -554,7 +512,6 @@ int NimBLEClient::getRssi() {
    if(rc != 0) {
        NIMBLE_LOGE(LOG_TAG, "Failed to read RSSI error code: %d, %s",
                                rc, NimBLEUtils::returnCodeToString(rc));
-        m_lastErr = rc;
        return 0;
    }

@ -682,8 +639,7 @@ bool NimBLEClient::retrieveServices(const NimBLEUUID *uuid_filter) {
    }

    int rc = 0;
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};

    if(uuid_filter == nullptr) {
        rc = ble_gattc_disc_all_svcs(m_conn_id, NimBLEClient::serviceDiscoveredCB, &taskData);
@ -694,18 +650,11 @@ bool NimBLEClient::retrieveServices(const NimBLEUUID *uuid_filter) {

    if (rc != 0) {
        NIMBLE_LOGE(LOG_TAG, "ble_gattc_disc_all_svcs: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
-        m_lastErr = rc;
        return false;
    }

-#ifdef ulTaskNotifyValueClear
-    // Clear the task notification value to ensure we block
-    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
-
    // wait until we have all the services
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
-    m_lastErr = taskData.rc;

    if(taskData.rc == 0){
        NIMBLE_LOGD(LOG_TAG, "<< retrieveServices");
@ -975,18 +924,19 @@ uint16_t NimBLEClient::getMTU() {
                    NIMBLE_LOGD(LOG_TAG, "Got Notification for characteristic %s",
                                (*characteristic)->toString().c_str());

-                    uint32_t data_len = OS_MBUF_PKTLEN(event->notify_rx.om);
                    time_t t = time(nullptr);
-                    ble_npl_hw_enter_critical();
-                    (*characteristic)->m_value = std::string((char *)event->notify_rx.om->om_data, data_len);
+                    portENTER_CRITICAL(&(*characteristic)->m_valMux);
+                    (*characteristic)->m_value = std::string((char *)event->notify_rx.om->om_data,
+                                                             event->notify_rx.om->om_len);
                    (*characteristic)->m_timestamp = t;
-                    ble_npl_hw_exit_critical(0);
+                    portEXIT_CRITICAL(&(*characteristic)->m_valMux);

                    if ((*characteristic)->m_notifyCallback != nullptr) {
                        NIMBLE_LOGD(LOG_TAG, "Invoking callback for notification on characteristic %s",
                                    (*characteristic)->toString().c_str());
                        (*characteristic)->m_notifyCallback(*characteristic, event->notify_rx.om->om_data,
-                                                            data_len, !event->notify_rx.indication);
+                                                            event->notify_rx.om->om_len,
+                                                            !event->notify_rx.indication);
                    }
                    break;
                }
@ -1084,7 +1034,7 @@ uint16_t NimBLEClient::getMTU() {
                NIMBLE_LOGD(LOG_TAG, "ble_sm_inject_io result: %d", rc);

            } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
-                NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %d", event->passkey.params.numcmp);
+                NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %lu", event->passkey.params.numcmp);
                pkey.action = event->passkey.params.action;
                // Compatibility only - Do not use, should be removed the in future
                if(NimBLEDevice::m_securityCallbacks != nullptr) {
@ -1186,15 +1136,6 @@ std::string NimBLEClient::toString() {
 } // toString


-/**
- * @brief Get the last error code reported by the NimBLE host
- * @return int, the NimBLE error code.
- */
-int NimBLEClient::getLastError() {
-    return m_lastErr;
-} // getLastError
-
-
 void NimBLEClientCallbacks::onConnect(NimBLEClient* pClient) {
    NIMBLE_LOGD("NimBLEClientCallbacks", "onConnect: default");
 }
@ -1229,4 +1170,5 @@ bool NimBLEClientCallbacks::onConfirmPIN(uint32_t pin){
    return true;
 }

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif // CONFIG_BT_ENABLED
--- a/src/NimBLEClient.h
+++ b/src/NimBLEClient.h
@ -14,8 +14,11 @@
 #ifndef MAIN_NIMBLECLIENT_H_
 #define MAIN_NIMBLECLIENT_H_

+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLEAddress.h"
 #include "NimBLEUUID.h"
@ -68,10 +71,8 @@ public:
                                                                    uint16_t scanInterval=16, uint16_t scanWindow=16);
    void                                        updateConnParams(uint16_t minInterval, uint16_t maxInterval,
                                                                 uint16_t latency, uint16_t timeout);
-    void                                        setDataLen(uint16_t tx_octets);
    void                                        discoverAttributes();
    NimBLEConnInfo                              getConnInfo();
-    int                                         getLastError();

 private:
    NimBLEClient(const NimBLEAddress &peerAddress);
@ -89,7 +90,6 @@ private:
    bool                    retrieveServices(const NimBLEUUID *uuid_filter = nullptr);

    NimBLEAddress           m_peerAddress;
-    int                     m_lastErr;
    uint16_t                m_conn_id;
    bool                    m_connEstablished;
    bool                    m_deleteCallbacks;
@ -158,5 +158,6 @@ public:
    virtual bool onConfirmPIN(uint32_t pin);
 };

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif // CONFIG_BT_ENABLED
 #endif /* MAIN_NIMBLECLIENT_H_ */
--- a/src/NimBLEDescriptor.cpp
+++ b/src/NimBLEDescriptor.cpp
@ -11,9 +11,11 @@
 *  Created on: Jun 22, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLEService.h"
 #include "NimBLEDescriptor.h"
@ -49,8 +51,8 @@ NimBLEDescriptor::NimBLEDescriptor(NimBLEUUID uuid, uint16_t properties, uint16_
    m_pCharacteristic    = pCharacteristic;
    m_pCallbacks         = &defaultCallbacks;           // No initial callback.
    m_value.attr_value   = (uint8_t*) calloc(max_len,1);  // Allocate storage for the value.
+    m_valMux             = portMUX_INITIALIZER_UNLOCKED;
    m_properties         = 0;
-    m_removed            = 0;

    if (properties & BLE_GATT_CHR_F_READ) {             // convert uint16_t properties to uint8_t
        m_properties |= BLE_ATT_F_READ;
@ -142,9 +144,6 @@ NimBLECharacteristic* NimBLEDescriptor::getCharacteristic() {

 int NimBLEDescriptor::handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
                                     struct ble_gatt_access_ctxt *ctxt, void *arg) {
-    (void)conn_handle;
-    (void)attr_handle;
-
    const ble_uuid_t *uuid;
    int rc;
    NimBLEDescriptor* pDescriptor = (NimBLEDescriptor*)arg;
@ -161,10 +160,9 @@ int NimBLEDescriptor::handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
                if(ctxt->om->om_pkthdr_len > 8) {
                    pDescriptor->m_pCallbacks->onRead(pDescriptor);
                }
-
-                ble_npl_hw_enter_critical();
+                portENTER_CRITICAL(&pDescriptor->m_valMux);
                rc = os_mbuf_append(ctxt->om, pDescriptor->getValue(), pDescriptor->getLength());
-                ble_npl_hw_exit_critical(0);
+                portEXIT_CRITICAL(&pDescriptor->m_valMux);
                return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
            }

@ -235,12 +233,10 @@ void NimBLEDescriptor::setValue(const uint8_t* data, size_t length) {
        NIMBLE_LOGE(LOG_TAG, "Size %d too large, must be no bigger than %d", length, m_value.attr_max_len);
        return;
    }
-
-    ble_npl_hw_enter_critical();
+    portENTER_CRITICAL(&m_valMux);
    m_value.attr_len = length;
    memcpy(m_value.attr_value, data, length);
-    ble_npl_hw_exit_critical(0);
-
+    portEXIT_CRITICAL(&m_valMux);
 } // setValue


@ -280,7 +276,6 @@ NimBLEDescriptorCallbacks::~NimBLEDescriptorCallbacks() {}
 * @param [in] pDescriptor The descriptor that is the source of the event.
 */
 void NimBLEDescriptorCallbacks::onRead(NimBLEDescriptor* pDescriptor) {
-    (void)pDescriptor;
    NIMBLE_LOGD("NimBLEDescriptorCallbacks", "onRead: default");
 } // onRead

@ -290,8 +285,8 @@ void NimBLEDescriptorCallbacks::onRead(NimBLEDescriptor* pDescriptor) {
 * @param [in] pDescriptor The descriptor that is the source of the event.
 */
 void NimBLEDescriptorCallbacks::onWrite(NimBLEDescriptor* pDescriptor) {
-    (void)pDescriptor;
    NIMBLE_LOGD("NimBLEDescriptorCallbacks", "onWrite: default");
 } // onWrite

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLEDescriptor.h
+++ b/src/NimBLEDescriptor.h
@ -14,9 +14,11 @@

 #ifndef MAIN_NIMBLEDESCRIPTOR_H_
 #define MAIN_NIMBLEDESCRIPTOR_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLECharacteristic.h"
 #include "NimBLEUUID.h"
@ -90,7 +92,7 @@ private:
    NimBLECharacteristic*      m_pCharacteristic;
    uint8_t                    m_properties;
    attr_value_t               m_value;
-    uint8_t                    m_removed;
+    portMUX_TYPE               m_valMux;
 }; // NimBLEDescriptor


@ -110,5 +112,6 @@ public:

 #include "NimBLE2904.h"

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* MAIN_NIMBLEDESCRIPTOR_H_ */
--- a/src/NimBLEDevice.cpp
+++ b/src/NimBLEDevice.cpp
@ -11,45 +11,27 @@
 *  Created on: Mar 16, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "NimBLEDevice.h"
 #include "NimBLEUtils.h"

-#ifdef ESP_PLATFORM
-#  include "esp_err.h"
-#  include "esp_bt.h"
-#  include "nvs_flash.h"
-#  if defined(CONFIG_NIMBLE_CPP_IDF)
-#    include "esp_nimble_hci.h"
-#    include "nimble/nimble_port.h"
-#    include "nimble/nimble_port_freertos.h"
-#    include "host/ble_hs.h"
-#    include "host/ble_hs_pvcy.h"
-#    include "host/util/util.h"
-#    include "services/gap/ble_svc_gap.h"
-#    include "services/gatt/ble_svc_gatt.h"
-#  else
-#    include "nimble/esp_port/esp-hci/include/esp_nimble_hci.h"
-#  endif
-#else
-#  include "nimble/nimble/controller/include/controller/ble_phy.h"
-#endif
+#include "esp_err.h"
+#include "esp_bt.h"
+#include "nvs_flash.h"
+#include "esp_nimble_hci.h"
+#include "nimble/nimble_port.h"
+#include "nimble/nimble_port_freertos.h"
+#include "host/ble_hs.h"
+#include "host/ble_hs_pvcy.h"
+#include "host/util/util.h"
+#include "services/gap/ble_svc_gap.h"
+#include "services/gatt/ble_svc_gatt.h"

-#ifndef CONFIG_NIMBLE_CPP_IDF
-#  include "nimble/porting/nimble/include/nimble/nimble_port.h"
-#  include "nimble/porting/npl/freertos/include/nimble/nimble_port_freertos.h"
-#  include "nimble/nimble/host/include/host/ble_hs.h"
-#  include "nimble/nimble/host/include/host/ble_hs_pvcy.h"
-#  include "nimble/nimble/host/util/include/host/util/util.h"
-#  include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
-#  include "nimble/nimble/host/services/gatt/include/services/gatt/ble_svc_gatt.h"
-#endif
-
-#if defined(ESP_PLATFORM) && defined(CONFIG_ENABLE_ARDUINO_DEPENDS)
-#  include "esp32-hal-bt.h"
+#if defined(CONFIG_ENABLE_ARDUINO_DEPENDS) && !defined(DONT_USE_ARDUINO_BULLSHIT)
+#include "esp32-hal-bt.h"
 #endif

 #include "NimBLELog.h"
@ -81,10 +63,9 @@ std::list <NimBLEAddress>   NimBLEDevice::m_ignoreList;
 std::vector<NimBLEAddress>  NimBLEDevice::m_whiteList;
 NimBLESecurityCallbacks*    NimBLEDevice::m_securityCallbacks = nullptr;
 uint8_t                     NimBLEDevice::m_own_addr_type = BLE_OWN_ADDR_PUBLIC;
-#ifdef ESP_PLATFORM
 uint16_t                    NimBLEDevice::m_scanDuplicateSize = CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE;
 uint8_t                     NimBLEDevice::m_scanFilterMode = CONFIG_BTDM_SCAN_DUPL_TYPE;
-#endif
+

 /**
 * @brief Create a new instance of a server.
@ -149,8 +130,7 @@ void NimBLEDevice::stopAdvertising() {
 * try and release/delete it.
 */
 #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
-/* STATIC */
-NimBLEScan* NimBLEDevice::getScan() {
+/* STATIC */ NimBLEScan* NimBLEDevice::getScan() {
    if (m_pScan == nullptr) {
        m_pScan = new NimBLEScan();
    }
@ -167,8 +147,7 @@ NimBLEScan* NimBLEDevice::getScan() {
 * @return A reference to the new client object.
 */
 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-/* STATIC */
-NimBLEClient* NimBLEDevice::createClient(NimBLEAddress peerAddress) {
+/* STATIC */ NimBLEClient* NimBLEDevice::createClient(NimBLEAddress peerAddress) {
    if(m_cList.size() >= NIMBLE_MAX_CONNECTIONS) {
        NIMBLE_LOGW(LOG_TAG,"Number of clients exceeds Max connections. Cur=%d Max=%d",
                    m_cList.size(), NIMBLE_MAX_CONNECTIONS);
@ -186,8 +165,7 @@ NimBLEClient* NimBLEDevice::createClient(NimBLEAddress peerAddress) {
 * Checks if it is connected or trying to connect and disconnects/stops it first.
 * @param [in] pClient A pointer to the client object.
 */
-/* STATIC */
-bool NimBLEDevice::deleteClient(NimBLEClient* pClient) {
+/* STATIC */ bool NimBLEDevice::deleteClient(NimBLEClient* pClient) {
    if(pClient == nullptr) {
        return false;
    }
@ -231,8 +209,7 @@ bool NimBLEDevice::deleteClient(NimBLEClient* pClient) {
 * @brief Get the list of created client objects.
 * @return A pointer to the list of clients.
 */
-/* STATIC */
-std::list<NimBLEClient*>* NimBLEDevice::getClientList() {
+/* STATIC */std::list<NimBLEClient*>* NimBLEDevice::getClientList() {
    return &m_cList;
 } // getClientList

@ -241,8 +218,7 @@ std::list<NimBLEClient*>* NimBLEDevice::getClientList() {
 * @brief Get the number of created client objects.
 * @return Number of client objects created.
 */
-/* STATIC */
-size_t NimBLEDevice::getClientListSize() {
+/* STATIC */size_t NimBLEDevice::getClientListSize() {
    return m_cList.size();
 } // getClientList

@ -252,8 +228,7 @@ size_t NimBLEDevice::getClientListSize() {
 * @param [in] conn_id The client connection ID to search for.
 * @return A pointer to the client object with the spcified connection ID.
 */
-/* STATIC */
-NimBLEClient* NimBLEDevice::getClientByID(uint16_t conn_id) {
+/* STATIC */NimBLEClient* NimBLEDevice::getClientByID(uint16_t conn_id) {
    for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
        if((*it)->getConnId() == conn_id) {
            return (*it);
@ -269,8 +244,7 @@ NimBLEClient* NimBLEDevice::getClientByID(uint16_t conn_id) {
 * @param [in] peer_addr The address of the peer to search for.
 * @return A pointer to the client object with the peer address.
 */
-/* STATIC */
-NimBLEClient* NimBLEDevice::getClientByPeerAddress(const NimBLEAddress &peer_addr) {
+/* STATIC */NimBLEClient* NimBLEDevice::getClientByPeerAddress(const NimBLEAddress &peer_addr) {
    for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
        if((*it)->getPeerAddress().equals(peer_addr)) {
            return (*it);
@ -284,8 +258,7 @@ NimBLEClient* NimBLEDevice::getClientByPeerAddress(const NimBLEAddress &peer_add
 * @brief Finds the first disconnected client in the list.
 * @return A pointer to the first client object that is not connected to a peer.
 */
-/* STATIC */
-NimBLEClient* NimBLEDevice::getDisconnectedClient() {
+/* STATIC */NimBLEClient* NimBLEDevice::getDisconnectedClient() {
    for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
        if(!(*it)->isConnected()) {
            return (*it);
@ -296,7 +269,7 @@ NimBLEClient* NimBLEDevice::getDisconnectedClient() {

 #endif // #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)

-#ifdef ESP_PLATFORM
+
 /**
 * @brief Set the transmission power.
 * @param [in] powerLevel The power level to set, can be one of:
@ -322,15 +295,12 @@ NimBLEClient* NimBLEDevice::getDisconnectedClient() {
 * *   ESP_BLE_PWR_TYPE_SCAN       = 10, For scan
 * *   ESP_BLE_PWR_TYPE_DEFAULT    = 11, For default, if not set other, it will use default value
 */
-/* STATIC */
-void NimBLEDevice::setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType) {
+/* STATIC */ void NimBLEDevice::setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType) {
    NIMBLE_LOGD(LOG_TAG, ">> setPower: %d (type: %d)", powerLevel, powerType);
-
    esp_err_t errRc = esp_ble_tx_power_set(powerType, powerLevel);
    if (errRc != ESP_OK) {
        NIMBLE_LOGE(LOG_TAG, "esp_ble_tx_power_set: rc=%d", errRc);
    }
-
    NIMBLE_LOGD(LOG_TAG, "<< setPower");
 } // setPower

@ -352,8 +322,9 @@ void NimBLEDevice::setPower(esp_power_level_t powerLevel, esp_ble_power_type_t p
 * *   ESP_BLE_PWR_TYPE_DEFAULT    = 11, For default, if not set other, it will use default value
 * @return the power level currently used by the type specified.
 */
-/* STATIC */
-int NimBLEDevice::getPower(esp_ble_power_type_t powerType) {
+
+/* STATIC */ int NimBLEDevice::getPower(esp_ble_power_type_t powerType) {
+
    switch(esp_ble_tx_power_get(powerType)) {
        case ESP_PWR_LVL_N12:
            return -12;
@ -376,25 +347,13 @@ int NimBLEDevice::getPower(esp_ble_power_type_t powerType) {
    }
 } // getPower

-#else
-
-void NimBLEDevice::setPower(int dbm) {
-    ble_phy_txpwr_set(dbm);
-}
-
-
-int NimBLEDevice::getPower() {
-    return ble_phy_txpwr_get();
-}
-#endif

 /**
 * @brief Get our device address.
 * @return A NimBLEAddress object of our public address if we have one,
 * if not then our current random address.
 */
-/* STATIC*/
-NimBLEAddress NimBLEDevice::getAddress() {
+/* STATIC*/ NimBLEAddress NimBLEDevice::getAddress() {
    ble_addr_t addr = {BLE_ADDR_PUBLIC, 0};

    if(BLE_HS_ENOADDR == ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, addr.val, NULL)) {
@ -411,8 +370,7 @@ NimBLEAddress NimBLEDevice::getAddress() {
 * @brief Return a string representation of the address of this device.
 * @return A string representation of this device address.
 */
-/* STATIC */
-std::string NimBLEDevice::toString() {
+/* STATIC */ std::string NimBLEDevice::toString() {
    return getAddress().toString();
 } // toString

@ -422,8 +380,7 @@ std::string NimBLEDevice::toString() {
 * @param [in] mtu Value to set local mtu:
 * * This should be larger than 23 and lower or equal to BLE_ATT_MTU_MAX = 527.
 */
-/* STATIC */
-int NimBLEDevice::setMTU(uint16_t mtu) {
+/* STATIC */int NimBLEDevice::setMTU(uint16_t mtu) {
    NIMBLE_LOGD(LOG_TAG, ">> setLocalMTU: %d", mtu);

    int rc =  ble_att_set_preferred_mtu(mtu);
@ -441,13 +398,11 @@ int NimBLEDevice::setMTU(uint16_t mtu) {
 * @brief Get local MTU value set.
 * @return The current preferred MTU setting.
 */
-/* STATIC */
-uint16_t NimBLEDevice::getMTU() {
+/* STATIC */uint16_t NimBLEDevice::getMTU() {
    return ble_att_preferred_mtu();
 }


-#ifdef ESP_PLATFORM
 /**
 * @brief Set the duplicate filter cache size for filtering scanned devices.
 * @param [in] cacheSize The number of advertisements filtered before the cache is reset.\n
@ -493,7 +448,6 @@ void NimBLEDevice::setScanFilterMode(uint8_t mode) {

    m_scanFilterMode = mode;
 }
-#endif

 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL) || defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 /**
@ -516,7 +470,7 @@ int NimBLEDevice::getNumBonds() {
 /**
 * @brief Deletes all bonding information.
 */
-/*STATIC*/
+ /*STATIC*/
 void NimBLEDevice::deleteAllBonds() {
    ble_store_clear();
 }
@ -596,7 +550,6 @@ NimBLEAddress NimBLEDevice::getBondedAddress(int index) {
 * @param [in] address The address to check for in the whitelist.
 * @returns true if the address is in the whitelist.
 */
-/*STATIC*/
 bool NimBLEDevice::onWhiteList(const NimBLEAddress & address) {
    for (auto &it : m_whiteList) {
        if (it == address) {
@ -613,7 +566,6 @@ bool NimBLEDevice::onWhiteList(const NimBLEAddress & address) {
 * @param [in] address The address to add to the whitelist.
 * @returns true if successful.
 */
-/*STATIC*/
 bool NimBLEDevice::whiteListAdd(const NimBLEAddress & address) {
    if (NimBLEDevice::onWhiteList(address)) {
        return true;
@ -645,7 +597,6 @@ bool NimBLEDevice::whiteListAdd(const NimBLEAddress & address) {
 * @param [in] address The address to remove from the whitelist.
 * @returns true if successful.
 */
-/*STATIC*/
 bool NimBLEDevice::whiteListRemove(const NimBLEAddress & address) {
    if (!NimBLEDevice::onWhiteList(address)) {
        return true;
@ -685,7 +636,6 @@ bool NimBLEDevice::whiteListRemove(const NimBLEAddress & address) {
 * @brief Gets the count of addresses in the whitelist.
 * @returns The number of addresses in the whitelist.
 */
-/*STATIC*/
 size_t NimBLEDevice::getWhiteListCount() {
    return m_whiteList.size();
 }
@ -696,7 +646,6 @@ size_t NimBLEDevice::getWhiteListCount() {
 * @param [in] index The vector index to retrieve the address from.
 * @returns the NimBLEAddress at the whitelist index or nullptr if not found.
 */
-/*STATIC*/
 NimBLEAddress NimBLEDevice::getWhiteListAddress(size_t index) {
    if (index > m_whiteList.size()) {
        NIMBLE_LOGE(LOG_TAG, "Invalid index; %u", index);
@ -710,8 +659,7 @@ NimBLEAddress NimBLEDevice::getWhiteListAddress(size_t index) {
 * @brief Host reset, we pass the message so we don't make calls until resynced.
 * @param [in] reason The reason code for the reset.
 */
-/* STATIC */
-void NimBLEDevice::onReset(int reason)
+/* STATIC */  void NimBLEDevice::onReset(int reason)
 {
    if(!m_synced) {
        return;
@ -735,8 +683,7 @@ void NimBLEDevice::onReset(int reason)
 /**
 * @brief Host resynced with controller, all clear to make calls to the stack.
 */
-/* STATIC */
-void NimBLEDevice::onSync(void)
+/* STATIC */ void NimBLEDevice::onSync(void)
 {
    NIMBLE_LOGI(LOG_TAG, "NimBle host synced.");
    // This check is needed due to potentially being called multiple times in succession
@ -749,14 +696,6 @@ void NimBLEDevice::onSync(void)
    int rc = ble_hs_util_ensure_addr(0);
    assert(rc == 0);

-#ifndef ESP_PLATFORM
-    rc = ble_hs_id_infer_auto(m_own_addr_type, &m_own_addr_type);
-    if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "error determining address type; rc=%d", rc);
-        return;
-    }
-#endif
-
    // Yield for houskeeping before returning to operations.
    // Occasionally triggers exception without.
    taskYIELD();
@ -782,11 +721,9 @@ void NimBLEDevice::onSync(void)
 /**
 * @brief The main host task.
 */
-/* STATIC */
-void NimBLEDevice::host_task(void *param)
+/* STATIC */ void NimBLEDevice::host_task(void *param)
 {
    NIMBLE_LOGI(LOG_TAG, "BLE Host Task Started");
-
    /* This function will return only when nimble_port_stop() is executed */
    nimble_port_run();

@ -798,14 +735,12 @@ void NimBLEDevice::host_task(void *param)
 * @brief Initialize the %BLE environment.
 * @param [in] deviceName The device name of the device.
 */
-/* STATIC */
-void NimBLEDevice::init(const std::string &deviceName) {
+/* STATIC */ void NimBLEDevice::init(const std::string &deviceName) {
    if(!initialized){
        int rc=0;
-#ifdef ESP_PLATFORM
        esp_err_t errRc = ESP_OK;

-#ifdef CONFIG_ENABLE_ARDUINO_DEPENDS
+#if defined(CONFIG_ENABLE_ARDUINO_DEPENDS) && !defined(DONT_USE_ARDUINO_BULLSHIT)
        // make sure the linker includes esp32-hal-bt.c so ardruino init doesn't release BLE memory.
        btStarted();
 #endif
@ -822,19 +757,14 @@ void NimBLEDevice::init(const std::string &deviceName) {
        esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT);

        esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
-#if  defined (CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
-        bt_cfg.bluetooth_mode = ESP_BT_MODE_BLE;
-#else
        bt_cfg.mode = ESP_BT_MODE_BLE;
        bt_cfg.ble_max_conn = CONFIG_BT_NIMBLE_MAX_CONNECTIONS;
-#endif
        bt_cfg.normal_adv_size = m_scanDuplicateSize;
        bt_cfg.scan_duplicate_type = m_scanFilterMode;

        ESP_ERROR_CHECK(esp_bt_controller_init(&bt_cfg));
        ESP_ERROR_CHECK(esp_bt_controller_enable(ESP_BT_MODE_BLE));
        ESP_ERROR_CHECK(esp_nimble_hci_init());
-#endif
        nimble_port_init();

        // Setup callbacks for host events
@ -853,16 +783,17 @@ void NimBLEDevice::init(const std::string &deviceName) {

        // Set the device name.
        rc = ble_svc_gap_device_name_set(deviceName.c_str());
+        if (rc != 0)
+            NIMBLE_LOGE(LOG_TAG, "ble_svc_gap_device_name_set() failed %i name_size=%zd", rc, deviceName.size());
        assert(rc == 0);

        ble_store_config_init();

        nimble_port_freertos_init(NimBLEDevice::host_task);
    }
-
    // Wait for host and controller to sync before returning and accepting new tasks
    while(!m_synced){
-        taskYIELD();
+        vTaskDelay(1 / portTICK_PERIOD_MS);
    }

    initialized = true; // Set the initialization flag to ensure we are only initialized once.
@ -874,17 +805,18 @@ void NimBLEDevice::init(const std::string &deviceName) {
 * @param [in] clearAll If true, deletes all server/advertising/scan/client objects after deinitializing.
 * @note If clearAll is true when called, any references to the created objects become invalid.
 */
-/* STATIC */
-void NimBLEDevice::deinit(bool clearAll) {
+/* STATIC */ void NimBLEDevice::deinit(bool clearAll) {
    int ret = nimble_port_stop();
    if (ret == 0) {
        nimble_port_deinit();
-#ifdef ESP_PLATFORM
+
+#if 0
        ret = esp_nimble_hci_and_controller_deinit();
        if (ret != ESP_OK) {
            NIMBLE_LOGE(LOG_TAG, "esp_nimble_hci_and_controller_deinit() failed with error: %d", ret);
        }
 #endif
+
        initialized = false;
        m_synced = false;

@ -931,7 +863,6 @@ void NimBLEDevice::deinit(bool clearAll) {
 * @brief Check if the initialization is complete.
 * @return true if initialized.
 */
-/*STATIC*/
 bool NimBLEDevice::getInitialized() {
    return initialized;
 } // getInitialized
@ -943,8 +874,7 @@ bool NimBLEDevice::getInitialized() {
 * @param mitm If true we are capable of man in the middle protection, false if not.
 * @param sc If true we will perform secure connection pairing, false we will use legacy pairing.
 */
-/*STATIC*/
-void NimBLEDevice::setSecurityAuth(bool bonding, bool mitm, bool sc) {
+/*STATIC*/ void NimBLEDevice::setSecurityAuth(bool bonding, bool mitm, bool sc) {
    NIMBLE_LOGD(LOG_TAG, "Setting bonding: %d, mitm: %d, sc: %d",bonding,mitm,sc);
    ble_hs_cfg.sm_bonding = bonding;
    ble_hs_cfg.sm_mitm = mitm;
@ -961,8 +891,7 @@ void NimBLEDevice::setSecurityAuth(bool bonding, bool mitm, bool sc) {
 * * 0x08 BLE_SM_PAIR_AUTHREQ_SC
 * * 0x10 BLE_SM_PAIR_AUTHREQ_KEYPRESS  - not yet supported.
 */
-/*STATIC*/
-void NimBLEDevice::setSecurityAuth(uint8_t auth_req) {
+/*STATIC*/void NimBLEDevice::setSecurityAuth(uint8_t auth_req) {
    NimBLEDevice::setSecurityAuth((auth_req & BLE_SM_PAIR_AUTHREQ_BOND)>0,
                                (auth_req & BLE_SM_PAIR_AUTHREQ_MITM)>0,
                                (auth_req & BLE_SM_PAIR_AUTHREQ_SC)>0);
@ -978,8 +907,7 @@ void NimBLEDevice::setSecurityAuth(uint8_t auth_req) {
 * * 0x03 BLE_HS_IO_NO_INPUT_OUTPUT      NoInputNoOutput IO capability
 * * 0x04 BLE_HS_IO_KEYBOARD_DISPLAY     KeyboardDisplay Only IO capability
 */
-/*STATIC*/
-void NimBLEDevice::setSecurityIOCap(uint8_t iocap) {
+/*STATIC*/ void NimBLEDevice::setSecurityIOCap(uint8_t iocap) {
    ble_hs_cfg.sm_io_cap = iocap;
 } // setSecurityIOCap

@ -993,8 +921,7 @@ void NimBLEDevice::setSecurityIOCap(uint8_t iocap) {
 * * 0x04: BLE_SM_PAIR_KEY_DIST_SIGN
 * * 0x08: BLE_SM_PAIR_KEY_DIST_LINK
 */
-/*STATIC*/
-void NimBLEDevice::setSecurityInitKey(uint8_t init_key) {
+/*STATIC*/void NimBLEDevice::setSecurityInitKey(uint8_t init_key) {
    ble_hs_cfg.sm_our_key_dist = init_key;
 } // setsSecurityInitKey

@ -1008,8 +935,7 @@ void NimBLEDevice::setSecurityInitKey(uint8_t init_key) {
 * * 0x04: BLE_SM_PAIR_KEY_DIST_SIGN
 * * 0x08: BLE_SM_PAIR_KEY_DIST_LINK
 */
-/*STATIC*/
-void NimBLEDevice::setSecurityRespKey(uint8_t resp_key) {
+/*STATIC*/void NimBLEDevice::setSecurityRespKey(uint8_t resp_key) {
    ble_hs_cfg.sm_their_key_dist = resp_key;
 } // setsSecurityRespKey

@ -1018,8 +944,7 @@ void NimBLEDevice::setSecurityRespKey(uint8_t resp_key) {
 * @brief Set the passkey the server will ask for when pairing.
 * @param [in] pin The passkey to use.
 */
-/*STATIC*/
-void NimBLEDevice::setSecurityPasskey(uint32_t pin) {
+/*STATIC*/void NimBLEDevice::setSecurityPasskey(uint32_t pin) {
    m_passkey = pin;
 } // setSecurityPasskey

@ -1028,8 +953,7 @@ void NimBLEDevice::setSecurityPasskey(uint32_t pin) {
 * @brief Get the current passkey used for pairing.
 * @return The current passkey.
 */
-/*STATIC*/
-uint32_t NimBLEDevice::getSecurityPasskey() {
+/*STATIC*/uint32_t NimBLEDevice::getSecurityPasskey() {
    return m_passkey;
 } // getSecurityPasskey

@ -1039,13 +963,11 @@ uint32_t NimBLEDevice::getSecurityPasskey() {
 * @param [in] callbacks Pointer to NimBLESecurityCallbacks class
 * @deprecated For backward compatibility, New code should use client/server callback methods.
 */
-/*STATIC*/
 void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
    NimBLEDevice::m_securityCallbacks = callbacks;
 } // setSecurityCallbacks


-#ifdef ESP_PLATFORM
 /**
 * @brief Set the own address type.
 * @param [in] own_addr_type Own Bluetooth Device address type.\n
@ -1056,39 +978,35 @@ void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
 * * 0x03: BLE_OWN_ADDR_RPA_RANDOM_DEFAULT
 * @param [in] useNRPA If true, and address type is random, uses a non-resolvable random address.
 */
-/*STATIC*/
 void NimBLEDevice::setOwnAddrType(uint8_t own_addr_type, bool useNRPA) {
    m_own_addr_type = own_addr_type;
    switch (own_addr_type) {
-#ifdef CONFIG_IDF_TARGET_ESP32
        case BLE_OWN_ADDR_PUBLIC:
            ble_hs_pvcy_rpa_config(NIMBLE_HOST_DISABLE_PRIVACY);
            break;
-#endif
        case BLE_OWN_ADDR_RANDOM:
            setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
-#ifdef CONFIG_IDF_TARGET_ESP32
            ble_hs_pvcy_rpa_config(useNRPA ? NIMBLE_HOST_ENABLE_NRPA : NIMBLE_HOST_ENABLE_RPA);
-#endif
            break;
        case BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT:
        case BLE_OWN_ADDR_RPA_RANDOM_DEFAULT:
            setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
-#ifdef CONFIG_IDF_TARGET_ESP32
            ble_hs_pvcy_rpa_config(NIMBLE_HOST_ENABLE_RPA);
-#endif
            break;
    }
 } // setOwnAddrType
-#endif
+

 /**
 * @brief Start the connection securing and authorization for this connection.
 * @param conn_id The connection id of the peer device.
 * @returns NimBLE stack return code, 0 = success.
 */
-/* STATIC */
-int NimBLEDevice::startSecurity(uint16_t conn_id) {
+/* STATIC */int NimBLEDevice::startSecurity(uint16_t conn_id) {
+  /*  if(m_securityCallbacks != nullptr) {
+        m_securityCallbacks->onSecurityRequest();
+    }
+  */
    int rc = ble_gap_security_initiate(conn_id);
    if(rc != 0){
        NIMBLE_LOGE(LOG_TAG, "ble_gap_security_initiate: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
@ -1103,8 +1021,7 @@ int NimBLEDevice::startSecurity(uint16_t conn_id) {
 * @param [in] address The address to look for.
 * @return True if ignoring.
 */
-/*STATIC*/
-bool NimBLEDevice::isIgnored(const NimBLEAddress &address) {
+/*STATIC*/ bool NimBLEDevice::isIgnored(const NimBLEAddress &address) {
    for(auto &it : m_ignoreList) {
        if(it.equals(address)){
            return true;
@ -1119,8 +1036,7 @@ bool NimBLEDevice::isIgnored(const NimBLEAddress &address) {
 * @brief Add a device to the ignore list.
 * @param [in] address The address of the device we want to ignore.
 */
-/*STATIC*/
-void NimBLEDevice::addIgnored(const NimBLEAddress &address) {
+/*STATIC*/ void NimBLEDevice::addIgnored(const NimBLEAddress &address) {
    m_ignoreList.push_back(address);
 }

@ -1129,8 +1045,7 @@ void NimBLEDevice::addIgnored(const NimBLEAddress &address) {
 * @brief Remove a device from the ignore list.
 * @param [in] address The address of the device we want to remove from the list.
 */
-/*STATIC*/
-void  NimBLEDevice::removeIgnored(const NimBLEAddress &address) {
+/*STATIC*/void  NimBLEDevice::removeIgnored(const NimBLEAddress &address) {
    for(auto it = m_ignoreList.begin(); it != m_ignoreList.end(); ++it) {
        if((*it).equals(address)){
            m_ignoreList.erase(it);
@ -1144,7 +1059,6 @@ void  NimBLEDevice::removeIgnored(const NimBLEAddress &address) {
 * @brief Set a custom callback for gap events.
 * @param [in] handler The function to call when gap events occur.
 */
-/*STATIC*/
 void NimBLEDevice::setCustomGapHandler(gap_event_handler handler) {
    m_customGapHandler = handler;
    int rc = ble_gap_event_listener_register(&m_listener, m_customGapHandler, NULL);
@ -1156,4 +1070,5 @@ void NimBLEDevice::setCustomGapHandler(gap_event_handler handler) {
    }
 } // setCustomGapHandler

+
 #endif // CONFIG_BT_ENABLED
--- a/src/NimBLEDevice.h
+++ b/src/NimBLEDevice.h
@ -14,9 +14,10 @@

 #ifndef MAIN_NIMBLEDEVICE_H_
 #define MAIN_NIMBLEDEVICE_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)

 #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 #include "NimBLEScan.h"
@ -38,9 +39,7 @@
 #include "NimBLESecurity.h"
 #include "NimBLEAddress.h"

-#ifdef ESP_PLATFORM
-#  include "esp_bt.h"
-#endif
+#include "esp_bt.h"

 #include <map>
 #include <string>
@ -111,17 +110,8 @@ public:
    static NimBLEServer*    getServer();
 #endif

-#ifdef ESP_PLATFORM
    static void             setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType=ESP_BLE_PWR_TYPE_DEFAULT);
    static int              getPower(esp_ble_power_type_t powerType=ESP_BLE_PWR_TYPE_DEFAULT);
-    static void             setOwnAddrType(uint8_t own_addr_type, bool useNRPA=false);
-    static void             setScanDuplicateCacheSize(uint16_t cacheSize);
-    static void             setScanFilterMode(uint8_t type);
-#else
-    static void             setPower(int dbm);
-    static int              getPower();
-#endif
-
    static void             setCustomGapHandler(gap_event_handler handler);
    static void             setSecurityAuth(bool bonding, bool mitm, bool sc);
    static void             setSecurityAuth(uint8_t auth_req);
@ -131,12 +121,15 @@ public:
    static void             setSecurityPasskey(uint32_t pin);
    static uint32_t         getSecurityPasskey();
    static void             setSecurityCallbacks(NimBLESecurityCallbacks* pCallbacks);
+    static void             setOwnAddrType(uint8_t own_addr_type, bool useNRPA=false);
    static int              startSecurity(uint16_t conn_id);
    static int              setMTU(uint16_t mtu);
    static uint16_t         getMTU();
    static bool             isIgnored(const NimBLEAddress &address);
    static void             addIgnored(const NimBLEAddress &address);
    static void             removeIgnored(const NimBLEAddress &address);
+    static void             setScanDuplicateCacheSize(uint16_t cacheSize);
+    static void             setScanFilterMode(uint8_t type);

 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
    static NimBLEAdvertising* getAdvertising();
@ -206,10 +199,8 @@ private:
    static ble_gap_event_listener     m_listener;
    static gap_event_handler          m_customGapHandler;
    static uint8_t                    m_own_addr_type;
-#ifdef ESP_PLATFORM
    static uint16_t                   m_scanDuplicateSize;
    static uint8_t                    m_scanFilterMode;
-#endif
    static std::vector<NimBLEAddress> m_whiteList;
 };

--- a/src/NimBLEEddystoneTLM.cpp
+++ b/src/NimBLEEddystoneTLM.cpp
@ -11,14 +11,12 @@
 *  Created on: Mar 12, 2018
 *      Author: pcbreflux
 */
-
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "NimBLEEddystoneTLM.h"
 #include "NimBLELog.h"

-#include <stdio.h>
 #include <cstring>

 #define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00)>>8) + (((x)&0xFF)<<8))
@ -126,30 +124,30 @@ std::string NimBLEEddystoneTLM::toString() {
  out += " C\n";

  out += "Adv. Count ";
-  snprintf(val, sizeof(val), "%" PRIu32, ENDIAN_CHANGE_U32(m_eddystoneData.advCount));
+  snprintf(val, sizeof(val), "%lu", ENDIAN_CHANGE_U32(m_eddystoneData.advCount));
  out += val;
  out += "\n";

  out += "Time in seconds ";
-  snprintf(val, sizeof(val), "%" PRIu32, rawsec/10);
+  snprintf(val, sizeof(val), "%lu", rawsec/10);
  out += val;
  out += "\n";

  out += "Time ";

-  snprintf(val, sizeof(val), "%04" PRIu32, rawsec / 864000);
+  snprintf(val, sizeof(val), "%04lu", rawsec / 864000);
  out += val;
  out += ".";

-  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 36000) % 24);
+  snprintf(val, sizeof(val), "%02lu", (rawsec / 36000) % 24);
  out += val;
  out += ":";

-  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 600) % 60);
+  snprintf(val, sizeof(val), "%02lu", (rawsec / 600) % 60);
  out += val;
  out += ":";

-  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 10) % 60);
+  snprintf(val, sizeof(val), "%02lu", (rawsec / 10) % 60);
  out += val;
  out += "\n";

--- a/src/NimBLEEddystoneTLM.h
+++ b/src/NimBLEEddystoneTLM.h
@ -15,6 +15,7 @@
 #ifndef _NimBLEEddystoneTLM_H_
 #define _NimBLEEddystoneTLM_H_

+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 #include "NimBLEUUID.h"

 #include <string>
@ -58,4 +59,5 @@ private:

 }; // NimBLEEddystoneTLM

+#endif
 #endif /* _NimBLEEddystoneTLM_H_ */
--- a/src/NimBLEEddystoneURL.cpp
+++ b/src/NimBLEEddystoneURL.cpp
@ -11,8 +11,8 @@
 *  Created on: Mar 12, 2018
 *      Author: pcbreflux
 */
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "NimBLEEddystoneURL.h"
 #include "NimBLELog.h"
--- a/src/NimBLEEddystoneURL.h
+++ b/src/NimBLEEddystoneURL.h
@ -14,6 +14,7 @@

 #ifndef _NIMBLEEddystoneURL_H_
 #define _NIMBLEEddystoneURL_H_
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 #include "NimBLEUUID.h"

 #include <string>
@ -49,4 +50,5 @@ private:

 }; // NIMBLEEddystoneURL

+#endif
 #endif /* _NIMBLEEddystoneURL_H_ */
--- a/src/NimBLEHIDDevice.cpp
+++ b/src/NimBLEHIDDevice.cpp
@ -11,9 +11,11 @@
 *  Created on: Jan 03, 2018
 *      Author: chegewara
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLEHIDDevice.h"
 #include "NimBLE2904.h"
@ -27,7 +29,7 @@ NimBLEHIDDevice::NimBLEHIDDevice(NimBLEServer* server) {
 	 * Here we create mandatory services described in bluetooth specification
 	 */
 	m_deviceInfoService = server->createService(NimBLEUUID((uint16_t) 0x180a));
-	m_hidService = server->createService(NimBLEUUID((uint16_t) 0x1812));
+	m_hidService = server->createService(NimBLEUUID((uint16_t) 0x1812), 40);
 	m_batteryService = server->createService(NimBLEUUID((uint16_t) 0x180f));

 	/*
@ -245,4 +247,5 @@ NimBLEService* NimBLEHIDDevice::batteryService() {
 	return m_batteryService;
 }

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif // #if defined(CONFIG_BT_ENABLED)
--- a/src/NimBLEHIDDevice.h
+++ b/src/NimBLEHIDDevice.h
@ -15,8 +15,11 @@
 #ifndef _BLEHIDDEVICE_H_
 #define _BLEHIDDEVICE_H_

+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)

 #include "NimBLECharacteristic.h"
 #include "NimBLEService.h"
@ -81,6 +84,6 @@ private:
 	NimBLECharacteristic* 	m_protocolModeCharacteristic;	//0x2a4e
 	NimBLECharacteristic*	m_batteryLevelCharacteristic;	//0x2a19
 };
-
-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER */
+#endif // CONFIG_BT_NIMBLE_ROLE_BROADCASTER
+#endif // CONFIG_BT_ENABLED
 #endif /* _BLEHIDDEVICE_H_ */
--- a/src/NimBLELog.h
+++ b/src/NimBLELog.h
@ -8,73 +8,56 @@
 #ifndef MAIN_NIMBLELOG_H_
 #define MAIN_NIMBLELOG_H_

-#include "nimconfig.h"
+#include "sdkconfig.h"

-#if defined(CONFIG_BT_ENABLED)
+#if defined(ARDUINO_ARCH_ESP32) && !defined(DONT_USE_ARDUINO_BULLSHIT)
+#include "syscfg/syscfg.h"
+#include "modlog/modlog.h"

-#if defined(CONFIG_NIMBLE_CPP_IDF) // using esp-idf
-#  include "esp_log.h"
-#  ifndef CONFIG_NIMBLE_CPP_LOG_LEVEL
-#    define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
-#  endif
+// If Arduino is being used, strip out the colors and ignore log printing below ui setting.
+// Note: because CONFIG_LOG_DEFAULT_LEVEL is set at ERROR in Arduino we must use MODLOG_DFLT(ERROR
+// otherwise no messages will be printed above that level.

-#  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__); \
-    } while(0)
+#ifndef CORE_DEBUG_LEVEL
+#define CORE_DEBUG_LEVEL CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
+#endif

-#  define NIMBLE_LOGD(tag, format, ...) \
-     NIMBLE_CPP_LOG_PRINT(ESP_LOG_DEBUG, tag, format, ##__VA_ARGS__)
+#if CORE_DEBUG_LEVEL >= 4
+#define NIMBLE_LOGD( tag, format, ... ) MODLOG_DFLT(ERROR,      "D %s: "#format"\n",tag,##__VA_ARGS__)
+#else
+#define NIMBLE_LOGD( tag, format, ... ) (void)tag
+#endif

-#  define NIMBLE_LOGI(tag, format, ...) \
-     NIMBLE_CPP_LOG_PRINT(ESP_LOG_INFO, tag, format, ##__VA_ARGS__)
+#if CORE_DEBUG_LEVEL >= 3
+#define NIMBLE_LOGI( tag, format, ... ) MODLOG_DFLT(ERROR,      "I %s: "#format"\n",tag,##__VA_ARGS__)
+#else
+#define NIMBLE_LOGI( tag, format, ... ) (void)tag
+#endif

-#  define NIMBLE_LOGW(tag, format, ...) \
-     NIMBLE_CPP_LOG_PRINT(ESP_LOG_WARN, tag, format, ##__VA_ARGS__)
+#if CORE_DEBUG_LEVEL >= 2
+#define NIMBLE_LOGW( tag, format, ... ) MODLOG_DFLT(ERROR,      "W %s: "#format"\n",tag,##__VA_ARGS__)
+#else
+#define NIMBLE_LOGW( tag, format, ... ) (void)tag
+#endif

-#  define NIMBLE_LOGE(tag, format, ...) \
-     NIMBLE_CPP_LOG_PRINT(ESP_LOG_ERROR, tag, format, ##__VA_ARGS__)
+#if CORE_DEBUG_LEVEL >= 1
+#define NIMBLE_LOGE( tag, format, ... ) MODLOG_DFLT(ERROR,      "E %s: "#format"\n",tag,##__VA_ARGS__)
+#else
+#define NIMBLE_LOGE( tag, format, ... ) (void)tag
+#endif

-#  define NIMBLE_LOGC(tag, format, ...) \
-     NIMBLE_CPP_LOG_PRINT(ESP_LOG_ERROR, tag, format, ##__VA_ARGS__)
+#define NIMBLE_LOGC( tag, format, ... ) MODLOG_DFLT(CRITICAL,   "CRIT %s: "#format"\n",tag,##__VA_ARGS__)

-#else // using Arduino
-#  include "nimble/porting/nimble/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
+#else

-#  if CONFIG_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
+#include "esp_log.h"

-#  if CONFIG_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
+#define NIMBLE_LOGE(tag, format, ...) ESP_LOGE(tag, format, ##__VA_ARGS__)
+#define NIMBLE_LOGW(tag, format, ...) ESP_LOGW(tag, format, ##__VA_ARGS__)
+#define NIMBLE_LOGI(tag, format, ...) ESP_LOGI(tag, format, ##__VA_ARGS__)
+#define NIMBLE_LOGD(tag, format, ...) ESP_LOGD(tag, format, ##__VA_ARGS__)
+#define NIMBLE_LOGC(tag, format, ...) ESP_LOGE(tag, format, ##__VA_ARGS__)

-#  if CONFIG_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
+#endif /*ARDUINO_ARCH_ESP32*/

-#  if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 1
-#    define NIMBLE_LOGE( tag, format, ... ) console_printf("E %s: "#format"\n",tag,##__VA_ARGS__)
-#    define NIMBLE_LOGC( tag, format, ... ) console_printf("CRIT %s: "#format"\n",tag,##__VA_ARGS__)
-#  else
-#    define NIMBLE_LOGE( tag, format, ... ) (void)tag
-#    define NIMBLE_LOGC( tag, format, ... ) (void)tag
-#  endif
-
-#endif /* CONFIG_NIMBLE_CPP_IDF */
-#endif /* CONFIG_BT_ENABLED */
-#endif /* MAIN_NIMBLELOG_H_ */
+#endif /*MAIN_NIMBLELOG_H_*/
--- a/src/NimBLERemoteCharacteristic.cpp
+++ b/src/NimBLERemoteCharacteristic.cpp
@ -12,15 +12,16 @@
 *      Author: kolban
 */

+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLERemoteCharacteristic.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"

-#include <climits>
-
 static const char* LOG_TAG = "NimBLERemoteCharacteristic";

 /**
@ -59,6 +60,7 @@ static const char* LOG_TAG = "NimBLERemoteCharacteristic";
    m_pRemoteService     = pRemoteService;
    m_notifyCallback     = nullptr;
    m_timestamp          = 0;
+    m_valMux             = portMUX_INITIALIZER_UNLOCKED;

    NIMBLE_LOGD(LOG_TAG, "<< NimBLERemoteCharacteristic(): %s", m_uuid.toString().c_str());
 } // NimBLERemoteCharacteristic
@ -239,8 +241,7 @@ bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID *uuid_filt
    }

    int rc = 0;
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};

    // If we don't know the end handle of this characteristic retrieve the next one in the service
    // The end handle is the next characteristic definition handle -1.
@ -255,10 +256,6 @@ bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID *uuid_filt
            return false;
        }

-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        if (taskData.rc != 0) {
@ -280,10 +277,6 @@ bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID *uuid_filt
        return false;
    }

-#ifdef ulTaskNotifyValueClear
-    // Clear the task notification value to ensure we block
-    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

    if (taskData.rc != 0) {
@ -415,12 +408,12 @@ NimBLEUUID NimBLERemoteCharacteristic::getUUID() {
 * @return The value of the remote characteristic.
 */
 std::string NimBLERemoteCharacteristic::getValue(time_t *timestamp) {
-    ble_npl_hw_enter_critical();
+    portENTER_CRITICAL(&m_valMux);
    std::string value = m_value;
    if(timestamp != nullptr) {
        *timestamp = m_timestamp;
    }
-    ble_npl_hw_exit_critical(0);
+    portEXIT_CRITICAL(&m_valMux);

    return value;
 }
@ -484,8 +477,7 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {

    int rc = 0;
    int retryCount = 1;
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, &value};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(),0, &value};

    do {
        rc = ble_gattc_read_long(pClient->getConnId(), m_handle, 0,
@ -497,10 +489,6 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
            return value;
        }

-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        rc = taskData.rc;

@ -527,13 +515,13 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
    } while(rc != 0 && retryCount--);

    time_t t = time(nullptr);
-    ble_npl_hw_enter_critical();
+    portENTER_CRITICAL(&m_valMux);
    m_value = value;
    m_timestamp = t;
    if(timestamp != nullptr) {
        *timestamp = m_timestamp;
    }
-    ble_npl_hw_exit_critical(0);
+    portEXIT_CRITICAL(&m_valMux);

    NIMBLE_LOGD(LOG_TAG, "<< readValue length: %d rc=%d", value.length(), rc);
    return value;
@ -563,12 +551,11 @@ int NimBLERemoteCharacteristic::onReadCB(uint16_t conn_handle,

    if(rc == 0) {
        if(attr) {
-            uint32_t data_len = OS_MBUF_PKTLEN(attr->om);
-            if(((*strBuf).length() + data_len) > BLE_ATT_ATTR_MAX_LEN) {
+            if(((*strBuf).length() + attr->om->om_len) > BLE_ATT_ATTR_MAX_LEN) {
                rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
            } else {
-                NIMBLE_LOGD(LOG_TAG, "Got %d bytes", data_len);
-                (*strBuf) += std::string((char*) attr->om->om_data, data_len);
+                NIMBLE_LOGD(LOG_TAG, "Got %d bytes", attr->om->om_len);
+                (*strBuf) += std::string((char*) attr->om->om_data, attr->om->om_len);
                return 0;
            }
        }
@ -758,8 +745,7 @@ bool NimBLERemoteCharacteristic::writeValue(const uint8_t* data, size_t length,
        return (rc==0);
    }

-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};

    do {
        if(length > mtu) {
@ -779,10 +765,6 @@ bool NimBLERemoteCharacteristic::writeValue(const uint8_t* data, size_t length,
            return false;
        }

-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        rc = taskData.rc;

@ -837,4 +819,6 @@ int NimBLERemoteCharacteristic::onWriteCB(uint16_t conn_handle,
    return 0;
 }

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLERemoteCharacteristic.h
+++ b/src/NimBLERemoteCharacteristic.h
@ -14,9 +14,11 @@

 #ifndef COMPONENTS_NIMBLEREMOTECHARACTERISTIC_H_
 #define COMPONENTS_NIMBLEREMOTECHARACTERISTIC_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLERemoteService.h"
 #include "NimBLERemoteDescriptor.h"
@ -159,10 +161,12 @@ private:
    std::string             m_value;
    notify_callback         m_notifyCallback;
    time_t                  m_timestamp;
+    portMUX_TYPE            m_valMux;

    // We maintain a vector of descriptors owned by this characteristic.
    std::vector<NimBLERemoteDescriptor*> m_descriptorVector;
 }; // NimBLERemoteCharacteristic

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_NIMBLEREMOTECHARACTERISTIC_H_ */
--- a/src/NimBLERemoteDescriptor.cpp
+++ b/src/NimBLERemoteDescriptor.cpp
@ -11,16 +11,16 @@
 *  Created on: Jul 8, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLERemoteDescriptor.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"

-#include <climits>
-
 static const char* LOG_TAG = "NimBLERemoteDescriptor";

 /**
@ -139,8 +139,7 @@ std::string NimBLERemoteDescriptor::readValue() {

    int rc = 0;
    int retryCount = 1;
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, &value};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(),0, &value};

    do {
        rc = ble_gattc_read_long(pClient->getConnId(), m_handle, 0,
@ -152,10 +151,6 @@ std::string NimBLERemoteDescriptor::readValue() {
            return value;
        }

-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        rc = taskData.rc;

@ -193,7 +188,6 @@ int NimBLERemoteDescriptor::onReadCB(uint16_t conn_handle,
                const struct ble_gatt_error *error,
                struct ble_gatt_attr *attr, void *arg)
 {
-    (void)attr;
    ble_task_data_t *pTaskData = (ble_task_data_t*)arg;
    NimBLERemoteDescriptor* desc = (NimBLERemoteDescriptor*)pTaskData->pATT;
    uint16_t conn_id = desc->getRemoteCharacteristic()->getRemoteService()->getClient()->getConnId();
@ -209,12 +203,11 @@ int NimBLERemoteDescriptor::onReadCB(uint16_t conn_handle,

    if(rc == 0) {
        if(attr) {
-            uint32_t data_len = OS_MBUF_PKTLEN(attr->om);
-            if(((*strBuf).length() + data_len) > BLE_ATT_ATTR_MAX_LEN) {
+            if(((*strBuf).length() + attr->om->om_len) > BLE_ATT_ATTR_MAX_LEN) {
                rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
            } else {
-                NIMBLE_LOGD(LOG_TAG, "Got %d bytes", data_len);
-                (*strBuf) += std::string((char*) attr->om->om_data, data_len);
+                NIMBLE_LOGD(LOG_TAG, "Got %d bytes", attr->om->om_len);
+                (*strBuf) += std::string((char*) attr->om->om_data, attr->om->om_len);
                return 0;
            }
        }
@ -296,8 +289,7 @@ bool NimBLERemoteDescriptor::writeValue(const uint8_t* data, size_t length, bool
        return (rc == 0);
    }

-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};

    do {
        if(length > mtu) {
@ -318,10 +310,6 @@ bool NimBLERemoteDescriptor::writeValue(const uint8_t* data, size_t length, bool
            return false;
        }

-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        rc = taskData.rc;

@ -362,4 +350,5 @@ bool NimBLERemoteDescriptor::writeValue(const std::string &newValue, bool respon
    return writeValue((uint8_t*) newValue.data(), newValue.length(), response);
 } // writeValue

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLERemoteDescriptor.h
+++ b/src/NimBLERemoteDescriptor.h
@ -14,9 +14,11 @@

 #ifndef COMPONENTS_NIMBLEREMOTEDESCRIPTOR_H_
 #define COMPONENTS_NIMBLEREMOTEDESCRIPTOR_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLERemoteCharacteristic.h"

@ -79,5 +81,6 @@ private:
    NimBLERemoteCharacteristic* m_pRemoteCharacteristic;
 };

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_NIMBLEREMOTEDESCRIPTOR_H_ */
--- a/src/NimBLERemoteService.cpp
+++ b/src/NimBLERemoteService.cpp
@ -11,17 +11,17 @@
 *  Created on: Jul 8, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLERemoteService.h"
 #include "NimBLEUtils.h"
 #include "NimBLEDevice.h"
 #include "NimBLELog.h"

-#include <climits>
-
 static const char* LOG_TAG = "NimBLERemoteService";

 /**
@ -198,8 +198,7 @@ bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID *uuid_filter)
    NIMBLE_LOGD(LOG_TAG, ">> retrieveCharacteristics() for service: %s", getUUID().toString().c_str());

    int rc = 0;
-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};

    if(uuid_filter == nullptr) {
        rc = ble_gattc_disc_all_chrs(m_pClient->getConnId(),
@ -221,10 +220,6 @@ bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID *uuid_filter)
        return false;
    }

-#ifdef ulTaskNotifyValueClear
-    // Clear the task notification value to ensure we block
-    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

    if(taskData.rc == 0){
@ -391,4 +386,6 @@ std::string NimBLERemoteService::toString() {
    return res;
 } // toString

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLERemoteService.h
+++ b/src/NimBLERemoteService.h
@ -14,9 +14,11 @@

 #ifndef COMPONENTS_NIMBLEREMOTESERVICE_H_
 #define COMPONENTS_NIMBLEREMOTESERVICE_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)

 #include "NimBLEClient.h"
 #include "NimBLEUUID.h"
@ -81,5 +83,6 @@ private:
    uint16_t            m_endHandle;
 }; // NimBLERemoteService

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
+#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_NIMBLEREMOTESERVICE_H_ */
--- a/src/NimBLEScan.cpp
+++ b/src/NimBLEScan.cpp
@ -11,16 +11,17 @@
 *  Created on: Jul 1, 2017
 *      Author: kolban
 */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)

 #include "NimBLEScan.h"
 #include "NimBLEDevice.h"
 #include "NimBLELog.h"

 #include <string>
-#include <climits>

 static const char* LOG_TAG = "NimBLEScan";

@ -109,7 +110,7 @@ NimBLEScan::~NimBLEScan() {

            advertisedDevice->m_timestamp = time(nullptr);
            advertisedDevice->setRSSI(event->disc.rssi);
-            advertisedDevice->setPayload(event->disc.data, event->disc.length_data,
+            advertisedDevice->setPayload(event->disc.data, event->disc.length_data, 
            event->disc.event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP);

            if (pScan->m_pAdvertisedDeviceCallbacks) {
@ -127,7 +128,7 @@ NimBLEScan::~NimBLEScan() {
                    advertisedDevice->m_callbackSent = true;
                    pScan->m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
                }
-                // If not storing results and we have invoked the callback, delete the device.
+                // If not storing results and we have invoked the callback, delete the device. 
                if(pScan->m_maxResults == 0 && advertisedDevice->m_callbackSent) {
                    pScan->erase(advertisedAddress);
                }
@ -283,7 +284,7 @@ bool NimBLEScan::isScanning() {
 * @return True if scan started or false if there was an error.
 */
 bool NimBLEScan::start(uint32_t duration, void (*scanCompleteCB)(NimBLEScanResults), bool is_continue) {
-    NIMBLE_LOGD(LOG_TAG, ">> start(duration=%d)", duration);
+    NIMBLE_LOGD(LOG_TAG, ">> start(duration=%lu)", duration);

    // Save the callback to be invoked when the scan completes.
    m_scanCompleteCB = scanCompleteCB;
@ -357,15 +358,10 @@ NimBLEScanResults NimBLEScan::start(uint32_t duration, bool is_continue) {
        NIMBLE_LOGW(LOG_TAG, "Blocking scan called with duration = forever");
    }

-    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
-    ble_task_data_t taskData = {nullptr, cur_task, 0, nullptr};
+    ble_task_data_t taskData = {nullptr, xTaskGetCurrentTaskHandle(),0, nullptr};
    m_pTaskData = &taskData;

    if(start(duration, nullptr, is_continue)) {
-#ifdef ulTaskNotifyValueClear
-        // Clear the task notification value to ensure we block
-        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
-#endif
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    }

@ -408,9 +404,7 @@ bool NimBLEScan::stop() {
 * @brief Clears the duplicate scan filter cache.
 */
 void NimBLEScan::clearDuplicateCache() {
-#ifdef CONFIG_IDF_TARGET_ESP32 // Not available for ESP32C3
    esp_ble_scan_dupilcate_list_flush();
-#endif
 }


@ -538,4 +532,5 @@ NimBLEAdvertisedDevice *NimBLEScanResults::getDevice(const NimBLEAddress &addres
    return nullptr;
 }

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#endif /* CONFIG_BT_ENABLED */
--- a/src/NimBLEScan.h
+++ b/src/NimBLEScan.h
@ -13,18 +13,16 @@
 */
 #ifndef COMPONENTS_NIMBLE_SCAN_H_
 #define COMPONENTS_NIMBLE_SCAN_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)

 #include "NimBLEAdvertisedDevice.h"
 #include "NimBLEUtils.h"

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
-#else
-#include "nimble/nimble/host/include/host/ble_gap.h"
-#endif

 #include <vector>

@ -99,5 +97,6 @@ private:
    uint8_t                             m_maxResults;
 };

-#endif /* CONFIG_BT_ENABLED CONFIG_BT_NIMBLE_ROLE_OBSERVER */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_NIMBLE_SCAN_H_ */
--- a/src/NimBLESecurity.cpp
+++ b/src/NimBLESecurity.cpp
@ -12,8 +12,8 @@
 *      Author: chegewara
 */

-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "NimBLESecurity.h"
 #include "NimBLEDevice.h"
--- a/src/NimBLESecurity.h
+++ b/src/NimBLESecurity.h
@ -14,16 +14,10 @@

 #ifndef COMPONENTS_NIMBLESECURITY_H_
 #define COMPONENTS_NIMBLESECURITY_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
-#else
-#include "nimble/nimble/host/include/host/ble_gap.h"
-#endif
-
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
--- a/src/NimBLEServer.cpp
+++ b/src/NimBLEServer.cpp
@ -12,20 +12,19 @@
 *      Author: kolban
 */

+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLEServer.h"
 #include "NimBLEDevice.h"
 #include "NimBLELog.h"

-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "services/gap/ble_svc_gap.h"
 #include "services/gatt/ble_svc_gatt.h"
-#else
-#include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
-#include "nimble/nimble/host/services/gatt/include/services/gatt/ble_svc_gatt.h"
-#endif
+

 static const char* LOG_TAG = "NimBLEServer";
 static NimBLEServerCallbacks defaultCallbacks;
@ -80,18 +79,24 @@ NimBLEService* NimBLEServer::createService(const char* uuid) {
 *             to provide inst_id value different for each service.
 * @return A reference to the new service object.
 */
-NimBLEService* NimBLEServer::createService(const NimBLEUUID &uuid) {
+NimBLEService* NimBLEServer::createService(const NimBLEUUID &uuid, uint32_t numHandles, uint8_t inst_id) {
    NIMBLE_LOGD(LOG_TAG, ">> createService - %s", uuid.toString().c_str());
-
+    // TODO: add functionality to use inst_id for multiple services with same uuid
+    (void)inst_id;
    // Check that a service with the supplied UUID does not already exist.
    if(getServiceByUUID(uuid) != nullptr) {
        NIMBLE_LOGW(LOG_TAG, "Warning creating a duplicate service UUID: %s",
                             std::string(uuid).c_str());
    }

-    NimBLEService* pService = new NimBLEService(uuid);
-    m_svcVec.push_back(pService);
-    serviceChanged();
+    NimBLEService* pService = new NimBLEService(uuid, numHandles, this);
+    m_svcVec.push_back(pService); // Save a reference to this service being on this server.
+
+    if(m_gattsStarted) {
+        ble_svc_gatt_changed(0x0001, 0xffff);
+        m_svcChanged = true;
+        resetGATT();
+    }

    NIMBLE_LOGD(LOG_TAG, "<< createService");
    return pService;
@ -152,18 +157,6 @@ NimBLEAdvertising* NimBLEServer::getAdvertising() {
 } // getAdvertising


-/**
- * @brief Sends a service changed notification and resets the GATT server.
- */
-void NimBLEServer::serviceChanged() {
-    if(m_gattsStarted) {
-        m_svcChanged = true;
-        ble_svc_gatt_changed(0x0001, 0xffff);
-        resetGATT();
-    }
-}
-
-
 /**
 * @brief Start the GATT server. Required to be called after setup of all
 * services and characteristics / descriptors for the NimBLE host to register them.
@ -181,7 +174,7 @@ void NimBLEServer::start() {
        abort();
    }

-#if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4
+#if CONFIG_LOG_DEFAULT_LEVEL > 3 || (ARDUINO_ARCH_ESP32 && !defined(DONT_USE_ARDUINO_BULLSHIT) && CORE_DEBUG_LEVEL >= 4)
    ble_gatts_show_local();
 #endif
 /*** Future use ***
@ -423,12 +416,6 @@ NimBLEConnInfo NimBLEServer::getPeerIDInfo(uint16_t id) {
            NIMBLE_LOGI(LOG_TAG, "mtu update event; conn_handle=%d mtu=%d",
                        event->mtu.conn_handle,
                        event->mtu.value);
-            rc = ble_gap_conn_find(event->mtu.conn_handle, &desc);
-            if (rc != 0) {
-                return 0;
-            }
-
-            server->m_pServerCallbacks->onMTUChange(event->mtu.value, &desc);
            return 0;
        } // BLE_GAP_EVENT_MTU

@ -537,7 +524,7 @@ NimBLEConnInfo NimBLEServer::getPeerIDInfo(uint16_t id) {
                NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_DISP; ble_sm_inject_io result: %d", rc);

            } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
-                NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %d", event->passkey.params.numcmp);
+                NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %lu", event->passkey.params.numcmp);
                pkey.action = event->passkey.params.action;
                // Compatibility only - Do not use, should be removed the in future
                if(NimBLEDevice::m_securityCallbacks != nullptr) {
@ -637,7 +624,7 @@ void NimBLEServer::removeService(NimBLEService* service, bool deleteSvc) {
    if(service->m_removed > 0) {
        if(deleteSvc) {
            for(auto it = m_svcVec.begin(); it != m_svcVec.end(); ++it) {
-                if ((*it) == service) {
+                if ((*it)->getUUID() == service->getUUID()) {
                    delete *it;
                    m_svcVec.erase(it);
                    break;
@ -653,8 +640,11 @@ void NimBLEServer::removeService(NimBLEService* service, bool deleteSvc) {
        return;
    }

-    service->m_removed = deleteSvc ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE;
-    serviceChanged();
+    service->m_removed = deleteSvc ? 2 : 1;
+    m_svcChanged = true;
+
+    ble_svc_gatt_changed(0x0001, 0xffff);
+    resetGATT();
    NimBLEDevice::getAdvertising()->removeServiceUUID(service->getUUID());
 }

@ -681,7 +671,10 @@ void NimBLEServer::addService(NimBLEService* service) {
    }

    service->m_removed = 0;
-    serviceChanged();
+    m_svcChanged = true;
+
+    ble_svc_gatt_changed(0x0001, 0xffff);
+    resetGATT();
 }


@ -700,7 +693,7 @@ void NimBLEServer::resetGATT() {

    for(auto it = m_svcVec.begin(); it != m_svcVec.end(); ) {
        if ((*it)->m_removed > 0) {
-            if ((*it)->m_removed == NIMBLE_ATT_REMOVE_DELETE) {
+            if ((*it)->m_removed == 2) {
                delete *it;
                it = m_svcVec.erase(it);
            } else {
@ -734,7 +727,7 @@ void NimBLEServer::startAdvertising() {
 */
 void NimBLEServer::stopAdvertising() {
    NimBLEDevice::stopAdvertising();
-} // stopAdvertising
+} // startAdvertising


 /**
@ -772,31 +765,7 @@ void NimBLEServer::updateConnParams(uint16_t conn_handle,
    if(rc != 0) {
        NIMBLE_LOGE(LOG_TAG, "Update params error: %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
    }
-} // updateConnParams
-
-
-/**
- * @brief Request an update of the data packet length.
- * * Can only be used after a connection has been established.
- * @details Sends a data length update request to the peer.
- * The Data Length Extension (DLE) allows to increase the Data Channel Payload from 27 bytes to up to 251 bytes.
- * The peer needs to support the Bluetooth 4.2 specifications, to be capable of DLE.
- * @param [in] conn_handle The connection handle of the peer to send the request to.
- * @param [in] tx_octets The preferred number of payload octets to use (Range 0x001B-0x00FB).
- */
-void NimBLEServer::setDataLen(uint16_t conn_handle, uint16_t tx_octets) {
-#if defined(CONFIG_NIMBLE_CPP_IDF) && defined(ESP_IDF_VERSION) && \
-           ESP_IDF_VERSION <= ESP_IDF_VERSION_VAL(4,3,2)
-    return;
-#else
-    uint16_t tx_time = (tx_octets + 14) * 8;
-
-    int rc = ble_gap_set_data_len(conn_handle, tx_octets, tx_time);
-    if(rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Set data length error: %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-    }
-#endif
-} // setDataLen
+}// updateConnParams


 bool NimBLEServer::setIndicateWait(uint16_t conn_handle) {
@ -840,10 +809,6 @@ void NimBLEServerCallbacks::onDisconnect(NimBLEServer* pServer, ble_gap_conn_des
    NIMBLE_LOGD("NimBLEServerCallbacks", "onDisconnect(): Default");
 } // onDisconnect

-void NimBLEServerCallbacks::onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc) {
-    NIMBLE_LOGD("NimBLEServerCallbacks", "onMTUChange(): Default");
-} // onMTUChange
-
 uint32_t NimBLEServerCallbacks::onPassKeyRequest(){
    NIMBLE_LOGD("NimBLEServerCallbacks", "onPassKeyRequest: default: 123456");
    return 123456;
@ -866,4 +831,6 @@ bool NimBLEServerCallbacks::onConfirmPIN(uint32_t pin){
    return true;
 }

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif // CONFIG_BT_ENABLED
--- a/src/NimBLEServer.h
+++ b/src/NimBLEServer.h
@ -14,14 +14,11 @@

 #ifndef MAIN_NIMBLESERVER_H_
 #define MAIN_NIMBLESERVER_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-
-#define NIMBLE_ATT_REMOVE_HIDE 1
-#define NIMBLE_ATT_REMOVE_DELETE 2
-
-#define onMtuChanged onMTUChange
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLEUtils.h"
 #include "NimBLEAddress.h"
@ -43,7 +40,8 @@ class NimBLEServer {
 public:
    size_t                 getConnectedCount();
    NimBLEService*         createService(const char* uuid);
-    NimBLEService*         createService(const NimBLEUUID &uuid);
+    NimBLEService*         createService(const NimBLEUUID &uuid, uint32_t numHandles=15,
+                                         uint8_t inst_id=0);
    void                   removeService(NimBLEService* service, bool deleteSvc = false);
    void                   addService(NimBLEService* service);
    NimBLEAdvertising*     getAdvertising();
@ -60,7 +58,6 @@ public:
    void                   updateConnParams(uint16_t conn_handle,
                                            uint16_t minInterval, uint16_t maxInterval,
                                            uint16_t latency, uint16_t timeout);
-    void                   setDataLen(uint16_t conn_handle, uint16_t tx_octets);
    uint16_t               getPeerMTU(uint16_t conn_id);
    std::vector<uint16_t>  getPeerDevices();
    NimBLEConnInfo         getPeerInfo(size_t index);
@ -72,7 +69,6 @@ private:
    NimBLEServer();
    ~NimBLEServer();
    friend class           NimBLECharacteristic;
-    friend class           NimBLEService;
    friend class           NimBLEDevice;
    friend class           NimBLEAdvertising;

@ -90,7 +86,6 @@ private:
    std::vector<NimBLECharacteristic*> m_notifyChrVec;

    static int             handleGapEvent(struct ble_gap_event *event, void *arg);
-    void                   serviceChanged();
    void                   resetGATT();
    bool                   setIndicateWait(uint16_t conn_handle);
    void                   clearIndicateWait(uint16_t conn_handle);
@ -136,14 +131,6 @@ public:
     */
    virtual void onDisconnect(NimBLEServer* pServer, ble_gap_conn_desc* desc);

-     /**
-     * @brief Called when the connection MTU changes.
-     * @param [in] MTU The new MTU value.
-     * @param [in] desc A pointer to the connection description structure containig information
-     * about the connection.
-     */
-    virtual void onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc);
-
    /**
     * @brief Called when a client requests a passkey for pairing.
     * @return The passkey to be sent to the client.
@ -168,5 +155,7 @@ public:
    virtual bool onConfirmPIN(uint32_t pin);
 }; // NimBLEServerCallbacks

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif /* CONFIG_BT_ENABLED */
 #endif /* MAIN_NIMBLESERVER_H_ */
--- a/src/NimBLEService.cpp
+++ b/src/NimBLEService.cpp
@ -14,10 +14,12 @@

 // A service is identified by a UUID.  A service is also the container for one or more characteristics.

-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

-#include "NimBLEDevice.h"
 #include "NimBLEService.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
@ -32,19 +34,25 @@ static const char* LOG_TAG = "NimBLEService"; // Tag for logging.
 /**
 * @brief Construct an instance of the NimBLEService
 * @param [in] uuid The UUID of the service.
+ * @param [in] numHandles The maximum number of handles associated with the service.
+ * @param [in] a pointer to the server instance that this service belongs to.
 */
-NimBLEService::NimBLEService(const char* uuid)
-: NimBLEService(NimBLEUUID(uuid)) {
+NimBLEService::NimBLEService(const char* uuid, uint16_t numHandles, NimBLEServer* pServer)
+: NimBLEService(NimBLEUUID(uuid), numHandles, pServer) {
 }


 /**
 * @brief Construct an instance of the BLEService
 * @param [in] uuid The UUID of the service.
+ * @param [in] numHandles The maximum number of handles associated with the service.
+ * @param [in] a pointer to the server instance that this service belongs to.
 */
-NimBLEService::NimBLEService(const NimBLEUUID &uuid) {
+NimBLEService::NimBLEService(const NimBLEUUID &uuid, uint16_t numHandles, NimBLEServer* pServer) {
    m_uuid         = uuid;
    m_handle       = NULL_HANDLE;
+    m_pServer      = pServer;
+    m_numHandles   = numHandles;
    m_pSvcDef      = nullptr;
    m_removed      = 0;

@ -110,12 +118,7 @@ NimBLEUUID NimBLEService::getUUID() {
 */
 bool NimBLEService::start() {
    NIMBLE_LOGD(LOG_TAG, ">> start(): Starting service: %s", toString().c_str());
-
-    // Rebuild the service definition if the server attributes have changed.
-    if(getServer()->m_svcChanged && m_pSvcDef != nullptr) {
-        delete(m_pSvcDef);
-        m_pSvcDef = nullptr;
-    }
+    int rc = 0;

    if(m_pSvcDef == nullptr) {
        // Nimble requires an array of services to be sent to the api
@ -129,23 +132,8 @@ bool NimBLEService::start() {
        svc[0].uuid = &m_uuid.getNative()->u;
        svc[0].includes = NULL;

-        int removedCount = 0;
-        for(auto it = m_chrVec.begin(); it != m_chrVec.end(); ) {
-            if ((*it)->m_removed > 0) {
-                if ((*it)->m_removed == NIMBLE_ATT_REMOVE_DELETE) {
-                    delete *it;
-                    it = m_chrVec.erase(it);
-                } else {
-                    ++removedCount;
-                    ++it;
-                }
-                continue;
-            }
+        size_t numChrs = m_chrVec.size();

-            ++it;
-        }
-
-        size_t numChrs = m_chrVec.size() - removedCount;
        NIMBLE_LOGD(LOG_TAG,"Adding %d characteristics for service %s", numChrs, toString().c_str());

        if(!numChrs){
@ -154,60 +142,40 @@ bool NimBLEService::start() {
            // Nimble requires the last characteristic to have it's uuid = 0 to indicate the end
            // of the characteristics for the service. We create 1 extra and set it to null
            // for this purpose.
-            pChr_a = new ble_gatt_chr_def[numChrs + 1];
-            uint8_t i = 0;
-            for(auto chr_it = m_chrVec.begin(); chr_it != m_chrVec.end(); ++chr_it) {
-                if((*chr_it)->m_removed > 0) {
-                    continue;
-                }
+            pChr_a = new ble_gatt_chr_def[numChrs+1];
+            NimBLECharacteristic* pCharacteristic = *m_chrVec.begin();

-                removedCount = 0;
-                for(auto it = (*chr_it)->m_dscVec.begin(); it != (*chr_it)->m_dscVec.end(); ) {
-                    if ((*it)->m_removed > 0) {
-                        if ((*it)->m_removed == NIMBLE_ATT_REMOVE_DELETE) {
-                            delete *it;
-                            it = (*chr_it)->m_dscVec.erase(it);
-                        } else {
-                            ++removedCount;
-                            ++it;
-                        }
-                        continue;
-                    }
-
-                    ++it;
-                }
-
-                size_t numDscs = (*chr_it)->m_dscVec.size() - removedCount;
+            for(uint8_t i=0; i < numChrs;) {
+                uint8_t numDscs = pCharacteristic->m_dscVec.size();

                if(!numDscs){
                    pChr_a[i].descriptors = NULL;
                } else {
                    // Must have last descriptor uuid = 0 so we have to create 1 extra
                    pDsc_a = new ble_gatt_dsc_def[numDscs+1];
-                    uint8_t d = 0;
-                    for(auto dsc_it = (*chr_it)->m_dscVec.begin(); dsc_it != (*chr_it)->m_dscVec.end(); ++dsc_it ) {
-                        if((*dsc_it)->m_removed > 0) {
-                            continue;
-                        }
-                        pDsc_a[d].uuid = &(*dsc_it)->m_uuid.getNative()->u;
-                        pDsc_a[d].att_flags = (*dsc_it)->m_properties;
+                    NimBLEDescriptor* pDescriptor = *pCharacteristic->m_dscVec.begin();
+                    for(uint8_t d=0; d < numDscs;) {
+                        pDsc_a[d].uuid = &pDescriptor->m_uuid.getNative()->u;
+                        pDsc_a[d].att_flags = pDescriptor->m_properties;
                        pDsc_a[d].min_key_size = 0;
                        pDsc_a[d].access_cb = NimBLEDescriptor::handleGapEvent;
-                        pDsc_a[d].arg = (*dsc_it);
-                        ++d;
+                        pDsc_a[d].arg = pDescriptor;
+                        d++;
+                        pDescriptor = *(pCharacteristic->m_dscVec.begin() + d);
                    }

                    pDsc_a[numDscs].uuid = NULL;
                    pChr_a[i].descriptors = pDsc_a;
                }

-                pChr_a[i].uuid = &(*chr_it)->m_uuid.getNative()->u;
+                pChr_a[i].uuid = &pCharacteristic->m_uuid.getNative()->u;
                pChr_a[i].access_cb = NimBLECharacteristic::handleGapEvent;
-                pChr_a[i].arg = (*chr_it);
-                pChr_a[i].flags = (*chr_it)->m_properties;
+                pChr_a[i].arg = pCharacteristic;
+                pChr_a[i].flags = pCharacteristic->m_properties;
                pChr_a[i].min_key_size = 0;
-                pChr_a[i].val_handle = &(*chr_it)->m_handle;
-                ++i;
+                pChr_a[i].val_handle = &pCharacteristic->m_handle;
+                i++;
+                pCharacteristic = *(m_chrVec.begin() + i);
            }

            pChr_a[numChrs].uuid = NULL;
@ -219,7 +187,7 @@ bool NimBLEService::start() {
        m_pSvcDef = svc;
    }

-    int rc = ble_gatts_count_cfg((const ble_gatt_svc_def*)m_pSvcDef);
+    rc = ble_gatts_count_cfg((const ble_gatt_svc_def*)m_pSvcDef);
    if (rc != 0) {
        NIMBLE_LOGE(LOG_TAG, "ble_gatts_count_cfg failed, rc= %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
        return false;
@ -271,63 +239,17 @@ NimBLECharacteristic* NimBLEService::createCharacteristic(const NimBLEUUID &uuid
                             std::string(uuid).c_str());
    }

-    addCharacteristic(pCharacteristic);
+    // Remember this characteristic in our vector of characteristics.
+    m_chrVec.push_back(pCharacteristic);
+
    return pCharacteristic;
 } // createCharacteristic


-/**
- * @brief Add a characteristic to the service.
- * @param[in] pCharacteristic A pointer to the characteristic instance to add to the service.
- */
 void NimBLEService::addCharacteristic(NimBLECharacteristic* pCharacteristic) {
-    bool foundRemoved = false;
-
-    if(pCharacteristic->m_removed > 0) {
-        for(auto& it : m_chrVec) {
-            if(it == pCharacteristic) {
-                foundRemoved = true;
-                pCharacteristic->m_removed = 0;
-            }
-        }
-    }
-
-    if(!foundRemoved) {
-        m_chrVec.push_back(pCharacteristic);
-    }
-
    pCharacteristic->setService(this);
-    getServer()->serviceChanged();
-} // addCharacteristic
-
-
-/**
- * @brief Remove a characteristic from the service.
- * @param[in] pCharacteristic A pointer to the characteristic instance to remove from the service.
- * @param[in] deleteChr If true it will delete the characteristic instance and free it's resources.
- */
-void NimBLEService::removeCharacteristic(NimBLECharacteristic* pCharacteristic, bool deleteChr) {
-    // Check if the characteristic was already removed and if so, check if this
-    // is being called to delete the object and do so if requested.
-    // Otherwise, ignore the call and return.
-    if(pCharacteristic->m_removed > 0) {
-        if(deleteChr) {
-            for(auto it = m_chrVec.begin(); it != m_chrVec.end(); ++it) {
-                if ((*it) == pCharacteristic) {
-                    m_chrVec.erase(it);
-                    delete *it;
-                    break;
-                }
-            }
-        }
-
-        return;
-    }
-
-    pCharacteristic->m_removed = deleteChr ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE;
-    getServer()->serviceChanged();
-} // removeCharacteristic
-
+    m_chrVec.push_back(pCharacteristic);
+}

 /**
 * @brief Get a pointer to the characteristic object with the specified UUID.
@ -421,7 +343,8 @@ std::string NimBLEService::toString() {
 * @return The BLEServer associated with this service.
 */
 NimBLEServer* NimBLEService::getServer() {
-    return NimBLEDevice::getServer();
+    return m_pServer;
 }// getServer

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif // CONFIG_BT_ENABLED
--- a/src/NimBLEService.h
+++ b/src/NimBLEService.h
@ -14,9 +14,11 @@

 #ifndef MAIN_NIMBLESERVICE_H_
 #define MAIN_NIMBLESERVICE_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)

 #include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

 #include "NimBLEServer.h"
 #include "NimBLECharacteristic.h"
@ -34,8 +36,8 @@ class NimBLECharacteristic;
 class NimBLEService {
 public:

-    NimBLEService(const char* uuid);
-    NimBLEService(const NimBLEUUID &uuid);
+    NimBLEService(const char* uuid, uint16_t numHandles, NimBLEServer* pServer);
+    NimBLEService(const NimBLEUUID &uuid, uint16_t numHandles, NimBLEServer* pServer);
    ~NimBLEService();

    NimBLEServer*         getServer();
@ -58,7 +60,6 @@ public:
                                               NIMBLE_PROPERTY::WRITE);

    void                  addCharacteristic(NimBLECharacteristic* pCharacteristic);
-    void                  removeCharacteristic(NimBLECharacteristic* pCharacteristic, bool deleteChr = false);
    NimBLECharacteristic* getCharacteristic(const char* uuid, uint16_t instanceId = 0);
    NimBLECharacteristic* getCharacteristic(const NimBLEUUID &uuid, uint16_t instanceId = 0);
    NimBLECharacteristic* getCharacteristicByHandle(uint16_t handle);
@ -74,12 +75,16 @@ private:
    friend class          NimBLEDevice;

    uint16_t              m_handle;
+    NimBLEServer*         m_pServer;
    NimBLEUUID            m_uuid;
+    uint16_t              m_numHandles;
    ble_gatt_svc_def*     m_pSvcDef;
    uint8_t               m_removed;
    std::vector<NimBLECharacteristic*> m_chrVec;

 }; // NimBLEService

-#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
+
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif // CONFIG_BT_ENABLED
 #endif /* MAIN_NIMBLESERVICE_H_ */
--- a/src/NimBLEUUID.cpp
+++ b/src/NimBLEUUID.cpp
@ -11,9 +11,8 @@
 *  Created on: Jun 21, 2017
 *      Author: kolban
 */
-
-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "NimBLEUtils.h"
 #include "NimBLEUUID.h"
--- a/src/NimBLEUUID.h
+++ b/src/NimBLEUUID.h
@ -14,16 +14,10 @@

 #ifndef COMPONENTS_NIMBLEUUID_H_
 #define COMPONENTS_NIMBLEUUID_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_uuid.h"
-#else
-#include "nimble/nimble/host/include/host/ble_uuid.h"
-#endif
-
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
--- a/src/NimBLEUtils.cpp
+++ b/src/NimBLEUtils.cpp
@ -6,13 +6,12 @@
 *
 */

-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
-
-#include <stdlib.h>
+#include "nimconfig.h"

 static const char* LOG_TAG = "NimBLEUtils";

@ -343,7 +342,6 @@ const char* NimBLEUtils::returnCodeToString(int rc) {
            return "Unknown";
    }
 #else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
-    (void)rc;
    return "";
 #endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
 }
@ -371,7 +369,6 @@ const char* NimBLEUtils::advTypeToString(uint8_t advType) {
            return "Unknown flag";
    }
 #else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT)
-    (void)advType;
    return "";
 #endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT)
 } // adFlagsToString
@ -419,11 +416,8 @@ char* NimBLEUtils::buildHexData(uint8_t* target, const uint8_t* source, uint8_t
 * @param [in] arg Unused.
 */
 void NimBLEUtils::dumpGapEvent(ble_gap_event *event, void *arg){
-    (void)arg;
 #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
    NIMBLE_LOGD(LOG_TAG, "Received a GAP event: %s", gapEventToString(event->type));
-#else
-    (void)event;
 #endif
 }

@ -510,7 +504,6 @@ const char* NimBLEUtils::gapEventToString(uint8_t eventType) {
            return "Unknown event type";
    }
 #else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
-    (void)eventType;
    return "";
 #endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
 } // gapEventToString
--- a/src/NimBLEUtils.h
+++ b/src/NimBLEUtils.h
@ -8,15 +8,10 @@

 #ifndef COMPONENTS_NIMBLEUTILS_H_
 #define COMPONENTS_NIMBLEUTILS_H_
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)

-#include "nimconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
-#else
-#include "nimble/nimble/host/include/host/ble_gap.h"
-#endif

 /****  FIX COMPILATION ****/
 #undef min
--- a/src/nimconfig.h
+++ b/src/nimconfig.h
@ -10,23 +10,6 @@
 #include "sdkconfig.h"
 #include "nimconfig_rename.h"

-#if defined(CONFIG_BT_ENABLED)
-
-// Allows cpp wrapper to select the correct include paths when using esp-idf
-#define CONFIG_NIMBLE_CPP_IDF
-
-/* Cannot use client without scan */
-#if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL) && !defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
-#define CONFIG_BT_NIMBLE_ROLE_OBSERVER
-#endif
-
-/* Cannot use server without advertise */
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL) && !defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
-#define CONFIG_BT_NIMBLE_ROLE_BROADCASTER
-#endif
-
-#endif /* CONFIG_BT_ENABLED */
-
 #ifdef _DOXYGEN_

 /** @brief Un-comment to change the number of simultaneous connections (esp controller max is 9) */
@ -38,17 +21,10 @@
 /** @brief Un-comment to change default device name */
 #define CONFIG_BT_NIMBLE_SVC_GAP_DEVICE_NAME "nimble"

-/** @brief Un-comment to set the debug log messages level from the NimBLE host stack.\n
- *  Values: 0 = DEBUG, 1 = INFO, 2 = WARNING, 3 = ERROR, 4 = CRITICAL, 5+ = NONE\n
+/** @brief Un-comment to see debug log messages from the NimBLE host
 *  Uses approx. 32kB of flash memory.
 */
-#define CONFIG_BT_NIMBLE_LOG_LEVEL 5
-
-/** @brief Un-comment to set the debug log messages level from the NimBLE CPP Wrapper.\n
- *  Values: 0 = NONE, 1 = ERROR, 2 = WARNING, 3 = INFO, 4+ = DEBUG\n
- *  Uses approx. 32kB of flash memory.
- */
-#define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
+#define CONFIG_BT_NIMBLE_DEBUG

 /** @brief Un-comment to see NimBLE host return codes as text debug log messages.
 *  Uses approx. 7kB of flash memory.
--- a/src/nimconfig_rename.h
+++ b/src/nimconfig_rename.h
@ -41,21 +41,13 @@
 #endif

 #if defined(CONFIG_SCAN_DUPLICATE_TYPE) && !defined(CONFIG_BTDM_SCAN_DUPL_TYPE)
-#define CONFIG_BTDM_SCAN_DUPL_TYPE CONFIG_SCAN_DUPLICATE_TYPE
-#endif
-
-#if defined(CONFIG_BT_CTRL_SCAN_DUPL_TYPE) && !defined(CONFIG_BTDM_SCAN_DUPL_TYPE)
-#define CONFIG_BTDM_SCAN_DUPL_TYPE CONFIG_BT_CTRL_SCAN_DUPL_TYPE
+#define CONFIG_BTDM_SCAN_DUPL_TYPE CONFIG_SCAN_DUPLICATE_TYPE 
 #endif

 #if defined(CONFIG_DUPLICATE_SCAN_CACHE_SIZE) && !defined(CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE)
-#define CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE CONFIG_DUPLICATE_SCAN_CACHE_SIZE
-#endif
-
-#if defined(CONFIG_BT_CTRL_SCAN_DUPL_CACHE_SIZE) && !defined(CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE)
-#define CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE CONFIG_BT_CTRL_SCAN_DUPL_CACHE_SIZE
+#define CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE CONFIG_DUPLICATE_SCAN_CACHE_SIZE 
 #endif

 #if defined(CONFIG_NIMBLE_MAX_CONNECTIONS ) && !defined(CONFIG_BT_NIMBLE_MAX_CONNECTIONS)
-#define CONFIG_BT_NIMBLE_MAX_CONNECTIONS CONFIG_NIMBLE_MAX_CONNECTIONS
+#define CONFIG_BT_NIMBLE_MAX_CONNECTIONS CONFIG_NIMBLE_MAX_CONNECTIONS  
 #endif
Author	SHA1	Message	Date
0xFEEDC0DE64	c218a27dd8	esp_nimble_hci_and_controller_deinit() does not exist in idf anymore, I hope we never need it	2022-09-17 22:14:05 +02:00
0xFEEDC0DE64	8883f44d9f	New compiler new printf chars	2022-09-17 22:13:46 +02:00
0xFEEDC0DE64	9c7b690771	New compiler new printf chars	2022-09-17 22:13:25 +02:00
0xFEEDC0DE64	641f297120	fix compiling issues when nimble is disabled in sdkconfig	2021-09-21 16:49:45 +02:00
0xFEEDC0DE64	7f853fa04b	Fixed shitty nimble logging	2021-05-29 01:21:34 +02:00
0xFEEDC0DE64	df4eb9f7d8	Removed arduino bullshit from nimble	2021-05-28 10:46:37 +02:00