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

This adds the functions:
- bool NimBLEDevice::whiteListAdd(const NimBLEAddress & address);
- bool NimBLEDevice::whiteListRemove(const NimBLEAddress & address);
- bool NimBLEDevice::onWhiteList(const NimBLEAddress & address);
- size_t NimBLEDevice::getWhiteListCount();
- NimBLEAddress NimBLEDevice::getWhiteListAddress(size_t index);

.travis.yml

@@ -2,11 +2,11 @@ sudo: false
 
 before_install:
  - cd ${TMPDIR-/tmp}
- - wget -q http://doxygen.nl/files/doxygen-1.8.19.src.tar.gz
- - tar -xzvf doxygen-1.8.19.src.tar.gz
+ - 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.8.19/
+ - cmake ../doxygen-1.9.0/
  - make
  - export PATH="${TMPDIR-/tmp}/doxygen_build/bin:$PATH"
  - cd ${TRAVIS_BUILD_DIR}

CHANGELOG.md

@@ -2,6 +2,140 @@
 
 All notable changes to this project will be documented in this file.  
 
+## [1.2.0] - 2021-02-08
+
+### Added
+- `NimBLECharacteristic::getDescriptorByHandle`: Return the BLE Descriptor for the given handle.
+
+- `NimBLEDescriptor::getStringValue`: Get the value of this descriptor as a string.
+
+- `NimBLEServer::getServiceByHandle`: Get a service by its handle.
+
+- `NimBLEService::getCharacteristicByHandle`: Get a pointer to the characteristic object with the specified handle.
+
+- `NimBLEService::getCharacteristics`: Get the vector containing pointers to each characteristic associated with this service.  
+Overloads to get a vector containing pointers to all the characteristics in a service with the UUID. (supports multiple same UUID's in a service)
+  - `NimBLEService::getCharacteristics(const char *uuid)`
+  - `NimBLEService::getCharacteristics(const NimBLEUUID &uuid)`
+
+- `NimBLEAdvertisementData` New methods:
+  - `NimBLEAdvertisementData::addTxPower`: Adds transmission power to the advertisement.
+  - `NimBLEAdvertisementData::setPreferredParams`: Adds connection parameters to the advertisement.
+  - `NimBLEAdvertisementData::setURI`: Adds URI data to the advertisement.
+
+- `NimBLEAdvertising` New methods:
+  - `NimBLEAdvertising::setName`: Set the name advertised.
+  - `NimBLEAdvertising::setManufacturerData`: Adds manufacturer data to the advertisement.
+  - `NimBLEAdvertising::setURI`: Adds URI data to the advertisement.
+  - `NimBLEAdvertising::setServiceData`: Adds service data to the advertisement.
+  - `NimBLEAdvertising::addTxPower`: Adds transmission power to the advertisement.
+  - `NimBLEAdvertising::reset`: Stops the current advertising and resets the advertising data to the default values.
+
+- `NimBLEDevice::setScanFilterMode`: Set the controller duplicate filter mode for filtering scanned devices.
+
+- `NimBLEDevice::setScanDuplicateCacheSize`: Sets the number of advertisements filtered before the cache is reset.
+
+- `NimBLEScan::setMaxResults`:  This allows for setting a maximum number of advertised devices stored in the results vector.
+
+- `NimBLEAdvertisedDevice` New data retrieval methods added:
+  - `haveAdvInterval/getAdvInterval`: checks if the interval is advertised / gets the advertisement interval value.
+
+  - `haveConnParams/getMinInterval/getMaxInterval`: checks if the parameters are advertised / get min value / get max value.
+
+  - `haveURI/getURI`: checks if a URI is advertised / gets the URI data.
+
+  - `haveTargetAddress/getTargetAddressCount/getTargetAddress(index)`: checks if a target address is present / gets a count of the addresses targeted / gets the address of the target at index.
+
+### Changed
+- `nimconfig.h` (Arduino) is now easier to use.
+
+- `NimBLEServer::getServiceByUUID` Now takes an extra parameter of instanceID to support multiple services with the same UUID.
+
+- `NimBLEService::getCharacteristic` Now takes an extra parameter of instanceID to support multiple characteristics with the same UUID.
+
+- `NimBLEAdvertising` Transmission power is no longer advertised by default and can be added to the advertisement by calling `NimBLEAdvertising::addTxPower`
+
+- `NimBLEAdvertising` Custom scan response data can now be used without custom advertisment.
+
+- `NimBLEScan` Now uses the controller duplicate filter.  
+
+- `NimBLEAdvertisedDevice` Has been refactored to store the complete advertisement payload and no longer parses the data from each advertisement.  
+Instead the data will be parsed on-demand when the user application asks for specific data.  
+
+### Fixed
+- `NimBLEHIDDevice` Characteristics now use encryption, this resolves an issue with communicating with devices requiring encryption for HID devices.
+
+
+## [1.1.0] - 2021-01-20
+
+### Added
+- `NimBLEDevice::setOwnAddrType` added to enable the use of random and random-resolvable addresses, by asukiaaa  
+
+- New examples for securing and authenticating client/server connections, by mblasee.  
+
+- `NimBLEAdvertising::SetMinPreferred` and `NimBLEAdvertising::SetMinPreferred` re-added.  
+
+- Conditional checks added for command line config options in `nimconfig.h` to support custom configuration in platformio.  
+
+- `NimBLEClient::setValue` Now takes an extra bool parameter `response` to enable the use of write with response (default = false).  
+
+- `NimBLEClient::getCharacteristic(uint16_t handle)` Enabling the use of the characteristic handle to be used to find 
+the NimBLERemoteCharacteristic object.  
+
+- `NimBLEHIDDevice` class added by wakwak-koba.  
+
+- `NimBLEServerCallbacks::onDisconnect` overloaded callback added to provide a ble_gap_conn_desc parameter for the application  
+to obtain information about the disconnected client.  
+
+- Conditional checks in `nimconfig.h` for command line defined macros to support platformio config settings.  
+
+### Changed
+- `NimBLEAdvertising::start` now returns a bool value to indicate success/failure.  
+
+- Some asserts were removed in `NimBLEAdvertising::start` and replaced with better return code handling and logging.    
+
+- If a host reset event occurs, scanning and advertising will now only be restarted if their previous duration was indefinite.  
+
+- `NimBLERemoteCharacteristic::subscribe` and `NimBLERemoteCharacteristic::registerForNotify` will now set the callback
+regardless of the existance of the CCCD and return true unless the descriptor write operation failed.  
+
+- Advertising tx power level is now sent in the advertisement packet instead of scan response.  
+
+- `NimBLEScan` When the scan ends the scan stopped flag is now set before calling the scan complete callback (if used)  
+this allows the starting of a new scan from the callback function.  
+
+### Fixed
+- Sometimes `NimBLEClient::connect` would hang on the task block if no event arrived to unblock.  
+A time limit has been added to timeout appropriately.  
+
+- When getting descriptors for a characterisic the end handle of the service was used as a proxy for the characteristic end  
+handle. This would be rejected by some devices and has been changed to use the next characteristic handle as the end when possible.  
+
+- An exception could occur when deleting a client instance if a notification arrived while the attribute vectors were being  
+deleted. A flag has been added to prevent this.  
+  
+- An exception could occur after a host reset event when the host re-synced if the tasks that were stopped during the event did  
+not finish processing. A yield has been added after re-syncing to allow tasks to finish before proceeding.  
+  
+- Occasionally the controller would fail to send a disconnected event causing the client to indicate it is connected  
+and would be unable to reconnect. A timer has been added to reset the host/controller if it expires.  
+  
+- Occasionally the call to start scanning would get stuck in a loop on BLE_HS_EBUSY, this loop has been removed.  
+
+- 16bit and 32bit UUID's in some cases were not discovered or compared correctly if the device  
+advertised them as 16/32bit but resolved them to 128bits. Both are now checked.  
+  
+- `FreeRTOS` compile errors resolved in latest Ardruino core and IDF v3.3.  
+
+- Multiple instances of `time()` called inside critical sections caused sporadic crashes, these have been moved out of critical regions.  
+
+- Advertisement type now correctly set when using non-connectable (advertiser only) mode.  
+
+- Advertising payload length correction, now accounts for appearance.  
+
+- (Arduino) Ensure controller mode is set to BLE Only.  
+
+
 ## [1.0.2] - 2020-09-13
 
 ### Changed
@@ -15,6 +149,7 @@ Any changes to the controller max connection settings in `sdkconfig.h` will now
 - (Arduino) Revert the previous change to fix the advertising start delay. Instead a replacement fix that routes all BLE controller commands from  
 a task running on core 0 (same as the controller) has been implemented. This improves response times and reliability for all BLE functions.
 
+
 ## [1.0.1] - 2020-09-02
 
 ### Added

CMakeLists.txt

@@ -2,28 +2,64 @@
 # CMakeLists in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.5)
 
-set(SUPPORTED_TARGETS esp32)
+idf_build_get_property(__hack_component_targets __COMPONENT_TARGETS)
 
-idf_component_register(SRCS "src/FreeRTOS.cpp"
-                            "src/NimBLE2904.cpp"
-                            "src/NimBLEAddress.cpp"
-                            "src/NimBLEAdvertisedDevice.cpp"
-                            "src/NimBLEAdvertising.cpp"
-                            "src/NimBLEBeacon.cpp"
-                            "src/NimBLECharacteristic.cpp"
-                            "src/NimBLEClient.cpp"
-                            "src/NimBLEDescriptor.cpp"
-                            "src/NimBLEDevice.cpp"
-                            "src/NimBLEEddystoneTLM.cpp"
-                            "src/NimBLEEddystoneURL.cpp"
-                            "src/NimBLERemoteCharacteristic.cpp"
-                            "src/NimBLERemoteDescriptor.cpp"
-                            "src/NimBLERemoteService.cpp"
-                            "src/NimBLEScan.cpp"
-                            "src/NimBLESecurity.cpp"
-                            "src/NimBLEServer.cpp"
-                            "src/NimBLEService.cpp"
-                            "src/NimBLEUtils.cpp"
-                            "src/NimBLEUUID.cpp"
-                  INCLUDE_DIRS "src"
-                  REQUIRES bt)
+if("esp-nimble-component" IN_LIST BUILD_COMPONENTS OR "__esp-nimble-component" IN_LIST __hack_component_targets)
+    list(APPEND ESP_NIMBLE_PRIV_REQUIRES
+        esp-nimble-component
+    )
+elseif("nimble" IN_LIST BUILD_COMPONENTS OR "__nimble" IN_LIST __hack_component_targets)
+    list(APPEND ESP_NIMBLE_PRIV_REQUIRES
+        nimble
+    )
+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
+    "esp32"
+    "esp32s3"
+    "esp32c3"
+  INCLUDE_DIRS
+    "src"
+  SRCS
+    "src/FreeRTOS.cpp"
+    "src/NimBLE2904.cpp"
+    "src/NimBLEAddress.cpp"
+    "src/NimBLEAdvertisedDevice.cpp"
+    "src/NimBLEAdvertising.cpp"
+    "src/NimBLEBeacon.cpp"
+    "src/NimBLECharacteristic.cpp"
+    "src/NimBLEClient.cpp"
+    "src/NimBLEDescriptor.cpp"
+    "src/NimBLEDevice.cpp"
+    "src/NimBLEEddystoneTLM.cpp"
+    "src/NimBLEEddystoneURL.cpp"
+    "src/NimBLEHIDDevice.cpp"
+    "src/NimBLERemoteCharacteristic.cpp"
+    "src/NimBLERemoteDescriptor.cpp"
+    "src/NimBLERemoteService.cpp"
+    "src/NimBLEScan.cpp"
+    "src/NimBLESecurity.cpp"
+    "src/NimBLEServer.cpp"
+    "src/NimBLEService.cpp"
+    "src/NimBLEUtils.cpp"
+    "src/NimBLEUUID.cpp"
+  REQUIRES
+    bt
+    nvs_flash
+    esp_ringbuf
+  PRIV_REQUIRES
+    ${ESP_NIMBLE_PRIV_REQUIRES}
+)
+
+target_compile_options(${COMPONENT_TARGET}
+    PUBLIC
+        -DDONT_USE_ARDUINO_BULLSHIT
+)

CMakeLists.txt_idf3

@@ -0,0 +1,57 @@
+# The following lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+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"
+    "src/NimBLEAdvertising.cpp"
+    "src/NimBLEBeacon.cpp"
+    "src/NimBLECharacteristic.cpp"
+    "src/NimBLEClient.cpp"
+    "src/NimBLEDescriptor.cpp"
+    "src/NimBLEDevice.cpp"
+    "src/NimBLEEddystoneTLM.cpp"
+    "src/NimBLEEddystoneURL.cpp"
+    "src/NimBLEHIDDevice.cpp"
+    "src/NimBLERemoteCharacteristic.cpp"
+    "src/NimBLERemoteDescriptor.cpp"
+    "src/NimBLERemoteService.cpp"
+    "src/NimBLEScan.cpp"
+    "src/NimBLESecurity.cpp"
+    "src/NimBLEServer.cpp"
+    "src/NimBLEService.cpp"
+    "src/NimBLEUtils.cpp"
+    "src/NimBLEUUID.cpp"
+)
+
+set(COMPONENT_ADD_INCLUDEDIRS
+    src
+)
+
+set(COMPONENT_PRIV_REQUIRES
+    nvs_flash
+    bt
+)
+
+if(COMPONENTS MATCHES "esp-nimble-component")
+    list(APPEND COMPONENT_PRIV_REQUIRES
+        esp-nimble-component
+    )
+elseif(COMPONENTS MATCHES "nimble")
+    list(APPEND COMPONENT_PRIV_REQUIRES
+        nimble
+    )
+endif()
+
+if(COMPONENTS MATCHES "arduino")
+    list(APPEND COMPONENT_PRIV_REQUIRES
+        arduino
+    )
+endif()
+
+register_component()

Kconfig.projbuild

@@ -1,27 +0,0 @@
-menu "ESP-NimBLE-CPP configuration"
-
-config NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
-    bool "Show NimBLE return codes as text in debug log."
-    default "n"
-    help
-        Enabling this option will display return code values as text
-        messages in the debug log. This will use approximately 8kB
-        of flash memory.
-        
-config NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
-    bool "Show NimBLE gap events as text in debug log."
-    default "n"
-    help
-        Enabling this option will display gap event codes as text
-        messages in the debug log. This will use approximately 1kB
-        of flash memory.
-
-config NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT
-    bool "Show advertisment types as text in debug log."
-    default "n"
-    help
-        Enabling this option will display advertisment types recieved
-        while scanning as text messages in the debug log. 
-        This will use approximately 250 bytes of flash memory.
-        
-endmenu

README.md

@@ -1,5 +1,7 @@
 [Latest release ![Release Version](https://img.shields.io/github/release/h2zero/esp-nimble-cpp.svg?style=plastic)
 ![Release Date](https://img.shields.io/github/release-date/h2zero/esp-nimble-cpp.svg?style=plastic)](https://github.com/h2zero/esp-nimble-cpp/releases/latest/)  
+
+Need help? Have questions or suggestions? Join the [![Gitter](https://badges.gitter.im/NimBLE-Arduino/community.svg)](https://gitter.im/NimBLE-Arduino/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)  
 <br/>
 
 # esp-nimble-cpp
@@ -17,7 +19,7 @@ to provide improved capabilites and stability over the original.
 *Your results may vary*  
 <br/>
 
-### What is NimBLE?
+# What is NimBLE?
 NimBLE is a completely open source Bluetooth Low Energy stack produced by [Apache](https://github.com/apache/mynewt-nimble).  
 It is more suited to resource constrained devices than bluedroid and has now been ported to the ESP32 by Espressif.  
 <br/>
@@ -34,7 +36,7 @@ Call `NimBLEDevice::init("");` in `app_main`.
 <br/>
 
 ### ESP-IDF v3.2 & v3.3
-The NimBLE component does not come with these versions of IDF.  
+The NimBLE component does not come with these versions of IDF (now included in 3.3.2 and above).  
 A backport that works in these versions has been created and is [available here](https://github.com/h2zero/esp-nimble-component).  
 Download or clone that repo into your project/components folder and run menuconfig.
 Configure settings in `main menu -> NimBLE Options`.  
@@ -55,6 +57,11 @@ Also see [Improvements_and_updates](docs/Improvements_and_updates.md) for inform
 [Full API documentation and class list can be found here.](https://h2zero.github.io/esp-nimble-cpp/)  
 <br/>  
 
+## Using with Arduino as an IDF component and CMake
+When using this library along with Arduino and compiling with *CMake* you must add `add_compile_definitions(ARDUINO_ARCH_ESP32=1)`  
+in your project/CMakeLists.txt after the line `include($ENV{IDF_PATH}/tools/cmake/project.cmake)` to prevent Arduino from releasing BLE memory.
+<br>
+
 # Acknowledgments
 * [nkolban](https://github.com/nkolban) and [chegewara](https://github.com/chegewara) for the [original esp32 BLE library](https://github.com/nkolban/esp32-snippets/tree/master/cpp_utils) this project was derived from.
 * [beegee-tokyo](https://github.com/beegee-tokyo) for contributing your time to test/debug and contributing the beacon examples.

docs/Command_line_config.md

@@ -0,0 +1,117 @@
+# Arduino command line and platformio config options  
+
+`CONFIG_BT_NIMBLE_MAX_CONNECTIONS`  
+
+Sets the number of simultaneous connections (esp controller max is 9)  
+- Default value is 3  
+<br/>
+
+`CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU`  
+
+Sets the default MTU size.  
+- Default value is 255  
+<br/>
+
+`CONFIG_BT_NIMBLE_SVC_GAP_DEVICE_NAME`  
+
+Set the default device name  
+- Default value is "nimble"  
+<br/>
+
+`CONFIG_BT_NIMBLE_DEBUG`   
+
+If defined, enables debug log messages from the NimBLE host  
+- Uses approx. 32kB of flash memory.  
+<br/>
+
+`CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT`  
+
+If defined, NimBLE host return codes will be printed as text in debug log messages.  
+- Uses approx. 7kB of flash memory.  
+<br/>
+
+`CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT`  
+
+If defined, GAP event codes will be printed as text in debug log messages.  
+- Uses approx. 1kB of flash memory.  
+<br/>
+
+`CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT`  
+
+If defined, advertisment types will be printed as text while scanning in debug log messages.  
+- Uses approx. 250 bytes of flash memory.  
+<br/>
+
+`CONFIG_BT_NIMBLE_SVC_GAP_APPEARANCE`  
+
+Set the default appearance.  
+- Default value is 0x00  
+<br/>
+
+`CONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED`  
+ 
+If defined, NimBLE Client functions will not be included.  
+- Reduces flash size by approx. 7kB.  
+<br/>
+
+`CONFIG_BT_NIMBLE_ROLE_OBSERVER_DISABLED`  
+
+If defined, NimBLE Scan functions will not be included.  
+- Reduces flash size by approx. 26kB.  
+<br/>
+
+`CONFIG_BT_NIMBLE_ROLE_PERIPHERAL_DISABLED`  
+
+If defined NimBLE Server functions will not be included.  
+- Reduces flash size by approx. 16kB.  
+<br/>
+
+`CONFIG_BT_NIMBLE_ROLE_BROADCASTER_DISABLED`  
+
+If defined, NimBLE Advertising functions will not be included.  
+- Reduces flash size by approx. 5kB.  
+<br/>
+
+`CONFIG_BT_NIMBLE_MAX_BONDS`  
+
+Sets the number of devices allowed to store/bond with  
+- Default value is 3  
+<br/>
+
+`CONFIG_BT_NIMBLE_MAX_CCCDS`  
+
+Sets the maximum number of CCCD subscriptions to store  
+- Default value is 8  
+<br/>
+
+`CONFIG_BT_NIMBLE_RPA_TIMEOUT`  
+
+Sets the random address refresh time in seconds.  
+- Default value is 900  
+<br/>
+
+`CONFIG_BT_NIMBLE_MSYS1_BLOCK_COUNT`  
+
+Set the number of msys blocks For prepare write & prepare responses. This may need to be increased if  
+you are sending large blocks of data with a low MTU. E.g: 512 bytes with 23 MTU will fail.  
+- Default value is 12  
+<br/>
+
+`CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL`  
+
+Sets the NimBLE stack to use external PSRAM will be loaded  
+- Must be defined with a value of 1; Default is CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL 1  
+<br/>
+
+`CONFIG_BT_NIMBLE_PINNED_TO_CORE`  
+
+Sets the core the NimBLE host stack will run on   
+- Options: 0 or 1
+<br/>
+
+`CONFIG_BT_NIMBLE_TASK_STACK_SIZE`  
+
+Set the task stack size for the NimBLE core.  
+- Default is 4096  
+<br/>
+

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.0.2
+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
@@ -2179,8 +2179,12 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = CONFIG_BT_ENABLED \
-                         _DOXYGEN_
+PREDEFINED             = _DOXYGEN_ \
+                         CONFIG_BT_ENABLED \
+                         CONFIG_BT_NIMBLE_ROLE_CENTRAL \
+                         CONFIG_BT_NIMBLE_ROLE_OBSERVER \
+                         CONFIG_BT_NIMBLE_ROLE_PERIPHERAL \
+                         CONFIG_BT_NIMBLE_ROLE_BROADCASTER
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

docs/Improvements_and_updates.md

@@ -69,6 +69,8 @@ Now takes 2 optional parameters, the first is the duration to advertise for (in
 that is invoked when advertsing ends and takes a pointer to a `NimBLEAdvertising` object (similar to the `NimBLEScan::start` API).  
 
 This provides an opportunity to update the advertisment data if desired.  
+
+Also now returns a bool value to indicate if advertising successfully started or not.
 <br/>  
 
 <a name="client"></a>
@@ -100,8 +102,18 @@ Has been **deprecated** as now the internally stored characteristic value is upd
 `NimBLERemoteCharacteristic::subscribe` and `NimBLERemoteCharacteristic::unsubscribe` have been implemented to replace it.  
 A callback is no longer requred to get the most recent value unless timing is important. Instead, the application can call `NimBLERemoteCharacteristic::getValue` to  
 get the last updated value any time.  
+<br/>  
 
-In addition `NimBLERemoteCharacteristic::readValue` and `NimBLERemoteCharacteristic::getValue` take an optional timestamp parameter which will update it's value with  
+The `notifiy_callback` function is now defined as a `std::function` to take advantage of using `std::bind` to specifiy a class member function for the callback.  
+
+Example:  
+```
+using namespace std::placeholders;
+notify_callback callback = std::bind(&<ClassName>::<memberFunctionCallbackName>, this, _1, _2, _3, _4);
+<remoteCharacteristicInstance>->subscribe(true, callback);
+```
+
+`NimBLERemoteCharacteristic::readValue` and `NimBLERemoteCharacteristic::getValue` take an optional timestamp parameter which will update it's value with  
 the time the last value was recieved.  
 
 > NimBLEClient::getService  

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`.
@@ -218,10 +220,11 @@ If you wish to advertise these parameters you can still do so manually via `BLEA
 <br/>
 
 Calling `NimBLEAdvertising::setAdvertisementData` will entirely replace any data set with `NimBLEAdvertising::addServiceUUID`, or  
-`NimBLEAdvertising::setAppearance`. You should set all the data you wish to advertise within the `NimBLEAdvertisementData` instead.  
+`NimBLEAdvertising::setAppearance` or similar methods. You should set all the data you wish to advertise within the `NimBLEAdvertisementData` instead.  
 
-Calling `NimBLEAdvertising::setScanResponseData` without also calling `NimBLEAdvertising::setAdvertisementData` will have no effect.  
-When using custom scan response data you must also use custom advertisement data.  
+~~Calling `NimBLEAdvertising::setScanResponseData` without also calling `NimBLEAdvertising::setAdvertisementData` will have no effect.  
+When using custom scan response data you must also use custom advertisement data.~~  
+No longer true as of release 1.2.0 and above, custom scan response is now supported without custom advertisement data.  
 <br/>
 
 > BLEAdvertising::start (NimBLEAdvertising::start)

docs/Usage_tips.md

@@ -0,0 +1,41 @@
+# Usage Tips
+
+## Put BLE functions in a task running on the NimBLE stack core
+
+When commands are sent to the stack from a differnt core they can experience delays in execution.  
+This library detects this and invokes the esp32 IPC to reroute these commands through the correct core but this also increases overhead.  
+Therefore it is highly recommended to create tasks for BLE to run on the same core, the macro `CONFIG_BT_NIMBLE_PINNED_TO_CORE` can be used to set the core.
+<br/>  
+
+## Do not delete client instances unless necessary or unused
+
+When a client instance has been created and has connected to a peer device and it has retrieved service/characteristic information it will store that data for the life of the client instance.  
+If you are periodically connecting to the same devices and you have deleted the client instance or the services when connecting again it will cause a retrieval of that information from the peer again.  
+This results in significant energy drain on the battery of the devices, fragments heap, and reduces connection performance.  
+  
+Client instances in this library use approximately 20% of the original bluedroid library, deleteing them will provide much less gain than it did before.  
+
+It is recommended to retain the client instance in cases where the time between connecting to the same device is less than 5 minutes.  
+<br/>  
+
+## Only retrieve the services and characteriscs needed
+
+As a client the use of `NimBLEClient::getServices` or `NimBLERemoteService::getCharacteristics` and using `true` for the parameter should be limited to devices that are not known.  
+Instead `NimBLEClient::getService(NimBLEUUID)` or `NimBLERemoteService::getCharacteristic(NimBLEUUID)` should be used to access certain attributes that are useful to the application.  
+This reduces energy consumed, heap allocated, connection time and improves overall efficiency.  
+<br/>  
+
+## Check return values
+
+Many user issues can be avoided by checking if a function returned successfully, by either testing for true/false such as when calling `NimBLEClient::connect`,  
+or nullptr such as when  calling `NimBLEClient::getService`. The latter being a must, as calling a method on a nullptr will surely result in a crash.  
+Most of the functions in this library return something that should be checked before proceeding.  
+<br/>  
+
+## There will be bugs - please report them
+
+No code is bug free and unit testing will not find them all on it's own. If you encounter a bug, please report it along with any logs and decoded backtrace if applicable.  
+Best efforts will be made to correct any errors ASAP.  
+
+Bug reports can be made at https://github.com/h2zero/NimBLE-Arduino/issues or https://github.com/h2zero/esp-nimble-cpp/issues.  
+Questions and suggestions will be happily accepted there as well.

docs/index.md

@@ -1,24 +1,28 @@
 # Overview
 
 This is a C++ BLE library for the ESP32 that uses the NimBLE host stack instead of bluedroid.  
-The aim is to maintain, as much as reasonable, the original bluedroid C++ API while adding new features  
-and making improvements in performance, resource use and stability.  
+The aim is to maintain, as much as reasonable, the original bluedroid C++ & Arduino BLE API by while adding new features  
+and making improvements in performance, resource use, and stability.  
 
 **Testing shows a nearly 50% reduction in flash use and approx. 100kB less ram consumed vs the original!**  
 *Your results may vary*
 <br/>  
 
-### What is NimBLE?
+# What is NimBLE?
 NimBLE is a completely open source Bluetooth Low Energy stack produced by [Apache](https://github.com/apache/mynewt-nimble).  
 It is more suited to resource constrained devices than bluedroid and has now been ported to the ESP32 by Espressif.  
 <br/>
 
 # Arduino Installation
-Download as .zip and extract to Arduino/libraries folder, or in Arduino IDE from Sketch menu -> Include library -> Add .Zip library.
+**Arduino Library manager:** Go to `sketch` -> `Include Library` -> `Manage Libraries` and search for NimBLE and install.  
+
+**Alternatively:** Download as .zip and extract to Arduino/libraries folder, or in Arduino IDE from Sketch menu -> Include library -> Add .Zip library.  
 
 `#include "NimBLEDevice.h"` at the beginning of your sketch.  
 
-Tested and working with esp32-arduino Arduino IDE and platform IO.  
+Call `NimBLEDevice::init` in `setup`.
+
+Tested and working with esp32-arduino in Arduino IDE and platform IO.  
 <br/>  
 
 # ESP-IDF Installation
@@ -28,17 +32,17 @@ Download as .zip and extract or clone into the components folder in your esp-idf
 Run menuconfig, go to `Component config->Bluetooth` enable Bluetooth and in `Bluetooth host` NimBLE.  
 Configure settings in `NimBLE Options`.  
 `#include "NimBLEDevice.h"` in main.cpp.  
-Call `NimBLEDevice::init("");` in `app_main`.  
+Call `NimBLEDevice::init` in `app_main`.  
 <br/>
 
 ### v3.2 & v3.3
-The NimBLE component does not come with these versions of IDF.  
+The NimBLE component does not come with these versions of IDF (now included in 3.3.2 and above).   
 A backport that works in these versions has been created and is [available here](https://github.com/h2zero/esp-nimble-component).  
 Download or clone that repo into your project/components folder and run menuconfig.
 Configure settings in `main menu -> NimBLE Options`.  
 
 `#include "NimBLEDevice.h"` in main.cpp.  
-Call `NimBLEDevice::init("");` in `app_main`.  
+Call `NimBLEDevice::init` in `app_main`.  
 <br/>  
 
 # Using
@@ -48,31 +52,28 @@ If you have not used the original Bluedroid library please refer to the [New use
 
 If you are familiar with the original library, see: [The migration guide](Migration_guide.md) for details.  
 
-Also see [Improvements_and_updates](Improvements_and_updates.md) for information about non-breaking changes.  
+Also see [Improvements and updates](Improvements_and_updates.md) for information about non-breaking changes.  
 
-### Arduino specific:
+For more advanced usage see [Usage tips](Usage_tips.md) for more performance and optimization.  
+<br/>
+
+### Arduino specific
 See the Refactored_original_examples in the examples folder for highlights of the differences with the original library.  
 
 More advanced examples highlighting many available features are in examples/NimBLE_Server, NimBLE_Client.  
     
 Beacon examples provided by [beegee-tokyo](https://github.com/beegee-tokyo) are in examples/BLE_Beacon_Scanner, BLE_EddystoneTLM_Beacon, BLE_EddystoneURL_Beacon.  
 
-Change the settings in the nimconfig.h file to customize NimBLE to your project, such as increasing max connections (default == 3).  
+Change the settings in the nimconfig.h file to customize NimBLE to your project, such as increasing max connections (default is 3).  
+<br/>
 
-**Note To increase max connections in Arduino it is also required to change the controller max connections defined in sdkconfig.h.**  
+### Arduino command line and platformio
+As an alternative to changing the configuration in nimconfig.h, Arduino command line and platformio.ini options are available.  
+See the command line configuration options available in [Command line config](Command_line_config.md).  
+<br/>  
 
-This is located in your Arduino/hardware/espressif/esp32/tools/sdk/include/config folder.
-
-The values in `sdkconfig.h` you will need to change are:  
-```
-#define CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN 3  
-#define CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN_EFF 3  
-```
-In `nimconfig.h` the value is:  
-```
-#define CONFIG_BT_NIMBLE_MAX_CONNECTIONS 3  
-```
-Espressif has stated the hard maximum connections is 9.  
+# Need help? Have a question or suggestion?
+Come chat on [gitter](https://gitter.im/NimBLE-Arduino/community?utm_source=share-link&utm_medium=link&utm_campaign=share-link) or open an issue at [NimBLE-Arduino](https://github.com/h2zero/NimBLE-Arduino/issues) or [esp-nimble-cpp](https://github.com/h2zero/esp-nimble-cpp/issues)  
 <br/>
 
 # Acknowledgments

src/FreeRTOS.cpp

@@ -155,7 +155,7 @@ void FreeRTOS::Semaphore::give() {
     } else {
         xSemaphoreGive(m_semaphore);
     }
-// #ifdef ARDUINO_ARCH_ESP32
+// #if defined(ARDUINO_ARCH_ESP32) && !defined(DONT_USE_ARDUINO_BULLSHIT)
 //  FreeRTOS::sleep(10);
 // #endif
 
@@ -243,7 +243,7 @@ bool FreeRTOS::Semaphore::take(uint32_t timeoutMs, std::string owner) {
 std::string FreeRTOS::Semaphore::toString() {
     char hex[9];
     std::string res = "name: " + m_name + " (0x";
-    snprintf(hex, sizeof(hex), "%08x", (uint32_t)m_semaphore);
+    snprintf(hex, sizeof(hex), "%08lx", (uint32_t)m_semaphore);
     res += hex;
     res += "), owner: " + m_owner;
     return res;
@@ -265,9 +265,13 @@ void FreeRTOS::Semaphore::setName(std::string name) {
  * @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
-Ringbuffer::Ringbuffer(size_t length, RingbufferType_t type) {
+#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) {
+    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

src/FreeRTOS.h

@@ -69,7 +69,11 @@ public:
 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

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

src/NimBLE2904.cpp

@@ -37,7 +37,7 @@ NimBLE2904::NimBLE2904(NimBLECharacteristic* pCharacterisitic)
     m_data.m_unit        = 0;
     m_data.m_description = 0;
     setValue((uint8_t*) &m_data, sizeof(m_data));
-} // BLE2902
+} // BLE2904
 
 
 /**

src/NimBLE2904.h

@@ -42,6 +42,7 @@ struct BLE2904_Data {
  */
 class NimBLE2904: public NimBLEDescriptor {
 public:
+    NimBLE2904(NimBLECharacteristic* pCharacterisitic = nullptr);
     static const uint8_t FORMAT_BOOLEAN   = 1;
     static const uint8_t FORMAT_UINT2     = 2;
     static const uint8_t FORMAT_UINT4     = 3;
@@ -77,7 +78,6 @@ public:
     void setUnit(uint16_t unit);
 
 private:
-    NimBLE2904(NimBLECharacteristic* pCharacterisitic);
     friend class NimBLECharacteristic;
     BLE2904_Data m_data;
 }; // BLE2904

src/NimBLEAddress.cpp

@@ -12,7 +12,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include <algorithm>
 

src/NimBLEAddress.h

@@ -15,7 +15,7 @@
 #ifndef COMPONENTS_NIMBLEADDRESS_H_
 #define COMPONENTS_NIMBLEADDRESS_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "nimble/ble.h"
 /****  FIX COMPILATION ****/

src/NimBLEAdvertisedDevice.cpp

@@ -28,25 +28,14 @@ static const char* LOG_TAG = "NimBLEAdvertisedDevice";
 /**
  * @brief Constructor
  */
-NimBLEAdvertisedDevice::NimBLEAdvertisedDevice() {
+NimBLEAdvertisedDevice::NimBLEAdvertisedDevice() :
+    m_payload(62,0)
+{
     m_advType          = 0;
-    m_appearance       = 0;
-    m_manufacturerData = "";
-    m_name             = "";
     m_rssi             = -9999;
-    m_txPower          = 0;
-    m_payloadLength    = 0;
-    m_payload          = nullptr;
-
-    m_haveAppearance       = false;
-    m_haveManufacturerData = false;
-    m_haveName             = false;
-    m_haveRSSI             = false;
-    m_haveServiceData      = false;
-    m_haveServiceUUID      = false;
-    m_haveTXPower          = false;
-    m_callbackSent         = false;
-
+    m_callbackSent     = false;
+    m_timestamp        = 0;
+    m_advLength        = 0;
 } // NimBLEAdvertisedDevice
 
 
@@ -82,25 +71,126 @@ uint8_t NimBLEAdvertisedDevice::getAdvType() {
  * @return The appearance of the advertised device.
  */
 uint16_t NimBLEAdvertisedDevice::getAppearance() {
-    return m_appearance;
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_APPEARANCE, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length == BLE_HS_ADV_APPEARANCE_LEN + 1) {
+            return *field->value | *(field->value + 1) << 8;
+        }
+    }
+
+    return 0;
 } // getAppearance
 
 
+/**
+ * @brief Get the advertisement interval.
+ * @return The advertisement interval in 0.625ms units.
+ */
+uint16_t NimBLEAdvertisedDevice::getAdvInterval() {
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_ADV_ITVL, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length == BLE_HS_ADV_ADV_ITVL_LEN + 1) {
+            return *field->value | *(field->value + 1) << 8;
+        }
+    }
+
+    return 0;
+} // getAdvInterval
+
+
+/**
+ * @brief Get the preferred min connection interval.
+ * @return The preferred min connection interval in 1.25ms units.
+ */
+uint16_t NimBLEAdvertisedDevice::getMinInterval() {
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length == BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN + 1) {
+            return *field->value | *(field->value + 1) << 8;
+        }
+    }
+
+    return 0;
+} // getMinInterval
+
+
+/**
+ * @brief Get the preferred max connection interval.
+ * @return The preferred max connection interval in 1.25ms units.
+ */
+uint16_t NimBLEAdvertisedDevice::getMaxInterval() {
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length == BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN + 1) {
+            return *(field->value + 2) | *(field->value + 3) << 8;
+        }
+    }
+
+    return 0;
+} // getMaxInterval
+
+
 /**
  * @brief Get the manufacturer data.
  * @return The manufacturer data of the advertised device.
  */
 std::string NimBLEAdvertisedDevice::getManufacturerData() {
-    return m_manufacturerData;
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_MFG_DATA, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length > 1) {
+            return std::string((char*)field->value, field->length - 1);
+        }
+    }
+
+    return "";
 } // getManufacturerData
 
 
+/**
+ * @brief Get the URI from the advertisement.
+ * @return The URI data.
+ */
+std::string NimBLEAdvertisedDevice::getURI() {
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_URI, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length > 1) {
+            return std::string((char*)field->value, field->length - 1);
+        }
+    }
+
+    return "";
+} // getURI
+
+
 /**
  * @brief Get the advertised name.
  * @return The name of the advertised device.
  */
 std::string NimBLEAdvertisedDevice::getName() {
-    return m_name;
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_COMP_NAME, 0, &data_loc) > 0 ||
+       findAdvField(BLE_HS_ADV_TYPE_INCOMP_NAME, 0, &data_loc) > 0)
+    {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length > 1) {
+            return std::string((char*)field->value, field->length - 1);
+        }
+    }
+
+    return "";
 } // getName
 
 
@@ -122,17 +212,70 @@ NimBLEScan* NimBLEAdvertisedDevice::getScan() {
 } // getScan
 
 
+/**
+ * @brief Get the number of target addresses.
+ * @return The number of addresses.
+ */
+size_t NimBLEAdvertisedDevice::getTargetAddressCount() {
+    uint8_t count = 0;
+
+    count = findAdvField(BLE_HS_ADV_TYPE_PUBLIC_TGT_ADDR);
+    count += findAdvField(BLE_HS_ADV_TYPE_RANDOM_TGT_ADDR);
+
+    return count;
+}
+
+
+/**
+ * @brief Get the target address at the index.
+ * @param [in] index The index of the target address.
+ * @return The target address.
+ */
+NimBLEAddress NimBLEAdvertisedDevice::getTargetAddress(uint8_t index) {
+    ble_hs_adv_field *field = nullptr;
+    uint8_t count = 0;
+    uint8_t data_loc = 0xFF;
+
+    index++;
+    count = findAdvField(BLE_HS_ADV_TYPE_PUBLIC_TGT_ADDR, index, &data_loc);
+
+    if (count < index) {
+        index -= count;
+        count = findAdvField(BLE_HS_ADV_TYPE_RANDOM_TGT_ADDR, index, &data_loc);
+    }
+
+    if(count > 0 && data_loc != 0xFF) {
+        field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length < index *  BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN) {
+            index -= count - field->length / BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN;
+        }
+        if(field->length > index * BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN) {
+            return NimBLEAddress(field->value + (index - 1) * BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN);
+        }
+    }
+
+    return NimBLEAddress("");
+}
+
+
 /**
  * @brief Get the service data.
- * @param [in] index The vector index of the service data requested.
+ * @param [in] index The index of the service data requested.
  * @return The advertised service data or empty string if no data.
  */
 std::string NimBLEAdvertisedDevice::getServiceData(uint8_t index) {
-    if(index > m_serviceDataVec.size()) {
-        NIMBLE_LOGW(LOG_TAG, "getServiceData: index out of range");
-        return "";
+    ble_hs_adv_field *field = nullptr;
+    uint8_t bytes;
+    uint8_t data_loc = findServiceData(index, &bytes);
+
+    if(data_loc != 0xFF) {
+        field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length > bytes) {
+            return std::string((char*)(field->value + bytes), field->length - bytes - 1);
+        }
     }
-    return m_serviceDataVec[index].second;
+
+    return "";
 } //getServiceData
 
 
@@ -141,51 +284,148 @@ std::string NimBLEAdvertisedDevice::getServiceData(uint8_t index) {
  * @param [in] uuid The uuid of the service data requested.
  * @return The advertised service data or empty string if no data.
  */
-std::string NimBLEAdvertisedDevice::getServiceData(const NimBLEUUID &uuid) const {
-    for(auto &it : m_serviceDataVec) {
-        if(it.first == uuid) {
-            return it.second;
+std::string NimBLEAdvertisedDevice::getServiceData(const NimBLEUUID &uuid) {
+    ble_hs_adv_field *field = nullptr;
+    uint8_t bytes;
+    uint8_t index = 0;
+    uint8_t data_loc = findServiceData(index, &bytes);
+    uint8_t uuidBytes = uuid.bitSize() / 8;
+    uint8_t plSize = m_payload.size() - 2;
+
+    while(data_loc < plSize) {
+        field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(bytes == uuidBytes && NimBLEUUID(field->value, bytes, false) == uuid) {
+           return std::string((char*)(field->value + bytes), field->length - bytes - 1);
         }
+
+        index++;
+        data_loc = findServiceData(index, &bytes);
     }
-        NIMBLE_LOGW(LOG_TAG, "getServiceData: uuid not found");
+
+    NIMBLE_LOGI(LOG_TAG, "No service data found");
     return "";
 } //getServiceData
 
 
 /**
- * @brief Get the advertised service UUID.
- * @param [in] index The vector index of the service data UUID requested.
- * @return The advertised service UUID or an empty UUID if not found.
+ * @brief Get the UUID of the serice data at the index.
+ * @param [in] index The index of the service data UUID requested.
+ * @return The advertised service data UUID or an empty UUID if not found.
  */
 NimBLEUUID NimBLEAdvertisedDevice::getServiceDataUUID(uint8_t index) {
-    if(!haveServiceData() || index > m_serviceDataVec.size()) {
-        NIMBLE_LOGW(LOG_TAG, "getServiceDataUUID: index out of range");
-        return NimBLEUUID("");
+    ble_hs_adv_field *field = nullptr;
+    uint8_t bytes;
+    uint8_t data_loc = findServiceData(index, &bytes);
+
+    if(data_loc != 0xFF) {
+        field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length >= bytes) {
+            return NimBLEUUID(field->value, bytes, false);
+        }
     }
-    return m_serviceDataVec[index].first;
+
+    return NimBLEUUID("");
 } // getServiceDataUUID
 
 
+/**
+ * @brief Find the service data at the index.
+ * @param [in] index The index of the service data to find.
+ * @param [in] bytes A pointer to storage for the number of the bytes in the UUID.
+ * @return The index in the vector where the data is located, 0xFF if not found.
+ */
+uint8_t NimBLEAdvertisedDevice::findServiceData(uint8_t index, uint8_t *bytes) {
+    uint8_t data_loc = 0;
+    uint8_t found = 0;
+
+    *bytes = 0;
+    index++;
+    found = findAdvField(BLE_HS_ADV_TYPE_SVC_DATA_UUID16, index, &data_loc);
+    if(found == index) {
+        *bytes = 2;
+        return data_loc;
+    }
+
+    index -= found;
+    found = findAdvField(BLE_HS_ADV_TYPE_SVC_DATA_UUID32, index, &data_loc);
+    if(found == index) {
+        *bytes = 4;
+        return data_loc;
+    }
+
+    index -= found;
+    found = findAdvField(BLE_HS_ADV_TYPE_SVC_DATA_UUID128, index, &data_loc);
+    if(found == index) {
+        *bytes = 16;
+        return data_loc;
+    }
+
+    return 0xFF;
+}
+
+
 /**
  * @brief Get the count of advertised service data UUIDS
  * @return The number of service data UUIDS in the vector.
  */
 size_t NimBLEAdvertisedDevice::getServiceDataCount() {
-    return m_serviceDataVec.size();
+    uint8_t count = 0;
+
+    count += findAdvField(BLE_HS_ADV_TYPE_SVC_DATA_UUID16);
+    count += findAdvField(BLE_HS_ADV_TYPE_SVC_DATA_UUID32);
+    count += findAdvField(BLE_HS_ADV_TYPE_SVC_DATA_UUID128);
+
+    return count;
 } // getServiceDataCount
 
 
 /**
  * @brief Get the Service UUID.
- * @param [in] index The vector index of the service UUID requested.
+ * @param [in] index The index of the service UUID requested.
  * @return The Service UUID of the advertised service, or an empty UUID if not found.
  */
 NimBLEUUID NimBLEAdvertisedDevice::getServiceUUID(uint8_t index) {
-    if(!haveServiceUUID() || index > m_serviceUUIDs.size()) {
-        NIMBLE_LOGW(LOG_TAG, "getServiceUUID: index out of range");
-        return NimBLEUUID("");
+    uint8_t count = 0;
+    uint8_t data_loc = 0;
+    uint8_t uuidBytes = 0;
+    uint8_t type = BLE_HS_ADV_TYPE_INCOMP_UUIDS16;
+    ble_hs_adv_field *field = nullptr;
+
+    index++;
+
+    do {
+        count = findAdvField(type, index, &data_loc);
+        if(count >= index) {
+            if(type < BLE_HS_ADV_TYPE_INCOMP_UUIDS32) {
+                uuidBytes = 2;
+            } else if(type < BLE_HS_ADV_TYPE_INCOMP_UUIDS128) {
+                uuidBytes = 4;
+            } else {
+                uuidBytes = 16;
+            }
+            break;
+
+        } else {
+            type++;
+            index -= count;
+        }
+
+    } while(type <= BLE_HS_ADV_TYPE_COMP_UUIDS128);
+
+    if(uuidBytes > 0) {
+        field = (ble_hs_adv_field *)&m_payload[data_loc];
+        // In the case of more than one field of service uuid's we need to adjust
+        // the index to account for the uuids of the previous fields.
+        if(field->length < index * uuidBytes) {
+            index -= count - field->length / uuidBytes;
+        }
+
+        if(field->length > uuidBytes * index) {
+            return NimBLEUUID(field->value + uuidBytes * (index - 1), uuidBytes, false);
+        }
     }
-    return m_serviceUUIDs[index];
+
+    return NimBLEUUID("");
 } // getServiceUUID
 
 
@@ -194,18 +434,32 @@ NimBLEUUID NimBLEAdvertisedDevice::getServiceUUID(uint8_t index) {
  * @return The count of services in the advertising packet.
  */
 size_t NimBLEAdvertisedDevice::getServiceUUIDCount() {
-    return m_serviceUUIDs.size();
+    uint8_t count = 0;
+
+    count += findAdvField(BLE_HS_ADV_TYPE_INCOMP_UUIDS16);
+    count += findAdvField(BLE_HS_ADV_TYPE_COMP_UUIDS16);
+    count += findAdvField(BLE_HS_ADV_TYPE_INCOMP_UUIDS32);
+    count += findAdvField(BLE_HS_ADV_TYPE_COMP_UUIDS32);
+    count += findAdvField(BLE_HS_ADV_TYPE_INCOMP_UUIDS128);
+    count += findAdvField(BLE_HS_ADV_TYPE_COMP_UUIDS128);
+
+    return count;
 } // getServiceUUIDCount
 
 
 /**
  * @brief Check advertised services for existance of the required UUID
+ * @param [in] uuid The service uuid to look for in the advertisement.
  * @return Return true if service is advertised
  */
-bool NimBLEAdvertisedDevice::isAdvertisingService(const NimBLEUUID &uuid) const {
-    for (int i = 0; i < m_serviceUUIDs.size(); i++) {
-        if (m_serviceUUIDs[i].equals(uuid)) return true;
+bool NimBLEAdvertisedDevice::isAdvertisingService(const NimBLEUUID &uuid) {
+    size_t count = getServiceUUIDCount();
+    for(size_t i = 0; i < count; i++) {
+        if(uuid == getServiceUUID(i)) {
+            return true;
+        }
     }
+
     return false;
 } // isAdvertisingService
 
@@ -215,16 +469,43 @@ bool NimBLEAdvertisedDevice::isAdvertisingService(const NimBLEUUID &uuid) const
  * @return The TX Power of the advertised device.
  */
 int8_t NimBLEAdvertisedDevice::getTXPower() {
-    return m_txPower;
+    uint8_t data_loc = 0;
+
+    if(findAdvField(BLE_HS_ADV_TYPE_TX_PWR_LVL, 0, &data_loc) > 0) {
+        ble_hs_adv_field *field = (ble_hs_adv_field *)&m_payload[data_loc];
+        if(field->length == BLE_HS_ADV_TX_PWR_LVL_LEN + 1) {
+            return *(int8_t*)field->value;
+        }
+    }
+
+    return -99;
 } // getTXPower
 
 
+/**
+ * @brief Does this advertisement have preferred connection parameters?
+ * @return True if connection parameters are present.
+ */
+bool NimBLEAdvertisedDevice::haveConnParams() {
+    return findAdvField(BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE) > 0;
+} // haveConnParams
+
+
+/**
+ * @brief Does this advertisement have have the advertising interval?
+ * @return True if the advertisement interval is present.
+ */
+bool NimBLEAdvertisedDevice::haveAdvInterval() {
+    return findAdvField(BLE_HS_ADV_TYPE_ADV_ITVL) > 0;
+} // haveAdvInterval
+
+
 /**
  * @brief Does this advertisement have an appearance value?
  * @return True if there is an appearance value present.
  */
 bool NimBLEAdvertisedDevice::haveAppearance() {
-    return m_haveAppearance;
+    return findAdvField(BLE_HS_ADV_TYPE_APPEARANCE) > 0;
 } // haveAppearance
 
 
@@ -233,16 +514,36 @@ bool NimBLEAdvertisedDevice::haveAppearance() {
  * @return True if there is manufacturer data present.
  */
 bool NimBLEAdvertisedDevice::haveManufacturerData() {
-    return m_haveManufacturerData;
+    return findAdvField(BLE_HS_ADV_TYPE_MFG_DATA) > 0;
 } // haveManufacturerData
 
 
+/**
+ * @brief Does this advertisement have a URI?
+ * @return True if there is a URI present.
+ */
+bool NimBLEAdvertisedDevice::haveURI() {
+    return findAdvField(BLE_HS_ADV_TYPE_URI) > 0;
+} // haveURI
+
+
+/**
+ * @brief Does the advertisement contain a target address?
+ * @return True if an address is present.
+ */
+bool NimBLEAdvertisedDevice::haveTargetAddress() {
+    return findAdvField(BLE_HS_ADV_TYPE_PUBLIC_TGT_ADDR) > 0 ||
+           findAdvField(BLE_HS_ADV_TYPE_RANDOM_TGT_ADDR) > 0;
+}
+
+
 /**
  * @brief Does this advertisement have a name value?
  * @return True if there is a name value present.
  */
 bool NimBLEAdvertisedDevice::haveName() {
-    return m_haveName;
+    return findAdvField(BLE_HS_ADV_TYPE_COMP_NAME) > 0 ||
+           findAdvField(BLE_HS_ADV_TYPE_INCOMP_NAME) > 0;
 } // haveName
 
 
@@ -251,7 +552,7 @@ bool NimBLEAdvertisedDevice::haveName() {
  * @return True if there is a signal strength value present.
  */
 bool NimBLEAdvertisedDevice::haveRSSI() {
-    return m_haveRSSI;
+    return m_rssi != -9999;
 } // haveRSSI
 
 
@@ -260,7 +561,7 @@ bool NimBLEAdvertisedDevice::haveRSSI() {
  * @return True if there is a service data value present.
  */
 bool NimBLEAdvertisedDevice::haveServiceData() {
-    return m_haveServiceData;
+    return getServiceDataCount() > 0;
 } // haveServiceData
 
 
@@ -269,7 +570,7 @@ bool NimBLEAdvertisedDevice::haveServiceData() {
  * @return True if there is a service UUID value present.
  */
 bool NimBLEAdvertisedDevice::haveServiceUUID() {
-    return m_haveServiceUUID;
+    return getServiceUUIDCount() > 0;
 } // haveServiceUUID
 
 
@@ -278,143 +579,71 @@ bool NimBLEAdvertisedDevice::haveServiceUUID() {
  * @return True if there is a transmission power value present.
  */
 bool NimBLEAdvertisedDevice::haveTXPower() {
-    return m_haveTXPower;
+    return findAdvField(BLE_HS_ADV_TYPE_TX_PWR_LVL) > 0;
 } // haveTXPower
 
 
-/**
- * @brief Parse the advertising pay load.
- *
- * The pay load is a buffer of bytes that is either 31 bytes long or terminated by
- * a 0 length value.  Each entry in the buffer has the format:
- * [length][type][data...]
- *
- * The length does not include itself but does include everything after it until the next record.  A record
- * with a length value of 0 indicates a terminator.
- *
- * https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile
- */
- void NimBLEAdvertisedDevice::parseAdvertisement(uint8_t* payload, uint8_t length) {
-    struct ble_hs_adv_fields fields;
-    int rc = ble_hs_adv_parse_fields(&fields, payload, length);
-    if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "Gap Event Parse ERROR.");
-        return;
+uint8_t NimBLEAdvertisedDevice::findAdvField(uint8_t type, uint8_t index, uint8_t *data_loc) {
+    ble_hs_adv_field *field = nullptr;
+    uint8_t data = 0;
+    uint8_t length = m_payload.size();
+    uint8_t count = 0;
+
+    if(length < 2) {
+        return count;
     }
 
-    m_payload = payload;
-    m_payloadLength = length;
+    while (length > 1) {
+        field = (ble_hs_adv_field*)&m_payload[data];
 
-#if CONFIG_LOG_DEFAULT_LEVEL > 3 || (ARDUINO_ARCH_ESP32 && CORE_DEBUG_LEVEL >= 4)
-    char* pHex = NimBLEUtils::buildHexData(nullptr, m_payload, m_payloadLength);
-    NIMBLE_LOGD(LOG_TAG,"payload: %s", pHex);
-    free(pHex);
-#endif
-
-    if (fields.uuids16 != NULL) {
-        for (int i = 0; i < fields.num_uuids16; i++) {
-            setServiceUUID(NimBLEUUID(fields.uuids16[i].value));
+        if (field->length >= length) {
+            return count;
         }
-    }
 
-    if (fields.uuids32 != NULL) {
-        for (int i = 0; i < fields.num_uuids32; i++) {
-            setServiceUUID(NimBLEUUID(fields.uuids32[i].value));
-        }
-    }
+        if (field->type == type) {
+            switch(type) {
+                case BLE_HS_ADV_TYPE_INCOMP_UUIDS16:
+                case BLE_HS_ADV_TYPE_COMP_UUIDS16:
+                    count += field->length / 2;
+                    break;
 
-    if (fields.uuids128 != NULL) {
-        for (int i = 0; i < fields.num_uuids128; i++) {
-            setServiceUUID(NimBLEUUID(&fields.uuids128[i]));
-        }
-    }
+                case BLE_HS_ADV_TYPE_INCOMP_UUIDS32:
+                case BLE_HS_ADV_TYPE_COMP_UUIDS32:
+                    count += field->length / 4;
+                    break;
 
-    if (fields.name != NULL) {
-        setName(std::string(reinterpret_cast<char*>(fields.name), fields.name_len));
-    }
+                case BLE_HS_ADV_TYPE_INCOMP_UUIDS128:
+                case BLE_HS_ADV_TYPE_COMP_UUIDS128:
+                    count += field->length / 16;
+                    break;
 
-    if (fields.tx_pwr_lvl_is_present) {
-        setTXPower(fields.tx_pwr_lvl);
-    }
+                case BLE_HS_ADV_TYPE_PUBLIC_TGT_ADDR:
+                case BLE_HS_ADV_TYPE_RANDOM_TGT_ADDR:
+                    count += field->length / 6;
+                    break;
 
-    if (fields.svc_data_uuid16 != NULL ||
-        fields.svc_data_uuid32 != NULL ||
-        fields.svc_data_uuid128 != NULL)
-    {
-        ble_hs_adv_field *field;
-        uint8_t *data = payload;
-        while(length > 1) {
-            field = (ble_hs_adv_field*)data;
-
-            if(field->length > length) {
-                break;
+                default:
+                    count++;
+                    break;
             }
 
-            if(field->type == BLE_HS_ADV_TYPE_SVC_DATA_UUID16) {
-                if(field->length > 2) {
-                    uint16_t uuid;
-                    memcpy(&uuid, field->value, 2);
-                    setServiceData(NimBLEUUID(uuid), std::string(reinterpret_cast<char*>(field->value + 2), field->length - 3));
+            if(data_loc != nullptr) {
+                if(index == 0 || count >= index) {
+                    break;
                 }
             }
-
-            if(field->type == BLE_HS_ADV_TYPE_SVC_DATA_UUID32) {
-                if(field->length > 4) {
-                    uint32_t uuid;
-                    memcpy(&uuid, field->value, 4);
-                    setServiceData(NimBLEUUID(uuid), std::string(reinterpret_cast<char*>(field->value + 4), field->length - 5));
-                }
-            }
-
-            if(field->type == BLE_HS_ADV_TYPE_SVC_DATA_UUID128) {
-                if(field->length > 16) {
-                    NimBLEUUID uuid(field->value, (size_t)16, false);
-                    setServiceData(uuid, std::string(reinterpret_cast<char*>(field->value + 16), field->length - 17));
-                }
-            }
-
-            length -= 1 + field->length;
-            data += 1 + field->length;
         }
+
+        length -= 1 + field->length;
+        data += 1 + field->length;
     }
 
-    if (fields.appearance_is_present) {
-        setAppearance(fields.appearance);
+    if(data_loc != nullptr && field != nullptr) {
+        *data_loc = data;
     }
 
-    if (fields.mfg_data != NULL) {
-        setManufacturerData(std::string(reinterpret_cast<char*>(fields.mfg_data), fields.mfg_data_len));
-    }
-
-/* TODO: create storage and fucntions for these parameters
-    if (fields.public_tgt_addr != NULL) {
-        NIMBLE_LOGD(LOG_TAG, "    public_tgt_addr=");
-        u8p = fields.public_tgt_addr;
-        for (i = 0; i < fields.num_public_tgt_addrs; i++) {
-            NIMBLE_LOGD(LOG_TAG, "public_tgt_addr=%s ", addr_str(u8p));
-            u8p += BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN;
-        }
-        NIMBLE_LOGD(LOG_TAG, "\n");
-    }
-
-    if (fields.slave_itvl_range != NULL) {
-        NIMBLE_LOGD(LOG_TAG, "    slave_itvl_range=");
-        print_bytes(fields.slave_itvl_range, BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN);
-        NIMBLE_LOGD(LOG_TAG, "\n");
-    }
-
-    if (fields.adv_itvl_is_present) {
-        NIMBLE_LOGD(LOG_TAG, "    adv_itvl=0x%04x\n", fields.adv_itvl);
-    }
-
-    if (fields.uri != NULL) {
-        NIMBLE_LOGD(LOG_TAG, "    uri=");
-        print_bytes(fields.uri, fields.uri_len);
-        NIMBLE_LOGD(LOG_TAG, "\n");
-    }
-*/
-
- } //parseAdvertisement
+    return count;
+}
 
 
 /**
@@ -428,106 +657,22 @@ void NimBLEAdvertisedDevice::setAddress(NimBLEAddress address) {
 
 /**
  * @brief Set the adFlag for this device.
- * @param [in] The discovered adFlag.
+ * @param [in] advType The advertisement flag data from the advertisement.
  */
 void NimBLEAdvertisedDevice::setAdvType(uint8_t advType) {
     m_advType = advType;
 } // setAdvType
 
 
-/**
- * @brief Set the appearance for this device.
- * @param [in] The discovered appearance.
- */
-void NimBLEAdvertisedDevice::setAppearance(uint16_t appearance) {
-    m_appearance     = appearance;
-    m_haveAppearance = true;
-} // setAppearance
-
-
-/**
- * @brief Set the manufacturer data for this device.
- * @param [in] The discovered manufacturer data.
- */
-void NimBLEAdvertisedDevice::setManufacturerData(std::string manufacturerData) {
-    m_manufacturerData     = manufacturerData;
-    m_haveManufacturerData = true;
-} // setManufacturerData
-
-
-/**
- * @brief Set the name for this device.
- * @param [in] name The discovered name.
- */
-void NimBLEAdvertisedDevice::setName(std::string name) {
-    m_name     = name;
-    m_haveName = true;
-} // setName
-
-
 /**
  * @brief Set the RSSI for this device.
- * @param [in] rssi The discovered RSSI.
+ * @param [in] rssi The RSSI of the discovered device.
  */
 void NimBLEAdvertisedDevice::setRSSI(int rssi) {
-    m_rssi     = rssi;
-    m_haveRSSI = true;
+    m_rssi = rssi;
 } // setRSSI
 
 
-/**
- * @brief Set the Service UUID for this device.
- * @param [in] serviceUUID The discovered serviceUUID
- */
-
-void NimBLEAdvertisedDevice::setServiceUUID(const char* serviceUUID) {
-    return setServiceUUID(NimBLEUUID(serviceUUID));
-} // setServiceUUID
-
-
-/**
- * @brief Set the Service UUID for this device.
- * @param [in] serviceUUID The discovered serviceUUID
- */
-void NimBLEAdvertisedDevice::setServiceUUID(NimBLEUUID serviceUUID) {
-    // Don't add duplicates
-    for (int i = 0; i < m_serviceUUIDs.size(); i++) {
-        if (m_serviceUUIDs[i] == serviceUUID) {
-            return;
-        }
-    }
-    m_serviceUUIDs.push_back(serviceUUID);
-    m_haveServiceUUID = true;
-} // setServiceUUID
-
-
-/**
- * @brief Set the ServiceData value.
- * @param [in] uuid The UUID that the service data belongs to.
- * @param [in] data The service data.
- */
-void NimBLEAdvertisedDevice::setServiceData(NimBLEUUID uuid, std::string data) {
-    m_haveServiceData = true;
-    for(auto &it : m_serviceDataVec) {
-        if(it.first == uuid) {
-            it.second = data;
-            return;
-        }
-    }
-    m_serviceDataVec.push_back({uuid, data});
-} //setServiceData
-
-
-/**
- * @brief Set the power level for this device.
- * @param [in] txPower The discovered power level.
- */
-void NimBLEAdvertisedDevice::setTXPower(int8_t txPower) {
-    m_txPower     = txPower;
-    m_haveTXPower = true;
-} // setTXPower
-
-
 /**
  * @brief Create a string representation of this device.
  * @return A string representation of this device.
@@ -579,10 +724,35 @@ std::string NimBLEAdvertisedDevice::toString() {
  * @return The advertisement payload.
  */
 uint8_t* NimBLEAdvertisedDevice::getPayload() {
-    return m_payload;
+    return &m_payload[0];
 } // getPayload
 
 
+/**
+ * @brief Stores the payload of the advertised device in a vector.
+ * @param [in] payload The advertisement payload.
+ * @param [in] length The length of the payload in bytes.
+ * @param [in] append Indicates if the the data should be appended (scan response).
+ */
+void NimBLEAdvertisedDevice::setPayload(const uint8_t *payload, uint8_t length, bool append) {
+    if(!append) {
+        m_advLength = length;
+        m_payload.assign(payload, payload + length);
+    } else {
+        m_payload.insert(m_payload.end(), payload, payload + length);
+    }
+}
+
+
+/**
+ * @brief Get the length of the advertisement data in the payload.
+ * @return The number of bytes in the payload that is from the advertisment.
+ */
+uint8_t NimBLEAdvertisedDevice::getAdvLength() {
+    return m_advLength;
+}
+
+
 /**
  * @brief Get the advertised device address type.
  * @return The device address type:
@@ -610,7 +780,7 @@ time_t NimBLEAdvertisedDevice::getTimestamp() {
  * @return The size of the payload in bytes.
  */
 size_t NimBLEAdvertisedDevice::getPayloadLength() {
-    return m_payloadLength;
+    return m_payload.size();
 } // getPayloadLength
 
 

src/NimBLEAdvertisedDevice.h

@@ -44,7 +44,11 @@ public:
     NimBLEAddress   getAddress();
     uint8_t         getAdvType();
     uint16_t        getAppearance();
+    uint16_t        getAdvInterval();
+    uint16_t        getMinInterval();
+    uint16_t        getMaxInterval();
     std::string     getManufacturerData();
+    std::string     getURI();
 
     /**
      * @brief A template to convert the service data to <type\>.
@@ -67,7 +71,7 @@ public:
     NimBLEScan*     getScan();
     size_t          getServiceDataCount();
     std::string     getServiceData(uint8_t index = 0);
-    std::string     getServiceData(const NimBLEUUID &uuid) const;
+    std::string     getServiceData(const NimBLEUUID &uuid);
 
     /**
      * @brief A template to convert the service data to <tt><type\></tt>.
@@ -106,12 +110,15 @@ public:
     NimBLEUUID      getServiceDataUUID(uint8_t index = 0);
     NimBLEUUID      getServiceUUID(uint8_t index = 0);
     size_t          getServiceUUIDCount();
+    NimBLEAddress   getTargetAddress(uint8_t index = 0);
+    size_t          getTargetAddressCount();
     int8_t          getTXPower();
     uint8_t*        getPayload();
+    uint8_t         getAdvLength();
     size_t          getPayloadLength();
     uint8_t         getAddressType();
     time_t          getTimestamp();
-    bool            isAdvertisingService(const NimBLEUUID &uuid) const;
+    bool            isAdvertisingService(const NimBLEUUID &uuid);
     bool            haveAppearance();
     bool            haveManufacturerData();
     bool            haveName();
@@ -119,46 +126,30 @@ public:
     bool            haveServiceData();
     bool            haveServiceUUID();
     bool            haveTXPower();
+    bool            haveConnParams();
+    bool            haveAdvInterval();
+    bool            haveTargetAddress();
+    bool            haveURI();
     std::string     toString();
 
 private:
     friend class NimBLEScan;
 
-    void parseAdvertisement(uint8_t* payload, uint8_t length);
-    void setAddress(NimBLEAddress address);
-    void setAdvType(uint8_t advType);
-    void setAppearance(uint16_t appearance);
-    void setManufacturerData(std::string manufacturerData);
-    void setName(std::string name);
-    void setRSSI(int rssi);
-    void setServiceData(NimBLEUUID serviceUUID, std::string data);
-    void setServiceUUID(const char* serviceUUID);
-    void setServiceUUID(NimBLEUUID serviceUUID);
-    void setTXPower(int8_t txPower);
-
-    bool m_haveAppearance;
-    bool m_haveManufacturerData;
-    bool m_haveName;
-    bool m_haveRSSI;
-    bool m_haveServiceData;
-    bool m_haveServiceUUID;
-    bool m_haveTXPower;
-
+    void    setAddress(NimBLEAddress address);
+    void    setAdvType(uint8_t advType);
+    void    setPayload(const uint8_t *payload, uint8_t length, bool append);
+    void    setRSSI(int rssi);
+    uint8_t findAdvField(uint8_t type, uint8_t index = 0, uint8_t *data_loc = nullptr);
+    uint8_t findServiceData(uint8_t index, uint8_t* bytes);
 
     NimBLEAddress   m_address = NimBLEAddress("");
     uint8_t         m_advType;
-    uint16_t        m_appearance;
-    std::string     m_manufacturerData;
-    std::string     m_name;
     int             m_rssi;
-    int8_t          m_txPower;
-    uint8_t*        m_payload;
-    size_t          m_payloadLength;
     time_t          m_timestamp;
     bool            m_callbackSent;
+    uint8_t         m_advLength;
 
-    std::vector<NimBLEUUID> m_serviceUUIDs;
-    std::vector<std::pair<NimBLEUUID, std::string>>m_serviceDataVec;
+    std::vector<uint8_t>    m_payload;
 };
 
 /**

src/NimBLEAdvertising.cpp

@@ -33,33 +33,42 @@ static const char* LOG_TAG = "NimBLEAdvertising";
  * @brief Construct a default advertising object.
  */
 NimBLEAdvertising::NimBLEAdvertising() {
+    reset();
+} // NimBLEAdvertising
+
+
+/**
+ * @brief Stops the current advertising and resets the advertising data to the default values.
+ */
+void NimBLEAdvertising::reset() {
+    if(NimBLEDevice::getInitialized() && isAdvertising()) {
+        stop();
+    }
     memset(&m_advData, 0, sizeof m_advData);
     memset(&m_scanData, 0, sizeof m_scanData);
     memset(&m_advParams, 0, sizeof m_advParams);
+    memset(&m_slaveItvl, 0, sizeof m_slaveItvl);
     const char *name = ble_svc_gap_device_name();
 
     m_advData.name                   = (uint8_t *)name;
     m_advData.name_len               = strlen(name);
     m_advData.name_is_complete       = 1;
-    m_scanData.tx_pwr_lvl_is_present = 1;
-    m_scanData.tx_pwr_lvl            = NimBLEDevice::getPower();
+    m_advData.tx_pwr_lvl             = NimBLEDevice::getPower();
     m_advData.flags                  = (BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_BREDR_UNSUP);
-    m_advData.appearance             = 0;
-    m_advData.appearance_is_present  = 0;
-    m_advData.mfg_data_len           = 0;
-    m_advData.mfg_data               = nullptr;
 
+#if !defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+    m_advParams.conn_mode            = BLE_GAP_CONN_MODE_NON;
+#else
     m_advParams.conn_mode            = BLE_GAP_CONN_MODE_UND;
+#endif
     m_advParams.disc_mode            = BLE_GAP_DISC_MODE_GEN;
-    m_advParams.itvl_min             = 0;
-    m_advParams.itvl_max             = 0;
-
     m_customAdvData                  = false;
     m_customScanResponseData         = false;
     m_scanResp                       = true;
     m_advDataSet                     = false;
-
-} // NimBLEAdvertising
+    // Set this to non-zero to prevent auto start if host reset before started by app.
+    m_duration                       = BLE_HS_FOREVER;
+} // reset
 
 
 /**
@@ -78,6 +87,7 @@ void NimBLEAdvertising::addServiceUUID(const NimBLEUUID &serviceUUID) {
  */
 void NimBLEAdvertising::addServiceUUID(const char* serviceUUID) {
     addServiceUUID(NimBLEUUID(serviceUUID));
+    m_advDataSet = false;
 } // addServiceUUID
 
 
@@ -86,7 +96,6 @@ void NimBLEAdvertising::addServiceUUID(const char* serviceUUID) {
  * @param [in] serviceUUID The UUID of the service to expose.
  */
 void NimBLEAdvertising::removeServiceUUID(const NimBLEUUID &serviceUUID) {
-    //m_serviceUUIDs.erase(std::remove_if(m_serviceUUIDs.begin(), m_serviceUUIDs.end(),[serviceUUID](const NimBLEUUID &s) {return serviceUUID == s;}), m_serviceUUIDs.end());
     for(auto it = m_serviceUUIDs.begin(); it != m_serviceUUIDs.end(); ++it) {
         if((*it) == serviceUUID) {
             m_serviceUUIDs.erase(it);
@@ -106,17 +115,101 @@ void NimBLEAdvertising::removeServiceUUID(const NimBLEUUID &serviceUUID) {
 void NimBLEAdvertising::setAppearance(uint16_t appearance) {
     m_advData.appearance = appearance;
     m_advData.appearance_is_present = 1;
+    m_advDataSet = false;
 } // setAppearance
 
 
+/**
+ * @brief Add the transmission power level to the advertisement packet.
+ */
+void NimBLEAdvertising::addTxPower() {
+    m_advData.tx_pwr_lvl_is_present = 1;
+    m_advDataSet = false;
+} // addTxPower
+
+
+/**
+ * @brief Set the advertised name of the device.
+ * @param [in] name The name to advertise.
+ */
+void NimBLEAdvertising::setName(const std::string &name) {
+    m_name.assign(name.begin(), name.end());
+    m_advData.name = &m_name[0];
+    m_advData.name_len = m_name.size();
+    m_advDataSet = false;
+} // setName
+
+
+/**
+ * @brief Set the advertised manufacturer data.
+ * @param [in] data The data to advertise.
+ */
+void NimBLEAdvertising::setManufacturerData(const std::string &data) {
+    m_mfgData.assign(data.begin(), data.end());
+    m_advData.mfg_data = &m_mfgData[0];
+    m_advData.mfg_data_len = m_mfgData.size();
+    m_advDataSet = false;
+} // setManufacturerData
+
+
+/**
+ * @brief Set the advertised URI.
+ * @param [in] uri The URI to advertise.
+ */
+void NimBLEAdvertising::setURI(const std::string &uri) {
+    m_uri.assign(uri.begin(), uri.end());
+    m_advData.uri = &m_uri[0];
+    m_advData.uri_len = m_uri.size();
+    m_advDataSet = false;
+} // setURI
+
+
+/**
+ * @brief Set the service data advertised for the UUID.
+ * @param [in] uuid The UUID the service data belongs to.
+ * @param [in] data The data to advertise.
+ * @note If data length is 0 the service data will not be advertised.
+ */
+void NimBLEAdvertising::setServiceData(const NimBLEUUID &uuid, const std::string &data) {
+    switch (uuid.bitSize()) {
+        case 16: {
+            m_svcData16.assign((uint8_t*)&uuid.getNative()->u16.value, (uint8_t*)&uuid.getNative()->u16.value + 2);
+            m_svcData16.insert(m_svcData16.end(), data.begin(), data.end());
+            m_advData.svc_data_uuid16 = (uint8_t*)&m_svcData16[0];
+            m_advData.svc_data_uuid16_len = (data.length() > 0) ? m_svcData16.size() : 0;
+            break;
+        }
+
+        case 32: {
+            m_svcData32.assign((uint8_t*)&uuid.getNative()->u32.value, (uint8_t*)&uuid.getNative()->u32.value + 4);
+            m_svcData32.insert(m_svcData32.end(), data.begin(), data.end());
+            m_advData.svc_data_uuid32 = (uint8_t*)&m_svcData32[0];
+            m_advData.svc_data_uuid32_len = (data.length() > 0) ? m_svcData32.size() : 0;
+            break;
+        }
+
+        case 128: {
+            m_svcData128.assign(uuid.getNative()->u128.value, uuid.getNative()->u128.value + 16);
+            m_svcData128.insert(m_svcData128.end(), data.begin(), data.end());
+            m_advData.svc_data_uuid128 = (uint8_t*)&m_svcData128[0];
+            m_advData.svc_data_uuid128_len = (data.length() > 0) ? m_svcData128.size() : 0;
+            break;
+        }
+
+        default:
+            return;
+    }
+
+    m_advDataSet = false;
+} // setServiceData
+
+
 /**
  * @brief Set the type of advertisment to use.
  * @param [in] adv_type:
- * * BLE_HCI_ADV_TYPE_ADV_IND            (0) - indirect advertising
- * * BLE_HCI_ADV_TYPE_ADV_DIRECT_IND_HD  (1) - direct advertisng - high duty cycle
- * * BLE_HCI_ADV_TYPE_ADV_SCAN_IND       (2) - indirect scan response
- * * BLE_HCI_ADV_TYPE_ADV_NONCONN_IND    (3) - indirect advertisng - not connectable
- * * BLE_HCI_ADV_TYPE_ADV_DIRECT_IND_LD  (4) - direct advertising - low duty cycle
+ * * BLE_GAP_CONN_MODE_NON    (0) - not connectable advertising
+ * * BLE_GAP_CONN_MODE_DIR    (1) - directed connectable advertising
+ * * BLE_GAP_CONN_MODE_UND    (2) - undirected connectable advertising
  */
 void NimBLEAdvertising::setAdvertisementType(uint8_t adv_type){
     m_advParams.conn_mode = adv_type;
@@ -141,12 +234,75 @@ void NimBLEAdvertising::setMaxInterval(uint16_t maxinterval) {
 } // setMaxInterval
 
 
+/**
+ * @brief Set the advertised min connection interval preferred by this device.
+ * @param [in] mininterval the max interval value. Range = 0x0006 to 0x0C80.
+ * @details Values not within the range will cancel advertising of this data.\n
+ * Consumes 6 bytes of advertising space (combined with max interval).
+ */
+void NimBLEAdvertising::setMinPreferred(uint16_t mininterval) {
+    // invalid paramters, set the slave interval to null
+    if(mininterval < 0x0006 || mininterval > 0x0C80) {
+        m_advData.slave_itvl_range = nullptr;
+        return;
+    }
+
+    if(m_advData.slave_itvl_range == nullptr) {
+        m_advData.slave_itvl_range = m_slaveItvl;
+    }
+
+    m_slaveItvl[0] = mininterval;
+    m_slaveItvl[1] = mininterval >> 8;
+
+    uint16_t maxinterval = *(uint16_t*)(m_advData.slave_itvl_range+2);
+
+    // If mininterval is higher than the maxinterval make them the same
+    if(mininterval > maxinterval) {
+        m_slaveItvl[2] = m_slaveItvl[0];
+        m_slaveItvl[3] = m_slaveItvl[1];
+    }
+
+    m_advDataSet = false;
+} // setMinPreferred
+
+
+/**
+ * @brief Set the advertised max connection interval preferred by this device.
+ * @param [in] maxinterval the max interval value. Range = 0x0006 to 0x0C80.
+ * @details Values not within the range will cancel advertising of this data.\n
+ * Consumes 6 bytes of advertising space (combined with min interval).
+ */
+void NimBLEAdvertising::setMaxPreferred(uint16_t maxinterval) {
+    // invalid paramters, set the slave interval to null
+    if(maxinterval < 0x0006 || maxinterval > 0x0C80) {
+        m_advData.slave_itvl_range = nullptr;
+        return;
+    }
+    if(m_advData.slave_itvl_range == nullptr) {
+        m_advData.slave_itvl_range = m_slaveItvl;
+    }
+    m_slaveItvl[2] = maxinterval;
+    m_slaveItvl[3] = maxinterval >> 8;
+
+    uint16_t mininterval = *(uint16_t*)(m_advData.slave_itvl_range);
+
+    // If mininterval is higher than the maxinterval make them the same
+    if(mininterval > maxinterval) {
+        m_slaveItvl[0] = m_slaveItvl[2];
+        m_slaveItvl[1] = m_slaveItvl[3];
+    }
+
+    m_advDataSet = false;
+} // setMaxPreferred
+
+
 /**
  * @brief Set if scan response is available.
  * @param [in] set true = scan response available.
  */
 void NimBLEAdvertising::setScanResponse(bool set) {
     m_scanResp = set;
+    m_advDataSet = false;
 } // setScanResponse
 
 
@@ -156,7 +312,8 @@ void NimBLEAdvertising::setScanResponse(bool set) {
  * @param [in] connectWhitelistOnly If true, only allow connections from those on the white list.
  */
 void NimBLEAdvertising::setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly) {
-    NIMBLE_LOGD(LOG_TAG, ">> setScanFilter: scanRequestWhitelistOnly: %d, connectWhitelistOnly: %d", scanRequestWhitelistOnly, connectWhitelistOnly);
+    NIMBLE_LOGD(LOG_TAG, ">> setScanFilter: scanRequestWhitelistOnly: %d, connectWhitelistOnly: %d",
+                scanRequestWhitelistOnly, connectWhitelistOnly);
     if (!scanRequestWhitelistOnly && !connectWhitelistOnly) {
         m_advParams.filter_policy = BLE_HCI_ADV_FILT_NONE;
         NIMBLE_LOGD(LOG_TAG, "<< setScanFilter");
@@ -194,7 +351,8 @@ void NimBLEAdvertising::setAdvertisementData(NimBLEAdvertisementData& advertisem
         (uint8_t*)advertisementData.getPayload().data(),
         advertisementData.getPayload().length());
     if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_set_data: %d %s", rc, NimBLEUtils::returnCodeToString(rc));
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_set_data: %d %s",
+                    rc, NimBLEUtils::returnCodeToString(rc));
     }
     m_customAdvData = true;   // Set the flag that indicates we are using custom advertising data.
     NIMBLE_LOGD(LOG_TAG, "<< setAdvertisementData");
@@ -213,7 +371,8 @@ void NimBLEAdvertising::setScanResponseData(NimBLEAdvertisementData& advertiseme
         (uint8_t*)advertisementData.getPayload().data(),
         advertisementData.getPayload().length());
     if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_rsp_set_data: %d %s", rc,  NimBLEUtils::returnCodeToString(rc));
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_rsp_set_data: %d %s",
+                    rc,  NimBLEUtils::returnCodeToString(rc));
     }
     m_customScanResponseData = true;   // Set the flag that indicates we are using custom scan response data.
     NIMBLE_LOGD(LOG_TAG, "<< setScanResponseData");
@@ -225,13 +384,14 @@ void NimBLEAdvertising::setScanResponseData(NimBLEAdvertisementData& advertiseme
  * @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.
  */
-void NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdvertising *pAdv)) {
-    NIMBLE_LOGD(LOG_TAG, ">> Advertising start: customAdvData: %d, customScanResponseData: %d", m_customAdvData, m_customScanResponseData);
+bool NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdvertising *pAdv)) {
+    NIMBLE_LOGD(LOG_TAG, ">> Advertising start: customAdvData: %d, customScanResponseData: %d",
+                m_customAdvData, m_customScanResponseData);
 
     // If Host is not synced we cannot start advertising.
     if(!NimBLEDevice::m_synced) {
         NIMBLE_LOGE(LOG_TAG, "Host reset, wait for sync.");
-        return;
+        return false;
     }
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
@@ -240,17 +400,21 @@ void NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdv
         if(!pServer->m_gattsStarted){
             pServer->start();
         } else if(pServer->getConnectedCount() >= NIMBLE_MAX_CONNECTIONS) {
-            NIMBLE_LOGW(LOG_TAG, "Max connections reached - not advertising");
-            return;
+            NIMBLE_LOGE(LOG_TAG, "Max connections reached - not advertising");
+            return false;
         }
     }
 #endif
 
     // If already advertising just return
     if(ble_gap_adv_active()) {
-        return;
+        NIMBLE_LOGW(LOG_TAG, "Advertising already active");
+        return false;
     }
 
+    // Save the duration incase of host reset so we can restart with the same params
+    m_duration = duration;
+
     if(duration == 0){
         duration = BLE_HS_FOREVER;
     }
@@ -260,165 +424,240 @@ void NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdv
 
     m_advCompCB = advCompleteCB;
 
+    m_advParams.disc_mode = BLE_GAP_DISC_MODE_GEN;
+    m_advData.flags = (BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_BREDR_UNSUP);
+    if(m_advParams.conn_mode == BLE_GAP_CONN_MODE_NON) {
+        if(!m_scanResp) {
+            m_advParams.disc_mode = BLE_GAP_DISC_MODE_NON;
+            m_advData.flags = BLE_HS_ADV_F_BREDR_UNSUP;
+        }
+    }
+
     int rc = 0;
 
     if (!m_customAdvData && !m_advDataSet) {
         //start with 3 bytes for the flags data
-        uint8_t payloadLen = 3;
+        uint8_t payloadLen = (2 + 1);
+        if(m_advData.mfg_data_len > 0)
+            payloadLen += (2 + m_advData.mfg_data_len);
+
+        if(m_advData.svc_data_uuid16_len > 0)
+            payloadLen += (2 + m_advData.svc_data_uuid16_len);
+
+        if(m_advData.svc_data_uuid32_len > 0)
+            payloadLen += (2 + m_advData.svc_data_uuid32_len);
+
+        if(m_advData.svc_data_uuid128_len > 0)
+            payloadLen += (2 + m_advData.svc_data_uuid128_len);
+
+        if(m_advData.uri_len > 0)
+            payloadLen += (2 + m_advData.uri_len);
+
+        if(m_advData.appearance_is_present)
+            payloadLen += (2 + BLE_HS_ADV_APPEARANCE_LEN);
+
+        if(m_advData.tx_pwr_lvl_is_present)
+            payloadLen += (2 + BLE_HS_ADV_TX_PWR_LVL_LEN);
+
+        if(m_advData.slave_itvl_range != nullptr)
+            payloadLen += (2 + BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN);
 
         for(auto &it : m_serviceUUIDs) {
             if(it.getNative()->u.type == BLE_UUID_TYPE_16) {
                 int add = (m_advData.num_uuids16 > 0) ? 2 : 4;
-                if((payloadLen + add) > 31){
+                if((payloadLen + add) > BLE_HS_ADV_MAX_SZ){
                     m_advData.uuids16_is_complete = 0;
                     continue;
                 }
                 payloadLen += add;
 
-                if(nullptr == (m_advData.uuids16 = (ble_uuid16_t*)realloc(m_advData.uuids16,
+                if(nullptr == (m_advData.uuids16 = (ble_uuid16_t*)realloc((void*)m_advData.uuids16,
                                                    (m_advData.num_uuids16 + 1) * sizeof(ble_uuid16_t))))
                 {
-                    NIMBLE_LOGE(LOG_TAG, "Error, no mem");
+                    NIMBLE_LOGC(LOG_TAG, "Error, no mem");
                     abort();
                 }
-                memcpy(&m_advData.uuids16[m_advData.num_uuids16].value,
-                       &it.getNative()->u16.value, 2);
-
-                m_advData.uuids16[m_advData.num_uuids16].u.type = BLE_UUID_TYPE_16;
+                memcpy((void*)&m_advData.uuids16[m_advData.num_uuids16],
+                       &it.getNative()->u16, sizeof(ble_uuid16_t));
                 m_advData.uuids16_is_complete = 1;
                 m_advData.num_uuids16++;
             }
             if(it.getNative()->u.type == BLE_UUID_TYPE_32) {
                 int add = (m_advData.num_uuids32 > 0) ? 4 : 6;
-                if((payloadLen + add) > 31){
+                if((payloadLen + add) > BLE_HS_ADV_MAX_SZ){
                     m_advData.uuids32_is_complete = 0;
                     continue;
                 }
                 payloadLen += add;
 
-                if(nullptr == (m_advData.uuids32 = (ble_uuid32_t*)realloc(m_advData.uuids32,
+                if(nullptr == (m_advData.uuids32 = (ble_uuid32_t*)realloc((void*)m_advData.uuids32,
                                                    (m_advData.num_uuids32 + 1) * sizeof(ble_uuid32_t))))
                 {
-                    NIMBLE_LOGE(LOG_TAG, "Error, no mem");
+                    NIMBLE_LOGC(LOG_TAG, "Error, no mem");
                     abort();
                 }
-                memcpy(&m_advData.uuids32[m_advData.num_uuids32].value,
-                       &it.getNative()->u32.value, 4);
-
-                m_advData.uuids32[m_advData.num_uuids32].u.type = BLE_UUID_TYPE_32;
+                memcpy((void*)&m_advData.uuids32[m_advData.num_uuids32],
+                       &it.getNative()->u32, sizeof(ble_uuid32_t));
                 m_advData.uuids32_is_complete = 1;
                 m_advData.num_uuids32++;
             }
             if(it.getNative()->u.type == BLE_UUID_TYPE_128){
                 int add = (m_advData.num_uuids128 > 0) ? 16 : 18;
-                if((payloadLen + add) > 31){
+                if((payloadLen + add) > BLE_HS_ADV_MAX_SZ){
                     m_advData.uuids128_is_complete = 0;
                     continue;
                 }
                 payloadLen += add;
 
-                if(nullptr == (m_advData.uuids128 = (ble_uuid128_t*)realloc(m_advData.uuids128,
+                if(nullptr == (m_advData.uuids128 = (ble_uuid128_t*)realloc((void*)m_advData.uuids128,
                               (m_advData.num_uuids128 + 1) * sizeof(ble_uuid128_t))))
                 {
-                    NIMBLE_LOGE(LOG_TAG, "Error, no mem");
+                    NIMBLE_LOGC(LOG_TAG, "Error, no mem");
                     abort();
                 }
-                memcpy(&m_advData.uuids128[m_advData.num_uuids128].value,
-                       &it.getNative()->u128.value, 16);
-
-                m_advData.uuids128[m_advData.num_uuids128].u.type = BLE_UUID_TYPE_128;
+                memcpy((void*)&m_advData.uuids128[m_advData.num_uuids128],
+                       &it.getNative()->u128, sizeof(ble_uuid128_t));
                 m_advData.uuids128_is_complete = 1;
                 m_advData.num_uuids128++;
             }
         }
 
         // check if there is room for the name, if not put it in scan data
-        if((payloadLen + m_advData.name_len) > 29) {
-            if(m_scanResp){
+        if((payloadLen + (2 + m_advData.name_len)) > BLE_HS_ADV_MAX_SZ) {
+            if(m_scanResp && !m_customScanResponseData){
                 m_scanData.name = m_advData.name;
                 m_scanData.name_len = m_advData.name_len;
-                m_scanData.name_is_complete = m_advData.name_is_complete;
+                if(m_scanData.name_len > BLE_HS_ADV_MAX_SZ - 2) {
+                    m_scanData.name_len = BLE_HS_ADV_MAX_SZ - 2;
+                    m_scanData.name_is_complete = 0;
+                } else {
+                    m_scanData.name_is_complete = 1;
+                }
                 m_advData.name = nullptr;
                 m_advData.name_len = 0;
+                m_advData.name_is_complete = 0;
             } else {
+                if(m_advData.tx_pwr_lvl_is_present) {
+                    m_advData.tx_pwr_lvl_is_present = 0;
+                    payloadLen -= (2 + 1);
+                }
                 // if not using scan response just cut the name down
                 // leaving 2 bytes for the data specifier.
-                m_advData.name_len = (29 - payloadLen);
-            }
-            m_advData.name_is_complete = 0;
-        }
-
-        if(m_advData.name_len > 0) {
-            payloadLen += (m_advData.name_len + 2);
-        }
-
-        if(m_scanResp) {
-            // name length + type byte + length byte + tx power type + length + data
-            if((m_scanData.name_len + 5) > 31) {
-                // prioritize name data over tx power
-                m_scanData.tx_pwr_lvl_is_present = 0;
-                m_scanData.tx_pwr_lvl = 0;
-                // limit name to 29 to leave room for the data specifiers
-                if(m_scanData.name_len > 29) {
-                    m_scanData.name_len = 29;
-                    m_scanData.name_is_complete = false;
+                if(m_advData.name_len > (BLE_HS_ADV_MAX_SZ - payloadLen - 2)) {
+                    m_advData.name_len = (BLE_HS_ADV_MAX_SZ - payloadLen - 2);
+                    m_advData.name_is_complete = 0;
                 }
             }
-
-            rc = ble_gap_adv_rsp_set_fields(&m_scanData);
-            if (rc != 0) {
-                NIMBLE_LOGC(LOG_TAG, "error setting scan response data; rc=%d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-                abort();
-            }
-        // if not using scan response and there is room,
-        // put the tx power data into the advertisment
-        } else if (payloadLen < 29) {
-            m_advData.tx_pwr_lvl_is_present = 1;
-            m_advData.tx_pwr_lvl = NimBLEDevice::getPower();
         }
 
-        rc = ble_gap_adv_set_fields(&m_advData);
-        if (rc != 0) {
-            NIMBLE_LOGC(LOG_TAG, "error setting advertisement data; rc=%d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-            abort();
+        if(m_scanResp && !m_customScanResponseData) {
+            rc = ble_gap_adv_rsp_set_fields(&m_scanData);
+            switch(rc) {
+                case 0:
+                    break;
+
+                case BLE_HS_EBUSY:
+                    NIMBLE_LOGE(LOG_TAG, "Already advertising");
+                    break;
+
+                case BLE_HS_EMSGSIZE:
+                    NIMBLE_LOGE(LOG_TAG, "Scan data too long");
+                    break;
+
+                default:
+                    NIMBLE_LOGE(LOG_TAG, "Error setting scan response data; rc=%d, %s",
+                                rc, NimBLEUtils::returnCodeToString(rc));
+                    break;
+            }
+        }
+
+        if(rc == 0) {
+            rc = ble_gap_adv_set_fields(&m_advData);
+            switch(rc) {
+                case 0:
+                    break;
+
+                case BLE_HS_EBUSY:
+                    NIMBLE_LOGE(LOG_TAG, "Already advertising");
+                    break;
+
+                case BLE_HS_EMSGSIZE:
+                    NIMBLE_LOGE(LOG_TAG, "Advertisement data too long");
+                    break;
+
+                default:
+                    NIMBLE_LOGE(LOG_TAG, "Error setting advertisement data; rc=%d, %s",
+                                rc, NimBLEUtils::returnCodeToString(rc));
+                    break;
+            }
         }
 
         if(m_advData.num_uuids128 > 0) {
-            free(m_advData.uuids128);
+            free((void*)m_advData.uuids128);
             m_advData.uuids128 = nullptr;
             m_advData.num_uuids128 = 0;
         }
 
         if(m_advData.num_uuids32 > 0) {
-            free(m_advData.uuids32);
+            free((void*)m_advData.uuids32);
             m_advData.uuids32 = nullptr;
             m_advData.num_uuids32 = 0;
         }
 
         if(m_advData.num_uuids16 > 0) {
-            free(m_advData.uuids16);
+            free((void*)m_advData.uuids16);
             m_advData.uuids16 = nullptr;
             m_advData.num_uuids16 = 0;
         }
 
+        if(rc !=0) {
+            return false;
+        }
+
         m_advDataSet = true;
     }
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-    rc = ble_gap_adv_start(0, NULL, duration,
+    rc = ble_gap_adv_start(NimBLEDevice::m_own_addr_type, NULL, duration,
                            &m_advParams,
-                           (pServer != nullptr) ? NimBLEServer::handleGapEvent : NimBLEAdvertising::handleGapEvent,
+                           (pServer != nullptr) ? NimBLEServer::handleGapEvent :
+                                                  NimBLEAdvertising::handleGapEvent,
                            (pServer != nullptr) ? (void*)pServer : (void*)this);
 #else
-    rc = ble_gap_adv_start(0, NULL, duration,
+    rc = ble_gap_adv_start(NimBLEDevice::m_own_addr_type, NULL, duration,
                            &m_advParams, NimBLEAdvertising::handleGapEvent, this);
 #endif
-    if (rc != 0) {
-        NIMBLE_LOGC(LOG_TAG, "Error enabling advertising; rc=%d, %s", rc, NimBLEUtils::returnCodeToString(rc));
-        abort();
+    switch(rc) {
+        case 0:
+             break;
+
+        case BLE_HS_EINVAL:
+             NIMBLE_LOGE(LOG_TAG, "Unable to advertise - Duration too long");
+             break;
+
+        case BLE_HS_EPREEMPTED:
+             NIMBLE_LOGE(LOG_TAG, "Unable to advertise - busy");
+             break;
+
+        case BLE_HS_ETIMEOUT_HCI:
+        case BLE_HS_EOS:
+        case BLE_HS_ECONTROLLER:
+        case BLE_HS_ENOTSYNCED:
+             NIMBLE_LOGE(LOG_TAG, "Unable to advertise - Host Reset");
+             break;
+
+        default:
+            NIMBLE_LOGE(LOG_TAG, "Error enabling advertising; rc=%d, %s",
+                        rc, NimBLEUtils::returnCodeToString(rc));
+            break;
+    }
+
+    if(rc != 0) {
+        return false;
     }
 
     NIMBLE_LOGD(LOG_TAG, "<< Advertising start");
+    return true;
 } // start
 
 
@@ -427,9 +666,11 @@ void NimBLEAdvertising::start(uint32_t duration, void (*advCompleteCB)(NimBLEAdv
  */
 void NimBLEAdvertising::stop() {
     NIMBLE_LOGD(LOG_TAG, ">> stop");
+
     int rc = ble_gap_adv_stop();
     if (rc != 0 && rc != BLE_HS_EALREADY) {
-        NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_stop rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_adv_stop rc=%d %s",
+                    rc, NimBLEUtils::returnCodeToString(rc));
         return;
     }
 
@@ -444,7 +685,7 @@ void NimBLEAdvertising::advCompleteCB() {
     if(m_advCompCB != nullptr) {
         m_advCompCB(this);
     }
-}
+} // advCompleteCB
 
 
 /**
@@ -453,16 +694,25 @@ void NimBLEAdvertising::advCompleteCB() {
  */
 bool NimBLEAdvertising::isAdvertising() {
     return ble_gap_adv_active();
-}
+} // isAdvertising
 
 
 /*
  * Host reset seems to clear advertising data,
  * we need clear the flag so it reloads it.
  */
-void NimBLEAdvertising::onHostReset() {
+void NimBLEAdvertising::onHostSync() {
+    NIMBLE_LOGD(LOG_TAG, "Host re-synced");
+
     m_advDataSet = false;
-}
+    // If we were advertising forever, restart it now
+    if(m_duration == 0) {
+        start(m_duration, m_advCompCB);
+    } else {
+    // Otherwise we should tell the app that advertising stopped.
+        advCompleteCB();
+    }
+} // onHostSync
 
 
 /**
@@ -475,6 +725,19 @@ int NimBLEAdvertising::handleGapEvent(struct ble_gap_event *event, void *arg) {
     NimBLEAdvertising *pAdv = (NimBLEAdvertising*)arg;
 
     if(event->type == BLE_GAP_EVENT_ADV_COMPLETE) {
+        switch(event->adv_complete.reason) {
+            // Don't call the callback if host reset, we want to
+            // preserve the active flag until re-sync to restart advertising.
+            case BLE_HS_ETIMEOUT_HCI:
+            case BLE_HS_EOS:
+            case BLE_HS_ECONTROLLER:
+            case BLE_HS_ENOTSYNCED:
+                NIMBLE_LOGC(LOG_TAG, "host reset, rc=%d", event->adv_complete.reason);
+                NimBLEDevice::onReset(event->adv_complete.reason);
+                return 0;
+            default:
+                break;
+        }
         pAdv->advCompleteCB();
     }
     return 0;
@@ -487,6 +750,7 @@ int NimBLEAdvertising::handleGapEvent(struct ble_gap_event *event, void *arg) {
  */
 void NimBLEAdvertisementData::addData(const std::string &data) {
     if ((m_payload.length() + data.length()) > BLE_HS_ADV_MAX_SZ) {
+        NIMBLE_LOGE(LOG_TAG, "Advertisement data length exceded");
         return;
     }
     m_payload.append(data);
@@ -498,11 +762,8 @@ void NimBLEAdvertisementData::addData(const std::string &data) {
  * @param [in] data The data to be added to the payload.
  * @param [in] length The size of data to be added to the payload.
  */
-void NimBLEAdvertisementData::addData(char * data, size_t length){
-    if ((m_payload.length() + length) > BLE_HS_ADV_MAX_SZ) {
-        return;
-    }
-    m_payload.append(data,length);
+void NimBLEAdvertisementData::addData(char * data, size_t length) {
+    addData(std::string(data, length));
 } // addData
 
 
@@ -521,43 +782,6 @@ void NimBLEAdvertisementData::setAppearance(uint16_t appearance) {
 } // setAppearance
 
 
-/**
- * @brief Set the complete services to advertise.
- * @param [in] uuid The UUID of the service.
- */
-void NimBLEAdvertisementData::setCompleteServices(const NimBLEUUID &uuid) {
-    char cdata[2];
-    switch (uuid.bitSize()) {
-        case 16: {
-            // [Len] [0x02] [LL] [HH]
-            cdata[0] = 3;
-            cdata[1] = BLE_HS_ADV_TYPE_COMP_UUIDS16;  // 0x03
-            addData(std::string(cdata, 2) + std::string((char*) &uuid.getNative()->u16.value, 2));
-            break;
-        }
-
-        case 32: {
-            // [Len] [0x04] [LL] [LL] [HH] [HH]
-            cdata[0] = 5;
-            cdata[1] = BLE_HS_ADV_TYPE_COMP_UUIDS32;  // 0x05
-            addData(std::string(cdata, 2) + std::string((char*) &uuid.getNative()->u32.value, 4));
-            break;
-        }
-
-        case 128: {
-            // [Len] [0x04] [0] [1] ... [15]
-            cdata[0] = 17;
-            cdata[1] = BLE_HS_ADV_TYPE_COMP_UUIDS128;  // 0x07
-            addData(std::string(cdata, 2) + std::string((char*) uuid.getNative()->u128.value, 16));
-            break;
-        }
-
-        default:
-            return;
-    }
-} // setCompleteServices
-
-
 /**
  * @brief Set the advertisement flags.
  * @param [in] flag The flags to be set in the advertisement.
@@ -579,64 +803,141 @@ void NimBLEAdvertisementData::setFlags(uint8_t flag) {
  * @param [in] data The manufacturer data to advertise.
  */
 void NimBLEAdvertisementData::setManufacturerData(const std::string &data) {
-    NIMBLE_LOGD("NimBLEAdvertisementData", ">> setManufacturerData");
     char cdata[2];
     cdata[0] = data.length() + 1;
     cdata[1] = BLE_HS_ADV_TYPE_MFG_DATA ;  // 0xff
     addData(std::string(cdata, 2) + data);
-    NIMBLE_LOGD("NimBLEAdvertisementData", "<< setManufacturerData");
 } // setManufacturerData
 
 
+/**
+ * @brief Set the URI to advertise.
+ * @param [in] uri The uri to advertise.
+ */
+void NimBLEAdvertisementData::setURI(const std::string &uri) {
+    char cdata[2];
+    cdata[0] = uri.length() + 1;
+    cdata[1] = BLE_HS_ADV_TYPE_URI;
+    addData(std::string(cdata, 2) + uri);
+} // setURI
+
+
 /**
  * @brief Set the complete name of this device.
  * @param [in] name The name to advertise.
  */
 void NimBLEAdvertisementData::setName(const std::string &name) {
-    NIMBLE_LOGD("NimBLEAdvertisementData", ">> setName: %s", name.c_str());
     char cdata[2];
     cdata[0] = name.length() + 1;
     cdata[1] = BLE_HS_ADV_TYPE_COMP_NAME;  // 0x09
     addData(std::string(cdata, 2) + name);
-    NIMBLE_LOGD("NimBLEAdvertisementData", "<< setName");
 } // setName
 
 
 /**
- * @brief Set the partial services to advertise.
- * @param [in] uuid The single service to advertise.
+ * @brief Set a single service to advertise as a complete list of services.
+ * @param [in] uuid The service to advertise.
+ */
+void NimBLEAdvertisementData::setCompleteServices(const NimBLEUUID &uuid) {
+    setServices(true, uuid.bitSize(), {uuid});
+} // setCompleteServices
+
+
+/**
+ * @brief Set the complete list of 16 bit services to advertise.
+ * @param [in] v_uuid A vector of 16 bit UUID's to advertise.
+ */
+void NimBLEAdvertisementData::setCompleteServices16(const std::vector<NimBLEUUID>& v_uuid) {
+    setServices(true, 16, v_uuid);
+} // setCompleteServices16
+
+
+/**
+ * @brief Set the complete list of 32 bit services to advertise.
+ * @param [in] v_uuid A vector of 32 bit UUID's to advertise.
+ */
+void NimBLEAdvertisementData::setCompleteServices32(const std::vector<NimBLEUUID>& v_uuid) {
+    setServices(true, 32, v_uuid);
+} // setCompleteServices32
+
+
+/**
+ * @brief Set a single service to advertise as a partial list of services.
+ * @param [in] uuid The service to advertise.
  */
 void NimBLEAdvertisementData::setPartialServices(const NimBLEUUID &uuid) {
+    setServices(false, uuid.bitSize(), {uuid});
+} // setPartialServices
+
+
+/**
+ * @brief Set the partial list of services to advertise.
+ * @param [in] v_uuid A vector of 16 bit UUID's to advertise.
+ */
+void NimBLEAdvertisementData::setPartialServices16(const std::vector<NimBLEUUID>& v_uuid) {
+    setServices(false, 16, v_uuid);
+} // setPartialServices16
+
+
+/**
+ * @brief Set the partial list of services to advertise.
+ * @param [in] v_uuid A vector of 32 bit UUID's to advertise.
+ */
+void NimBLEAdvertisementData::setPartialServices32(const std::vector<NimBLEUUID>& v_uuid) {
+    setServices(false, 32, v_uuid);
+} // setPartialServices32
+
+
+/**
+ * @brief Utility function to create the list of service UUID's from a vector.
+ * @param [in] complete If true the vector is the complete set of services.
+ * @param [in] size The bit size of the UUID's in the vector. (16, 32, or 128).
+ * @param [in] v_uuid The vector of service UUID's to advertise.
+ */
+void NimBLEAdvertisementData::setServices(const bool complete, const uint8_t size,
+                                          const std::vector<NimBLEUUID> &v_uuid)
+{
     char cdata[2];
-    switch (uuid.bitSize()) {
-        case 16: {
-            // [Len] [0x02] [LL] [HH]
-            cdata[0] = 3;
-            cdata[1] =  BLE_HS_ADV_TYPE_INCOMP_UUIDS16;  // 0x02
-            addData(std::string(cdata, 2) + std::string((char *) &uuid.getNative()->u16.value, 2));
+    cdata[0] = (size / 8) * v_uuid.size() + 1;
+    switch(size) {
+        case 16:
+            cdata[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS16 : BLE_HS_ADV_TYPE_INCOMP_UUIDS16;
             break;
-        }
-
-        case 32: {
-            // [Len] [0x04] [LL] [LL] [HH] [HH]
-            cdata[0] = 5;
-            cdata[1] =  BLE_HS_ADV_TYPE_INCOMP_UUIDS32; // 0x04
-            addData(std::string(cdata, 2) + std::string((char *) &uuid.getNative()->u32.value, 4));
+        case 32:
+            cdata[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS32 : BLE_HS_ADV_TYPE_INCOMP_UUIDS32;
             break;
-        }
-
-        case 128: {
-            // [Len] [0x04] [0] [1] ... [15]
-            cdata[0] = 17;
-            cdata[1] = BLE_HS_ADV_TYPE_INCOMP_UUIDS128;  // 0x06
-            addData(std::string(cdata, 2) + std::string((char *) &uuid.getNative()->u128.value, 16));
+        case 128:
+            cdata[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS128 : BLE_HS_ADV_TYPE_INCOMP_UUIDS128;
             break;
-        }
-
         default:
             return;
     }
-} // setPartialServices
+
+    std::string uuids;
+
+    for(auto &it : v_uuid){
+        if(it.bitSize() != size) {
+            NIMBLE_LOGE(LOG_TAG, "Service UUID(%d) invalid", size);
+            return;
+        } else {
+            switch(size) {
+                case 16:
+                    uuids += std::string((char*)&it.getNative()->u16.value, 2);
+                    break;
+                case 32:
+                    uuids += std::string((char*)&it.getNative()->u32.value, 4);
+                    break;
+                case 128:
+                    uuids += std::string((char*)&it.getNative()->u128.value, 16);
+                    break;
+                default:
+                    return;
+            }
+        }
+    }
+
+    addData(std::string(cdata, 2) + uuids);
+} // setServices
 
 
 /**
@@ -682,15 +983,42 @@ void NimBLEAdvertisementData::setServiceData(const NimBLEUUID &uuid, const std::
  * @param [in] name The short name of the device.
  */
 void NimBLEAdvertisementData::setShortName(const std::string &name) {
-    NIMBLE_LOGD("NimBLEAdvertisementData", ">> setShortName: %s", name.c_str());
     char cdata[2];
     cdata[0] = name.length() + 1;
     cdata[1] = BLE_HS_ADV_TYPE_INCOMP_NAME;  // 0x08
     addData(std::string(cdata, 2) + name);
-    NIMBLE_LOGD("NimBLEAdvertisementData", "<< setShortName");
 } // setShortName
 
 
+/**
+ * @brief Adds Tx power level to the advertisement data.
+ */
+void NimBLEAdvertisementData::addTxPower() {
+    char cdata[3];
+    cdata[0] = BLE_HS_ADV_TX_PWR_LVL_LEN + 1;
+    cdata[1] = BLE_HS_ADV_TYPE_TX_PWR_LVL;
+    cdata[2] = NimBLEDevice::getPower();
+    addData(cdata, 3);
+} // addTxPower
+
+
+/**
+ * @brief Set the preferred connection interval parameters.
+ * @param [in] min The minimum interval desired.
+ * @param [in] max The maximum interval desired.
+ */
+void NimBLEAdvertisementData::setPreferredParams(uint16_t min, uint16_t max) {
+    char cdata[6];
+    cdata[0] = BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN + 1;
+    cdata[1] = BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE;
+    cdata[2] = min;
+    cdata[3] = min >> 8;
+    cdata[4] = max;
+    cdata[5] = max >> 8;
+    addData(cdata, 6);
+} // setPreferredParams
+
+
 /**
  * @brief Retrieve the payload that is to be advertised.
  * @return The payload that is to be advertised.

src/NimBLEAdvertising.h

@@ -50,18 +50,27 @@ class NimBLEAdvertisementData {
 public:
     void setAppearance(uint16_t appearance);
     void setCompleteServices(const NimBLEUUID &uuid);
+    void setCompleteServices16(const std::vector<NimBLEUUID> &v_uuid);
+    void setCompleteServices32(const std::vector<NimBLEUUID> &v_uuid);
     void setFlags(uint8_t);
     void setManufacturerData(const std::string &data);
+    void setURI(const std::string &uri);
     void setName(const std::string &name);
     void setPartialServices(const NimBLEUUID &uuid);
+    void setPartialServices16(const std::vector<NimBLEUUID> &v_uuid);
+    void setPartialServices32(const std::vector<NimBLEUUID> &v_uuid);
     void setServiceData(const NimBLEUUID &uuid, const std::string &data);
     void setShortName(const std::string &name);
     void addData(const std::string &data);  // Add data to the payload.
     void addData(char * data, size_t length);
+    void addTxPower();
+    void setPreferredParams(uint16_t min, uint16_t max);
     std::string getPayload();               // Retrieve the current advert payload.
 
 private:
     friend class NimBLEAdvertising;
+    void setServices(const bool complete, const uint8_t size,
+                     const std::vector<NimBLEUUID> &v_uuid);
     std::string m_payload;   // The payload of the advertisement.
 };   // NimBLEAdvertisementData
 
@@ -77,9 +86,13 @@ public:
     void addServiceUUID(const NimBLEUUID &serviceUUID);
     void addServiceUUID(const char* serviceUUID);
     void removeServiceUUID(const NimBLEUUID &serviceUUID);
-    void start(uint32_t duration = 0, void (*advCompleteCB)(NimBLEAdvertising *pAdv) = nullptr);
+    bool start(uint32_t duration = 0, void (*advCompleteCB)(NimBLEAdvertising *pAdv) = nullptr);
     void stop();
     void setAppearance(uint16_t appearance);
+    void setName(const std::string &name);
+    void setManufacturerData(const std::string &data);
+    void setURI(const std::string &uri);
+    void setServiceData(const NimBLEUUID &uuid, const std::string &data);
     void setAdvertisementType(uint8_t adv_type);
     void setMaxInterval(uint16_t maxinterval);
     void setMinInterval(uint16_t mininterval);
@@ -87,13 +100,17 @@ public:
     void setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly);
     void setScanResponseData(NimBLEAdvertisementData& advertisementData);
     void setScanResponse(bool);
+    void setMinPreferred(uint16_t);
+    void setMaxPreferred(uint16_t);
+    void addTxPower();
+    void reset();
     void advCompleteCB();
     bool isAdvertising();
 
 private:
     friend class NimBLEDevice;
 
-    void                    onHostReset();
+    void                    onHostSync();
     static int              handleGapEvent(struct ble_gap_event *event, void *arg);
 
     ble_hs_adv_fields       m_advData;
@@ -104,8 +121,15 @@ private:
     bool                    m_customScanResponseData;
     bool                    m_scanResp;
     bool                    m_advDataSet;
-    void                   (*m_advCompCB)(NimBLEAdvertising *pAdv);
-
+    void                    (*m_advCompCB)(NimBLEAdvertising *pAdv);
+    uint8_t                 m_slaveItvl[4];
+    uint32_t                m_duration;
+    std::vector<uint8_t>    m_svcData16;
+    std::vector<uint8_t>    m_svcData32;
+    std::vector<uint8_t>    m_svcData128;
+    std::vector<uint8_t>    m_name;
+    std::vector<uint8_t>    m_mfgData;
+    std::vector<uint8_t>    m_uri;
 };
 
 #endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)

src/NimBLEBeacon.cpp

@@ -12,7 +12,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include <string.h>
 #include <algorithm>

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_ */

src/NimBLECharacteristic.cpp

@@ -52,7 +52,6 @@ NimBLECharacteristic::NimBLECharacteristic(const NimBLEUUID &uuid, uint16_t prop
     m_pService   = pService;
     m_value      = "";
     m_valMux     = portMUX_INITIALIZER_UNLOCKED;
-    m_pTaskData  = nullptr;
     m_timestamp  = 0;
 } // NimBLECharacteristic
 
@@ -95,15 +94,26 @@ NimBLEDescriptor* NimBLECharacteristic::createDescriptor(const NimBLEUUID &uuid,
         pDescriptor = new NimBLEDescriptor(uuid, properties, max_len, this);
     }
 
-    m_dscVec.push_back(pDescriptor);
+    addDescriptor(pDescriptor);
+
     return pDescriptor;
-} // createCharacteristic
+} // createDescriptor
 
 
 /**
- * @brief Return the BLE Descriptor for the given UUID if associated with this characteristic.
- * @param [in] uuid The UUID of the descriptor that we wish to retrieve.
- * @return pointer to the NimBLEDescriptor. If no such descriptor is associated with the characteristic, nullptr is returned.
+ * @brief Add a descriptor to the characteristic.
+ * @param [in] A pointer to the descriptor to add.
+ */
+void NimBLECharacteristic::addDescriptor(NimBLEDescriptor *pDescriptor) {
+    pDescriptor->setCharacteristic(this);
+    m_dscVec.push_back(pDescriptor);
+}
+
+
+/**
+ * @brief Return the BLE Descriptor for the given UUID.
+ * @param [in] uuid The UUID of the descriptor.
+ * @return A pointer to the descriptor object or nullptr if not found.
  */
 NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const char* uuid) {
     return getDescriptorByUUID(NimBLEUUID(uuid));
@@ -111,9 +121,9 @@ NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const char* uuid) {
 
 
 /**
- * @brief Return the BLE Descriptor for the given UUID if associated with this characteristic.
- * @param [in] uuid The UUID of the descriptor that we wish to retrieve.
- * @return pointer to the NimBLEDescriptor. If no such descriptor is associated with the characteristic, nullptr is returned.
+ * @brief Return the BLE Descriptor for the given UUID.
+ * @param [in] uuid The UUID of the descriptor.
+ * @return A pointer to the descriptor object or nullptr if not found.
  */
 NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const NimBLEUUID &uuid) {
     for (auto &it : m_dscVec) {
@@ -124,6 +134,20 @@ NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const NimBLEUUID &uu
     return nullptr;
 } // getDescriptorByUUID
 
+/**
+ * @brief Return the BLE Descriptor for the given handle.
+ * @param [in] handle The handle of the descriptor.
+ * @return A pointer to the descriptor object or nullptr if not found.
+ */
+NimBLEDescriptor *NimBLECharacteristic::getDescriptorByHandle(uint16_t handle) {
+    for (auto &it : m_dscVec) {
+        if (it->getHandle() == handle) {
+            return it;
+        }
+    }
+    return nullptr;
+}
+
 
 /**
  * @brief Get the handle of the characteristic.
@@ -151,6 +175,11 @@ NimBLEService* NimBLECharacteristic::getService() {
 } // getService
 
 
+void NimBLECharacteristic::setService(NimBLEService *pService) {
+    m_pService = pService;
+}
+
+
 /**
  * @brief Get the UUID of the characteristic.
  * @return The UUID of the characteristic.
@@ -287,16 +316,13 @@ void NimBLECharacteristic::setSubscribe(struct ble_gap_event *event) {
         subVal |= NIMBLE_SUB_INDICATE;
     }
 
-    if(m_pTaskData != nullptr) {
-        m_pTaskData->rc = (subVal & NIMBLE_SUB_INDICATE) ? 0 :
-                          NimBLECharacteristicCallbacks::Status::ERROR_INDICATE_DISABLED;
-        xTaskNotifyGive(m_pTaskData->task);
+    NIMBLE_LOGI(LOG_TAG, "New subscribe value for conn: %d val: %d",
+                          event->subscribe.conn_handle, subVal);
+
+    if(!event->subscribe.cur_indicate && event->subscribe.prev_indicate) {
+       NimBLEDevice::getServer()->clearIndicateWait(event->subscribe.conn_handle);
     }
 
-    NIMBLE_LOGI(LOG_TAG, "New subscribe value for conn: %d val: %d",
-                         event->subscribe.conn_handle, subVal);
-
-    m_pCallbacks->onSubscribe(this, &desc, subVal);
 
     auto it = m_subscribedVec.begin();
     for(;it != m_subscribedVec.end(); ++it) {
@@ -308,16 +334,14 @@ void NimBLECharacteristic::setSubscribe(struct ble_gap_event *event) {
     if(subVal > 0) {
         if(it == m_subscribedVec.end()) {
             m_subscribedVec.push_back({event->subscribe.conn_handle, subVal});
-            return;
+        } else {
+            (*it).second = subVal;
         }
-
-        (*it).second = subVal;
-
     } else if(it != m_subscribedVec.end()) {
         m_subscribedVec.erase(it);
-        m_subscribedVec.shrink_to_fit();
     }
 
+    m_pCallbacks->onSubscribe(this, &desc, subVal);
 }
 
 
@@ -402,40 +426,20 @@ void NimBLECharacteristic::notify(bool is_notification) {
         // We also must create it in each loop iteration because it is consumed with each host call.
         os_mbuf *om = ble_hs_mbuf_from_flat((uint8_t*)value.data(), length);
 
-        NimBLECharacteristicCallbacks::Status statusRC;
-
         if(!is_notification && (m_properties & NIMBLE_PROPERTY::INDICATE)) {
-            ble_task_data_t taskData = {nullptr, xTaskGetCurrentTaskHandle(),0, nullptr};
-            m_pTaskData = &taskData;
+            if(!NimBLEDevice::getServer()->setIndicateWait(it.first)) {
+               NIMBLE_LOGE(LOG_TAG, "prior Indication in progress");
+               os_mbuf_free_chain(om);
+               return;
+            }
 
             rc = ble_gattc_indicate_custom(it.first, m_handle, om);
             if(rc != 0){
-                statusRC = NimBLECharacteristicCallbacks::Status::ERROR_GATT;
-            } else {
-                ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
-                rc = m_pTaskData->rc;
-            }
-
-            m_pTaskData = nullptr;
-
-            if(rc == BLE_HS_EDONE) {
-                rc = 0;
-                statusRC = NimBLECharacteristicCallbacks::Status::SUCCESS_INDICATE;
-            } else if(rc == BLE_HS_ETIMEOUT) {
-                statusRC = NimBLECharacteristicCallbacks::Status::ERROR_INDICATE_TIMEOUT;
-            } else {
-                statusRC = NimBLECharacteristicCallbacks::Status::ERROR_INDICATE_FAILURE;
+                NimBLEDevice::getServer()->clearIndicateWait(it.first);
             }
         } else {
-            rc = ble_gattc_notify_custom(it.first, m_handle, om);
-            if(rc == 0) {
-                statusRC = NimBLECharacteristicCallbacks::Status::SUCCESS_NOTIFY;
-            } else {
-                statusRC = NimBLECharacteristicCallbacks::Status::ERROR_GATT;
-            }
+            ble_gattc_notify_custom(it.first, m_handle, om);
         }
-
-        m_pCallbacks->onStatus(this, statusRC, rc);
     }
 
     NIMBLE_LOGD(LOG_TAG, "<< notify");
@@ -455,6 +459,13 @@ void NimBLECharacteristic::setCallbacks(NimBLECharacteristicCallbacks* pCallback
     }
 } // setCallbacks
 
+/**
+ * @brief Get the callback handlers for this characteristic.
+ */
+NimBLECharacteristicCallbacks* NimBLECharacteristic::getCallbacks() {
+    return m_pCallbacks;
+} //getCallbacks
+
 
 /**
  * @brief Set the value of the characteristic.
@@ -462,7 +473,7 @@ void NimBLECharacteristic::setCallbacks(NimBLECharacteristicCallbacks* pCallback
  * @param [in] length The length of the data in bytes.
  */
 void NimBLECharacteristic::setValue(const uint8_t* data, size_t length) {
-#if CONFIG_LOG_DEFAULT_LEVEL > 3 || (ARDUINO_ARCH_ESP32 && CORE_DEBUG_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);
@@ -473,9 +484,10 @@ void NimBLECharacteristic::setValue(const uint8_t* data, size_t length) {
         return;
     }
 
+    time_t t = time(nullptr);
     portENTER_CRITICAL(&m_valMux);
     m_value = std::string((char*)data, length);
-    m_timestamp = time(nullptr);
+    m_timestamp = t;
     portEXIT_CRITICAL(&m_valMux);
 
     NIMBLE_LOGD(LOG_TAG, "<< setValue");

src/NimBLECharacteristic.h

@@ -59,6 +59,31 @@ class NimBLECharacteristicCallbacks;
  */
 class NimBLECharacteristic {
 public:
+    NimBLECharacteristic(const char* uuid,
+                         uint16_t properties =
+                         NIMBLE_PROPERTY::READ |
+                         NIMBLE_PROPERTY::WRITE,
+                         NimBLEService* pService = nullptr);
+    NimBLECharacteristic(const NimBLEUUID &uuid,
+                         uint16_t properties =
+                         NIMBLE_PROPERTY::READ |
+                         NIMBLE_PROPERTY::WRITE,
+                         NimBLEService* pService = nullptr);
+
+    ~NimBLECharacteristic();
+
+    uint16_t          getHandle();
+    NimBLEUUID        getUUID();
+    std::string       toString();
+
+    void              setCallbacks(NimBLECharacteristicCallbacks* pCallbacks);
+    NimBLECharacteristicCallbacks*
+                      getCallbacks();
+
+    void              indicate();
+    void              notify(bool is_notification = true);
+    size_t            getSubscribedCount();
+
     NimBLEDescriptor* createDescriptor(const char* uuid,
                                        uint32_t properties =
                                        NIMBLE_PROPERTY::READ |
@@ -70,11 +95,13 @@ public:
                                        NIMBLE_PROPERTY::WRITE,
                                        uint16_t max_len = 100);
 
+    void              addDescriptor(NimBLEDescriptor *pDescriptor);
     NimBLEDescriptor* getDescriptorByUUID(const char* uuid);
     NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID &uuid);
-    NimBLEUUID        getUUID();
-    std::string       getValue(time_t *timestamp = nullptr);
+    NimBLEDescriptor* getDescriptorByHandle(uint16_t handle);
 
+    std::string       getValue(time_t *timestamp = nullptr);
+    size_t            getDataLength();
     /**
      * @brief A template to convert the characteristic data to <type\>.
      * @tparam T The type to convert the data to.
@@ -92,46 +119,26 @@ public:
         return *((T *)pData);
     }
 
-    size_t            getDataLength();
-    void              indicate();
-    void              notify(bool is_notification = true);
-    void              setCallbacks(NimBLECharacteristicCallbacks* pCallbacks);
     void              setValue(const uint8_t* data, size_t size);
     void              setValue(const std::string &value);
-
     /**
      * @brief Convenience template to set the characteristic value to <type\>val.
      * @param [in] s The value to set.
      */
     template<typename T>
-    void setValue(const T &s) {
+    void              setValue(const T &s) {
         setValue((uint8_t*)&s, sizeof(T));
     }
 
-    std::string       toString();
-    uint16_t          getHandle();
-    size_t            getSubscribedCount();
+    NimBLEService*    getService();
+    uint16_t          getProperties();
 
 private:
 
-    friend class      NimBLEServer;
-    friend class      NimBLEService;
+    friend class    NimBLEServer;
+    friend class    NimBLEService;
 
-    NimBLECharacteristic(const char* uuid,
-                         uint16_t properties =
-                         NIMBLE_PROPERTY::READ |
-                         NIMBLE_PROPERTY::WRITE,
-                         NimBLEService* pService = nullptr);
-    NimBLECharacteristic(const NimBLEUUID &uuid,
-                         uint16_t properties =
-                         NIMBLE_PROPERTY::READ |
-                         NIMBLE_PROPERTY::WRITE,
-                         NimBLEService* pService = nullptr);
-
-    ~NimBLECharacteristic();
-
-    NimBLEService*  getService();
-    uint16_t        getProperties();
+    void            setService(NimBLEService *pService);
     void            setSubscribe(struct ble_gap_event *event);
     static int      handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
                                    struct ble_gatt_access_ctxt *ctxt, void *arg);
@@ -143,7 +150,6 @@ private:
     NimBLEService*                 m_pService;
     std::string                    m_value;
     std::vector<NimBLEDescriptor*> m_dscVec;
-    ble_task_data_t                *m_pTaskData;
     portMUX_TYPE                   m_valMux;
     time_t                         m_timestamp;
 

src/NimBLEClient.cpp

@@ -24,6 +24,9 @@
 #include <string>
 #include <unordered_set>
 
+#include "nimble/nimble_port.h"
+
+
 static const char* LOG_TAG = "NimBLEClient";
 static NimBLEClientCallbacks defaultCallbacks;
 
@@ -56,11 +59,10 @@ static NimBLEClientCallbacks defaultCallbacks;
 NimBLEClient::NimBLEClient(const NimBLEAddress &peerAddress) : m_peerAddress(peerAddress) {
     m_pClientCallbacks = &defaultCallbacks;
     m_conn_id          = BLE_HS_CONN_HANDLE_NONE;
-    m_isConnected      = false;
-    m_waitingToConnect = false;
     m_connectTimeout   = 30000;
     m_deleteCallbacks  = false;
     m_pTaskData        = nullptr;
+    m_connEstablished  = false;
 
     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)
@@ -70,6 +72,9 @@ NimBLEClient::NimBLEClient(const NimBLEAddress &peerAddress) : m_peerAddress(pee
     m_pConnParams.supervision_timeout = BLE_GAP_INITIAL_SUPERVISION_TIMEOUT; // timeout = 400*10ms = 4000ms
     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
+
+    ble_npl_callout_init(&m_dcTimer, nimble_port_get_dflt_eventq(),
+                         NimBLEClient::dcTimerCb, this);
 } // NimBLEClient
 
 
@@ -89,6 +94,20 @@ NimBLEClient::~NimBLEClient() {
 } // ~NimBLEClient
 
 
+/**
+ * @brief If we have asked to disconnect and the event does not
+ * occur within the supervision timeout + added delay, this will
+ * be called to reset the host in the case of a stalled controller.
+ */
+void NimBLEClient::dcTimerCb(ble_npl_event *event) {
+ /*   NimBLEClient *pClient = (NimBLEClient*)event->arg;
+    NIMBLE_LOGC(LOG_TAG, "Timed out disconnecting from %s - resetting host",
+                std::string(pClient->getPeerAddress()).c_str());
+ */
+    ble_hs_sched_reset(BLE_HS_ECONTROLLER);
+}
+
+
 /**
  * @brief Delete all service objects created by this client and clear the vector.
  */
@@ -164,70 +183,119 @@ bool NimBLEClient::connect(const NimBLEAddress &address, bool deleteAttibutes) {
         return false;
     }
 
-    if(ble_gap_conn_active()) {
-        NIMBLE_LOGE(LOG_TAG, "Connection in progress - must wait.");
+    if(isConnected() || m_connEstablished || m_pTaskData != nullptr) {
+        NIMBLE_LOGE(LOG_TAG, "Client busy, connected to %s, id=%d",
+                    std::string(m_peerAddress).c_str(), getConnId());
         return false;
     }
 
-    if(!NimBLEDevice::getScan()->stop()) {
+    ble_addr_t peerAddr_t;
+    memcpy(&peerAddr_t.val, address.getNative(),6);
+    peerAddr_t.type = address.getType();
+    if(ble_gap_conn_find_by_addr(&peerAddr_t, NULL) == 0) {
+        NIMBLE_LOGE(LOG_TAG, "A connection to %s already exists",
+                    address.toString().c_str());
         return false;
     }
 
     if(address == NimBLEAddress("")) {
         NIMBLE_LOGE(LOG_TAG, "Invalid peer address;(NULL)");
         return false;
-    } else if(m_peerAddress != address) {
+    } else {
         m_peerAddress = address;
     }
 
-    ble_addr_t peerAddrt;
-    memcpy(&peerAddrt.val, m_peerAddress.getNative(),6);
-    peerAddrt.type = m_peerAddress.getType();
-
     ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
     m_pTaskData = &taskData;
-
     int rc = 0;
 
     /* Try to connect the the advertiser.  Allow 30 seconds (30000 ms) for
      *  timeout (default value of m_connectTimeout).
      *  Loop on BLE_HS_EBUSY if the scan hasn't stopped yet.
      */
-    do{
-        rc = ble_gap_connect(BLE_OWN_ADDR_PUBLIC, &peerAddrt, m_connectTimeout, &m_pConnParams,
-                            NimBLEClient::handleGapEvent, this);
-        if(rc == BLE_HS_EBUSY) {
-            vTaskDelay(1 / portTICK_PERIOD_MS);
-        }
-    }while(rc == BLE_HS_EBUSY);
+    do {
+        rc = ble_gap_connect(NimBLEDevice::m_own_addr_type, &peerAddr_t,
+                             m_connectTimeout, &m_pConnParams,
+                             NimBLEClient::handleGapEvent, this);
+        switch (rc) {
+            case 0:
+                break;
 
-    if (rc != 0 && rc != BLE_HS_EDONE) {
-        NIMBLE_LOGE(LOG_TAG, "Error: Failed to connect to device; "
-                    "addr=%s, rc=%d; %s",
-                    std::string(m_peerAddress).c_str(),
-                    rc, NimBLEUtils::returnCodeToString(rc));
+            case BLE_HS_EBUSY:
+                // Scan was still running, stop it and try again
+                if (!NimBLEDevice::getScan()->stop()) {
+                    rc = BLE_HS_EUNKNOWN;
+                }
+                break;
+
+            case BLE_HS_EDONE:
+                // A connection to this device already exists, do not connect twice.
+                NIMBLE_LOGE(LOG_TAG, "Already connected to device; addr=%s",
+                            std::string(m_peerAddress).c_str());
+                break;
+
+            case BLE_HS_EALREADY:
+                // Already attemting to connect to this device, cancel the previous
+                // attempt and report failure here so we don't get 2 connections.
+                NIMBLE_LOGE(LOG_TAG, "Already attempting to connect to %s - cancelling",
+                            std::string(m_peerAddress).c_str());
+                ble_gap_conn_cancel();
+                break;
+
+            default:
+                NIMBLE_LOGE(LOG_TAG, "Failed to connect to %s, rc=%d; %s",
+                            std::string(m_peerAddress).c_str(),
+                            rc, NimBLEUtils::returnCodeToString(rc));
+                break;
+        }
+
+    } while (rc == BLE_HS_EBUSY);
+
+    if(rc != 0) {
         m_pTaskData = nullptr;
-        m_waitingToConnect = false;
         return false;
     }
 
-    m_waitingToConnect = true;
+    // 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;
+        // If a connection was made but no response from MTU exchange; disconnect
+        if(isConnected()) {
+            NIMBLE_LOGE(LOG_TAG, "Connect timeout - no response");
+            disconnect();
+        } else {
+        // workaround; if the controller doesn't cancel the connection
+        // at the timeout, cancel it here.
+            NIMBLE_LOGE(LOG_TAG, "Connect timeout - cancelling");
+            ble_gap_conn_cancel();
+        }
 
-    // Wait for the connection to complete.
-    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
-
-    if(taskData.rc != 0){
         return false;
+
+    } else if(taskData.rc != 0){
+        NIMBLE_LOGE(LOG_TAG, "Connection failed; status=%d %s",
+                    taskData.rc,
+                    NimBLEUtils::returnCodeToString(taskData.rc));
+        // If the failure was not a result of a disconnection
+        // make sure we disconnect now to avoid dangling connections
+        if(isConnected()) {
+            disconnect();
+        }
+        return false;
+    } else {
+        NIMBLE_LOGI(LOG_TAG, "Connection established");
     }
 
     if(deleteAttibutes) {
         deleteServices();
     }
 
+    m_connEstablished = true;
     m_pClientCallbacks->onConnect(this);
 
     NIMBLE_LOGD(LOG_TAG, "<< connect()");
-    return true;
+    // Check if still connected before returning
+    return isConnected();
 } // connect
 
 
@@ -268,12 +336,39 @@ bool NimBLEClient::secureConnection() {
 int NimBLEClient::disconnect(uint8_t reason) {
     NIMBLE_LOGD(LOG_TAG, ">> disconnect()");
     int rc = 0;
-    if(m_isConnected){
-        rc = ble_gap_terminate(m_conn_id, reason);
-        if(rc != 0){
-            NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s", rc,
-                                    NimBLEUtils::returnCodeToString(rc));
+    if(isConnected()) {
+        // If the timer was already started, ignore this call.
+        if(ble_npl_callout_is_active(&m_dcTimer)) {
+            NIMBLE_LOGI(LOG_TAG, "Already disconnecting, timer started");
+            return BLE_HS_EALREADY;
         }
+
+        ble_gap_conn_desc desc;
+        if(ble_gap_conn_find(m_conn_id, &desc) != 0){
+            NIMBLE_LOGI(LOG_TAG, "Connection ID not found");
+            return BLE_HS_EALREADY;
+        }
+
+        // We use a timer to detect a controller error in the event that it does
+        // not inform the stack when disconnection is complete.
+        // This is a common error in certain esp-idf versions.
+        // The disconnect timeout time is the supervison timeout time + 1 second.
+        // In the case that the event happenss shortly after the supervision timeout
+        // we don't want to prematurely reset the host.
+        ble_npl_time_t ticks;
+        ble_npl_time_ms_to_ticks((desc.supervision_timeout + 100) * 10, &ticks);
+        ble_npl_callout_reset(&m_dcTimer, ticks);
+
+        rc = ble_gap_terminate(m_conn_id, reason);
+        if (rc != 0) {
+            if(rc != BLE_HS_EALREADY) {
+                ble_npl_callout_stop(&m_dcTimer);
+            }
+            NIMBLE_LOGE(LOG_TAG, "ble_gap_terminate failed: rc=%d %s",
+                        rc, NimBLEUtils::returnCodeToString(rc));
+        }
+    } else {
+        NIMBLE_LOGD(LOG_TAG, "Not connected to any peers");
     }
 
     NIMBLE_LOGD(LOG_TAG, "<< disconnect()");
@@ -283,12 +378,12 @@ int NimBLEClient::disconnect(uint8_t reason) {
 
 /**
  * @brief Set the connection paramaters to use when connecting to a server.
- * @param [in] minInterval minimum connection interval in 0.625ms units.
- * @param [in] maxInterval maximum connection interval in 0.625ms units.
- * @param [in] latency number of packets allowed to skip (extends max interval)
- * @param [in] timeout the timeout time in 10ms units before disconnecting
- * @param [in] scanInterval the scan interval to use when attempting to connect in 0.625ms units.
- * @param [in] scanWindow the scan window to use when attempting to connect in 0.625ms units.
+ * @param [in] minInterval The minimum connection interval in 1.25ms units.
+ * @param [in] maxInterval The maximum connection interval in 1.25ms units.
+ * @param [in] latency The number of packets allowed to skip (extends max interval).
+ * @param [in] timeout The timeout time in 10ms units before disconnecting.
+ * @param [in] scanInterval The scan interval to use when attempting to connect in 0.625ms units.
+ * @param [in] scanWindow The scan window to use when attempting to connect in 0.625ms units.
  */
 void NimBLEClient::setConnectionParams(uint16_t minInterval, uint16_t maxInterval,
                                 uint16_t latency, uint16_t timeout,
@@ -315,10 +410,10 @@ void NimBLEClient::setConnectionParams(uint16_t minInterval, uint16_t maxInterva
 /**
  * @brief Update the connection parameters:
  * * Can only be used after a connection has been established.
- * @param [in] minInterval minimum connection interval in 0.625ms units.
- * @param [in] maxInterval maximum connection interval in 0.625ms units.
- * @param [in] latency number of packets allowed to skip (extends max interval)
- * @param [in] timeout the timeout time in 10ms units before disconnecting
+ * @param [in] minInterval The minimum connection interval in 1.25ms units.
+ * @param [in] maxInterval The maximum connection interval in 1.25ms units.
+ * @param [in] latency The number of packets allowed to skip (extends max interval).
+ * @param [in] timeout The timeout time in 10ms units before disconnecting.
  */
 void NimBLEClient::updateConnParams(uint16_t minInterval, uint16_t maxInterval,
                             uint16_t latency, uint16_t timeout)
@@ -341,6 +436,24 @@ void NimBLEClient::updateConnParams(uint16_t minInterval, uint16_t maxInterval,
 } // updateConnParams
 
 
+/**
+ * @brief Get detailed information about the current peer connection.
+ */
+NimBLEConnInfo NimBLEClient::getConnInfo() {
+    NimBLEConnInfo connInfo;
+    if (!isConnected()) {
+        NIMBLE_LOGE(LOG_TAG, "Not connected");
+    } else {
+        int rc = ble_gap_conn_find(m_conn_id, &connInfo.m_desc);
+        if (rc != 0) {
+            NIMBLE_LOGE(LOG_TAG, "Connection info not found");
+        }
+    }
+
+    return connInfo;
+} // getConnInfo
+
+
 /**
  * @brief Set the timeout to wait for connection attempt to complete.
  * @param [in] time The number of seconds before timeout.
@@ -454,6 +567,16 @@ NimBLERemoteService* NimBLEClient::getService(const NimBLEUUID &uuid) {
         if(m_servicesVector.size() > prev_size) {
             return m_servicesVector.back();
         }
+
+        // If the request was successful but 16/32 bit service not found
+        // try again with the 128 bit uuid.
+        if(uuid.bitSize() == BLE_UUID_TYPE_16 ||
+           uuid.bitSize() == BLE_UUID_TYPE_32)
+        {
+            NimBLEUUID uuid128(uuid);
+            uuid128.to128();
+            return getService(uuid128);
+        }
     }
 
     NIMBLE_LOGD(LOG_TAG, "<< getService: not found");
@@ -510,7 +633,7 @@ bool NimBLEClient::retrieveServices(const NimBLEUUID *uuid_filter) {
 
     NIMBLE_LOGD(LOG_TAG, ">> retrieveServices");
 
-    if(!m_isConnected){
+    if(!isConnected()){
         NIMBLE_LOGE(LOG_TAG, "Disconnected, could not retrieve services -aborting");
         return false;
     }
@@ -618,10 +741,11 @@ std::string NimBLEClient::getValue(const NimBLEUUID &serviceUUID, const NimBLEUU
  * @param [in] serviceUUID The service that owns the characteristic.
  * @param [in] characteristicUUID The characteristic whose value we wish to write.
  * @param [in] value The value to write to the characteristic.
+ * @param [in] response If true, uses write with response operation.
  * @returns true if successful otherwise false
  */
 bool NimBLEClient::setValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID,
-                            const std::string &value)
+                            const std::string &value, bool response)
 {
     NIMBLE_LOGD(LOG_TAG, ">> setValue: serviceUUID: %s, characteristicUUID: %s",
                          serviceUUID.toString().c_str(), characteristicUUID.toString().c_str());
@@ -632,7 +756,7 @@ bool NimBLEClient::setValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &cha
     if(pService != nullptr) {
         NimBLERemoteCharacteristic* pChar = pService->getCharacteristic(characteristicUUID);
         if(pChar != nullptr) {
-            ret = pChar->writeValue(value);
+            ret = pChar->writeValue(value, response);
         }
     }
 
@@ -641,6 +765,31 @@ bool NimBLEClient::setValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &cha
 } // setValue
 
 
+/**
+ * @brief Get the remote characteristic with the specified handle.
+ * @param [in] handle The handle of the desired characteristic.
+ * @returns The matching remote characteristic, nullptr otherwise.
+ */
+NimBLERemoteCharacteristic* NimBLEClient::getCharacteristic(const uint16_t handle)
+{
+    NimBLERemoteService *pService = nullptr;
+    for(auto it = m_servicesVector.begin(); it != m_servicesVector.end(); ++it) {
+      if ((*it)->getStartHandle() <= handle && handle <= (*it)->getEndHandle()) {
+          pService = *it;
+          break;
+      }
+    }
+
+    if (pService != nullptr) {
+        for (auto it = pService->begin(); it != pService->end(); ++it) {
+            if ((*it)->getHandle() == handle) {
+                return *it;
+            }
+        }
+    }
+
+    return nullptr;
+}
 
 /**
  * @brief Get the current mtu of this connection.
@@ -656,7 +805,8 @@ uint16_t NimBLEClient::getMTU() {
  * @param [in] event The event structure sent by the NimBLE stack.
  * @param [in] arg A pointer to the client instance that registered for this callback.
  */
- /*STATIC*/ int NimBLEClient::handleGapEvent(struct ble_gap_event *event, void *arg) {
+ /*STATIC*/
+ int NimBLEClient::handleGapEvent(struct ble_gap_event *event, void *arg) {
     NimBLEClient* client = (NimBLEClient*)arg;
     int rc;
 
@@ -665,61 +815,67 @@ uint16_t NimBLEClient::getMTU() {
     switch(event->type) {
 
         case BLE_GAP_EVENT_DISCONNECT: {
-            if(!client->m_isConnected)
-                return 0;
-
-            if(client->m_conn_id != event->disconnect.conn.conn_handle)
-                return 0;
-
-            client->m_isConnected = false;
-            client->m_waitingToConnect=false;
-            // Remove the device from ignore list so we will scan it again
-            NimBLEDevice::removeIgnored(client->m_peerAddress);
-
-            NIMBLE_LOGI(LOG_TAG, "disconnect; reason=%d, %s", event->disconnect.reason,
-                                    NimBLEUtils::returnCodeToString(event->disconnect.reason));
-
+            rc = event->disconnect.reason;
             // If Host reset tell the device now before returning to prevent
             // any errors caused by calling host functions before resyncing.
-            switch(event->disconnect.reason) {
-                case BLE_HS_ETIMEOUT_HCI:
-                case BLE_HS_EOS:
+            switch(rc) {
                 case BLE_HS_ECONTROLLER:
+                case BLE_HS_ETIMEOUT_HCI:
                 case BLE_HS_ENOTSYNCED:
-                    NIMBLE_LOGC(LOG_TAG, "Disconnect - host reset, rc=%d", event->disconnect.reason);
-                    NimBLEDevice::onReset(event->disconnect.reason);
+                case BLE_HS_EOS:
+                    NIMBLE_LOGC(LOG_TAG, "Disconnect - host reset, rc=%d", rc);
+                    NimBLEDevice::onReset(rc);
                     break;
                 default:
+                    // Check that the event is for this client.
+                    if(client->m_conn_id != event->disconnect.conn.conn_handle) {
+                        return 0;
+                    }
                     break;
             }
 
-            //client->m_conn_id = BLE_HS_CONN_HANDLE_NONE;
+            // Stop the disconnect timer since we are now disconnected.
+            ble_npl_callout_stop(&client->m_dcTimer);
+
+            // Remove the device from ignore list so we will scan it again
+            NimBLEDevice::removeIgnored(client->m_peerAddress);
+
+            // No longer connected, clear the connection ID.
+            client->m_conn_id = BLE_HS_CONN_HANDLE_NONE;
+
+            // If we received a connected event but did not get established (no PDU)
+            // then a disconnect event will be sent but we should not send it to the
+            // app for processing. Instead we will ensure the task is released
+            // and report the error.
+            if(!client->m_connEstablished)
+                break;
+
+            NIMBLE_LOGI(LOG_TAG, "disconnect; reason=%d, %s",
+                        rc, NimBLEUtils::returnCodeToString(rc));
+
+            client->m_connEstablished = false;
             client->m_pClientCallbacks->onDisconnect(client);
-            rc = event->disconnect.reason;
             break;
         } // BLE_GAP_EVENT_DISCONNECT
 
         case BLE_GAP_EVENT_CONNECT: {
-
-            if(!client->m_waitingToConnect)
+            // If we aren't waiting for this connection response
+            // we should drop the connection immediately.
+            if(client->isConnected() || client->m_pTaskData == nullptr) {
+                ble_gap_terminate(event->connect.conn_handle, BLE_ERR_REM_USER_CONN_TERM);
                 return 0;
+            }
 
-            //if(client->m_conn_id != BLE_HS_CONN_HANDLE_NONE)
-            //  return 0;
-
-            client->m_waitingToConnect=false;
-
-            if (event->connect.status == 0) {
-                client->m_isConnected = true;
-
-                NIMBLE_LOGD(LOG_TAG, "Connection established");
+            rc = event->connect.status;
+            if (rc == 0) {
+                NIMBLE_LOGI(LOG_TAG, "Connected event");
 
                 client->m_conn_id = event->connect.conn_handle;
 
                 rc = ble_gattc_exchange_mtu(client->m_conn_id, NULL,NULL);
                 if(rc != 0) {
-                    NIMBLE_LOGE(LOG_TAG, "ble_gattc_exchange_mtu: rc=%d %s",rc,
-                                            NimBLEUtils::returnCodeToString(rc));
+                    NIMBLE_LOGE(LOG_TAG, "MTU exchange error; rc=%d %s",
+                                rc, NimBLEUtils::returnCodeToString(rc));
                     break;
                 }
 
@@ -727,14 +883,10 @@ uint16_t NimBLEClient::getMTU() {
                 // scanning since we are already connected to it
                 NimBLEDevice::addIgnored(client->m_peerAddress);
             } else {
-                NIMBLE_LOGE(LOG_TAG, "Error: Connection failed; status=%d %s",
-                            event->connect.status,
-                            NimBLEUtils::returnCodeToString(event->connect.status));
-
-                client->m_isConnected = false;
-                rc = event->connect.status;
+                client->m_conn_id = BLE_HS_CONN_HANDLE_NONE;
                 break;
             }
+
             return 0;
         } // BLE_GAP_EVENT_CONNECT
 
@@ -742,7 +894,14 @@ uint16_t NimBLEClient::getMTU() {
             if(client->m_conn_id != event->notify_rx.conn_handle)
                 return 0;
 
-            NIMBLE_LOGD(LOG_TAG, "Notify Recieved for handle: %d",event->notify_rx.attr_handle);
+            // If a notification comes before this flag is set we might
+            // access a vector while it is being cleared in connect()
+            if(!client->m_connEstablished) {
+                return 0;
+            }
+
+            NIMBLE_LOGD(LOG_TAG, "Notify Recieved for handle: %d",
+                        event->notify_rx.attr_handle);
 
             for(auto &it: client->m_servicesVector) {
                 // Dont waste cycles searching services without this handle in its range
@@ -752,8 +911,8 @@ uint16_t NimBLEClient::getMTU() {
 
                 auto cVector = &it->m_characteristicVector;
                 NIMBLE_LOGD(LOG_TAG, "checking service %s for handle: %d",
-                                      it->getUUID().toString().c_str(),
-                                      event->notify_rx.attr_handle);
+                            it->getUUID().toString().c_str(),
+                            event->notify_rx.attr_handle);
 
                 auto characteristic = cVector->cbegin();
                 for(; characteristic != cVector->cend(); ++characteristic) {
@@ -762,16 +921,19 @@ uint16_t NimBLEClient::getMTU() {
                 }
 
                 if(characteristic != cVector->cend()) {
-                    NIMBLE_LOGD(LOG_TAG, "Got Notification for characteristic %s", (*characteristic)->toString().c_str());
+                    NIMBLE_LOGD(LOG_TAG, "Got Notification for characteristic %s",
+                                (*characteristic)->toString().c_str());
 
+                    time_t t = time(nullptr);
                     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 = time(nullptr);
+                    (*characteristic)->m_value = std::string((char *)event->notify_rx.om->om_data,
+                                                             event->notify_rx.om->om_len);
+                    (*characteristic)->m_timestamp = t;
                     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)->toString().c_str());
                         (*characteristic)->m_notifyCallback(*characteristic, event->notify_rx.om->om_data,
                                                             event->notify_rx.om->om_len,
                                                             !event->notify_rx.indication);
@@ -790,10 +952,10 @@ uint16_t NimBLEClient::getMTU() {
             }
             NIMBLE_LOGD(LOG_TAG, "Peer requesting to update connection parameters");
             NIMBLE_LOGD(LOG_TAG, "MinInterval: %d, MaxInterval: %d, Latency: %d, Timeout: %d",
-                                    event->conn_update_req.peer_params->itvl_min,
-                                    event->conn_update_req.peer_params->itvl_max,
-                                    event->conn_update_req.peer_params->latency,
-                                    event->conn_update_req.peer_params->supervision_timeout);
+                        event->conn_update_req.peer_params->itvl_min,
+                        event->conn_update_req.peer_params->itvl_max,
+                        event->conn_update_req.peer_params->latency,
+                        event->conn_update_req.peer_params->supervision_timeout);
 
             rc = client->m_pClientCallbacks->onConnParamsUpdateRequest(client,
                                     event->conn_update_req.peer_params) ? 0 : BLE_ERR_CONN_PARMS;
@@ -827,7 +989,9 @@ uint16_t NimBLEClient::getMTU() {
                 return 0;
             }
 
-            if(event->enc_change.status == 0 || event->enc_change.status == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING)) {
+            if(event->enc_change.status == 0 ||
+               event->enc_change.status == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING))
+            {
                 struct ble_gap_conn_desc desc;
                 rc = ble_gap_conn_find(event->enc_change.conn_handle, &desc);
                 assert(rc == 0);
@@ -870,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) {
@@ -922,7 +1086,9 @@ uint16_t NimBLEClient::getMTU() {
 
     if(client->m_pTaskData != nullptr) {
         client->m_pTaskData->rc = rc;
-        xTaskNotifyGive(client->m_pTaskData->task);
+        if(client->m_pTaskData->task) {
+            xTaskNotifyGive(client->m_pTaskData->task);
+        }
         client->m_pTaskData = nullptr;
     }
 
@@ -935,7 +1101,7 @@ uint16_t NimBLEClient::getMTU() {
  * @return True if we are connected and false if we are not connected.
  */
 bool NimBLEClient::isConnected() {
-    return m_isConnected;
+    return m_conn_id != BLE_HS_CONN_HANDLE_NONE;
 } // isConnected
 
 

src/NimBLEClient.h

@@ -23,6 +23,7 @@
 #include "NimBLEAddress.h"
 #include "NimBLEUUID.h"
 #include "NimBLEUtils.h"
+#include "NimBLEConnInfo.h"
 #include "NimBLEAdvertisedDevice.h"
 #include "NimBLERemoteService.h"
 
@@ -30,6 +31,7 @@
 #include <string>
 
 class NimBLERemoteService;
+class NimBLERemoteCharacteristic;
 class NimBLEClientCallbacks;
 class NimBLEAdvertisedDevice;
 
@@ -54,7 +56,8 @@ public:
     size_t                                      deleteService(const NimBLEUUID &uuid);
     std::string                                 getValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID);
     bool                                        setValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID,
-                                                         const std::string &value);
+                                                         const std::string &value, bool response = false);
+    NimBLERemoteCharacteristic*                 getCharacteristic(const uint16_t handle);
     bool                                        isConnected();
     void                                        setClientCallbacks(NimBLEClientCallbacks *pClientCallbacks,
                                                                    bool deleteCallbacks = true);
@@ -69,6 +72,7 @@ public:
     void                                        updateConnParams(uint16_t minInterval, uint16_t maxInterval,
                                                                  uint16_t latency, uint16_t timeout);
     void                                        discoverAttributes();
+    NimBLEConnInfo                              getConnInfo();
 
 private:
     NimBLEClient(const NimBLEAddress &peerAddress);
@@ -82,16 +86,17 @@ private:
                                                 const struct ble_gatt_error *error,
                                                 const struct ble_gatt_svc *service,
                                                 void *arg);
+    static void             dcTimerCb(ble_npl_event *event);
     bool                    retrieveServices(const NimBLEUUID *uuid_filter = nullptr);
 
     NimBLEAddress           m_peerAddress;
     uint16_t                m_conn_id;
-    bool                    m_isConnected;
-    bool                    m_waitingToConnect;
+    bool                    m_connEstablished;
     bool                    m_deleteCallbacks;
     int32_t                 m_connectTimeout;
     NimBLEClientCallbacks*  m_pClientCallbacks;
-    ble_task_data_t         *m_pTaskData;
+    ble_task_data_t*        m_pTaskData;
+    ble_npl_callout         m_dcTimer;
 
     std::vector<NimBLERemoteService*> m_servicesVector;
 

src/NimBLEConnInfo.h

@@ -0,0 +1,55 @@
+#ifndef NIMBLECONNINFO_H_
+#define NIMBLECONNINFO_H_
+
+#include "NimBLEAddress.h"
+
+/**
+ * @brief Connection information.
+ */
+class NimBLEConnInfo {
+friend class NimBLEServer;
+friend class NimBLEClient;
+    ble_gap_conn_desc m_desc;
+    NimBLEConnInfo()                       { m_desc = {}; }
+    NimBLEConnInfo(ble_gap_conn_desc desc) { m_desc = desc; }
+public:
+    /** @brief Gets the over-the-air address of the connected peer */
+    NimBLEAddress    getAddress()          { return NimBLEAddress(m_desc.peer_ota_addr); }
+
+    /** @brief Gets the ID address of the connected peer */
+    NimBLEAddress    getIdAddress()        { return NimBLEAddress(m_desc.peer_id_addr); }
+
+    /** @brief Gets the connection handle of the connected peer */
+    uint16_t         getConnHandle()       { return m_desc.conn_handle; }
+
+    /** @brief Gets the connection interval for this connection (in 1.25ms units) */
+    uint16_t         getConnInterval()     { return m_desc.conn_itvl; }
+
+    /** @brief Gets the supervision timeout for this connection (in 10ms units) */
+    uint16_t         getConnTimeout()      { return m_desc.supervision_timeout; }
+
+    /** @brief Gets the allowable latency for this connection (unit = number of intervals) */
+    uint16_t         getConnLatency()      { return m_desc.conn_latency; }
+
+    /** @brief Gets the maximum transmission unit size for this connection (in bytes) */
+    uint16_t         getMTU()              { return ble_att_mtu(m_desc.conn_handle); }
+
+    /** @brief Check if we are in the master role in this connection */
+    bool             isMaster()            { return (m_desc.role == BLE_GAP_ROLE_MASTER); }
+
+    /** @brief Check if we are in the slave role in this connection */
+    bool             isSlave()             { return (m_desc.role == BLE_GAP_ROLE_SLAVE); }
+
+    /** @brief Check if we are connected to a bonded peer */
+    bool             isBonded()            { return (m_desc.sec_state.bonded == 1); }
+
+    /** @brief Check if the connection in encrypted */
+    bool             isEncrypted()         { return (m_desc.sec_state.encrypted == 1); }
+
+    /** @brief Check if the the connection has been authenticated */
+    bool             isAuthenticated()     { return (m_desc.sec_state.authenticated == 1); }
+
+    /** @brief Gets the key size used to encrypt the connection */
+    uint8_t          getSecKeySize()       { return m_desc.sec_state.key_size; }
+};
+#endif

src/NimBLEDescriptor.cpp

@@ -37,6 +37,7 @@ NimBLEDescriptor::NimBLEDescriptor(const char* uuid, uint16_t properties, uint16
 : NimBLEDescriptor(NimBLEUUID(uuid), max_len, properties, pCharacteristic) {
 }
 
+
 /**
  * @brief NimBLEDescriptor constructor.
  */
@@ -47,7 +48,7 @@ NimBLEDescriptor::NimBLEDescriptor(NimBLEUUID uuid, uint16_t properties, uint16_
     m_value.attr_len     = 0;                           // Initial length is 0.
     m_value.attr_max_len = max_len;                     // Maximum length of the data.
     m_handle             = NULL_HANDLE;                 // Handle is initially unknown.
-    m_pCharacteristic    = nullptr;                     // No initial characteristic.
+    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;
@@ -123,10 +124,26 @@ uint8_t* NimBLEDescriptor::getValue() {
 } // getValue
 
 
+/**
+ * @brief Get the value of this descriptor as a string.
+ * @return A std::string instance containing a copy of the descriptor's value.
+ */
+std::string NimBLEDescriptor::getStringValue() {
+    return std::string((char *) m_value.attr_value, m_value.attr_len);
+}
+
+
+/**
+ * @brief Get the characteristic this descriptor belongs to.
+ * @return A pointer to the characteristic this descriptor belongs to.
+ */
+NimBLECharacteristic* NimBLEDescriptor::getCharacteristic() {
+    return m_pCharacteristic;
+} // getCharacteristic
+
+
 int NimBLEDescriptor::handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
-                             struct ble_gatt_access_ctxt *ctxt,
-                             void *arg)
-{
+                                     struct ble_gatt_access_ctxt *ctxt, void *arg) {
     const ble_uuid_t *uuid;
     int rc;
     NimBLEDescriptor* pDescriptor = (NimBLEDescriptor*)arg;
@@ -163,7 +180,7 @@ int NimBLEDescriptor::handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
                     if((len + next->om_len) > pDescriptor->m_value.attr_max_len) {
                         return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
                     }
-                    memcpy(&buf[len-1], next->om_data, next->om_len);
+                    memcpy(&buf[len], next->om_data, next->om_len);
                     len += next->om_len;
                     next = SLIST_NEXT(next, om_next);
                 }
@@ -231,6 +248,14 @@ void NimBLEDescriptor::setValue(const std::string &value) {
     setValue((uint8_t*) value.data(), value.length());
 } // setValue
 
+/**
+ * @brief Set the characteristic this descriptor belongs to.
+ * @param [in] pChar A pointer to the characteristic this descriptior belongs to.
+ */
+void NimBLEDescriptor::setCharacteristic(NimBLECharacteristic* pChar) {
+    m_pCharacteristic = pChar;
+} // setCharacteristic
+
 
 /**
  * @brief Return a string representation of the descriptor.

src/NimBLEDescriptor.h

@@ -43,14 +43,29 @@ class NimBLEDescriptorCallbacks;
  */
 class NimBLEDescriptor {
 public:
-    uint16_t     getHandle();
-    size_t       getLength();
-    NimBLEUUID   getUUID();
-    uint8_t*     getValue();
-    void         setCallbacks(NimBLEDescriptorCallbacks* pCallbacks);
-    void         setValue(const uint8_t* data, size_t size);
-    void         setValue(const std::string &value);
-    std::string  toString();
+    NimBLEDescriptor(const char* uuid, uint16_t properties,
+                     uint16_t max_len,
+                     NimBLECharacteristic* pCharacteristic = nullptr);
+
+    NimBLEDescriptor(NimBLEUUID uuid, uint16_t properties,
+                     uint16_t max_len,
+                     NimBLECharacteristic* pCharacteristic = nullptr);
+
+    ~NimBLEDescriptor();
+
+    uint16_t              getHandle();
+    NimBLEUUID            getUUID();
+    std::string           toString();
+
+    void                  setCallbacks(NimBLEDescriptorCallbacks* pCallbacks);
+
+    size_t                getLength();
+    uint8_t*              getValue();
+    std::string           getStringValue();
+
+    void                  setValue(const uint8_t* data, size_t size);
+    void                  setValue(const std::string &value);
+    NimBLECharacteristic* getCharacteristic();
 
     /**
      * @brief Convenience template to set the descriptor value to <type\>val.
@@ -64,22 +79,12 @@ public:
 private:
     friend class NimBLECharacteristic;
     friend class NimBLEService;
-    friend class NimBLE2902;
     friend class NimBLE2904;
 
-    NimBLEDescriptor(const char* uuid, uint16_t properties,
-                     uint16_t max_len,
-                     NimBLECharacteristic* pCharacteristic);
-
-    NimBLEDescriptor(NimBLEUUID uuid, uint16_t properties,
-                     uint16_t max_len,
-                     NimBLECharacteristic* pCharacteristic);
-
-    ~NimBLEDescriptor();
-
     static int handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
                               struct ble_gatt_access_ctxt *ctxt, void *arg);
     void       setHandle(uint16_t handle);
+    void       setCharacteristic(NimBLECharacteristic* pChar);
 
     NimBLEUUID                 m_uuid;
     uint16_t                   m_handle;

src/NimBLEDevice.cpp

@@ -12,7 +12,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "nimconfig.h"
 #include "NimBLEDevice.h"
@@ -25,11 +25,12 @@
 #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"
 
-#ifdef ARDUINO_ARCH_ESP32
+#if defined(CONFIG_ENABLE_ARDUINO_DEPENDS) && !defined(DONT_USE_ARDUINO_BULLSHIT)
 #include "esp32-hal-bt.h"
 #endif
 
@@ -59,7 +60,11 @@ ble_gap_event_listener      NimBLEDevice::m_listener;
 std::list <NimBLEClient*>   NimBLEDevice::m_cList;
 #endif
 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;
+uint16_t                    NimBLEDevice::m_scanDuplicateSize = CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE;
+uint8_t                     NimBLEDevice::m_scanFilterMode = CONFIG_BTDM_SCAN_DUPL_TYPE;
 
 
 /**
@@ -144,8 +149,8 @@ void NimBLEDevice::stopAdvertising() {
 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 /* STATIC */ NimBLEClient* NimBLEDevice::createClient(NimBLEAddress peerAddress) {
     if(m_cList.size() >= NIMBLE_MAX_CONNECTIONS) {
-        NIMBLE_LOGW("Number of clients exceeds Max connections. Max=(%d)",
-                                            NIMBLE_MAX_CONNECTIONS);
+        NIMBLE_LOGW(LOG_TAG,"Number of clients exceeds Max connections. Cur=%d Max=%d",
+                    m_cList.size(), NIMBLE_MAX_CONNECTIONS);
     }
 
     NimBLEClient* pClient = new NimBLEClient(peerAddress);
@@ -165,26 +170,31 @@ void NimBLEDevice::stopAdvertising() {
         return false;
     }
 
+    // Set the connection established flag to false to stop notifications
+    // from accessing the attribute vectors while they are being deleted.
+    pClient->m_connEstablished = false;
     int rc =0;
 
-    if(pClient->m_isConnected) {
+    if(pClient->isConnected()) {
         rc = pClient->disconnect();
         if (rc != 0 && rc != BLE_HS_EALREADY && rc != BLE_HS_ENOTCONN) {
             return false;
         }
 
-        while(pClient->m_isConnected) {
-            vTaskDelay(10);
+        while(pClient->isConnected()) {
+            taskYIELD();
         }
-    }
+        // Since we set the flag to false the app will not get a callback
+        // in the disconnect event so we call it here for good measure.
+        pClient->m_pClientCallbacks->onDisconnect(pClient);
 
-    if(pClient->m_waitingToConnect) {
+    } else if(pClient->m_pTaskData != nullptr) {
         rc = ble_gap_conn_cancel();
         if (rc != 0 && rc != BLE_HS_EALREADY) {
             return false;
         }
-        while(pClient->m_waitingToConnect) {
-            vTaskDelay(10);
+        while(pClient->m_pTaskData != nullptr) {
+            taskYIELD();
         }
     }
 
@@ -296,7 +306,7 @@ void NimBLEDevice::stopAdvertising() {
 
 
 /**
- * @brief Set the transmission power.
+ * @brief Get the transmission power.
  * @param [in] powerType The power level to set, can be one of:
  * *   ESP_BLE_PWR_TYPE_CONN_HDL0  = 0,  For connection handle 0
  * *   ESP_BLE_PWR_TYPE_CONN_HDL1  = 1,  For connection handle 1
@@ -335,7 +345,7 @@ void NimBLEDevice::stopAdvertising() {
         default:
             return BLE_HS_ADV_TX_PWR_LVL_AUTO;
     }
-} // setPower
+} // getPower
 
 
 /**
@@ -393,6 +403,258 @@ void NimBLEDevice::stopAdvertising() {
 }
 
 
+/**
+ * @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
+ * Range is 10-1000, a larger value will reduce how often the same devices are reported.
+ * @details Must only be called before calling NimBLEDevice::init.
+ */
+/*STATIC*/
+void NimBLEDevice::setScanDuplicateCacheSize(uint16_t cacheSize) {
+    if(initialized) {
+        NIMBLE_LOGE(LOG_TAG, "Cannot change scan cache size while initialized");
+        return;
+    } else if(cacheSize > 1000 || cacheSize <10) {
+        NIMBLE_LOGE(LOG_TAG, "Invalid scan cache size; min=10 max=1000");
+        return;
+    }
+
+    m_scanDuplicateSize = cacheSize;
+}
+
+
+/**
+ * @brief Set the duplicate filter mode for filtering scanned devices.
+ * @param [in] mode One of three possible options:
+ * * CONFIG_BTDM_SCAN_DUPL_TYPE_DEVICE (0) (default)\n
+     Filter by device address only, advertisements from the same address will be reported only once.
+ * * CONFIG_BTDM_SCAN_DUPL_TYPE_DATA (1)\n
+     Filter by data only, advertisements with the same data will only be reported once,\n
+     even from different addresses.
+ * * CONFIG_BTDM_SCAN_DUPL_TYPE_DATA_DEVICE (2)\n
+     Filter by address and data, advertisements from the same address will be reported only once,\n
+     except if the data in the advertisement has changed, then it will be reported again.
+ * @details Must only be called before calling NimBLEDevice::init.
+ */
+/*STATIC*/
+void NimBLEDevice::setScanFilterMode(uint8_t mode) {
+    if(initialized) {
+        NIMBLE_LOGE(LOG_TAG, "Cannot change scan duplicate type while initialized");
+        return;
+    } else if(mode > 2) {
+        NIMBLE_LOGE(LOG_TAG, "Invalid scan duplicate type");
+        return;
+    }
+
+    m_scanFilterMode = mode;
+}
+
+#if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL) || defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+/**
+ * @brief Gets the number of bonded peers stored
+ */
+/*STATIC*/
+int NimBLEDevice::getNumBonds() {
+    ble_addr_t peer_id_addrs[MYNEWT_VAL(BLE_STORE_MAX_BONDS)];
+    int num_peers, rc;
+
+    rc = ble_store_util_bonded_peers(&peer_id_addrs[0], &num_peers, MYNEWT_VAL(BLE_STORE_MAX_BONDS));
+    if (rc !=0) {
+        return 0;
+    }
+
+    return num_peers;
+}
+
+
+/**
+ * @brief Deletes all bonding information.
+ */
+ /*STATIC*/
+void NimBLEDevice::deleteAllBonds() {
+    ble_store_clear();
+}
+
+
+/**
+ * @brief Deletes a peer bond.
+ * @param [in] address The address of the peer with which to delete bond info.
+ * @returns true on success.
+ */
+/*STATIC*/
+bool NimBLEDevice::deleteBond(const NimBLEAddress &address) {
+    ble_addr_t delAddr;
+    memcpy(&delAddr.val, address.getNative(),6);
+    delAddr.type = address.getType();
+
+    int rc = ble_gap_unpair(&delAddr);
+    if (rc != 0) {
+        return false;
+    }
+
+    return true;
+}
+
+
+/**
+ * @brief Checks if a peer device is bonded.
+ * @param [in] address The address to check for bonding.
+ * @returns true if bonded.
+ */
+/*STATIC*/
+bool NimBLEDevice::isBonded(const NimBLEAddress &address) {
+    ble_addr_t peer_id_addrs[MYNEWT_VAL(BLE_STORE_MAX_BONDS)];
+    int num_peers, rc;
+
+    rc = ble_store_util_bonded_peers(&peer_id_addrs[0], &num_peers, MYNEWT_VAL(BLE_STORE_MAX_BONDS));
+    if (rc != 0) {
+        return false;
+    }
+
+    for (int i = 0; i < num_peers; i++) {
+        NimBLEAddress storedAddr(peer_id_addrs[i]);
+        if(storedAddr == address) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+/**
+ * @brief Get the address of a bonded peer device by index.
+ * @param [in] index The index to retrieve the peer address of.
+ * @returns NimBLEAddress of the found bonded peer or nullptr if not found.
+ */
+/*STATIC*/
+NimBLEAddress NimBLEDevice::getBondedAddress(int index) {
+    ble_addr_t peer_id_addrs[MYNEWT_VAL(BLE_STORE_MAX_BONDS)];
+    int num_peers, rc;
+
+    rc = ble_store_util_bonded_peers(&peer_id_addrs[0], &num_peers, MYNEWT_VAL(BLE_STORE_MAX_BONDS));
+    if (rc != 0) {
+        return nullptr;
+    }
+
+    if (index > num_peers || index < 0) {
+        return nullptr;
+    }
+
+    return NimBLEAddress(peer_id_addrs[index]);
+}
+#endif
+
+/**
+ * @brief Checks if a peer device is whitelisted.
+ * @param [in] address The address to check for in the whitelist.
+ * @returns true if the address is in the whitelist.
+ */
+bool NimBLEDevice::onWhiteList(const NimBLEAddress & address) {
+    for (auto &it : m_whiteList) {
+        if (it == address) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+/**
+ * @brief Add a peer address to the whitelist.
+ * @param [in] address The address to add to the whitelist.
+ * @returns true if successful.
+ */
+bool NimBLEDevice::whiteListAdd(const NimBLEAddress & address) {
+    if (NimBLEDevice::onWhiteList(address)) {
+        return true;
+    }
+
+    m_whiteList.push_back(address);
+    std::vector<ble_addr_t> wlVec;
+    wlVec.reserve(m_whiteList.size());
+
+    for (auto &it : m_whiteList) {
+        ble_addr_t wlAddr;
+        memcpy(&wlAddr.val, it.getNative(), 6);
+        wlAddr.type = it.getType();
+        wlVec.push_back(wlAddr);
+    }
+
+    int rc = ble_gap_wl_set(&wlVec[0], wlVec.size());
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Failed adding to whitelist rc=%d", rc);
+        return false;
+    }
+
+    return true;
+}
+
+
+/**
+ * @brief Remove a peer address from the whitelist.
+ * @param [in] address The address to remove from the whitelist.
+ * @returns true if successful.
+ */
+bool NimBLEDevice::whiteListRemove(const NimBLEAddress & address) {
+    if (!NimBLEDevice::onWhiteList(address)) {
+        return true;
+    }
+
+    std::vector<ble_addr_t> wlVec;
+    wlVec.reserve(m_whiteList.size());
+
+    for (auto &it : m_whiteList) {
+        if (it != address) {
+            ble_addr_t wlAddr;
+            memcpy(&wlAddr.val, it.getNative(), 6);
+            wlAddr.type = it.getType();
+            wlVec.push_back(wlAddr);
+        }
+    }
+
+    int rc = ble_gap_wl_set(&wlVec[0], wlVec.size());
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Failed removing from whitelist rc=%d", rc);
+        return false;
+    }
+
+    // Don't remove from the list unless NimBLE returned success
+    for (auto it = m_whiteList.begin(); it < m_whiteList.end(); ++it) {
+        if ((*it) == address) {
+            m_whiteList.erase(it);
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+/**
+ * @brief Gets the count of addresses in the whitelist.
+ * @returns The number of addresses in the whitelist.
+ */
+size_t NimBLEDevice::getWhiteListCount() {
+    return m_whiteList.size();
+}
+
+
+/**
+ * @brief Gets the address at the vector index.
+ * @param [in] index The vector index to retrieve the address from.
+ * @returns the NimBLEAddress at the whitelist index or nullptr if not found.
+ */
+NimBLEAddress NimBLEDevice::getWhiteListAddress(size_t index) {
+    if (index > m_whiteList.size()) {
+        NIMBLE_LOGE(LOG_TAG, "Invalid index; %u", index);
+        return nullptr;
+    }
+    return m_whiteList[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.
@@ -405,30 +667,16 @@ void NimBLEDevice::stopAdvertising() {
 
     m_synced = false;
 
-#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
-    if(m_pScan != nullptr) {
-        m_pScan->onHostReset();
-    }
-#endif
-
-/*  Not needed
-    if(m_pServer != nullptr) {
-        m_pServer->onHostReset();
-    }
-
-    for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
-        (*it)->onHostReset();
-    }
-*/
-
-#if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
-    if(m_bleAdvertising != nullptr) {
-        m_bleAdvertising->onHostReset();
-    }
-#endif
-
     NIMBLE_LOGC(LOG_TAG, "Resetting state; reason=%d, %s", reason,
                         NimBLEUtils::returnCodeToString(reason));
+
+#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+    if(initialized) {
+        if(m_pScan != nullptr) {
+            m_pScan->onHostReset();
+        }
+    }
+#endif
 } // onReset
 
 
@@ -448,20 +696,22 @@ void NimBLEDevice::stopAdvertising() {
     int rc = ble_hs_util_ensure_addr(0);
     assert(rc == 0);
 
+    // Yield for houskeeping before returning to operations.
+    // Occasionally triggers exception without.
+    taskYIELD();
+
     m_synced = true;
 
     if(initialized) {
 #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
         if(m_pScan != nullptr) {
-            // Restart scanning with the last values sent, allow to clear results.
-            m_pScan->start(m_pScan->m_duration, m_pScan->m_scanCompleteCB);
+            m_pScan->onHostSync();
         }
 #endif
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
         if(m_bleAdvertising != nullptr) {
-            // Restart advertisng, parameters should already be set.
-            m_bleAdvertising->start();
+            m_bleAdvertising->onHostSync();
         }
 #endif
     }
@@ -490,7 +740,7 @@ void NimBLEDevice::stopAdvertising() {
         int rc=0;
         esp_err_t errRc = ESP_OK;
 
-#ifdef ARDUINO_ARCH_ESP32
+#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
@@ -504,8 +754,17 @@ void NimBLEDevice::stopAdvertising() {
 
         ESP_ERROR_CHECK(errRc);
 
-        ESP_ERROR_CHECK(esp_nimble_hci_and_controller_init());
+        esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT);
 
+        esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+        bt_cfg.mode = ESP_BT_MODE_BLE;
+        bt_cfg.ble_max_conn = CONFIG_BT_NIMBLE_MAX_CONNECTIONS;
+        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());
         nimble_port_init();
 
         // Setup callbacks for host events
@@ -524,6 +783,8 @@ void NimBLEDevice::stopAdvertising() {
 
         // 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();
@@ -549,10 +810,12 @@ void NimBLEDevice::stopAdvertising() {
     if (ret == 0) {
         nimble_port_deinit();
 
+#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;
@@ -705,6 +968,35 @@ void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
 } // setSecurityCallbacks
 
 
+/**
+ * @brief Set the own address type.
+ * @param [in] own_addr_type Own Bluetooth Device address type.\n
+ * The available bits are defined as:
+ * * 0x00: BLE_OWN_ADDR_PUBLIC
+ * * 0x01: BLE_OWN_ADDR_RANDOM
+ * * 0x02: BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT
+ * * 0x03: BLE_OWN_ADDR_RPA_RANDOM_DEFAULT
+ * @param [in] useNRPA If true, and address type is random, uses a non-resolvable random address.
+ */
+void NimBLEDevice::setOwnAddrType(uint8_t own_addr_type, bool useNRPA) {
+    m_own_addr_type = own_addr_type;
+    switch (own_addr_type) {
+        case BLE_OWN_ADDR_PUBLIC:
+            ble_hs_pvcy_rpa_config(NIMBLE_HOST_DISABLE_PRIVACY);
+            break;
+        case BLE_OWN_ADDR_RANDOM:
+            setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+            ble_hs_pvcy_rpa_config(useNRPA ? NIMBLE_HOST_ENABLE_NRPA : NIMBLE_HOST_ENABLE_RPA);
+            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);
+            ble_hs_pvcy_rpa_config(NIMBLE_HOST_ENABLE_RPA);
+            break;
+    }
+} // setOwnAddrType
+
+
 /**
  * @brief Start the connection securing and authorization for this connection.
  * @param conn_id The connection id of the peer device.

src/NimBLEDevice.h

@@ -15,7 +15,7 @@
 #ifndef MAIN_NIMBLEDEVICE_H_
 #define MAIN_NIMBLEDEVICE_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "nimconfig.h"
 
@@ -95,6 +95,11 @@ public:
     static bool             getInitialized();
     static NimBLEAddress    getAddress();
     static std::string      toString();
+    static bool             whiteListAdd(const NimBLEAddress & address);
+    static bool             whiteListRemove(const NimBLEAddress & address);
+    static bool             onWhiteList(const NimBLEAddress & address);
+    static size_t           getWhiteListCount();
+    static NimBLEAddress    getWhiteListAddress(size_t index);
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
     static NimBLEScan*      getScan();
@@ -116,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();
@@ -139,6 +147,14 @@ public:
     static std::list<NimBLEClient*>* getClientList();
 #endif
 
+#if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL) || defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+    static bool             deleteBond(const NimBLEAddress &address);
+    static int              getNumBonds();
+    static bool             isBonded(const NimBLEAddress &address);
+    static void             deleteAllBonds();
+    static NimBLEAddress    getBondedAddress(int index);
+#endif
+
 private:
 #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
     friend class NimBLEClient;
@@ -182,6 +198,10 @@ private:
     static uint32_t                   m_passkey;
     static ble_gap_event_listener     m_listener;
     static gap_event_handler          m_customGapHandler;
+    static uint8_t                    m_own_addr_type;
+    static uint16_t                   m_scanDuplicateSize;
+    static uint8_t                    m_scanFilterMode;
+    static std::vector<NimBLEAddress> m_whiteList;
 };
 
 

src/NimBLEEddystoneTLM.cpp

@@ -12,7 +12,7 @@
  *      Author: pcbreflux
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "NimBLEEddystoneTLM.h"
 #include "NimBLELog.h"
@@ -124,30 +124,30 @@ std::string NimBLEEddystoneTLM::toString() {
   out += " C\n";
 
   out += "Adv. Count ";
-  snprintf(val, sizeof(val), "%d", 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), "%d", rawsec/10);
+  snprintf(val, sizeof(val), "%lu", rawsec/10);
   out += val;
   out += "\n";
 
   out += "Time ";
 
-  snprintf(val, sizeof(val), "%04d", rawsec / 864000);
+  snprintf(val, sizeof(val), "%04lu", rawsec / 864000);
   out += val;
   out += ".";
 
-  snprintf(val, sizeof(val), "%02d", (rawsec / 36000) % 24);
+  snprintf(val, sizeof(val), "%02lu", (rawsec / 36000) % 24);
   out += val;
   out += ":";
 
-  snprintf(val, sizeof(val), "%02d", (rawsec / 600) % 60);
+  snprintf(val, sizeof(val), "%02lu", (rawsec / 600) % 60);
   out += val;
   out += ":";
 
-  snprintf(val, sizeof(val), "%02d", (rawsec / 10) % 60);
+  snprintf(val, sizeof(val), "%02lu", (rawsec / 10) % 60);
   out += val;
   out += "\n";
 

src/NimBLEEddystoneTLM.h

@@ -14,6 +14,8 @@
 
 #ifndef _NimBLEEddystoneTLM_H_
 #define _NimBLEEddystoneTLM_H_
+
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 #include "NimBLEUUID.h"
 
 #include <string>
@@ -57,4 +59,5 @@ private:
 
 }; // NimBLEEddystoneTLM
 
+#endif
 #endif /* _NimBLEEddystoneTLM_H_ */

src/NimBLEEddystoneURL.cpp

@@ -12,7 +12,7 @@
  *      Author: pcbreflux
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "NimBLEEddystoneURL.h"
 #include "NimBLELog.h"

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_ */

src/NimBLEHIDDevice.cpp

@@ -0,0 +1,251 @@
+/*
+ * NimBLEHIDDevice.cpp
+ *
+ *  Created: on Oct 06 2020
+ *      Author wakwak-koba
+ *
+ * Originally:
+ *
+ * BLEHIDDevice.cpp
+ *
+ *  Created on: Jan 03, 2018
+ *      Author: chegewara
+ */
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+
+#include "NimBLEHIDDevice.h"
+#include "NimBLE2904.h"
+
+/**
+ * @brief Construct a default NimBLEHIDDevice object.
+ * @param [in] server A pointer to the server instance this HID Device will use.
+ */
+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), 40);
+	m_batteryService = server->createService(NimBLEUUID((uint16_t) 0x180f));
+
+	/*
+	 * Mandatory characteristic for device info service
+	 */
+	m_pnpCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t) 0x2a50, NIMBLE_PROPERTY::READ);
+
+	/*
+	 * Mandatory characteristics for HID service
+	 */
+	m_hidInfoCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4a, NIMBLE_PROPERTY::READ);
+	m_reportMapCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4b, NIMBLE_PROPERTY::READ);
+	m_hidControlCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4c, NIMBLE_PROPERTY::WRITE_NR);
+	m_protocolModeCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4e, NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ);
+
+	/*
+	 * Mandatory battery level characteristic with notification and presence descriptor
+	 */
+	m_batteryLevelCharacteristic = m_batteryService->createCharacteristic((uint16_t) 0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
+	NimBLE2904* batteryLevelDescriptor = (NimBLE2904*)m_batteryLevelCharacteristic->createDescriptor((uint16_t) 0x2904);
+	batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
+	batteryLevelDescriptor->setNamespace(1);
+	batteryLevelDescriptor->setUnit(0x27ad);
+
+	/*
+	 * This value is setup here because its default value in most usage cases, its very rare to use boot mode
+	 * and we want to simplify library using as much as possible
+	 */
+	const uint8_t pMode[] = { 0x01 };
+	protocolMode()->setValue((uint8_t*) pMode, 1);
+}
+
+NimBLEHIDDevice::~NimBLEHIDDevice() {
+}
+
+/**
+ * @brief Set the report map data formatting information.
+ * @param [in] map A pointer to an array with the values to set.
+ * @param [in] size The number of values in the array.
+ */
+void NimBLEHIDDevice::reportMap(uint8_t* map, uint16_t size) {
+	m_reportMapCharacteristic->setValue(map, size);
+}
+
+/**
+ * @brief Start the HID device services.\n
+ * This function called when all the services have been created.
+ */
+void NimBLEHIDDevice::startServices() {
+	m_deviceInfoService->start();
+	m_hidService->start();
+	m_batteryService->start();
+}
+
+/**
+ * @brief Create a manufacturer characteristic (this characteristic is optional).
+ */
+NimBLECharacteristic* NimBLEHIDDevice::manufacturer() {
+	m_manufacturerCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t) 0x2a29, NIMBLE_PROPERTY::READ);
+	return m_manufacturerCharacteristic;
+}
+
+/**
+ * @brief Set manufacturer name
+ * @param [in] name The manufacturer name of this HID device.
+ */
+void NimBLEHIDDevice::manufacturer(std::string name) {
+	m_manufacturerCharacteristic->setValue(name);
+}
+
+/**
+ * @brief Sets the Plug n Play characterisc value.
+ * @param [in] sig The vendor ID source number.
+ * @param [in] vid The vendor ID number.
+ * @param [in] pid The product ID number.
+ * @param [in] version The produce version number.
+ */
+void NimBLEHIDDevice::pnp(uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version) {
+	uint8_t pnp[] = { sig, (uint8_t) (vid >> 8), (uint8_t) vid, (uint8_t) (pid >> 8), (uint8_t) pid, (uint8_t) (version >> 8), (uint8_t) version };
+	m_pnpCharacteristic->setValue(pnp, sizeof(pnp));
+}
+
+/**
+ * @brief Sets the HID Information characteristic value.
+ * @param [in] country The country code for the device.
+ * @param [in] flags The HID Class Specification release number to use.
+ */
+void NimBLEHIDDevice::hidInfo(uint8_t country, uint8_t flags) {
+	uint8_t info[] = { 0x11, 0x1, country, flags };
+	m_hidInfoCharacteristic->setValue(info, sizeof(info));
+}
+
+/**
+ * @brief Create input report characteristic
+ * @param [in] reportID input report ID, the same as in report map for input object related to the characteristic
+ * @return pointer to new input report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::inputReport(uint8_t reportID) {
+	NimBLECharacteristic* inputReportCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4d, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ_ENC);
+	NimBLEDescriptor* inputReportDescriptor = inputReportCharacteristic->createDescriptor((uint16_t) 0x2908, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC);
+
+	uint8_t desc1_val[] = { reportID, 0x01 };
+	inputReportDescriptor->setValue((uint8_t*) desc1_val, 2);
+
+	return inputReportCharacteristic;
+}
+
+/**
+ * @brief Create output report characteristic
+ * @param [in] reportID Output report ID, the same as in report map for output object related to the characteristic
+ * @return Pointer to new output report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::outputReport(uint8_t reportID) {
+	NimBLECharacteristic* outputReportCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4d, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+	NimBLEDescriptor* outputReportDescriptor = outputReportCharacteristic->createDescriptor((uint16_t) 0x2908, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+
+	uint8_t desc1_val[] = { reportID, 0x02 };
+	outputReportDescriptor->setValue((uint8_t*) desc1_val, 2);
+
+	return outputReportCharacteristic;
+}
+
+/**
+ * @brief Create feature report characteristic.
+ * @param [in] reportID Feature report ID, the same as in report map for feature object related to the characteristic
+ * @return Pointer to new feature report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::featureReport(uint8_t reportID) {
+	NimBLECharacteristic* featureReportCharacteristic = m_hidService->createCharacteristic((uint16_t) 0x2a4d, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+	NimBLEDescriptor* featureReportDescriptor = featureReportCharacteristic->createDescriptor((uint16_t) 0x2908, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
+
+	uint8_t desc1_val[] = { reportID, 0x03 };
+	featureReportDescriptor->setValue((uint8_t*) desc1_val, 2);
+
+	return featureReportCharacteristic;
+}
+
+/**
+ * @brief Creates a keyboard boot input report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::bootInput() {
+	return m_hidService->createCharacteristic((uint16_t) 0x2a22, NIMBLE_PROPERTY::NOTIFY);
+}
+
+/**
+ * @brief Create a keyboard boot output report characteristic
+ */
+NimBLECharacteristic* NimBLEHIDDevice::bootOutput() {
+	return m_hidService->createCharacteristic((uint16_t) 0x2a32, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR);
+}
+
+/**
+ * @brief Returns a pointer to the HID control point characteristic.
+ */
+NimBLECharacteristic* NimBLEHIDDevice::hidControl() {
+	return m_hidControlCharacteristic;
+}
+
+/**
+ * @brief Returns a pointer to the protocol mode characteristic.
+ */
+NimBLECharacteristic* NimBLEHIDDevice::protocolMode() {
+	return m_protocolModeCharacteristic;
+}
+
+/**
+ * @brief Set the battery level characteristic value.
+ * @param [in] level The battery level value.
+ */
+void NimBLEHIDDevice::setBatteryLevel(uint8_t level) {
+	m_batteryLevelCharacteristic->setValue(&level, 1);
+}
+/*
+ * @brief Returns battery level characteristic
+ * @ return battery level characteristic
+ *//*
+BLECharacteristic* BLEHIDDevice::batteryLevel() {
+	return m_batteryLevelCharacteristic;
+}
+
+
+
+BLECharacteristic*	 BLEHIDDevice::reportMap() {
+	return m_reportMapCharacteristic;
+}
+
+BLECharacteristic*	 BLEHIDDevice::pnp() {
+	return m_pnpCharacteristic;
+}
+
+
+BLECharacteristic*	BLEHIDDevice::hidInfo() {
+	return m_hidInfoCharacteristic;
+}
+*/
+
+/**
+ * @brief Returns a pointer to the device information service.
+ */
+NimBLEService* NimBLEHIDDevice::deviceInfo() {
+	return m_deviceInfoService;
+}
+
+/**
+ * @brief Returns a pointer to the HID service.
+ */
+NimBLEService* NimBLEHIDDevice::hidService() {
+	return m_hidService;
+}
+
+/**
+ * @brief @brief Returns a pointer to the battery service.
+ */
+NimBLEService* NimBLEHIDDevice::batteryService() {
+	return m_batteryService;
+}
+
+#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#endif // #if defined(CONFIG_BT_ENABLED)

src/NimBLEHIDDevice.h

@@ -0,0 +1,89 @@
+/*
+ * NimBLEHIDDevice.h
+ *
+ *  Created: on Oct 06 2020
+ *      Author wakwak-koba
+ *
+ * Originally:
+ *
+ * BLEHIDDevice.h
+ *
+ *  Created on: Jan 03, 2018
+ *      Author: chegewara
+ */
+
+#ifndef _BLEHIDDEVICE_H_
+#define _BLEHIDDEVICE_H_
+
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+
+#include "NimBLECharacteristic.h"
+#include "NimBLEService.h"
+#include "NimBLEDescriptor.h"
+#include "HIDTypes.h"
+
+#define GENERIC_HID		0x03C0
+#define HID_KEYBOARD	   0x03C1
+#define HID_MOUSE		  0x03C2
+#define HID_JOYSTICK	   0x03C3
+#define HID_GAMEPAD		0x03C4
+#define HID_TABLET		 0x03C5
+#define HID_CARD_READER	0x03C6
+#define HID_DIGITAL_PEN	0x03C7
+#define HID_BARCODE		0x03C8
+
+
+/**
+ * @brief A model of a %BLE Human Interface Device.
+ */
+class NimBLEHIDDevice {
+public:
+	NimBLEHIDDevice(NimBLEServer*);
+	virtual ~NimBLEHIDDevice();
+
+	void reportMap(uint8_t* map, uint16_t);
+	void startServices();
+
+	NimBLEService* deviceInfo();
+	NimBLEService* hidService();
+	NimBLEService* batteryService();
+
+	NimBLECharacteristic* 	manufacturer();
+	void 	manufacturer(std::string name);
+	//NimBLECharacteristic* 	pnp();
+	void	pnp(uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version);
+	//NimBLECharacteristic*	hidInfo();
+	void	hidInfo(uint8_t country, uint8_t flags);
+	//NimBLECharacteristic* 	batteryLevel();
+	void 	setBatteryLevel(uint8_t level);
+
+
+	//NimBLECharacteristic* 	reportMap();
+	NimBLECharacteristic* 	hidControl();
+	NimBLECharacteristic* 	inputReport(uint8_t reportID);
+	NimBLECharacteristic* 	outputReport(uint8_t reportID);
+	NimBLECharacteristic* 	featureReport(uint8_t reportID);
+	NimBLECharacteristic* 	protocolMode();
+	NimBLECharacteristic* 	bootInput();
+	NimBLECharacteristic* 	bootOutput();
+
+private:
+	NimBLEService*			m_deviceInfoService;			//0x180a
+	NimBLEService*			m_hidService;					//0x1812
+	NimBLEService*			m_batteryService = 0;			//0x180f
+
+	NimBLECharacteristic* 	m_manufacturerCharacteristic;	//0x2a29
+	NimBLECharacteristic* 	m_pnpCharacteristic;			//0x2a50
+	NimBLECharacteristic* 	m_hidInfoCharacteristic;		//0x2a4a
+	NimBLECharacteristic* 	m_reportMapCharacteristic;		//0x2a4b
+	NimBLECharacteristic* 	m_hidControlCharacteristic;		//0x2a4c
+	NimBLECharacteristic* 	m_protocolModeCharacteristic;	//0x2a4e
+	NimBLECharacteristic*	m_batteryLevelCharacteristic;	//0x2a19
+};
+#endif // CONFIG_BT_NIMBLE_ROLE_BROADCASTER
+#endif // CONFIG_BT_ENABLED
+#endif /* _BLEHIDDEVICE_H_ */

src/NimBLELog.h

@@ -7,17 +7,17 @@
  */
 #ifndef MAIN_NIMBLELOG_H_
 #define MAIN_NIMBLELOG_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
+#include "sdkconfig.h"
+
+#if defined(ARDUINO_ARCH_ESP32) && !defined(DONT_USE_ARDUINO_BULLSHIT)
 #include "syscfg/syscfg.h"
 #include "modlog/modlog.h"
 
-
 // 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.
-#ifdef ARDUINO_ARCH_ESP32
+
 #ifndef CORE_DEBUG_LEVEL
 #define CORE_DEBUG_LEVEL CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
 #endif
@@ -49,12 +49,15 @@
 #define NIMBLE_LOGC( tag, format, ... ) MODLOG_DFLT(CRITICAL,   "CRIT %s: "#format"\n",tag,##__VA_ARGS__)
 
 #else
-#define NIMBLE_LOGE( tag, format, ... ) MODLOG_DFLT(ERROR,      "\033[0;31mE %s: "#format"\033[0m\n",tag,##__VA_ARGS__)
-#define NIMBLE_LOGW( tag, format, ... ) MODLOG_DFLT(WARN,       "\033[0;33mW %s: "#format"\033[0m\n",tag,##__VA_ARGS__)
-#define NIMBLE_LOGI( tag, format, ... ) MODLOG_DFLT(INFO,       "\033[0;32mI %s: "#format"\033[0m\n",tag,##__VA_ARGS__)
-#define NIMBLE_LOGD( tag, format, ... ) MODLOG_DFLT(DEBUG,      "D %s: "#format"\n",tag,##__VA_ARGS__)
-#define NIMBLE_LOGC( tag, format, ... ) MODLOG_DFLT(CRITICAL,   "\033[1;31mCRIT %s: "#format"\033[0m\n",tag,##__VA_ARGS__)
+
+#include "esp_log.h"
+
+#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__)
+
 #endif /*ARDUINO_ARCH_ESP32*/
 
-#endif /*CONFIG_BT_ENABLED*/
 #endif /*MAIN_NIMBLELOG_H_*/

src/NimBLERemoteCharacteristic.cpp

@@ -38,7 +38,7 @@ static const char* LOG_TAG = "NimBLERemoteCharacteristic";
  NimBLERemoteCharacteristic::NimBLERemoteCharacteristic(NimBLERemoteService *pRemoteService,
                                                         const struct ble_gatt_chr *chr)
 {
-
+    NIMBLE_LOGD(LOG_TAG, ">> NimBLERemoteCharacteristic()");
      switch (chr->uuid.u.type) {
         case BLE_UUID_TYPE_16:
             m_uuid = NimBLEUUID(chr->uuid.u16.value);
@@ -50,17 +50,19 @@ static const char* LOG_TAG = "NimBLERemoteCharacteristic";
             m_uuid = NimBLEUUID(const_cast<ble_uuid128_t*>(&chr->uuid.u128));
             break;
         default:
-            m_uuid = nullptr;
             break;
     }
 
     m_handle             = chr->val_handle;
     m_defHandle          = chr->def_handle;
+    m_endHandle          = 0;
     m_charProp           = chr->properties;
     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
 
 
@@ -145,31 +147,25 @@ int NimBLERemoteCharacteristic::descriptorDiscCB(uint16_t conn_handle,
                                     const struct ble_gatt_dsc *dsc,
                                     void *arg)
 {
-    NIMBLE_LOGD(LOG_TAG,"Descriptor Discovered >> status: %d handle: %d",
-                        error->status, (error->status == 0) ? dsc->handle : -1);
+    int rc = error->status;
+    NIMBLE_LOGD(LOG_TAG, "Descriptor Discovered >> status: %d handle: %d",
+                         rc, (rc == 0) ? dsc->handle : -1);
 
     desc_filter_t *filter = (desc_filter_t*)arg;
     const NimBLEUUID *uuid_filter = filter->uuid;
     ble_task_data_t *pTaskData = (ble_task_data_t*)filter->task_data;
     NimBLERemoteCharacteristic *characteristic = (NimBLERemoteCharacteristic*)pTaskData->pATT;
-    int rc=0;
 
-    if(characteristic->getRemoteService()->getClient()->getConnId() != conn_handle){
+    if (characteristic->getRemoteService()->getClient()->getConnId() != conn_handle){
         return 0;
     }
 
-    switch (error->status) {
+    switch (rc) {
         case 0: {
-            if(dsc->uuid.u.type == BLE_UUID_TYPE_16 && dsc->uuid.u16.value == uint16_t(0x2803)) {
-                NIMBLE_LOGD(LOG_TAG,"Descriptor NOT found - end of Characteristic definintion");
-                rc = BLE_HS_EDONE;
-                break;
-            }
-            if(uuid_filter != nullptr) {
-                if(ble_uuid_cmp(&uuid_filter->getNative()->u, &dsc->uuid.u) != 0) {
+            if (uuid_filter != nullptr) {
+                if (ble_uuid_cmp(&uuid_filter->getNative()->u, &dsc->uuid.u) != 0) {
                     return 0;
                 } else {
-                    NIMBLE_LOGD(LOG_TAG,"Descriptor Found");
                     rc = BLE_HS_EDONE;
                 }
             }
@@ -179,11 +175,10 @@ int NimBLERemoteCharacteristic::descriptorDiscCB(uint16_t conn_handle,
             break;
         }
         default:
-            rc = error->status;
             break;
     }
 
-    /** If rc == BLE_HS_EDONE, resume the task with a success error code and stop the discovery process.
+    /*  If rc == BLE_HS_EDONE, resume the task with a success error code and stop the discovery process.
      *  Else if rc == 0, just return 0 to continue the discovery until we get BLE_HS_EDONE.
      *  If we get any other error code tell the application to abort by returning non-zero in the rc.
      */
@@ -201,6 +196,38 @@ int NimBLERemoteCharacteristic::descriptorDiscCB(uint16_t conn_handle,
 }
 
 
+/**
+ * @brief callback from NimBLE when the next characteristic of the service is discovered.
+ */
+int NimBLERemoteCharacteristic::nextCharCB(uint16_t conn_handle,
+                                           const struct ble_gatt_error *error,
+                                           const struct ble_gatt_chr *chr, void *arg)
+{
+    int rc = error->status;
+    NIMBLE_LOGD(LOG_TAG, "Next Characteristic >> status: %d handle: %d",
+                         rc, (rc == 0) ? chr->val_handle : -1);
+
+    ble_task_data_t *pTaskData = (ble_task_data_t*)arg;
+    NimBLERemoteCharacteristic *pChar = (NimBLERemoteCharacteristic*)pTaskData->pATT;
+
+    if (pChar->getRemoteService()->getClient()->getConnId() != conn_handle) {
+        return 0;
+    }
+
+    if (rc == 0) {
+        pChar->m_endHandle = chr->def_handle - 1;
+        rc = BLE_HS_EDONE;
+    } else if (rc == BLE_HS_EDONE) {
+        pChar->m_endHandle = pChar->getRemoteService()->getEndHandle();
+    } else {
+        pTaskData->rc = rc;
+    }
+
+    xTaskNotifyGive(pTaskData->task);
+    return rc;
+}
+
+
 /**
  * @brief Populate the descriptors (if any) for this characteristic.
  * @param [in] the end handle of the characteristic, or the service, whichever comes first.
@@ -208,29 +235,58 @@ int NimBLERemoteCharacteristic::descriptorDiscCB(uint16_t conn_handle,
 bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID *uuid_filter) {
     NIMBLE_LOGD(LOG_TAG, ">> retrieveDescriptors() for characteristic: %s", getUUID().toString().c_str());
 
+    // If this is the last handle then there are no descriptors
+    if (m_handle == getRemoteService()->getEndHandle()) {
+        return true;
+    }
+
     int rc = 0;
     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.
+    if (m_endHandle == 0) {
+        rc = ble_gattc_disc_all_chrs(getRemoteService()->getClient()->getConnId(),
+                                     m_handle,
+                                     getRemoteService()->getEndHandle(),
+                                     NimBLERemoteCharacteristic::nextCharCB,
+                                     &taskData);
+        if (rc != 0) {
+            NIMBLE_LOGE(LOG_TAG, "Error getting end handle rc=%d", rc);
+            return false;
+        }
+
+        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+        if (taskData.rc != 0) {
+            NIMBLE_LOGE(LOG_TAG, "Could not retrieve end handle rc=%d", taskData.rc);
+            return false;
+        }
+    }
+
     desc_filter_t filter = {uuid_filter, &taskData};
 
     rc = ble_gattc_disc_all_dscs(getRemoteService()->getClient()->getConnId(),
                                  m_handle,
-                                 getRemoteService()->getEndHandle(),
+                                 m_endHandle,
                                  NimBLERemoteCharacteristic::descriptorDiscCB,
                                  &filter);
+
     if (rc != 0) {
-        NIMBLE_LOGE(LOG_TAG, "ble_gattc_disc_all_chrs: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
+        NIMBLE_LOGE(LOG_TAG, "ble_gattc_disc_all_dscs: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
         return false;
     }
 
     ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
 
-    if(taskData.rc != 0) {
-        return false;
+    if (taskData.rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Failed to retrieve descriptors; startHandle:%d endHandle:%d taskData.rc=%d",
+                             m_handle, m_endHandle, taskData.rc);
     }
 
-    return true;
     NIMBLE_LOGD(LOG_TAG, "<< retrieveDescriptors(): Found %d descriptors.", m_descriptorVector.size());
-} // getDescriptors
+    return (taskData.rc == 0);
+} // retrieveDescriptors
 
 
 /**
@@ -243,7 +299,7 @@ NimBLERemoteDescriptor* NimBLERemoteCharacteristic::getDescriptor(const NimBLEUU
 
     for(auto &it: m_descriptorVector) {
         if(it->getUUID() == uuid) {
-            NIMBLE_LOGD(LOG_TAG, "<< getDescriptor: found");
+            NIMBLE_LOGD(LOG_TAG, "<< getDescriptor: found the descriptor with uuid: %s", uuid.toString().c_str());
             return it;
         }
     }
@@ -253,7 +309,18 @@ NimBLERemoteDescriptor* NimBLERemoteCharacteristic::getDescriptor(const NimBLEUU
         if(m_descriptorVector.size() > prev_size) {
             return m_descriptorVector.back();
         }
+
+        // If the request was successful but 16/32 bit descriptor not found
+        // try again with the 128 bit uuid.
+        if(uuid.bitSize() == BLE_UUID_TYPE_16 ||
+           uuid.bitSize() == BLE_UUID_TYPE_32)
+        {
+            NimBLEUUID uuid128(uuid);
+            uuid128.to128();
+            return getDescriptor(uuid128);
+        }
     }
+
     NIMBLE_LOGD(LOG_TAG, "<< getDescriptor: Not found");
     return nullptr;
 } // getDescriptor
@@ -447,9 +514,10 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
         }
     } while(rc != 0 && retryCount--);
 
+    time_t t = time(nullptr);
     portENTER_CRITICAL(&m_valMux);
     m_value = value;
-    m_timestamp = time(nullptr);
+    m_timestamp = t;
     if(timestamp != nullptr) {
         *timestamp = m_timestamp;
     }
@@ -506,19 +574,19 @@ int NimBLERemoteCharacteristic::onReadCB(uint16_t conn_handle,
  * @param [in] notifyCallback A callback to be invoked for a notification.
  * @param [in] response If write response required set this to true.
  * If NULL is provided then no callback is performed.
- * @return true if successful.
+ * @return false if writing to the descriptor failed.
  */
 bool NimBLERemoteCharacteristic::setNotify(uint16_t val, notify_callback notifyCallback, bool response) {
     NIMBLE_LOGD(LOG_TAG, ">> setNotify(): %s, %02x", toString().c_str(), val);
 
+    m_notifyCallback = notifyCallback;
+
     NimBLERemoteDescriptor* desc = getDescriptor(NimBLEUUID((uint16_t)0x2902));
     if(desc == nullptr) {
-        NIMBLE_LOGE(LOG_TAG, "<< setNotify(): Could not get descriptor");
-        return false;
+        NIMBLE_LOGW(LOG_TAG, "<< setNotify(): Callback set, CCCD not found");
+        return true;
     }
 
-    m_notifyCallback = notifyCallback;
-
     NIMBLE_LOGD(LOG_TAG, "<< setNotify()");
 
     return desc->writeValue((uint8_t *)&val, 2, response);
@@ -531,7 +599,7 @@ bool NimBLERemoteCharacteristic::setNotify(uint16_t val, notify_callback notifyC
  * @param [in] notifyCallback A callback to be invoked for a notification.
  * @param [in] response If true, require a write response from the descriptor write operation.
  * If NULL is provided then no callback is performed.
- * @return true if successful.
+ * @return false if writing to the descriptor failed.
  */
 bool NimBLERemoteCharacteristic::subscribe(bool notifications, notify_callback notifyCallback, bool response) {
     if(notifications) {
@@ -545,7 +613,7 @@ bool NimBLERemoteCharacteristic::subscribe(bool notifications, notify_callback n
 /**
  * @brief Unsubscribe for notifications or indications.
  * @param [in] response bool if true, require a write response from the descriptor write operation.
- * @return true if successful.
+ * @return false if writing to the descriptor failed.
  */
 bool NimBLERemoteCharacteristic::unsubscribe(bool response) {
     return setNotify(0x00, nullptr, response);
@@ -644,7 +712,7 @@ std::string NimBLERemoteCharacteristic::toString() {
  * @return false if not connected or cant perform write for some reason.
  */
 bool NimBLERemoteCharacteristic::writeValue(const std::string &newValue, bool response) {
-    return writeValue((uint8_t*)newValue.c_str(), strlen(newValue.c_str()), response);
+    return writeValue((uint8_t*)newValue.c_str(), newValue.length(), response);
 } // writeValue
 
 

src/NimBLERemoteCharacteristic.h

@@ -148,12 +148,15 @@ private:
     static int        descriptorDiscCB(uint16_t conn_handle, const struct ble_gatt_error *error,
                                        uint16_t chr_val_handle, const struct ble_gatt_dsc *dsc,
                                        void *arg);
+    static int        nextCharCB(uint16_t conn_handle, const struct ble_gatt_error *error,
+                                 const struct ble_gatt_chr *chr, void *arg);
 
     // Private properties
     NimBLEUUID              m_uuid;
     uint8_t                 m_charProp;
     uint16_t                m_handle;
     uint16_t                m_defHandle;
+    uint16_t                m_endHandle;
     NimBLERemoteService*    m_pRemoteService;
     std::string             m_value;
     notify_callback         m_notifyCallback;

src/NimBLERemoteDescriptor.cpp

@@ -31,6 +31,7 @@ static const char* LOG_TAG = "NimBLERemoteDescriptor";
 NimBLERemoteDescriptor::NimBLERemoteDescriptor(NimBLERemoteCharacteristic* pRemoteCharacteristic,
                                                const struct ble_gatt_dsc *dsc)
 {
+    NIMBLE_LOGD(LOG_TAG, ">> NimBLERemoteDescriptor()");
     switch (dsc->uuid.u.type) {
         case BLE_UUID_TYPE_16:
             m_uuid = NimBLEUUID(dsc->uuid.u16.value);
@@ -42,12 +43,13 @@ NimBLERemoteDescriptor::NimBLERemoteDescriptor(NimBLERemoteCharacteristic* pRemo
             m_uuid = NimBLEUUID(const_cast<ble_uuid128_t*>(&dsc->uuid.u128));
             break;
         default:
-            m_uuid = nullptr;
             break;
     }
 
     m_handle                = dsc->handle;
     m_pRemoteCharacteristic = pRemoteCharacteristic;
+
+    NIMBLE_LOGD(LOG_TAG, "<< NimBLERemoteDescriptor(): %s", m_uuid.toString().c_str());
 }
 
 

src/NimBLERemoteService.cpp

@@ -44,12 +44,11 @@ NimBLERemoteService::NimBLERemoteService(NimBLEClient* pClient, const struct ble
             m_uuid = NimBLEUUID(const_cast<ble_uuid128_t*>(&service->uuid.u128));
             break;
         default:
-            m_uuid = nullptr;
             break;
     }
     m_startHandle = service->start_handle;
     m_endHandle = service->end_handle;
-    NIMBLE_LOGD(LOG_TAG, "<< NimBLERemoteService()");
+    NIMBLE_LOGD(LOG_TAG, "<< NimBLERemoteService(): %s", m_uuid.toString().c_str());
 }
 
 
@@ -95,8 +94,11 @@ NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const char* u
  * @return A pointer to the characteristic object, or nullptr if not found.
  */
 NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const NimBLEUUID &uuid) {
+    NIMBLE_LOGD(LOG_TAG, ">> getCharacteristic: uuid: %s", uuid.toString().c_str());
+
     for(auto &it: m_characteristicVector) {
         if(it->getUUID() == uuid) {
+            NIMBLE_LOGD(LOG_TAG, "<< getCharacteristic: found the characteristic with uuid: %s", uuid.toString().c_str());
             return it;
         }
     }
@@ -106,8 +108,19 @@ NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const NimBLEU
         if(m_characteristicVector.size() > prev_size) {
             return m_characteristicVector.back();
         }
+
+        // If the request was successful but 16/32 bit characteristic not found
+        // try again with the 128 bit uuid.
+        if(uuid.bitSize() == BLE_UUID_TYPE_16 ||
+           uuid.bitSize() == BLE_UUID_TYPE_32)
+        {
+            NimBLEUUID uuid128(uuid);
+            uuid128.to128();
+            return getCharacteristic(uuid128);
+        }
     }
 
+    NIMBLE_LOGD(LOG_TAG, "<< getCharacteristic: not found");
     return nullptr;
 } // getCharacteristic
 
@@ -210,6 +223,20 @@ bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID *uuid_filter)
     ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
 
     if(taskData.rc == 0){
+        if (uuid_filter == nullptr) {
+            if (m_characteristicVector.size() > 1) {
+                for (auto it = m_characteristicVector.begin(); it != m_characteristicVector.end(); ++it ) {
+                    auto nx = std::next(it, 1);
+                    if (nx == m_characteristicVector.end()) {
+                        break;
+                    }
+                    (*it)->m_endHandle = (*nx)->m_defHandle - 1;
+                }
+            }
+
+            m_characteristicVector.back()->m_endHandle = getEndHandle();
+        }
+
         NIMBLE_LOGD(LOG_TAG, "<< retrieveCharacteristics()");
         return true;
     }

src/NimBLEScan.cpp

@@ -30,7 +30,6 @@ static const char* LOG_TAG = "NimBLEScan";
  * @brief Scan constuctor.
  */
 NimBLEScan::NimBLEScan() {
-    m_own_addr_type                  = 0;
     m_scan_params.filter_policy      = BLE_HCI_SCAN_FILT_NO_WL;
     m_scan_params.passive            = 1; // If set, don’t send scan requests to advertisers (i.e., don’t request additional advertising data).
     m_scan_params.itvl               = 0; // This is defined as the time interval from when the Controller started its last LE scan until it begins the subsequent LE scan. (units=0.625 msec)
@@ -38,9 +37,10 @@ NimBLEScan::NimBLEScan() {
     m_scan_params.limited            = 0; // If set, only discover devices in limited discoverable mode.
     m_scan_params.filter_duplicates  = 0; // If set, the controller ignores all but the first advertisement from each device.
     m_pAdvertisedDeviceCallbacks     = nullptr;
-    m_stopped                        = true;
-    m_wantDuplicates                 = false;
+    m_ignoreResults                  = false;
     m_pTaskData                      = nullptr;
+    m_duration                       = BLE_HS_FOREVER; // make sure this is non-zero in the event of a host reset
+    m_maxResults                     = 0xFF;
 }
 
 
@@ -63,8 +63,8 @@ NimBLEScan::~NimBLEScan() {
     switch(event->type) {
 
         case BLE_GAP_EVENT_DISC: {
-            if(pScan->m_stopped) {
-                NIMBLE_LOGE(LOG_TAG, "Scan stop called, ignoring results.");
+            if(pScan->m_ignoreResults) {
+                NIMBLE_LOGI(LOG_TAG, "Scan op in progress - ignoring results");
                 return 0;
             }
 
@@ -88,34 +88,49 @@ NimBLEScan::~NimBLEScan() {
 
             // If we haven't seen this device before; create a new instance and insert it in the vector.
             // Otherwise just update the relevant parameters of the already known device.
-            if(advertisedDevice == nullptr){
+            if(advertisedDevice == nullptr && event->disc.event_type != BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP){
+                // Check if we have reach the scan results limit, ignore this one if so.
+                // We still need to store each device when maxResults is 0 to be able to append the scan results
+                if(pScan->m_maxResults > 0 && pScan->m_maxResults < 0xFF &&
+                  (pScan->m_scanResults.m_advertisedDevicesVector.size() >= pScan->m_maxResults))
+                {
+                    return 0;
+                }
                 advertisedDevice = new NimBLEAdvertisedDevice();
                 advertisedDevice->setAddress(advertisedAddress);
                 advertisedDevice->setAdvType(event->disc.event_type);
                 pScan->m_scanResults.m_advertisedDevicesVector.push_back(advertisedDevice);
-                NIMBLE_LOGI(LOG_TAG, "NEW DEVICE FOUND: %s", advertisedAddress.toString().c_str());
-            }
-            else{
-                NIMBLE_LOGI(LOG_TAG, "UPDATING PREVIOUSLY FOUND DEVICE: %s", advertisedAddress.toString().c_str());
-            }
-            advertisedDevice->setRSSI(event->disc.rssi);
-            if(event->disc.length_data > 0) {
-                advertisedDevice->parseAdvertisement(event->disc.data, event->disc.length_data);
+                NIMBLE_LOGI(LOG_TAG, "New advertiser: %s", advertisedAddress.toString().c_str());
+            } else if(advertisedDevice != nullptr) {
+                NIMBLE_LOGI(LOG_TAG, "Updated advertiser: %s", advertisedAddress.toString().c_str());
+            } else {
+                // Scan response from unknown device
+                return 0;
             }
+
             advertisedDevice->m_timestamp = time(nullptr);
+            advertisedDevice->setRSSI(event->disc.rssi);
+            advertisedDevice->setPayload(event->disc.data, event->disc.length_data, 
+            event->disc.event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP);
 
             if (pScan->m_pAdvertisedDeviceCallbacks) {
-                if(pScan->m_wantDuplicates || !advertisedDevice->m_callbackSent) {
-                    // If not active scanning report the result to the listener.
-                    if(pScan->m_scan_params.passive || event->disc.event_type == BLE_HCI_ADV_TYPE_ADV_NONCONN_IND) {
-                        advertisedDevice->m_callbackSent = true;
-                        pScan->m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
+                // If not active scanning or scan response is not available
+                // report the result to the callback now.
+                if(pScan->m_scan_params.passive ||
+                  (advertisedDevice->getAdvType() != BLE_HCI_ADV_TYPE_ADV_IND &&
+                   advertisedDevice->getAdvType() != BLE_HCI_ADV_TYPE_ADV_SCAN_IND))
+                {
+                    advertisedDevice->m_callbackSent = true;
+                    pScan->m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
 
-                    // Otherwise wait for the scan response so we can report all of the data at once.
-                    } else if (event->disc.event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
-                        advertisedDevice->m_callbackSent = true;
-                        pScan->m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
-                    }
+                // Otherwise, wait for the scan response so we can report the complete data.
+                } else if (event->disc.event_type == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
+                    advertisedDevice->m_callbackSent = true;
+                    pScan->m_pAdvertisedDeviceCallbacks->onResult(advertisedDevice);
+                }
+                // If not storing results and we have invoked the callback, delete the device. 
+                if(pScan->m_maxResults == 0 && advertisedDevice->m_callbackSent) {
+                    pScan->erase(advertisedAddress);
                 }
             }
 
@@ -123,13 +138,26 @@ NimBLEScan::~NimBLEScan() {
         }
         case BLE_GAP_EVENT_DISC_COMPLETE: {
             NIMBLE_LOGD(LOG_TAG, "discovery complete; reason=%d",
-                    event->disc_complete.reason);
+                        event->disc_complete.reason);
+
+            // If a device advertised with scan reponse available and it was not received
+            // the callback would not have been invoked, so do it here.
+            if(pScan->m_pAdvertisedDeviceCallbacks) {
+                for(auto &it : pScan->m_scanResults.m_advertisedDevicesVector) {
+                    if(!it->m_callbackSent) {
+                        pScan->m_pAdvertisedDeviceCallbacks->onResult(it);
+                    }
+                }
+            }
+
+            if(pScan->m_maxResults == 0) {
+                pScan->clearResults();
+            }
 
             if (pScan->m_scanCompleteCB != nullptr) {
                 pScan->m_scanCompleteCB(pScan->m_scanResults);
             }
 
-            pScan->m_stopped = true;
             if(pScan->m_pTaskData != nullptr) {
                 pScan->m_pTaskData->rc = event->disc_complete.reason;
                 xTaskNotifyGive(pScan->m_pTaskData->task);
@@ -146,15 +174,11 @@ NimBLEScan::~NimBLEScan() {
 
 /**
  * @brief Should we perform an active or passive scan?
- * The default is a passive scan.  An active scan means that we will wish a scan response.
+ * The default is a passive scan. An active scan means that we will request a scan response.
  * @param [in] active If true, we perform an active scan otherwise a passive scan.
  */
 void NimBLEScan::setActiveScan(bool active) {
-    if (active) {
-        m_scan_params.passive = 0;
-    } else {
-        m_scan_params.passive = 1;
-    }
+    m_scan_params.passive = !active;
 } // setActiveScan
 
 
@@ -203,6 +227,16 @@ void NimBLEScan::setFilterPolicy(uint8_t filter) {
 } // setFilterPolicy
 
 
+/**
+ * @brief Sets the max number of results to store.
+ * @param [in] maxResults The number of results to limit storage to\n
+ * 0 == none (callbacks only) 0xFF == unlimited, any other value is the limit.
+ */
+void NimBLEScan::setMaxResults(uint8_t maxResults) {
+    m_maxResults = maxResults;
+}
+
+
 /**
  * @brief Set the call backs to be invoked.
  * @param [in] pAdvertisedDeviceCallbacks Call backs to be invoked.
@@ -210,7 +244,7 @@ void NimBLEScan::setFilterPolicy(uint8_t filter) {
  */
 void NimBLEScan::setAdvertisedDeviceCallbacks(NimBLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks,
                                               bool wantDuplicates) {
-    m_wantDuplicates = wantDuplicates;
+    setDuplicateFilter(!wantDuplicates);
     m_pAdvertisedDeviceCallbacks = pAdvertisedDeviceCallbacks;
 } // setAdvertisedDeviceCallbacks
 
@@ -238,7 +272,7 @@ void NimBLEScan::setWindow(uint16_t windowMSecs) {
  * @return true if scanning or scan starting.
  */
 bool NimBLEScan::isScanning() {
-    return !m_stopped;
+    return ble_gap_disc_active();
 }
 
 
@@ -250,26 +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);
-
-    // If Host is not synced we cannot start scanning.
-    if(!NimBLEDevice::m_synced) {
-        NIMBLE_LOGC(LOG_TAG, "Host reset, wait for sync.");
-        return false;
-    }
-
-    if(ble_gap_conn_active()) {
-        NIMBLE_LOGE(LOG_TAG, "Connection in progress - must wait.");
-        return false;
-    }
-
-    // If we are already scanning don't start again or we will get stuck on the semaphore.
-    if(!m_stopped || ble_gap_disc_active()) { // double check - can cause host reset.
-        NIMBLE_LOGE(LOG_TAG, "Scan already in progress");
-        return false;
-    }
-
-    m_stopped = false;
+    NIMBLE_LOGD(LOG_TAG, ">> start(duration=%lu)", duration);
 
     // Save the callback to be invoked when the scan completes.
     m_scanCompleteCB = scanCompleteCB;
@@ -281,32 +296,53 @@ bool NimBLEScan::start(uint32_t duration, void (*scanCompleteCB)(NimBLEScanResul
         duration = BLE_HS_FOREVER;
     }
     else{
-        duration = duration*1000; // convert duration to milliseconds
+        // convert duration to milliseconds
+        duration = duration * 1000;
     }
 
-    //  if we are connecting to devices that are advertising even after being connected, multiconnecting peripherals
-    //  then we should not clear vector or we will connect the same device few times
+    // Set the flag to ignore the results while we are deleting the vector
     if(!is_continue) {
-        clearResults();
+        m_ignoreResults = true;
     }
 
-    int rc = 0;
-    do{
-        rc = ble_gap_disc(m_own_addr_type, duration, &m_scan_params,
-                                    NimBLEScan::handleGapEvent, this);
-        if(rc == BLE_HS_EBUSY) {
-            vTaskDelay(1 / portTICK_PERIOD_MS);
-        }
-    } while(rc == BLE_HS_EBUSY);
+    int rc = ble_gap_disc(NimBLEDevice::m_own_addr_type, duration, &m_scan_params,
+                          NimBLEScan::handleGapEvent, this);
 
-    if (rc != 0 && rc != BLE_HS_EDONE) {
-        NIMBLE_LOGE(LOG_TAG, "Error initiating GAP discovery procedure; rc=%d, %s",
-                                        rc, NimBLEUtils::returnCodeToString(rc));
-        m_stopped = true;
+    switch(rc) {
+        case 0:
+            if(!is_continue) {
+                clearResults();
+            }
+            break;
+
+        case BLE_HS_EALREADY:
+            // Clear the cache if already scanning in case an advertiser was missed.
+            clearDuplicateCache();
+            break;
+
+        case BLE_HS_EBUSY:
+            NIMBLE_LOGE(LOG_TAG, "Unable to scan - connection in progress.");
+            break;
+
+        case BLE_HS_ETIMEOUT_HCI:
+        case BLE_HS_EOS:
+        case BLE_HS_ECONTROLLER:
+        case BLE_HS_ENOTSYNCED:
+            NIMBLE_LOGC(LOG_TAG, "Unable to scan - Host Reset");
+            break;
+
+        default:
+            NIMBLE_LOGE(LOG_TAG, "Error initiating GAP discovery procedure; rc=%d, %s",
+                        rc, NimBLEUtils::returnCodeToString(rc));
+            break;
+    }
+
+    m_ignoreResults = false;
+    NIMBLE_LOGD(LOG_TAG, "<< start()");
+
+    if(rc != 0 && rc != BLE_HS_EALREADY) {
         return false;
     }
-
-    NIMBLE_LOGD(LOG_TAG, "<< start()");
     return true;
 } // start
 
@@ -343,11 +379,13 @@ bool NimBLEScan::stop() {
 
     int rc = ble_gap_disc_cancel();
     if (rc != 0 && rc != BLE_HS_EALREADY) {
-        NIMBLE_LOGE(LOG_TAG, "Failed to cancel scan; rc=%d\n", rc);
+        NIMBLE_LOGE(LOG_TAG, "Failed to cancel scan; rc=%d", rc);
         return false;
     }
 
-    m_stopped = true;
+    if(m_maxResults == 0) {
+        clearResults();
+    }
 
     if (rc != BLE_HS_EALREADY && m_scanCompleteCB != nullptr) {
         m_scanCompleteCB(m_scanResults);
@@ -362,13 +400,21 @@ bool NimBLEScan::stop() {
 } // stop
 
 
+/**
+ * @brief Clears the duplicate scan filter cache.
+ */
+void NimBLEScan::clearDuplicateCache() {
+    esp_ble_scan_dupilcate_list_flush();
+}
+
+
 /**
  * @brief Delete peer device from the scan results vector.
  * @param [in] address The address of the device to delete from the results.
  * @details After disconnecting, it may be required in the case we were connected to a device without a public address.
  */
 void NimBLEScan::erase(const NimBLEAddress &address) {
-    NIMBLE_LOGI(LOG_TAG, "erase device: %s", address.toString().c_str());
+    NIMBLE_LOGD(LOG_TAG, "erase device: %s", address.toString().c_str());
 
     for(auto it = m_scanResults.m_advertisedDevicesVector.begin(); it != m_scanResults.m_advertisedDevicesVector.end(); ++it) {
         if((*it)->getAddress() == address) {
@@ -381,13 +427,25 @@ void NimBLEScan::erase(const NimBLEAddress &address) {
 
 
 /**
- * @brief If the host reset the scan will have stopped so we should set the flag as stopped.
+ * @brief Called when host reset, we set a flag to stop scanning until synced.
  */
 void NimBLEScan::onHostReset() {
-    m_stopped = true;
+    m_ignoreResults = true;
 }
 
 
+/**
+ * @brief If the host reset and re-synced this is called.
+ * If the application was scanning indefinitely with a callback, restart it.
+ */
+void NimBLEScan::onHostSync() {
+    m_ignoreResults = false;
+
+    if(m_duration == 0 && m_pAdvertisedDeviceCallbacks != nullptr) {
+        start(m_duration, m_scanCompleteCB);
+    }
+}
+
 /**
  * @brief Get the results of the scan.
  * @return NimBLEScanResults object.
@@ -405,6 +463,7 @@ void NimBLEScan::clearResults() {
         delete it;
     }
     m_scanResults.m_advertisedDevicesVector.clear();
+    clearDuplicateCache();
 }
 
 

src/NimBLEScan.h

@@ -70,9 +70,11 @@ public:
     void                setDuplicateFilter(bool enabled);
     void                setLimitedOnly(bool enabled);
     void                setFilterPolicy(uint8_t filter);
+    void                clearDuplicateCache();
     bool                stop();
     void                clearResults();
     NimBLEScanResults   getResults();
+    void                setMaxResults(uint8_t maxResults);
     void                erase(const NimBLEAddress &address);
 
 
@@ -83,16 +85,16 @@ private:
     ~NimBLEScan();
     static int          handleGapEvent(ble_gap_event*  event, void* arg);
     void                onHostReset();
+    void                onHostSync();
 
     NimBLEAdvertisedDeviceCallbacks*    m_pAdvertisedDeviceCallbacks = nullptr;
     void                                (*m_scanCompleteCB)(NimBLEScanResults scanResults);
     ble_gap_disc_params                 m_scan_params;
-    uint8_t                             m_own_addr_type;
-    bool                                m_stopped;
-    bool                                m_wantDuplicates;
+    bool                                m_ignoreResults;
     NimBLEScanResults                   m_scanResults;
     uint32_t                            m_duration;
     ble_task_data_t                     *m_pTaskData;
+    uint8_t                             m_maxResults;
 };
 
 #endif // #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)

src/NimBLESecurity.cpp

@@ -13,7 +13,7 @@
  */
 
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "NimBLESecurity.h"
 #include "NimBLEDevice.h"

src/NimBLESecurity.h

@@ -15,7 +15,7 @@
 #ifndef COMPONENTS_NIMBLESECURITY_H_
 #define COMPONENTS_NIMBLESECURITY_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "host/ble_gap.h"
 /****  FIX COMPILATION ****/

src/NimBLEServer.cpp

@@ -37,6 +37,7 @@ static NimBLEServerCallbacks defaultCallbacks;
  * the NimBLEDevice class.
  */
 NimBLEServer::NimBLEServer() {
+    memset(m_indWait, BLE_HS_CONN_HANDLE_NONE, sizeof(m_indWait));
 //    m_svcChgChrHdl          = 0xffff; // Future Use
     m_pServerCallbacks      = &defaultCallbacks;
     m_gattsStarted          = false;
@@ -104,28 +105,47 @@ NimBLEService* NimBLEServer::createService(const NimBLEUUID &uuid, uint32_t numH
 
 /**
  * @brief Get a %BLE Service by its UUID
- * @param [in] uuid The UUID of the new service.
- * @return A reference to the service object.
+ * @param [in] uuid The UUID of the service.
+ * @param instanceId The index of the service to return (used when multiple services have the same UUID).
+ * @return A pointer to the service object or nullptr if not found.
  */
-NimBLEService* NimBLEServer::getServiceByUUID(const char* uuid) {
-    return getServiceByUUID(NimBLEUUID(uuid));
+NimBLEService* NimBLEServer::getServiceByUUID(const char* uuid, uint16_t instanceId) {
+    return getServiceByUUID(NimBLEUUID(uuid), instanceId);
 } // getServiceByUUID
 
 
 /**
  * @brief Get a %BLE Service by its UUID
- * @param [in] uuid The UUID of the new service.
- * @return A reference to the service object.
+ * @param [in] uuid The UUID of the service.
+ * @param instanceId The index of the service to return (used when multiple services have the same UUID).
+ * @return A pointer to the service object or nullptr if not found.
  */
-NimBLEService* NimBLEServer::getServiceByUUID(const NimBLEUUID &uuid) {
+NimBLEService* NimBLEServer::getServiceByUUID(const NimBLEUUID &uuid, uint16_t instanceId) {
+    uint16_t position = 0;
     for (auto &it : m_svcVec) {
         if (it->getUUID() == uuid) {
-            return it;
+            if (position == instanceId){
+                return it;
+            }
+            position++;
         }
     }
     return nullptr;
 } // getServiceByUUID
 
+/**
+ * @brief Get a %BLE Service by its handle
+ * @param handle The handle of the service.
+ * @return A pointer to the service object or nullptr if not found.
+ */
+NimBLEService *NimBLEServer::getServiceByHandle(uint16_t handle) {
+    for (auto &it : m_svcVec) {
+        if (it->getHandle() == handle) {
+            return it;
+        }
+    }
+    return nullptr;
+}
 
 /**
  * @brief Retrieve the advertising object that can be used to advertise the existence of the server.
@@ -154,7 +174,7 @@ void NimBLEServer::start() {
         abort();
     }
 
-#if CONFIG_LOG_DEFAULT_LEVEL > 3 || (ARDUINO_ARCH_ESP32 && CORE_DEBUG_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 ***
@@ -234,6 +254,63 @@ size_t NimBLEServer::getConnectedCount() {
 } // getConnectedCount
 
 
+/**
+ * @brief Get the vector of the connected client ID's.
+ */
+std::vector<uint16_t> NimBLEServer::getPeerDevices() {
+    return m_connectedPeersVec;
+} // getPeerDevices
+
+
+/**
+ * @brief Get the connection information of a connected peer by vector index.
+ * @param [in] index The vector index of the peer.
+ */
+NimBLEConnInfo NimBLEServer::getPeerInfo(size_t index) {
+    if (index >= m_connectedPeersVec.size()) {
+        NIMBLE_LOGE(LOG_TAG, "No peer at index %u", index);
+        return NimBLEConnInfo();
+    }
+
+    return getPeerIDInfo(m_connectedPeersVec[index]);
+} // getPeerInfo
+
+
+/**
+ * @brief Get the connection information of a connected peer by address.
+ * @param [in] address The address of the peer.
+ */
+NimBLEConnInfo NimBLEServer::getPeerInfo(const NimBLEAddress& address) {
+    ble_addr_t peerAddr;
+    memcpy(&peerAddr.val, address.getNative(),6);
+    peerAddr.type = address.getType();
+
+    NimBLEConnInfo peerInfo;
+    int rc = ble_gap_conn_find_by_addr(&peerAddr, &peerInfo.m_desc);
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Peer info not found");
+    }
+
+    return peerInfo;
+} // getPeerInfo
+
+
+/**
+ * @brief Get the connection information of a connected peer by connection ID.
+ * @param [in] id The connection id of the peer.
+ */
+NimBLEConnInfo NimBLEServer::getPeerIDInfo(uint16_t id) {
+    NimBLEConnInfo peerInfo;
+
+    int rc = ble_gap_conn_find(id, &peerInfo.m_desc);
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Peer info not found");
+    }
+
+    return peerInfo;
+} // getPeerIDInfo
+
+
 /**
  * @brief Handle a GATT Server Event.
  *
@@ -261,7 +338,9 @@ size_t NimBLEServer::getConnectedCount() {
                 server->m_connectedPeersVec.push_back(event->connect.conn_handle);
 
                 rc = ble_gap_conn_find(event->connect.conn_handle, &desc);
-                assert(rc == 0);
+                if (rc != 0) {
+                    return 0;
+                }
 
                 server->m_pServerCallbacks->onConnect(server);
                 server->m_pServerCallbacks->onConnect(server, &desc);
@@ -296,6 +375,7 @@ size_t NimBLEServer::getConnectedCount() {
             }
 
             server->m_pServerCallbacks->onDisconnect(server);
+            server->m_pServerCallbacks->onDisconnect(server, &event->disconnect.conn);
 
             if(server->m_advertiseOnDisconnect) {
                 server->startAdvertising();
@@ -315,7 +395,9 @@ size_t NimBLEServer::getConnectedCount() {
                        (it->getProperties() & BLE_GATT_CHR_F_READ_ENC))
                     {
                         rc = ble_gap_conn_find(event->subscribe.conn_handle, &desc);
-                        assert(rc == 0);
+                        if (rc != 0) {
+                            break;
+                        }
 
                         if(!desc.sec_state.encrypted) {
                             NimBLEDevice::startSecurity(event->subscribe.conn_handle);
@@ -338,18 +420,44 @@ size_t NimBLEServer::getConnectedCount() {
         } // BLE_GAP_EVENT_MTU
 
         case BLE_GAP_EVENT_NOTIFY_TX: {
-            if(event->notify_tx.indication && event->notify_tx.status != 0) {
-                for(auto &it : server->m_notifyChrVec) {
-                    if(it->getHandle() == event->notify_tx.attr_handle) {
-                        if(it->m_pTaskData != nullptr) {
-                            it->m_pTaskData->rc = event->notify_tx.status;
-                            xTaskNotifyGive(it->m_pTaskData->task);
-                        }
-                        break;
-                    }
+            NimBLECharacteristic *pChar = nullptr;
+
+            for(auto &it : server->m_notifyChrVec) {
+                if(it->getHandle() == event->notify_tx.attr_handle) {
+                    pChar = it;
                 }
             }
 
+            if(pChar == nullptr) {
+                return 0;
+            }
+
+            NimBLECharacteristicCallbacks::Status statusRC;
+
+            if(event->notify_tx.indication) {
+                if(event->notify_tx.status != 0) {
+                    if(event->notify_tx.status == BLE_HS_EDONE) {
+                        statusRC = NimBLECharacteristicCallbacks::Status::SUCCESS_INDICATE;
+                    } else if(rc == BLE_HS_ETIMEOUT) {
+                        statusRC = NimBLECharacteristicCallbacks::Status::ERROR_INDICATE_TIMEOUT;
+                    } else {
+                        statusRC = NimBLECharacteristicCallbacks::Status::ERROR_INDICATE_FAILURE;
+                    }
+                } else {
+                    return 0;
+                }
+
+                server->clearIndicateWait(event->notify_tx.conn_handle);
+            } else {
+                if(event->notify_tx.status == 0) {
+                    statusRC = NimBLECharacteristicCallbacks::Status::SUCCESS_NOTIFY;
+                } else {
+                    statusRC = NimBLECharacteristicCallbacks::Status::ERROR_GATT;
+                }
+            }
+
+            pChar->m_pCallbacks->onStatus(pChar, statusRC, event->notify_tx.status);
+
             return 0;
         } // BLE_GAP_EVENT_NOTIFY_TX
 
@@ -372,7 +480,10 @@ size_t NimBLEServer::getConnectedCount() {
 
             /* Delete the old bond. */
             rc = ble_gap_conn_find(event->repeat_pairing.conn_handle, &desc);
-            assert(rc == 0);
+            if (rc != 0){
+                return BLE_GAP_REPEAT_PAIRING_IGNORE;
+            }
+
             ble_store_util_delete_peer(&desc.peer_id_addr);
 
             /* Return BLE_GAP_REPEAT_PAIRING_RETRY to indicate that the host should
@@ -413,7 +524,7 @@ size_t NimBLEServer::getConnectedCount() {
                 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) {
@@ -539,14 +650,23 @@ void NimBLEServer::removeService(NimBLEService* service, bool deleteSvc) {
 
 
 /**
- * @brief Adds a service which was already created, but removed from availability.
+ * @brief Adds a service which was either already created but removed from availability,\n
+ * or created and later added to services list.
  * @param [in] service The service object to add.
  * @note If it is desired to advertise the service it must be added by
  * calling NimBLEAdvertising::addServiceUUID.
  */
 void NimBLEServer::addService(NimBLEService* service) {
-    // If adding a service that was not removed just return.
+    // Check that a service with the supplied UUID does not already exist.
+    if(getServiceByUUID(service->getUUID()) != nullptr) {
+        NIMBLE_LOGW(LOG_TAG, "Warning creating a duplicate service UUID: %s",
+                             std::string(service->getUUID()).c_str());
+    }
+
+    // If adding a service that was not removed add it and return.
+    // Else reset GATT and send service changed notification.
     if(service->m_removed == 0) {
+        m_svcVec.push_back(service);
         return;
     }
 
@@ -620,7 +740,13 @@ uint16_t NimBLEServer::getPeerMTU(uint16_t conn_id) {
 
 
 /**
- * Update connection parameters can be called only after connection has been established
+ * @brief Request an Update the connection parameters:
+ * * Can only be used after a connection has been established.
+ * @param [in] conn_handle The connection handle of the peer to send the request to.
+ * @param [in] minInterval The minimum connection interval in 1.25ms units.
+ * @param [in] maxInterval The maximum connection interval in 1.25ms units.
+ * @param [in] latency The number of packets allowed to skip (extends max interval).
+ * @param [in] timeout The timeout time in 10ms units before disconnecting.
  */
 void NimBLEServer::updateConnParams(uint16_t conn_handle,
                             uint16_t minInterval, uint16_t maxInterval,
@@ -639,7 +765,28 @@ void NimBLEServer::updateConnParams(uint16_t conn_handle,
     if(rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "Update params error: %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
     }
-} // updateConnParams
+}// updateConnParams
+
+
+bool NimBLEServer::setIndicateWait(uint16_t conn_handle) {
+    for(auto i = 0; i < CONFIG_BT_NIMBLE_MAX_CONNECTIONS; i++) {
+        if(m_indWait[i] == conn_handle) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+void NimBLEServer::clearIndicateWait(uint16_t conn_handle) {
+    for(auto i = 0; i < CONFIG_BT_NIMBLE_MAX_CONNECTIONS; i++) {
+        if(m_indWait[i] == conn_handle) {
+            m_indWait[i] = BLE_HS_CONN_HANDLE_NONE;
+            return;
+        }
+    }
+}
 
 
 /** Default callback handlers */
@@ -658,6 +805,10 @@ void NimBLEServerCallbacks::onDisconnect(NimBLEServer* pServer) {
     NIMBLE_LOGD("NimBLEServerCallbacks", "onDisconnect(): Default");
 } // onDisconnect
 
+void NimBLEServerCallbacks::onDisconnect(NimBLEServer* pServer, ble_gap_conn_desc* desc) {
+    NIMBLE_LOGD("NimBLEServerCallbacks", "onDisconnect(): Default");
+} // onDisconnect
+
 uint32_t NimBLEServerCallbacks::onPassKeyRequest(){
     NIMBLE_LOGD("NimBLEServerCallbacks", "onPassKeyRequest: default: 123456");
     return 123456;

src/NimBLEServer.h

@@ -25,6 +25,7 @@
 #include "NimBLEAdvertising.h"
 #include "NimBLEService.h"
 #include "NimBLESecurity.h"
+#include "NimBLEConnInfo.h"
 
 
 class NimBLEService;
@@ -49,15 +50,19 @@ public:
     void                   startAdvertising();
     void                   stopAdvertising();
     void                   start();
-    NimBLEService*         getServiceByUUID(const char* uuid);
-    NimBLEService*         getServiceByUUID(const NimBLEUUID &uuid);
+    NimBLEService*         getServiceByUUID(const char* uuid, uint16_t instanceId = 0);
+    NimBLEService*         getServiceByUUID(const NimBLEUUID &uuid, uint16_t instanceId = 0);
+    NimBLEService*         getServiceByHandle(uint16_t handle);
     int                    disconnect(uint16_t connID,
                                       uint8_t reason = BLE_ERR_REM_USER_CONN_TERM);
     void                   updateConnParams(uint16_t conn_handle,
                                             uint16_t minInterval, uint16_t maxInterval,
                                             uint16_t latency, uint16_t timeout);
     uint16_t               getPeerMTU(uint16_t conn_id);
-//    std::vector<uint16_t>  getPeerDevices();
+    std::vector<uint16_t>  getPeerDevices();
+    NimBLEConnInfo         getPeerInfo(size_t index);
+    NimBLEConnInfo         getPeerInfo(const NimBLEAddress& address);
+    NimBLEConnInfo         getPeerIDInfo(uint16_t id);
     void                   advertiseOnDisconnect(bool);
 
 private:
@@ -72,6 +77,7 @@ private:
     bool                   m_svcChanged;
     NimBLEServerCallbacks* m_pServerCallbacks;
     bool                   m_deleteCallbacks;
+    uint16_t               m_indWait[CONFIG_BT_NIMBLE_MAX_CONNECTIONS];
     std::vector<uint16_t>  m_connectedPeersVec;
 
 //    uint16_t               m_svcChgChrHdl; // Future use
@@ -81,6 +87,8 @@ private:
 
     static int             handleGapEvent(struct ble_gap_event *event, void *arg);
     void                   resetGATT();
+    bool                   setIndicateWait(uint16_t conn_handle);
+    void                   clearIndicateWait(uint16_t conn_handle);
 }; // NimBLEServer
 
 
@@ -114,6 +122,15 @@ public:
      */
     virtual void onDisconnect(NimBLEServer* pServer);
 
+     /**
+     * @brief Handle a client disconnection.
+     * This is called when a client discconnects.
+     * @param [in] pServer A pointer to the %BLE server that received the client disconnection.
+     * @param [in] desc A pointer to the connection description structure containig information
+     * about the connection.
+     */
+    virtual void onDisconnect(NimBLEServer* pServer, ble_gap_conn_desc* desc);
+
     /**
      * @brief Called when a client requests a passkey for pairing.
      * @return The passkey to be sent to the client.

src/NimBLEService.cpp

@@ -233,9 +233,9 @@ NimBLECharacteristic* NimBLEService::createCharacteristic(const char* uuid, uint
  */
 NimBLECharacteristic* NimBLEService::createCharacteristic(const NimBLEUUID &uuid, uint32_t properties) {
     NimBLECharacteristic* pCharacteristic = new NimBLECharacteristic(uuid, properties, this);
-    // Check that we don't add the same characteristic twice.
+
     if (getCharacteristic(uuid) != nullptr) {
-        NIMBLE_LOGW(LOG_TAG, "<< Adding a duplicate characteristic with UUID: %s",
+        NIMBLE_LOGD(LOG_TAG, "<< Adding a duplicate characteristic with UUID: %s",
                              std::string(uuid).c_str());
     }
 
@@ -246,31 +246,80 @@ NimBLECharacteristic* NimBLEService::createCharacteristic(const NimBLEUUID &uuid
 } // createCharacteristic
 
 
-/**
- * @brief Get a pointer to the characteristic object with the specified UUID.
- * @param [in] uuid The UUID of the characteristic.
- * @return A pointer to the characteristic object or nullptr if not found.
- */
-NimBLECharacteristic* NimBLEService::getCharacteristic(const char* uuid) {
-    return getCharacteristic(NimBLEUUID(uuid));
+void NimBLEService::addCharacteristic(NimBLECharacteristic* pCharacteristic) {
+    pCharacteristic->setService(this);
+    m_chrVec.push_back(pCharacteristic);
 }
 
+/**
+ * @brief Get a pointer to the characteristic object with the specified UUID.
+ * @param [in] uuid The UUID of the characteristic.
+ * @param instanceId The index of the characteristic to return (used when multiple characteristics have the same UUID).
+ * @return A pointer to the characteristic object or nullptr if not found.
+ */
+NimBLECharacteristic* NimBLEService::getCharacteristic(const char* uuid, uint16_t instanceId) {
+    return getCharacteristic(NimBLEUUID(uuid), instanceId);
+}
 
 /**
  * @brief Get a pointer to the characteristic object with the specified UUID.
  * @param [in] uuid The UUID of the characteristic.
+ * @param instanceId The index of the characteristic to return (used when multiple characteristics have the same UUID).
  * @return A pointer to the characteristic object or nullptr if not found.
  */
-NimBLECharacteristic* NimBLEService::getCharacteristic(const NimBLEUUID &uuid) {
+NimBLECharacteristic* NimBLEService::getCharacteristic(const NimBLEUUID &uuid, uint16_t instanceId) {
+    uint16_t position = 0;
     for (auto &it : m_chrVec) {
         if (it->getUUID() == uuid) {
-            return it;
+            if (position == instanceId) {
+                return it;
+            }
+            position++;
         }
     }
-
     return nullptr;
 }
 
+/**
+ * @brief Get a pointer to the characteristic object with the specified handle.
+ * @param handle The handle of the characteristic.
+ * @return A pointer to the characteristic object or nullptr if not found.
+ */
+NimBLECharacteristic *NimBLEService::getCharacteristicByHandle(uint16_t handle) {
+    for (auto &it : m_chrVec) {
+        if (it->getHandle() == handle) {
+            return it;
+        }
+    }
+    return nullptr;
+}
+
+/**
+ * @return A vector containing pointers to each characteristic associated with this service.
+ */
+std::vector<NimBLECharacteristic *> NimBLEService::getCharacteristics() {
+    return m_chrVec;
+}
+
+/**
+ * @return A vector containing pointers to each characteristic with the provided UUID associated with this service.
+ */
+std::vector<NimBLECharacteristic *> NimBLEService::getCharacteristics(const char *uuid) {
+    return getCharacteristics(NimBLEUUID(uuid));
+}
+
+/**
+ * @return A vector containing pointers to each characteristic with the provided UUID associated with this service.
+ */
+std::vector<NimBLECharacteristic *> NimBLEService::getCharacteristics(const NimBLEUUID &uuid) {
+    std::vector<NimBLECharacteristic*> result;
+    for (auto &it : m_chrVec) {
+        if (it->getUUID() == uuid) {
+            result.push_back(it);
+        }
+    }
+    return result;
+}
 
 /**
  * @brief Return a string representation of this service.
@@ -295,7 +344,7 @@ std::string NimBLEService::toString() {
  */
 NimBLEServer* NimBLEService::getServer() {
     return m_pServer;
-} // getServer
+}// getServer
 
 #endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 #endif // CONFIG_BT_ENABLED

src/NimBLEService.h

@@ -35,6 +35,20 @@ class NimBLECharacteristic;
  */
 class NimBLEService {
 public:
+
+    NimBLEService(const char* uuid, uint16_t numHandles, NimBLEServer* pServer);
+    NimBLEService(const NimBLEUUID &uuid, uint16_t numHandles, NimBLEServer* pServer);
+    ~NimBLEService();
+
+    NimBLEServer*         getServer();
+
+    NimBLEUUID            getUUID();
+    uint16_t              getHandle();
+    std::string           toString();
+    void                  dump();
+
+    bool                  start();
+
     NimBLECharacteristic* createCharacteristic(const char* uuid,
                                               uint32_t properties =
                                               NIMBLE_PROPERTY::READ |
@@ -45,19 +59,17 @@ public:
                                                NIMBLE_PROPERTY::READ |
                                                NIMBLE_PROPERTY::WRITE);
 
-    void                  dump();
-    NimBLECharacteristic* getCharacteristic(const char* uuid);
-    NimBLECharacteristic* getCharacteristic(const NimBLEUUID &uuid);
-    NimBLEUUID            getUUID();
-    NimBLEServer*         getServer();
-    bool                  start();
-    std::string           toString();
-    uint16_t              getHandle();
+    void                  addCharacteristic(NimBLECharacteristic* pCharacteristic);
+    NimBLECharacteristic* getCharacteristic(const char* uuid, uint16_t instanceId = 0);
+    NimBLECharacteristic* getCharacteristic(const NimBLEUUID &uuid, uint16_t instanceId = 0);
+    NimBLECharacteristic* getCharacteristicByHandle(uint16_t handle);
+
+    std::vector<NimBLECharacteristic*> getCharacteristics();
+    std::vector<NimBLECharacteristic*> getCharacteristics(const char* uuid);
+    std::vector<NimBLECharacteristic*> getCharacteristics(const NimBLEUUID &uuid);
+
 
 private:
-    NimBLEService(const char* uuid, uint16_t numHandles, NimBLEServer* pServer);
-    NimBLEService(const NimBLEUUID &uuid, uint16_t numHandles, NimBLEServer* pServer);
-    ~NimBLEService();
 
     friend class          NimBLEServer;
     friend class          NimBLEDevice;

src/NimBLEUUID.cpp

@@ -12,7 +12,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "NimBLEUtils.h"
 #include "NimBLEUUID.h"
@@ -65,29 +65,42 @@ static const char* LOG_TAG = "NimBLEUUID";
         *this = NimBLEUUID(first, second, third, (uint64_t(fourth) << 48) + fifth);
     }
     else {
-        NIMBLE_LOGE(LOG_TAG,"ERROR: UUID value not 2, 4, 16 or 36 bytes");
         m_valueSet = false;
     }
 } // NimBLEUUID(std::string)
 
 
 /**
- * @brief Create a UUID from 16 bytes of memory.
+ * @brief Create a UUID from 2, 4, 16 bytes of memory.
  * @param [in] pData The pointer to the start of the UUID.
  * @param [in] size The size of the data.
  * @param [in] msbFirst Is the MSB first in pData memory?
  */
 NimBLEUUID::NimBLEUUID(const uint8_t* pData, size_t size, bool msbFirst) {
-    if (size != 16) {
-        NIMBLE_LOGE(LOG_TAG,"ERROR: UUID length not 16 bytes");
-        return;
-    }
-    m_uuid.u.type = BLE_UUID_TYPE_128;
+    uint8_t *uuidValue = nullptr;
 
+    switch(size) {
+        case 2:
+            uuidValue = (uint8_t*)&m_uuid.u16.value;
+            m_uuid.u.type = BLE_UUID_TYPE_16;
+            break;
+        case 4:
+            uuidValue = (uint8_t*)&m_uuid.u32.value;
+            m_uuid.u.type = BLE_UUID_TYPE_32;
+            break;
+        case 16:
+            uuidValue = m_uuid.u128.value;
+            m_uuid.u.type = BLE_UUID_TYPE_128;
+            break;
+        default:
+            m_valueSet = false;
+            NIMBLE_LOGE(LOG_TAG, "Invalid UUID size");
+            return;
+    }
     if (msbFirst) {
-        std::reverse_copy(pData, pData + 16, m_uuid.u128.value);
+        std::reverse_copy(pData, pData + size, uuidValue);
     } else {
-        memcpy(m_uuid.u128.value, pData, 16);
+        memcpy(uuidValue, pData, size);
     }
     m_valueSet = true;
 } // NimBLEUUID
@@ -264,6 +277,33 @@ std::string NimBLEUUID::toString() const {
  */
 bool NimBLEUUID::operator ==(const NimBLEUUID & rhs) const {
     if(m_valueSet && rhs.m_valueSet) {
+        if(m_uuid.u.type != rhs.m_uuid.u.type) {
+            uint8_t uuidBase[16] = {
+                0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
+                0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+            };
+
+            if(m_uuid.u.type == BLE_UUID_TYPE_128){
+                if(rhs.m_uuid.u.type == BLE_UUID_TYPE_16){
+                    memcpy(uuidBase+12, &rhs.m_uuid.u16.value, 2);
+                } else if (rhs.m_uuid.u.type == BLE_UUID_TYPE_32){
+                    memcpy(uuidBase+12, &rhs.m_uuid.u32.value, 4);
+                }
+                return memcmp(m_uuid.u128.value,uuidBase,16) == 0;
+
+            } else if(rhs.m_uuid.u.type == BLE_UUID_TYPE_128) {
+                if(m_uuid.u.type == BLE_UUID_TYPE_16){
+                    memcpy(uuidBase+12, &m_uuid.u16.value, 2);
+                } else if (m_uuid.u.type == BLE_UUID_TYPE_32){
+                    memcpy(uuidBase+12, &m_uuid.u32.value, 4);
+                }
+                return memcmp(rhs.m_uuid.u128.value,uuidBase,16) == 0;
+
+            } else {
+                return false;
+            }
+        }
+
         return ble_uuid_cmp(&m_uuid.u, &rhs.m_uuid.u) == 0;
     }
 

src/NimBLEUUID.h

@@ -15,7 +15,7 @@
 #ifndef COMPONENTS_NIMBLEUUID_H_
 #define COMPONENTS_NIMBLEUUID_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "host/ble_uuid.h"
 /****  FIX COMPILATION ****/

src/NimBLEUtils.cpp

@@ -7,7 +7,7 @@
  */
 
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"

src/NimBLEUtils.h

@@ -9,7 +9,7 @@
 #ifndef COMPONENTS_NIMBLEUTILS_H_
 #define COMPONENTS_NIMBLEUTILS_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_NIMBLE_ENABLED)
 
 #include "host/ble_gap.h"
 

src/nimconfig.h

@@ -2,214 +2,92 @@
  *
  * IGNORE THIS FILE IF USING ESP-IDF, USE MENUCONFIG TO SET NIMBLE OPTIONS.
  *
- * The config options here are for Arduino use only.
+ * The config options here are for doxygen documentation only.
  */
 
 #pragma once
 
 #include "sdkconfig.h"
+#include "nimconfig_rename.h"
 
-/*
- * For ESP-IDF compatibility
- * Some versions of ESP-IDF used the config name format "CONFIG_NIMBLE_".
- * This converts them to "CONFIG_BT_NIMBLE_" format used in the latest IDF.
- */
+#ifdef _DOXYGEN_
 
-/* Detect if using ESP-IDF or Arduino (Arduino won't have these defines in sdkconfig) */
-#if defined(CONFIG_BT_NIMBLE_TASK_STACK_SIZE) || defined(CONFIG_NIMBLE_TASK_STACK_SIZE)
-
-#if defined(CONFIG_NIMBLE_ENABLED) && !defined(CONFIG_BT_NIMBLE_ENABLED)
-#define CONFIG_BT_NIMBLE_ENABLED
-#endif
-
-#if defined(CONFIG_NIMBLE_ROLE_OBSERVER) && !defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
-#define CONFIG_BT_NIMBLE_ROLE_OBSERVER
-#endif
-
-#if defined(CONFIG_NIMBLE_ROLE_BROADCASTER) && !defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
-#define CONFIG_BT_NIMBLE_ROLE_BROADCASTER
-#endif
-
-#if defined(CONFIG_NIMBLE_ROLE_CENTRAL) && !defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#define CONFIG_BT_NIMBLE_ROLE_CENTRAL
-#endif
-
-#if defined(CONFIG_NIMBLE_ROLE_PERIPHERAL) && !defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#define CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
-#endif
-
-#if defined(CONFIG_NIMBLE_DEBUG) && !defined(CONFIG_BT_NIMBLE_DEBUG)
-#define CONFIG_BT_NIMBLE_DEBUG
-#endif
-
-#else // Using Arduino
-
-/***********************************************
- * Arduino config options start here
- **********************************************/
-
-/** @brief Comment out if not using NimBLE Client functions \n
- *  Reduces flash size by approx. 7kB.
- */
-#define CONFIG_BT_NIMBLE_ROLE_CENTRAL
-
-/** @brief Comment out if not using NimBLE Scan functions \n
- *  Reduces flash size by approx. 26kB.
- */
-#define CONFIG_BT_NIMBLE_ROLE_OBSERVER
-
-/** @brief Comment out if not using NimBLE Server functions \n
- *  Reduces flash size by approx. 16kB.
- */
-#define CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
-
-/** @brief Comment out if not using NimBLE Advertising functions \n
- *  Reduces flash size by approx. 5kB.
- */
-#define CONFIG_BT_NIMBLE_ROLE_BROADCASTER
-
-/*  Uncomment to see debug log messages from the NimBLE host
- *  Uses approx. 32kB of flash memory.
- */
-// #define CONFIG_BT_NIMBLE_DEBUG
-
-/*  Uncomment to see NimBLE host return codes as text debug log messages.
- *  Uses approx. 7kB of flash memory.
- */
-// #define CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
-
-/*  Uncomment to see GAP event codes as text in debug log messages.
- *  Uses approx. 1kB of flash memory.
- */
-// #define CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
-
-/*  Uncomment to see advertisment types as text while scanning in debug log messages.
- *  Uses approx. 250 bytes of flash memory.
- */
-// #define CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT
-
-/** @brief Sets the core NimBLE host runs on */
-#define CONFIG_BT_NIMBLE_PINNED_TO_CORE 0
-
-/** @brief Sets the stack size for the NimBLE host task */
-#define CONFIG_BT_NIMBLE_TASK_STACK_SIZE 4096
-
-/**
- * @brief Sets the memory pool where NimBLE will be loaded
- * @details By default NimBLE is loaded in internal ram.\n
- * To use external PSRAM you must change this to `#define CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL 1`
- */
-#define CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL 1
-
-/** @brief Sets the number of simultaneous connections (esp controller max is 9) */
+/** @brief Un-comment to change the number of simultaneous connections (esp controller max is 9) */
 #define CONFIG_BT_NIMBLE_MAX_CONNECTIONS 3
 
-/** @brief Sets the number of devices allowed to store/bond with */
-#define CONFIG_BT_NIMBLE_MAX_BONDS 3
+/** @brief Un-comment to change the default MTU size */
+#define CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU 255
 
-/** @brief Sets the maximum number of CCCD subscriptions to store */
-#define CONFIG_BT_NIMBLE_MAX_CCCDS 8
-
-/** @brief Set if CCCD's and bond data should be stored in NVS */
-#define CONFIG_BT_NIMBLE_NVS_PERSIST 1
-
-/** @brief Allow legacy paring */
-#define CONFIG_BT_NIMBLE_SM_LEGACY 1
-
-/** @brief Allow BLE secure connections */
-#define CONFIG_BT_NIMBLE_SM_SC 1
-
-/** @brief Default device name */
+/** @brief Un-comment to change default device name */
 #define CONFIG_BT_NIMBLE_SVC_GAP_DEVICE_NAME "nimble"
 
-/** @brief Max device name length (bytes) */
-#define CONFIG_BT_NIMBLE_GAP_DEVICE_NAME_MAX_LEN 31
+/** @brief Un-comment to see debug log messages from the NimBLE host
+ *  Uses approx. 32kB of flash memory.
+ */
+#define CONFIG_BT_NIMBLE_DEBUG
 
-/** @brief Default MTU size */
-#define CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU 256
+/** @brief Un-comment to see NimBLE host return codes as text debug log messages.
+ *  Uses approx. 7kB of flash memory.
+ */
+#define CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
 
-/** @brief Default GAP appearance */
+/** @brief Un-comment to see GAP event codes as text in debug log messages.
+ *  Uses approx. 1kB of flash memory.
+ */
+#define CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
+
+/** @brief Un-comment to see advertisment types as text while scanning in debug log messages.
+ *  Uses approx. 250 bytes of flash memory.
+ */
+#define CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT
+
+/** @brief Un-comment to change the default GAP appearance */
 #define CONFIG_BT_NIMBLE_SVC_GAP_APPEARANCE 0x0
 
-/** @brief ACL Buffer count */
-#define CONFIG_BT_NIMBLE_ACL_BUF_COUNT 12
+ /** @brief Un-comment if not using NimBLE Client functions \n
+ *  Reduces flash size by approx. 7kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
 
-/** @brief ACL Buffer size */
-#define CONFIG_BT_NIMBLE_ACL_BUF_SIZE 255
+/** @brief Un-comment if not using NimBLE Scan functions \n
+ *  Reduces flash size by approx. 26kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_OBSERVER_DISABLED
 
-/** @brief HCI Event Buffer size */
-#define CONFIG_BT_NIMBLE_HCI_EVT_BUF_SIZE 70
+/** @brief Un-comment if not using NimBLE Server functions \n
+ *  Reduces flash size by approx. 16kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_PERIPHERAL_DISABLED
 
-/** @brief Number of high priority HCI event buffers */
-#define CONFIG_BT_NIMBLE_HCI_EVT_HI_BUF_COUNT 30
+/** @brief Un-comment if not using NimBLE Advertising functions \n
+ *  Reduces flash size by approx. 5kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_BROADCASTER_DISABLED
 
-/** @brief Number of low priority HCI event buffers */
-#define CONFIG_BT_NIMBLE_HCI_EVT_LO_BUF_COUNT 8
+/** @brief Un-comment to change the number of devices allowed to store/bond with */
+#define CONFIG_BT_NIMBLE_MAX_BONDS 3
+
+/** @brief Un-comment to change the maximum number of CCCD subscriptions to store */
+#define CONFIG_BT_NIMBLE_MAX_CCCDS 8
+
+/** @brief Un-comment to change the random address refresh time (in seconds) */
+#define CONFIG_BT_NIMBLE_RPA_TIMEOUT 900
 
 /**
- * @brief Sets the number of MSYS buffers available.
+ * @brief Un-comment to change the number of MSYS buffers available.
  * @details MSYS is a system level mbuf registry. For prepare write & prepare \n
  * responses MBUFs are allocated out of msys_1 pool. This may need to be increased if\n
  * you are sending large blocks of data with a low MTU. E.g: 512 bytes with 23 MTU will fail.
  */
 #define CONFIG_BT_NIMBLE_MSYS1_BLOCK_COUNT 12
 
+/** @brief Un-comment to use external PSRAM for the NimBLE host */
+#define CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL 1
 
-/** @brief Random address refresh time in seconds */
-#define CONFIG_BT_NIMBLE_RPA_TIMEOUT 900
+/** @brief Un-comment to change the core NimBLE host runs on */
+#define CONFIG_BT_NIMBLE_PINNED_TO_CORE 0
 
-/** @brief Maximum number of connection oriented channels */
-#define CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM 0
+/** @brief Un-comment to change the stack size for the NimBLE host task */
+#define CONFIG_BT_NIMBLE_TASK_STACK_SIZE 4096
 
-/* These should not be altered */
-#define CONFIG_BT_NIMBLE_HS_FLOW_CTRL 1
-#define CONFIG_BT_NIMBLE_HS_FLOW_CTRL_ITVL 1000
-#define CONFIG_BT_NIMBLE_HS_FLOW_CTRL_THRESH 2
-#define CONFIG_BT_NIMBLE_HS_FLOW_CTRL_TX_ON_DISCONNECT 1
-
-#ifndef CONFIG_BT_ENABLED
-#define CONFIG_BT_ENABLED
-#endif
-
-#define CONFIG_BTDM_CONTROLLER_MODE_BLE_ONLY
-
-#endif // #if defined(CONFIG_BT_NIMBLE_TASK_STACK_SIZE) || defined(CONFIG_NIMBLE_TASK_STACK_SIZE)
-
-/**********************************
- End Arduino config
-**********************************/
-
-
-/* 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
-
-
-
-#ifdef _DOXYGEN_
-/** @brief Uncomment to see debug log messages from the NimBLE host \n
- *  Uses approx. 32kB of flash memory.
- */
-#define CONFIG_BT_NIMBLE_DEBUG
-
-/** @brief Uncomment to see NimBLE host return codes as text debug log messages. \n
- *  Uses approx. 7kB of flash memory.
- */
-#define CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
-
-/** @brief Uncomment to see GAP event codes as text in debug log messages. \n
- *  Uses approx. 1kB of flash memory.
- */
-#define CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT
-
-/** @brief Uncomment to see advertisment types as text while scanning in debug log messages. \n
- *  Uses approx. 250 bytes of flash memory.
- */
-#define CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT
 #endif // _DOXYGEN_

src/nimconfig_rename.h

@@ -0,0 +1,53 @@
+/*
+ * For ESP-IDF compatibility
+ * Some versions of ESP-IDF used the config name format "CONFIG_NIMBLE_".
+ * This converts them to "CONFIG_BT_NIMBLE_" format used in the latest IDF.
+ */
+
+#if defined(CONFIG_NIMBLE_ENABLED) && !defined(CONFIG_BT_NIMBLE_ENABLED)
+#define CONFIG_BT_NIMBLE_ENABLED
+#endif
+
+#if defined(CONFIG_NIMBLE_ROLE_OBSERVER) && !defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#define CONFIG_BT_NIMBLE_ROLE_OBSERVER
+#endif
+
+#if defined(CONFIG_NIMBLE_ROLE_BROADCASTER) && !defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#define CONFIG_BT_NIMBLE_ROLE_BROADCASTER
+#endif
+
+#if defined(CONFIG_NIMBLE_ROLE_CENTRAL) && !defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#define CONFIG_BT_NIMBLE_ROLE_CENTRAL
+#endif
+
+#if defined(CONFIG_NIMBLE_ROLE_PERIPHERAL) && !defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#define CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
+#endif
+
+#if defined(CONFIG_NIMBLE_DEBUG) && !defined(CONFIG_BT_NIMBLE_DEBUG)
+#define CONFIG_BT_NIMBLE_DEBUG
+#endif
+
+#if defined(CONFIG_SCAN_DUPLICATE_BY_DEVICE_ADDR) && !defined(CONFIG_BTDM_SCAN_DUPL_TYPE_DEVICE)
+#define CONFIG_BTDM_SCAN_DUPL_TYPE_DEVICE CONFIG_SCAN_DUPLICATE_BY_DEVICE_ADDR
+#endif
+
+#if defined(CONFIG_SCAN_DUPLICATE_BY_ADV_DATA ) && !defined(CONFIG_BTDM_SCAN_DUPL_TYPE_DATA)
+#define CONFIG_BTDM_SCAN_DUPL_TYPE_DATA CONFIG_SCAN_DUPLICATE_BY_ADV_DATA
+#endif
+
+#if defined(CONFIG_SCAN_DUPLICATE_BY_ADV_DATA_AND_DEVICE_ADDR) && !defined(CONFIG_BTDM_SCAN_DUPL_TYPE_DATA_DEVICE)
+#define CONFIG_BTDM_SCAN_DUPL_TYPE_DATA_DEVICE CONFIG_SCAN_DUPLICATE_BY_ADV_DATA_AND_DEVICE_ADDR
+#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_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_NIMBLE_MAX_CONNECTIONS ) && !defined(CONFIG_BT_NIMBLE_MAX_CONNECTIONS)
+#define CONFIG_BT_NIMBLE_MAX_CONNECTIONS CONFIG_NIMBLE_MAX_CONNECTIONS  
+#endif