Add persistent storage for Mesh config.

Adds support for advertising and connections with coded/2M PHY's.

Adds new classes `NimBLEExtAdvertising` and `NimBLEExtAdvertisement`.
When extended advertising is enabled the original advertising classes become unavailable and the new classes must be used.

Changed some return values for advertising methods for consistency with the new classes methods.

.travis.yml

@@ -1,27 +0,0 @@
-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
- - mkdir doxygen_build
- - cd doxygen_build
- - cmake ../doxygen-1.8.19/
- - make
- - export PATH="${TMPDIR-/tmp}/doxygen_build/bin:$PATH"
- - cd ${TRAVIS_BUILD_DIR}
- 
-branches:
-  only:
-    - master
-
-script:
-  - doxygen ./docs/Doxyfile
-
-deploy:
-  provider: pages
-  skip_cleanup: true
-  local_dir: docs/html
-  github_token: $GH_REPO_TOKEN
-  on:
-    branch: master

CHANGELOG.md

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

CMakeLists.txt

@@ -2,28 +2,79 @@
 # 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
+    )
+elseif("bt" IN_LIST BUILD_COMPONENTS OR "__bt" IN_LIST __hack_component_targets)
+    list(APPEND ESP_NIMBLE_PRIV_REQUIRES
+        bt
+    )
+endif()
+
+if("arduino" IN_LIST BUILD_COMPONENTS OR __hack_component_targets MATCHES "__idf_arduino")
+    list(APPEND ESP_NIMBLE_PRIV_REQUIRES
+        arduino
+    )
+endif()
+
+set(srcs "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/NimBLEExtAdvertising.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")
+
+if(CONFIG_BT_NIMBLE_MESH)
+    list(APPEND srcs "src/NimBLEMeshCreateModel.c"
+    "src/NimBLEMeshElement.cpp"
+    "src/NimBLEMeshModel.cpp"
+    "src/NimBLEMeshNode.cpp")
+endif()
+
+if(CONFIG_NIMBLE_CPP_PERSIST_MESH_SETTINGS)
+    list(APPEND srcs "src/mesh_config_store/config/config_store.c")
+endif()
+
+idf_component_register(
+  REQUIRED_IDF_TARGETS
+    "esp32"
+    "esp32s3"
+    "esp32c3"
+  INCLUDE_DIRS
+    "src"
+  SRCS "${srcs}"
+
+  REQUIRES
+    bt
+    nvs_flash
+  PRIV_REQUIRES
+    ${ESP_NIMBLE_PRIV_REQUIRES}
+)
+
+if(CONFIG_BT_NIMBLE_MESH AND CONFIG_NIMBLE_CPP_PERSIST_MESH_SETTINGS)
+  idf_build_set_property(COMPILE_OPTIONS "-DMYNEWT_VAL_BLE_MESH_SETTINGS=1" APPEND)
+  idf_build_set_property(COMPILE_OPTIONS "-I${COMPONENT_DIR}/src/mesh_config_store" APPEND)
+endif()

CMakeLists.txt_idf3

@@ -0,0 +1,56 @@
+# 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/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

@@ -1,5 +1,31 @@
 menu "ESP-NimBLE-CPP configuration"
 
+choice NIMBLE_CPP_LOG_LEVEL
+    prompt "NimBLE CPP log verbosity"
+    default NIMBLE_CPP_LOG_LEVEL_NONE
+    help
+        Select NimBLE CPP log verbosity level.
+
+    config NIMBLE_CPP_LOG_LEVEL_NONE
+        bool "No logs"
+    config NIMBLE_CPP_LOG_LEVEL_ERROR
+        bool "Error logs"
+    config NIMBLE_CPP_LOG_LEVEL_WARNING
+        bool "Warning logs"
+    config NIMBLE_CPP_LOG_LEVEL_INFO
+        bool "Info logs"
+    config NIMBLE_CPP_LOG_LEVEL_DEBUG
+        bool "Debug logs"
+endchoice #NIMBLE_CPP_LOG_LEVEL
+
+config NIMBLE_CPP_LOG_LEVEL
+    int
+    default 0 if NIMBLE_CPP_LOG_LEVEL_NONE
+    default 1 if NIMBLE_CPP_LOG_LEVEL_ERROR
+    default 2 if NIMBLE_CPP_LOG_LEVEL_WARNING
+    default 3 if NIMBLE_CPP_LOG_LEVEL_INFO
+    default 4 if NIMBLE_CPP_LOG_LEVEL_DEBUG
+
 config NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
     bool "Show NimBLE return codes as text in debug log."
     default "n"
@@ -7,7 +33,7 @@ config NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT
         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"
@@ -21,7 +47,34 @@ config NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT
     default "n"
     help
         Enabling this option will display advertisment types recieved
-        while scanning as text messages in the debug log. 
+        while scanning as text messages in the debug log.
         This will use approximately 250 bytes of flash memory.
-        
+
+config NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+    bool "Enable timestamps to be stored with attribute values."
+    default "n"
+    help
+        Enabling this option will store the timestamp when an attribute value is updated.
+        This allows for checking the last update time using getTimeStamp()
+        or getValue(time_t*). If disabled, the timestamp returned from these functions will be 0.
+        Disabling timestamps will reduce the memory used for each value.
+
+config NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
+    int "Initial attribute value size (bytes) for empty values."
+    range 1 512
+    default 20
+    help
+        Sets the default allocation size (bytes) for each attribute if not specified
+        when the constructor is called. This is also the size used when a remote
+        characteristic or descriptor is constructed before a value is read/notifed.
+        Increasing this will reduce reallocations but increase memory footprint.
+
+config NIMBLE_CPP_PERSIST_MESH_SETTINGS
+    bool "Enable persistent storage of mesh config settings."
+    default "n"
+    depends on BT_NIMBLE_MESH
+    help
+        Enabling this option will store the provisioning and app key settings
+        in non-volatile storage when using NimBLE Mesh.
+
 endmenu

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,15 +57,14 @@ 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.
 * [Jeroen88](https://github.com/Jeroen88) for the amazing help debugging and improving the client code.  
 <br/>  
 
-# Todo
-- Improve host reset handler
-- Implement random address handling
-- Implement bond management
-- Add Bluetooth Mesh
-<br/>  

docs/Bluetooth 5 features.md

@@ -0,0 +1,29 @@
+# Bluetooth 5.x features
+
+## About extended advertising
+Extended advertising allows for much more capability and flexibility.
+
+* Allows for 251 bytes of advertisement data and up to 1650 bytes when chained (configuration dependant) vs 31.
+
+* New PHY's (physical layers) that allow for faster data rate (2M PHY) or long range/slower data rates (CODED PHY) as well as the original 1M PHY.
+
+* New periodic advertising, allowing the scanning device to sync with the advertisements of a beacon. This allows for the scanning device to sleep or perform other tasks before the next expected advertisement is sent, preserving cpu cycles and power (To be implemented).
+<br>
+
+## Enabling extended advertising
+Extended advertising is supported when enabled with the config option `CONFIG_BT_NIMBLE_EXT_ADV` set to a value of 1. This is done in menuconfig under `Component config > Bluetooth > NimBLE options >
+Enable extended advertising`.
+
+When enabled the following will occur:
+* `NimBLEScan::start` method will scan on both the 1M PHY and the coded PHY standards automatically.
+
+* `NimBLEClient::connect` will use the primary PHY the device is listening on, unless specified (see below).
+
+* `NimBLEClient::setConnectPhy` becomes available to specify the PHY's to connect with (default is all).
+
+* `NimBLEAdvertising` is no longer available for use and is replaced by `NimBLEExtAdvertising`. `NimBLEDevice::getAdvertising` will now return an instance of `NimBLEExtAdvertising`.
+
+* `NimBLEAdvertisementData` is no longer available for use and is replaced by `NimBLEExtAdvertisement`. This new class is where everything about the advertisement is configured, including the advertisement intervals and advertisement ended callback.
+
+
+

docs/Command_line_config.md

@@ -0,0 +1,142 @@
+# 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_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED`
+
+Enable/disable storing the timestamp when an attribute value is updated  
+This allows for checking the last update time using getTimeStamp() or getValue(time_t*)  
+If disabled, the timestamp returned from these functions will be 0.  
+Disabling timestamps will reduce the memory used for each value.  
+1 = Enabled, 0 = Disabled; Default = Disabled  
+<br/>
+
+`CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH`
+
+Set the default allocation size (bytes) for each attribute.  
+If not specified when the constructor is called. This is also the size used when a remote  
+characteristic or descriptor is constructed before a value is read/notifed.  
+Increasing this will reduce reallocations but increase memory footprint.  
+Default value is 20. Range: 1 : 512 (BLE_ATT_ATTR_MAX_LEN)  
+ <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_LOG_LEVEL`   
+
+Define to set the debug log message level from the NimBLE CPP Wrapper.  
+If not defined it will use the same value as the Arduino core debug level.  
+Values: 0 = NONE, 1 = ERROR, 2 = WARNING, 3 = INFO, 4+ = DEBUG  
+<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

@@ -1,4 +1,4 @@
-# Doxyfile 1.8.18
+# Doxyfile 1.9.1
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -32,13 +32,13 @@ DOXYFILE_ENCODING      = UTF-8
 # title of most generated pages and in a few other places.
 # The default value is: My Project.
 
-PROJECT_NAME           = "esp-nimble-cpp / NimBLE-Arduino"
+PROJECT_NAME           = esp-nimble-cpp
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 1.0.0
+PROJECT_NUMBER         = 1.3.2
 
 # 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
@@ -58,7 +58,7 @@ PROJECT_LOGO           =
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = docs
+OUTPUT_DIRECTORY       = .
 
 # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
@@ -227,6 +227,14 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = NO
 
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
@@ -315,7 +323,10 @@ OPTIMIZE_OUTPUT_SLICE  = NO
 # Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
 
 EXTENSION_MAPPING      =
 
@@ -449,6 +460,19 @@ TYPEDEF_HIDES_STRUCT   = NO
 
 LOOKUP_CACHE_SIZE      = 0
 
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which efficively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -512,6 +536,13 @@ EXTRACT_LOCAL_METHODS  = NO
 
 EXTRACT_ANON_NSPACES   = NO
 
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
@@ -549,11 +580,18 @@ HIDE_IN_BODY_DOCS      = YES
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# (including Cygwin) ands Mac users are advised to set this option to NO.
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = NO
@@ -792,7 +830,10 @@ WARN_IF_DOC_ERROR      = YES
 WARN_NO_PARAMDOC       = NO
 
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
 # The default value is: NO.
 
 WARN_AS_ERROR          = NO
@@ -823,13 +864,15 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = .
+INPUT                  = ../CHANGELOG.md \
+                         . \
+                         ../src
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
-# possible encodings.
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
@@ -842,13 +885,15 @@ INPUT_ENCODING         = UTF-8
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # read by doxygen.
 #
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
 # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
 # *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
-# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen
-# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
-# *.vhdl, *.ucf, *.qsf and *.ice.
+# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
+# *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          = *.c \
                          *.cc \
@@ -911,11 +956,7 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                = ./README.md \
-                         ./src/FreeRTOS.h \
-                         ./src/FreeRTOS.cpp \
-                         ./examples \
-                         ./CMakelists.txt
+EXCLUDE                = ../src/nimconfig_rename.h
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
@@ -1112,6 +1153,44 @@ USE_HTAGS              = NO
 
 VERBATIM_HEADERS       = YES
 
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled and the CLANG_ADD_INC_PATHS tag is set to
+# YES then doxygen will add the directory of each input to the include path.
+# The default value is: YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
@@ -1123,13 +1202,6 @@ VERBATIM_HEADERS       = YES
 
 ALPHABETICAL_INDEX     = YES
 
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
@@ -1300,10 +1372,11 @@ HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: https://developer.apple.com/xcode/), introduced with OSX
-# 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
 # startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
 # genXcode/_index.html for more information.
@@ -1345,8 +1418,8 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
+# (see:
+# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1376,7 +1449,7 @@ CHM_FILE               =
 HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
@@ -1421,7 +1494,8 @@ QCH_FILE               =
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
-# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1429,8 +1503,8 @@ QHP_NAMESPACE          = org.doxygen.Project
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
-# folders).
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1438,16 +1512,16 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
@@ -1459,9 +1533,9 @@ QHP_CUST_FILTER_ATTRS  =
 
 QHP_SECT_FILTER_ATTRS  =
 
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           =
@@ -1542,8 +1616,8 @@ EXT_LINKS_IN_WINDOW    = NO
 # tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
 # https://inkscape.org) to generate formulas as SVG images instead of PNGs for
 # the HTML output. These images will generally look nicer at scaled resolutions.
-# Possible values are: png The default and svg Looks nicer but requires the
-# pdf2svg tool.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
 # The default value is: png.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
@@ -1588,7 +1662,7 @@ USE_MATHJAX            = NO
 
 # When MathJax is enabled you can set the default output format to be used for
 # the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
 # Possible values are: HTML-CSS (which is slower, but has the best
 # compatibility), NativeMML (i.e. MathML) and SVG.
 # The default value is: HTML-CSS.
@@ -1618,7 +1692,8 @@ MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1665,7 +1740,8 @@ SERVER_BASED_SEARCH    = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/).
+# Xapian (see:
+# https://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
@@ -1678,8 +1754,9 @@ EXTERNAL_SEARCH        = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/). See the section "External Indexing and
-# Searching" for details.
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
@@ -1843,9 +1920,11 @@ LATEX_EXTRA_FILES      =
 
 PDF_HYPERLINKS         = YES
 
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -2084,6 +2163,10 @@ DOCBOOK_PROGRAMLISTING = NO
 
 GENERATE_AUTOGEN_DEF   = NO
 
+#---------------------------------------------------------------------------
+# Configuration options related to Sqlite3 output
+#---------------------------------------------------------------------------
+
 #---------------------------------------------------------------------------
 # Configuration options related to the Perl module output
 #---------------------------------------------------------------------------
@@ -2179,8 +2262,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
@@ -2357,10 +2444,32 @@ UML_LOOK               = NO
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
+# This tag requires that the tag UML_LOOK is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
@@ -2550,9 +2659,11 @@ DOT_MULTI_TARGETS      = NO
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc and
+# plantuml temporary files.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES

docs/Improvements_and_updates.md

@@ -4,6 +4,7 @@ Many improvements have been made to this library vs the original, this is a brie
 Refer to the [class documentation](https://h2zero.github.io/esp-nimble-cpp/annotated.html) for futher information on class specifics.  
 
 * [Server](#server)
+* [Advertising](#advertising)
 * [Client](#client)
 * [General](#general)  
 <br/>
@@ -60,6 +61,18 @@ it's characteristics / descriptors will remain valid and the service can be re-a
 using `NimBLEServer::addService`.  
 <br/>
 
+<a name="advertising"></a>
+# Advertising
+`NimBLEAdvertising::start`
+
+Now takes 2 optional parameters, the first is the duration to advertise for (in seconds), the second is a callback  
+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>
 # Client  
 
@@ -89,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

@@ -209,12 +209,28 @@ This can be changed to use passkey authentication or numeric comparison. See [Se
 
 <a name="advertising-api"></a>
 ## Advertising API
-Advertising works the same as the original API except with the removal of:  
+Advertising works the same as the original API except:  
 > BLEAdvertising::setMinPreferred  
 > BLEAdvertising::setMaxPreferred  
 
 These methods were found to not provide useful functionality and consumed valuable advertising space (6 bytes of 31) if used unknowingly.  
-If you wish to advertise these parameters you can still do so manually via `NimBLEAdvertisementData::addData`.  
+If you wish to advertise these parameters you can still do so manually via `BLEAdvertisementData::addData` (`NimBLEAdvertisementData::addData`).  
+<br/>
+
+Calling `NimBLEAdvertising::setAdvertisementData` will entirely replace any data set with `NimBLEAdvertising::addServiceUUID`, or  
+`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.~~  
+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)
+
+Now takes 2 optional parameters, the first is the duration to advertise for (in seconds), the second is a callback  
+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.  
 <br/>
 
 <a name="client-api"></a>

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/>
+*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.  
 
-`#include "NimBLEDevice.h"` at the beginning of your sketch.
+**Alternatively:** Download as .zip and extract to Arduino/libraries folder, or in Arduino IDE from Sketch menu -> Include library -> Add .Zip library.  
 
-Tested and working with esp32-arduino Arduino IDE and platform IO.  
+`#include "NimBLEDevice.h"` at the beginning of your sketch.  
+
+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,33 +52,30 @@ 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.**  
-
-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.  
+### 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/>  
 
+# 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
 
 * [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.

examples/Advanced/NimBLE_Server/main/main.cpp

@@ -41,6 +41,9 @@ class ServerCallbacks: public NimBLEServerCallbacks {
         printf("Client disconnected - start advertising\n");
         NimBLEDevice::startAdvertising();
     };
+    void onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc) {
+        printf("MTU updated: %u for connection ID: %u\n", MTU, desc->conn_handle);
+    };
     
 /********************* Security handled here **********************
 ****** Note: these are the same return values as defaults ********/

examples/Bluetooth_5/NimBLE_extended_client/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32c3 esp32s3)
+project(NimBLE_extended_client)

examples/Bluetooth_5/NimBLE_extended_client/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_extended_client
+
+include $(IDF_PATH)/make/project.mk

examples/Bluetooth_5/NimBLE_extended_client/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "main.cpp")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()

examples/Bluetooth_5/NimBLE_extended_client/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Bluetooth_5/NimBLE_extended_client/main/main.cpp

@@ -0,0 +1,169 @@
+
+/** NimBLE Extended Client Demo:
+ *
+ *  Demonstrates the Bluetooth 5.x client capabilities.
+ *
+ *  Created: on April 2 2022
+ *      Author: H2zero
+ *
+*/
+#include <NimBLEDevice.h>
+
+extern "C" void app_main(void);
+
+void scanEndedCB(NimBLEScanResults results);
+
+#define SERVICE_UUID        "ABCD"
+#define CHARACTERISTIC_UUID "1234"
+
+static NimBLEAdvertisedDevice* advDevice;
+static bool doConnect = false;
+static uint32_t scanTime = 10; /* 0 = scan forever */
+
+/* Define the PHY's to use when connecting to peer devices, can be 1, 2, or all 3 (default).*/
+static uint8_t connectPhys = BLE_GAP_LE_PHY_CODED_MASK | BLE_GAP_LE_PHY_1M_MASK /*| BLE_GAP_LE_PHY_2M_MASK */ ;
+
+/* Define a class to handle the callbacks for client connection events */
+class ClientCallbacks : public NimBLEClientCallbacks {
+    void onConnect(NimBLEClient* pClient) {
+        printf("Connected\n");
+    };
+
+    void onDisconnect(NimBLEClient* pClient) {
+        printf("%s Disconnected - Starting scan\n", pClient->getPeerAddress().toString().c_str());
+        NimBLEDevice::getScan()->start(scanTime, scanEndedCB);
+    };
+};
+
+
+/* Define a class to handle the callbacks when advertisements are received */
+class AdvertisedDeviceCallbacks: public NimBLEAdvertisedDeviceCallbacks {
+
+    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
+        printf("Advertised Device found: %s\n", advertisedDevice->toString().c_str());
+        if(advertisedDevice->isAdvertisingService(NimBLEUUID("ABCD")))
+        {
+            printf("Found Our Service\n");
+            /* Ready to connect now */
+            doConnect = true;
+            /* Save the device reference in a global for the client to use*/
+            advDevice = advertisedDevice;
+            /* stop scan before connecting */
+            NimBLEDevice::getScan()->stop();
+        }
+    };
+};
+
+
+/* Callback to process the results of the last scan or restart it */
+void scanEndedCB(NimBLEScanResults results){
+    printf("Scan Ended\n");
+    if (!doConnect) { /* Don't start the scan while connecting */
+        NimBLEDevice::getScan()->start(scanTime, scanEndedCB);
+    }
+}
+
+
+/* Handles the provisioning of clients and connects / interfaces with the server */
+bool connectToServer() {
+    NimBLEClient* pClient = nullptr;
+
+    pClient = NimBLEDevice::createClient();
+    pClient->setClientCallbacks(new ClientCallbacks, false);
+
+    /* Set the PHY's to use for this connection. This is a bitmask that represents the PHY's:
+     * * 0x01 BLE_GAP_LE_PHY_1M_MASK
+     * * 0x02 BLE_GAP_LE_PHY_2M_MASK
+     * * 0x04 BLE_GAP_LE_PHY_CODED_MASK
+     * Combine these with OR ("|"), eg BLE_GAP_LE_PHY_1M_MASK | BLE_GAP_LE_PHY_2M_MASK | BLE_GAP_LE_PHY_CODED_MASK;
+     */
+    pClient->setConnectPhy(connectPhys);
+
+    /** Set how long we are willing to wait for the connection to complete (seconds), default is 30. */
+    pClient->setConnectTimeout(10);
+
+    if (!pClient->connect(advDevice)) {
+        /* Created a client but failed to connect, don't need to keep it as it has no data */
+        NimBLEDevice::deleteClient(pClient);
+        printf("Failed to connect, deleted client\n");
+        return false;
+    }
+
+    printf("Connected to: %s RSSI: %d\n",
+           pClient->getPeerAddress().toString().c_str(),
+           pClient->getRssi());
+
+    /* Now we can read/write/subscribe the charateristics of the services we are interested in */
+    NimBLERemoteService* pSvc = nullptr;
+    NimBLERemoteCharacteristic* pChr = nullptr;
+
+    pSvc = pClient->getService(SERVICE_UUID);
+
+    if (pSvc) {
+        pChr = pSvc->getCharacteristic(CHARACTERISTIC_UUID);
+
+        if (pChr) {
+            // Read the value of the characteristic.
+            if (pChr->canRead()) {
+                std::string value = pChr->readValue();
+                printf("Characteristic value: %s\n", value.c_str());
+            }
+        }
+
+    } else {
+        printf("ABCD service not found.\n");
+    }
+
+    NimBLEDevice::deleteClient(pClient);
+    printf("Done with this device!\n");
+    return true;
+}
+
+void connectTask (void * parameter){
+    /* Loop here until we find a device we want to connect to */
+    for (;;) {
+        if (doConnect) {
+            /* Found a device we want to connect to, do it now */
+            if (connectToServer()) {
+                printf("Success!, scanning for more!\n");
+            } else {
+                printf("Failed to connect, starting scan\n");
+            }
+
+            doConnect = false;
+            NimBLEDevice::getScan()->start(scanTime, scanEndedCB);
+        }
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+
+    vTaskDelete(NULL);
+}
+
+void app_main (void) {
+    printf("Starting NimBLE Client\n");
+    /* Create a task to handle connecting to peers */
+    xTaskCreate(connectTask, "connectTask", 5000, NULL, 1, NULL);
+
+    /* Initialize NimBLE, no device name specified as we are not advertising */
+    NimBLEDevice::init("");
+    NimBLEScan* pScan = NimBLEDevice::getScan();
+
+    /* create a callback that gets called when advertisers are found */
+    pScan->setAdvertisedDeviceCallbacks(new AdvertisedDeviceCallbacks());
+
+    /* Set scan interval (how often) and window (how long) in milliseconds */
+    pScan->setInterval(97);
+    pScan->setWindow(67);
+
+    /*  Active scan will gather scan response data from advertisers
+     *  but will use more energy from both devices
+     */
+    pScan->setActiveScan(true);
+
+    /*  Start scanning for advertisers for the scan time specified (in seconds) 0 = forever
+     *  Optional callback for when scanning stops.
+     */
+    pScan->start(scanTime, scanEndedCB);
+
+    printf("Scanning for peripherals\n");
+}

examples/Bluetooth_5/NimBLE_extended_server/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32c3 esp32s3)
+project(NimBLE_extended_server)

examples/Bluetooth_5/NimBLE_extended_server/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_extended_server
+
+include $(IDF_PATH)/make/project.mk

examples/Bluetooth_5/NimBLE_extended_server/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "main.cpp")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()

examples/Bluetooth_5/NimBLE_extended_server/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Bluetooth_5/NimBLE_extended_server/main/main.cpp

@@ -0,0 +1,139 @@
+/** NimBLE Extended Server Demo:
+ *
+ *  Demonstrates the Bluetooth 5.x extended advertising capabilities.
+ *
+ *  This demo will advertise a long data string on the CODED and 1M Phy's and
+ *  starts a server allowing connection over either PHY's. It will advertise for
+ *  5 seconds then sleep for 20 seconds, if a client connects it will sleep once
+ *  it has disconnected then repeats.
+ *
+ *  Created: on April 2 2022
+ *      Author: H2zero
+ *
+*/
+
+#include "NimBLEDevice.h"
+#include "esp_sleep.h"
+
+extern "C" void app_main(void);
+
+#define SERVICE_UUID        "ABCD"
+#define CHARACTERISTIC_UUID "1234"
+
+/* Time in milliseconds to advertise */
+static uint32_t advTime = 5000;
+
+/* Time to sleep between advertisements */
+static uint32_t sleepSeconds = 20;
+
+/* Primary PHY used for advertising, can be one of BLE_HCI_LE_PHY_1M or BLE_HCI_LE_PHY_CODED */
+static uint8_t primaryPhy = BLE_HCI_LE_PHY_CODED;
+
+/* Secondary PHY used for advertising and connecting,
+ * can be one of BLE_HCI_LE_PHY_1M, BLE_HCI_LE_PHY_2M or BLE_HCI_LE_PHY_CODED
+ */
+static uint8_t secondaryPhy = BLE_HCI_LE_PHY_1M;
+
+
+/* Handler class for server events */
+class ServerCallbacks: public NimBLEServerCallbacks {
+    void onConnect(NimBLEServer* pServer, ble_gap_conn_desc* desc) {
+        printf("Client connected: %s\n", NimBLEAddress(desc->peer_ota_addr).toString().c_str());
+    };
+
+    void onDisconnect(NimBLEServer* pServer) {
+        printf("Client disconnected - sleeping for %u seconds\n", sleepSeconds);
+        esp_deep_sleep_start();
+    };
+};
+
+/* Callback class to handle advertising events */
+class advertisingCallbacks: public NimBLEExtAdvertisingCallbacks {
+    void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t inst_id) {
+        /* Check the reason advertising stopped, don't sleep if client is connecting */
+        printf("Advertising instance %u stopped\n", inst_id);
+        switch (reason) {
+            case 0:
+                printf("Client connecting\n");
+                return;
+            case BLE_HS_ETIMEOUT:
+                printf("Time expired - sleeping for %u seconds\n", sleepSeconds);
+                break;
+            default:
+                break;
+        }
+
+        esp_deep_sleep_start();
+    }
+};
+
+void app_main (void) {
+    NimBLEDevice::init("Extended advertiser");
+
+    /* Create the server and add the services/characteristics/descriptors */
+    NimBLEServer *pServer = NimBLEDevice::createServer();
+    pServer->setCallbacks(new ServerCallbacks);
+
+    NimBLEService *pService = pServer->createService(SERVICE_UUID);
+    NimBLECharacteristic *pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID,
+                                                                           NIMBLE_PROPERTY::READ |
+                                                                           NIMBLE_PROPERTY::WRITE |
+                                                                           NIMBLE_PROPERTY::NOTIFY);
+
+    pCharacteristic->setValue("Hello World");
+
+    /* Start the services */
+    pService->start();
+
+    /*
+    * Create an extended advertisement with the instance ID 0 and set the PHY's.
+    * Multiple instances can be added as long as the instance ID is incremented.
+    */
+    NimBLEExtAdvertisement extAdv(primaryPhy, secondaryPhy);
+
+    /* Set the advertisement as connectable */
+    extAdv.setConnectable(true);
+
+    /* As per Bluetooth specification, extended advertising cannot be both scannable and connectable */
+    extAdv.setScannable(false); // The default is false, set here for demonstration.
+
+    /* Extended advertising allows for 251 bytes (minus header bytes ~20) in a single advertisement or up to 1650 if chained */
+    extAdv.setServiceData(NimBLEUUID(SERVICE_UUID), std::string("Extended Advertising Demo.\r\n"
+                                                                "Extended advertising allows for "
+                                                                "251 bytes of data in a single advertisement,\r\n"
+                                                                "or up to 1650 bytes with chaining.\r\n"
+                                                                "This example message is 226 bytes long "
+                                                                "and is using CODED_PHY for long range."));
+
+    extAdv.setCompleteServices16({NimBLEUUID(SERVICE_UUID)});
+
+    /* When extended advertising is enabled `NimBLEDevice::getAdvertising` returns a pointer to `NimBLEExtAdvertising */
+    NimBLEExtAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
+
+    /* Set the callbacks for advertising events */
+    pAdvertising->setCallbacks(new advertisingCallbacks);
+
+    /*
+     * NimBLEExtAdvertising::setInstanceData takes the instance ID and
+     * a reference to a `NimBLEExtAdvertisement` object. This sets the data
+     * that will be advertised for this instance ID, returns true if successful.
+     *
+     * Note: It is safe to create the advertisement as a local variable if setInstanceData
+     * is called before exiting the code block as the data will be copied.
+     */
+    if (pAdvertising->setInstanceData(0, extAdv)) {
+        /*
+         * `NimBLEExtAdvertising::start` takes the advertisement instance ID to start
+         * and a duration in milliseconds or a max number of advertisements to send (or both).
+         */
+        if (pAdvertising->start(0, advTime)) {
+            printf("Started advertising\n");
+        } else {
+            printf("Failed to start advertising\n");
+        }
+    } else {
+        printf("Failed to register advertisment data\n");
+    }
+
+    esp_sleep_enable_timer_wakeup(sleepSeconds * 1000000);
+}

examples/Bluetooth_5/NimBLE_multi_advertiser/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32c3 esp32s3)
+project(NimBLE_multi_advertiser)

examples/Bluetooth_5/NimBLE_multi_advertiser/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := NimBLE_multi_advertiser
+
+include $(IDF_PATH)/make/project.mk

examples/Bluetooth_5/NimBLE_multi_advertiser/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "main.cpp")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()

examples/Bluetooth_5/NimBLE_multi_advertiser/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/Bluetooth_5/NimBLE_multi_advertiser/main/main.cpp

@@ -0,0 +1,170 @@
+/** NimBLE Multi Advertiser Demo:
+ *
+ *  Demonstrates the Bluetooth 5.x extended advertising capabilities.
+ *
+ *  This demo will advertise 2 advertisements, and extended scannable instance
+ *  and a connectable legacy instance. They will advertise for 5 seconds then
+ *  sleep for 20 seconds. The extended scannable instance will use the scan
+ *  request callback to update it's data when a scan response is requested.
+ *
+ *  Created: on April 9 2022
+ *      Author: H2zero
+ *
+*/
+
+#include "NimBLEDevice.h"
+#include "esp_sleep.h"
+
+extern "C" void app_main(void);
+
+#define SERVICE_UUID        "ABCD"
+#define CHARACTERISTIC_UUID "1234"
+
+/* Time in milliseconds to advertise */
+static uint32_t advTime = 5000;
+
+/* Time to sleep between advertisements */
+static uint32_t sleepTime = 20;
+
+/* Primary PHY used for advertising, can be one of BLE_HCI_LE_PHY_1M or BLE_HCI_LE_PHY_CODED */
+static uint8_t primaryPhy = BLE_HCI_LE_PHY_CODED;
+
+/* Secondary PHY used for advertising and connecting,
+ * can be one of BLE_HCI_LE_PHY_1M, BLE_HCI_LE_PHY_2M or BLE_HCI_LE_PHY_CODED
+ */
+static uint8_t secondaryPhy = BLE_HCI_LE_PHY_1M;
+
+
+/* Handler class for server events */
+class ServerCallbacks: public NimBLEServerCallbacks {
+    void onConnect(NimBLEServer* pServer, ble_gap_conn_desc* desc) {
+        printf("Client connected: %s\n", NimBLEAddress(desc->peer_ota_addr).toString().c_str());
+    };
+
+    void onDisconnect(NimBLEServer* pServer) {
+        printf("Client disconnected\n");
+        // if still advertising we won't sleep yet.
+        if (!pServer->getAdvertising()->isAdvertising()) {
+            printf("Sleeping for %u seconds\n", sleepTime);
+            esp_deep_sleep_start();
+        }
+    };
+};
+
+/* Callback class to handle advertising events */
+class advCallbacks: public NimBLEExtAdvertisingCallbacks {
+    void onStopped(NimBLEExtAdvertising* pAdv, int reason, uint8_t inst_id) {
+        /* Check the reason advertising stopped, don't sleep if client is connecting */
+        printf("Advertising instance %u stopped\n", inst_id);
+        switch (reason) {
+            case 0:
+                printf(" client connecting\n");
+                return;
+            case BLE_HS_ETIMEOUT:
+                printf("Time expired - sleeping for %u seconds\n", sleepTime);
+                break;
+            default:
+                break;
+        }
+
+        esp_deep_sleep_start();
+    }
+
+    bool m_updatedSR = false;
+
+    void onScanRequest(NimBLEExtAdvertising* pAdv, uint8_t inst_id, NimBLEAddress addr) {
+        printf("Scan request for instance %u\n", inst_id);
+        // if the data has already been updated we don't need to change it again.
+        if (!m_updatedSR) {
+            printf("Updating scan data\n");
+            NimBLEExtAdvertisement sr;
+            sr.setServiceData(NimBLEUUID(SERVICE_UUID), std::string("Hello from scan response!"));
+            pAdv->setScanResponseData(inst_id, sr);
+            m_updatedSR = true;
+        }
+    }
+};
+
+void app_main (void) {
+    NimBLEDevice::init("Multi advertiser");
+
+    /* Create a server for our legacy advertiser */
+    NimBLEServer *pServer = NimBLEDevice::createServer();
+    pServer->setCallbacks(new ServerCallbacks);
+
+    NimBLEService *pService = pServer->createService(SERVICE_UUID);
+    NimBLECharacteristic *pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID,
+                                                                           NIMBLE_PROPERTY::READ |
+                                                                           NIMBLE_PROPERTY::WRITE |
+                                                                           NIMBLE_PROPERTY::NOTIFY);
+
+    pCharacteristic->setValue("Hello World");
+
+    /* Start the service */
+    pService->start();
+
+    /* Create our multi advertising instances */
+
+    // extended scannable instance advertising on coded and 1m PHY's.
+    NimBLEExtAdvertisement extScannable(primaryPhy, secondaryPhy);
+
+    // Legacy advertising as a connectable device.
+    NimBLEExtAdvertisement legacyConnectable;
+
+    // Optional scan response data.
+    NimBLEExtAdvertisement legacyScanResponse;
+
+    /* As per Bluetooth specification, extended advertising cannot be both scannable and connectable */
+    extScannable.setScannable(true);
+    extScannable.setConnectable(false);
+
+    /* Set the initial data */
+    extScannable.setServiceData(NimBLEUUID(SERVICE_UUID), std::string("Scan me!"));
+
+    /* enable the scan response callback, we will use this to update the data. */
+    extScannable.enableScanRequestCallback(true);
+
+    /* Optional custom address for this advertisment. */
+    legacyConnectable.setAddress(NimBLEAddress("DE:AD:BE:EF:BA:AD"));
+
+    /* Set the advertising data. */
+    legacyConnectable.setName("Legacy");
+    legacyConnectable.setCompleteServices16({NimBLEUUID(SERVICE_UUID)});
+
+    /* Set the legacy and connectable flags. */
+    legacyConnectable.setLegacyAdvertising(true);
+    legacyConnectable.setConnectable(true);
+
+    /* Put some data in the scan response if desired. */
+    legacyScanResponse.setServiceData(NimBLEUUID(SERVICE_UUID), "Legacy SR");
+
+    /* Get the advertising ready */
+    NimBLEExtAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
+
+    /* Set the callbacks to handle advertising events */
+    pAdvertising->setCallbacks(new advCallbacks);
+
+    /* Set instance data.
+     * Up to 5 instances can be used if configured in menuconfig, instance 0 is always available.
+     *
+     * We will set the extended scannable data on instance 0 and the legacy data on instance 1.
+     * Note that the legacy scan response data needs to be set to the same instance (1).
+     */
+    if (pAdvertising->setInstanceData( 0, extScannable )  &&
+        pAdvertising->setInstanceData( 1, legacyConnectable ) &&
+        pAdvertising->setScanResponseData( 1, legacyScanResponse )) {
+        /*
+         * `NimBLEExtAdvertising::start` takes the advertisement instance ID to start
+         * and a duration in milliseconds or a max number of advertisements to send (or both).
+         */
+        if (pAdvertising->start(0, advTime) && pAdvertising->start(1, advTime)) {
+            printf("Started advertising\n");
+        } else {
+            printf("Failed to start advertising\n");
+        }
+    } else {
+        printf("Failed to register advertisment data\n");
+    }
+
+    esp_sleep_enable_timer_wakeup(sleepTime * 1000000);
+}

examples/mesh/basic_on_off_level_server/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 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)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(SUPPORTED_TARGETS esp32)
+project(basic_on_off_level_server)

examples/mesh/basic_on_off_level_server/Makefile

@@ -0,0 +1,3 @@
+PROJECT_NAME := basic_on_off_level_server
+
+include $(IDF_PATH)/make/project.mk

examples/mesh/basic_on_off_level_server/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(COMPONENT_SRCS "main.cpp")
+set(COMPONENT_ADD_INCLUDEDIRS ".")
+
+register_component()

examples/mesh/basic_on_off_level_server/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

examples/mesh/basic_on_off_level_server/main/main.cpp

@@ -0,0 +1,64 @@
+#include "NimBLEDevice.h"
+#include "driver/gpio.h"
+
+extern "C" {void app_main(void);}
+
+#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
+
+// LED pins
+#define LEDR GPIO_NUM_16
+#define LEDG GPIO_NUM_17
+#define LEDB GPIO_NUM_18
+#define OUTPUT_PIN (1ULL<<LEDG)
+
+static uint8_t onOffVal = 0; 
+static int16_t levelVal = 0; 
+
+class onOffSrvModelCallbacks : public NimBLEMeshModelCallbacks {
+    void setOnOff(NimBLEMeshModel *pModel, uint8_t val) {
+        printf("on/off set val %d, transition time: %dms\n", val, pModel->getTransTime());
+        onOffVal = val;
+        gpio_set_level(LEDG, !onOffVal);
+    }
+
+    uint8_t getOnOff(NimBLEMeshModel *pModel) {
+        printf("on/off get val %d\n", onOffVal);
+        return onOffVal;
+    }
+};
+
+class levelSrvModelCallbacks : public NimBLEMeshModelCallbacks {
+    void setLevel(NimBLEMeshModel *pModel, int16_t val) {
+        printf("Level set val %d, transition time: %dms\n", val, pModel->getTransTime());
+        levelVal = val;
+    }
+
+    int16_t getLevel(NimBLEMeshModel *pModel) {
+        printf("Level get val %d\n", levelVal);
+        return levelVal;
+    }
+};
+
+
+void app_main(void) {
+    gpio_config_t io_conf;
+    io_conf.intr_type = (gpio_int_type_t)GPIO_PIN_INTR_DISABLE;
+    io_conf.mode = GPIO_MODE_OUTPUT;
+    io_conf.pin_bit_mask = OUTPUT_PIN;
+    io_conf.pull_down_en = (gpio_pulldown_t)0;
+    io_conf.pull_up_en = (gpio_pullup_t)0;
+    gpio_config(&io_conf); 
+    gpio_set_level(LEDG, 1);
+
+    NimBLEDevice::init("");
+    NimBLEMeshNode *pMesh = NimBLEDevice::createMeshNode(NimBLEUUID(SERVICE_UUID),0);
+    NimBLEMeshElement* pElem = pMesh->getElement();
+    NimBLEMeshModel* pModel = pElem->createModel(BT_MESH_MODEL_ID_GEN_ONOFF_SRV, new onOffSrvModelCallbacks());
+    pModel->setValue(onOffVal);
+
+    //pElem = pMesh->createElement();
+    pModel = pElem->createModel(BT_MESH_MODEL_ID_GEN_LEVEL_SRV, new levelSrvModelCallbacks());
+    pModel->setValue(levelVal);
+    pMesh->start();
+    printf("Mesh Started");
+}

src/FreeRTOS.cpp

@@ -1,312 +0,0 @@
-/*
- * FreeRTOS.cpp
- *
- *  Created on: Feb 24, 2017
- *      Author: kolban
- */
-#include "sdkconfig.h"
-#include "FreeRTOS.h"
-#include "NimBLELog.h"
-
-#include <freertos/FreeRTOS.h>   // Include the base FreeRTOS definitions
-#include <freertos/task.h>       // Include the task definitions
-#include <freertos/semphr.h>     // Include the semaphore definitions
-#include <string>
-
-static const char* LOG_TAG = "FreeRTOS";
-
-
-/**
- * Sleep for the specified number of milliseconds.
- * @param[in] ms The period in milliseconds for which to sleep.
- */
-void FreeRTOS::sleep(uint32_t ms) {
-    ::vTaskDelay(ms / portTICK_PERIOD_MS);
-} // sleep
-
-
-/**
- * Start a new task.
- * @param[in] task The function pointer to the function to be run in the task.
- * @param[in] taskName A string identifier for the task.
- * @param[in] param An optional parameter to be passed to the started task.
- * @param[in] stackSize An optional paremeter supplying the size of the stack in which to run the task.
- */
-void FreeRTOS::startTask(void task(void*), std::string taskName, void* param, uint32_t stackSize) {
-    ::xTaskCreate(task, taskName.data(), stackSize, param, 5, NULL);
-} // startTask
-
-
-/**
- * Delete the task.
- * @param[in] pTask An optional handle to the task to be deleted.  If not supplied the calling task will be deleted.
- */
-void FreeRTOS::deleteTask(TaskHandle_t pTask) {
-    ::vTaskDelete(pTask);
-} // deleteTask
-
-
-/**
- * Get the time in milliseconds since the %FreeRTOS scheduler started.
- * @return The time in milliseconds since the %FreeRTOS scheduler started.
- */
-uint32_t FreeRTOS::getTimeSinceStart() {
-    return (uint32_t) (xTaskGetTickCount() * portTICK_PERIOD_MS);
-} // getTimeSinceStart
-
-
-/**
- * @brief Wait for a semaphore to be released by trying to take it and
- * then releasing it again.
- * @param [in] owner A debug tag.
- * @return The value associated with the semaphore.
- */
-uint32_t FreeRTOS::Semaphore::wait(std::string owner) {
-    NIMBLE_LOGD(LOG_TAG, ">> wait: Semaphore waiting: %s for %s", toString().c_str(), owner.c_str());
-
-    if (m_usePthreads) {
-        pthread_mutex_lock(&m_pthread_mutex);
-    } else {
-        xSemaphoreTake(m_semaphore, portMAX_DELAY);
-    }
-
-    if (m_usePthreads) {
-        pthread_mutex_unlock(&m_pthread_mutex);
-    } else {
-        xSemaphoreGive(m_semaphore);
-    }
-
-    NIMBLE_LOGD(LOG_TAG, "<< wait: Semaphore released: %s", toString().c_str());
-    return m_value;
-} // wait
-
-
-/**
- * @brief Wait for a semaphore to be released in a given period of time by trying to take it and
- * then releasing it again. The value associated with the semaphore can be taken by value() call after return
- * @param [in] owner A debug tag.
- * @param [in] timeoutMs timeout to wait in ms.
- * @return True if we took the semaphore within timeframe.
- */
-bool FreeRTOS::Semaphore::timedWait(std::string owner, uint32_t timeoutMs) {
-    NIMBLE_LOGD(LOG_TAG, ">> wait: Semaphore waiting: %s for %s", toString().c_str(), owner.c_str());
-
-    if (m_usePthreads && timeoutMs != portMAX_DELAY) {
-        assert(false);  // We apparently don't have a timed wait for pthreads.
-    }
-
-    auto ret = pdTRUE;
-
-    if (m_usePthreads) {
-        pthread_mutex_lock(&m_pthread_mutex);
-    } else {
-        ret = xSemaphoreTake(m_semaphore, timeoutMs);
-    }
-
-    if (m_usePthreads) {
-        pthread_mutex_unlock(&m_pthread_mutex);
-    } else {
-        xSemaphoreGive(m_semaphore);
-    }
-
-    NIMBLE_LOGD(LOG_TAG, "<< wait: Semaphore %s released: %d", toString().c_str(), ret);
-    return ret;
-} // wait
-
-
-/**
- * @brief Construct a semaphore, the semaphore is given when created.
- * @param [in] name A name string to provide debugging support.
- */
-FreeRTOS::Semaphore::Semaphore(std::string name) {
-    m_usePthreads = false;      // Are we using pThreads or FreeRTOS?
-    if (m_usePthreads) {
-        pthread_mutex_init(&m_pthread_mutex, nullptr);
-    } else {
-        //m_semaphore = xSemaphoreCreateMutex();
-        m_semaphore = xSemaphoreCreateBinary();
-        xSemaphoreGive(m_semaphore);
-    }
-
-    m_name      = name;
-    m_owner     = std::string("<N/A>");
-    m_value     = 0;
-}
-
-
-FreeRTOS::Semaphore::~Semaphore() {
-    if (m_usePthreads) {
-        pthread_mutex_destroy(&m_pthread_mutex);
-    } else {
-        vSemaphoreDelete(m_semaphore);
-    }
-}
-
-
-/**
- * @brief Give the semaphore.
- */
-void FreeRTOS::Semaphore::give() {
-    NIMBLE_LOGD(LOG_TAG, "Semaphore giving: %s", toString().c_str());
-    m_owner = std::string("<N/A>");
-
-    if (m_usePthreads) {
-        pthread_mutex_unlock(&m_pthread_mutex);
-    } else {
-        xSemaphoreGive(m_semaphore);
-    }
-// #ifdef ARDUINO_ARCH_ESP32
-//  FreeRTOS::sleep(10);
-// #endif
-
-} // Semaphore::give
-
-
-/**
- * @brief Give a semaphore.
- * The Semaphore is given with an associated value.
- * @param [in] value The value to associate with the semaphore.
- */
-void FreeRTOS::Semaphore::give(uint32_t value) {
-    m_value = value;
-    give();
-} // give
-
-
-/**
- * @brief Give a semaphore from an ISR.
- */
-void FreeRTOS::Semaphore::giveFromISR() {
-    BaseType_t higherPriorityTaskWoken;
-    if (m_usePthreads) {
-        assert(false);
-    } else {
-        xSemaphoreGiveFromISR(m_semaphore, &higherPriorityTaskWoken);
-    }
-} // giveFromISR
-
-
-/**
- * @brief Take a semaphore.
- * Take a semaphore and wait indefinitely.
- * @param [in] owner The new owner (for debugging)
- * @return True if we took the semaphore.
- */
-bool FreeRTOS::Semaphore::take(std::string owner) {
-    NIMBLE_LOGD(LOG_TAG, "Semaphore taking: %s for %s", toString().c_str(), owner.c_str());
-    bool rc = false;
-    if (m_usePthreads) {
-        pthread_mutex_lock(&m_pthread_mutex);
-    } else {
-        rc = ::xSemaphoreTake(m_semaphore, portMAX_DELAY) == pdTRUE;
-    }
-    m_owner = owner;
-    if (rc) {
-        NIMBLE_LOGD(LOG_TAG, "Semaphore taken:  %s", toString().c_str());
-    } else {
-        NIMBLE_LOGE(LOG_TAG, "Semaphore NOT taken:  %s", toString().c_str());
-    }
-    return rc;
-} // Semaphore::take
-
-
-/**
- * @brief Take a semaphore.
- * Take a semaphore but return if we haven't obtained it in the given period of milliseconds.
- * @param [in] timeoutMs Timeout in milliseconds.
- * @param [in] owner The new owner (for debugging)
- * @return True if we took the semaphore.
- */
-bool FreeRTOS::Semaphore::take(uint32_t timeoutMs, std::string owner) {
-    NIMBLE_LOGD(LOG_TAG, "Semaphore taking: %s for %s", toString().c_str(), owner.c_str());
-    bool rc = false;
-    if (m_usePthreads) {
-        assert(false);  // We apparently don't have a timed wait for pthreads.
-    } else {
-        rc = ::xSemaphoreTake(m_semaphore, timeoutMs / portTICK_PERIOD_MS) == pdTRUE;
-    }
-    m_owner = owner;
-    if (rc) {
-        NIMBLE_LOGD(LOG_TAG, "Semaphore taken:  %s", toString().c_str());
-    } else {
-        NIMBLE_LOGE(LOG_TAG, "Semaphore NOT taken:  %s", toString().c_str());
-    }
-    return rc;
-} // Semaphore::take
-
-
-
-/**
- * @brief Create a string representation of the semaphore.
- * @return A string representation of the semaphore.
- */
-std::string FreeRTOS::Semaphore::toString() {
-    char hex[9];
-    std::string res = "name: " + m_name + " (0x";
-    snprintf(hex, sizeof(hex), "%08x", (uint32_t)m_semaphore);
-    res += hex;
-    res += "), owner: " + m_owner;
-    return res;
-} // toString
-
-
-/**
- * @brief Set the name of the semaphore.
- * @param [in] name The name of the semaphore.
- */
-void FreeRTOS::Semaphore::setName(std::string name) {
-    m_name = name;
-} // setName
-
-
-/**
- * @brief Create a ring buffer.
- * @param [in] length The amount of storage to allocate for the ring buffer.
- * @param [in] type The type of buffer.  One of RINGBUF_TYPE_NOSPLIT, RINGBUF_TYPE_ALLOWSPLIT, RINGBUF_TYPE_BYTEBUF.
- */
-#ifdef ESP_IDF_VERSION //Quick hack to detect if using IDF version that replaced ringbuf_type_t
-Ringbuffer::Ringbuffer(size_t length, RingbufferType_t type) {
-#else
-Ringbuffer::Ringbuffer(size_t length, ringbuf_type_t type) {
-#endif
-    m_handle = ::xRingbufferCreate(length, type);
-} // Ringbuffer
-
-
-Ringbuffer::~Ringbuffer() {
-    ::vRingbufferDelete(m_handle);
-} // ~Ringbuffer
-
-
-/**
- * @brief Receive data from the buffer.
- * @param [out] size On return, the size of data returned.
- * @param [in] wait How long to wait.
- * @return A pointer to the storage retrieved.
- */
-void* Ringbuffer::receive(size_t* size, TickType_t wait) {
-    return ::xRingbufferReceive(m_handle, size, wait);
-} // receive
-
-
-/**
- * @brief Return an item.
- * @param [in] item The item to be returned/released.
- */
-void Ringbuffer::returnItem(void* item) {
-    ::vRingbufferReturnItem(m_handle, item);
-} // returnItem
-
-
-/**
- * @brief Send data to the buffer.
- * @param [in] data The data to place into the buffer.
- * @param [in] length The length of data to place into the buffer.
- * @param [in] wait How long to wait before giving up.  The default is to wait indefinitely.
- * @return
- */
-bool Ringbuffer::send(void* data, size_t length, TickType_t wait) {
-    return ::xRingbufferSend(m_handle, data, length, wait) == pdTRUE;
-} // send
-
-

src/FreeRTOS.h

@@ -1,85 +0,0 @@
-/*
- * FreeRTOS.h
- *
- *  Created on: Feb 24, 2017
- *      Author: kolban
- */
-
-#ifndef MAIN_FREERTOS_H_
-#define MAIN_FREERTOS_H_
-
-#include <freertos/FreeRTOS.h>   // Include the base FreeRTOS definitions.
-#include <freertos/task.h>       // Include the task definitions.
-#include <freertos/semphr.h>     // Include the semaphore definitions.
-#include <freertos/ringbuf.h>    // Include the ringbuffer definitions.
-
-#include <stdint.h>
-#include <string>
-#include <pthread.h>
-
-
-/**
- * @brief Interface to %FreeRTOS functions.
- */
-class FreeRTOS {
-public:
-    static void sleep(uint32_t ms);
-    static void startTask(void task(void*), std::string taskName, void* param = nullptr, uint32_t stackSize = 2048);
-    static void deleteTask(TaskHandle_t pTask = nullptr);
-
-    static uint32_t getTimeSinceStart();
-
-/**
- * @brief A binary semaphore class that operates like a mutex, it is already given when constructed.
- */
-    class Semaphore {
-    public:
-        Semaphore(std::string owner = "<Unknown>");
-        ~Semaphore();
-        void        give();
-        void        give(uint32_t value);
-        void        giveFromISR();
-        void        setName(std::string name);
-        bool        take(std::string owner = "<Unknown>");
-        bool        take(uint32_t timeoutMs, std::string owner = "<Unknown>");
-        std::string toString();
-        bool        timedWait(std::string owner = "<Unknown>", uint32_t timeoutMs = portMAX_DELAY);
-        uint32_t    wait(std::string owner = "<Unknown>");
-        /**
-         * @brief Get the value of the semaphore.
-         * @return The value stored if the semaphore was given with give(value);
-         */
-        uint32_t    value(){ return m_value; };
-
-    private:
-        SemaphoreHandle_t m_semaphore;
-        pthread_mutex_t   m_pthread_mutex;
-        std::string       m_name;
-        std::string       m_owner;
-        uint32_t          m_value;
-        bool              m_usePthreads;
-
-    };
-};
-
-
-/**
- * @brief A wrapper class for a freeRTOS ringbuffer.
- */
-class Ringbuffer {
-public:
-#ifdef ESP_IDF_VERSION //Quick hack to detect if using IDF version that replaced ringbuf_type_t
-    Ringbuffer(size_t length, RingbufferType_t type = RINGBUF_TYPE_NOSPLIT);
-#else
-    Ringbuffer(size_t length, ringbuf_type_t type = RINGBUF_TYPE_NOSPLIT);
-#endif
-    ~Ringbuffer();
-
-    void*    receive(size_t* size, TickType_t wait = portMAX_DELAY);
-    void     returnItem(void* item);
-    bool     send(void* data, size_t length, TickType_t wait = portMAX_DELAY);
-private:
-    RingbufHandle_t m_handle;
-};
-
-#endif /* MAIN_FREERTOS_H_ */

src/HIDTypes.h

@@ -45,13 +45,8 @@
 /* of data as per HID Class standard */
 
 /* Main items */
-#ifdef ARDUINO_ARCH_ESP32
-#define HIDINPUT(size)             (0x80 | size)
-#define HIDOUTPUT(size)            (0x90 | size)
-#else
-#define INPUT(size)             (0x80 | size)
-#define OUTPUT(size)            (0x90 | size)
-#endif
+#define HIDINPUT(size)          (0x80 | size)
+#define HIDOUTPUT(size)         (0x90 | size)
 #define FEATURE(size)           (0xb0 | size)
 #define COLLECTION(size)        (0xa0 | size)
 #define END_COLLECTION(size)    (0xc0 | size)

src/NimBLE2904.cpp

@@ -16,11 +16,8 @@
  * See also:
  * https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.characteristic_presentation_format.xml
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLE2904.h"
 
@@ -37,7 +34,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
 
 
 /**
@@ -86,5 +83,4 @@ void NimBLE2904::setUnit(uint16_t unit) {
     setValue((uint8_t*) &m_data, sizeof(m_data));
 } // setUnit
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLE2904.h

@@ -14,11 +14,8 @@
 
 #ifndef MAIN_NIMBLE2904_H_
 #define MAIN_NIMBLE2904_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLEDescriptor.h"
 
@@ -42,6 +39,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,11 +75,9 @@ public:
     void setUnit(uint16_t unit);
 
 private:
-    NimBLE2904(NimBLECharacteristic* pCharacterisitic);
     friend class NimBLECharacteristic;
     BLE2904_Data m_data;
 }; // BLE2904
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
 #endif /* MAIN_NIMBLE2904_H_ */

src/NimBLEAddress.cpp

@@ -11,7 +11,7 @@
  *  Created on: Jul 2, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include <algorithm>

src/NimBLEAddress.h

@@ -14,10 +14,15 @@
 
 #ifndef COMPONENTS_NIMBLEADDRESS_H_
 #define COMPONENTS_NIMBLEADDRESS_H_
-#include "sdkconfig.h"
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "nimble/ble.h"
+#else
+#include "nimble/nimble/include/nimble/ble.h"
+#endif
+
 /****  FIX COMPILATION ****/
 #undef min
 #undef max

src/NimBLEAdvertisedDevice.cpp

@@ -11,42 +11,31 @@
  *  Created on: Jul 3, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 
 #include "NimBLEDevice.h"
 #include "NimBLEAdvertisedDevice.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
 
+#include <climits>
+
 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;
+    size_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() {
+    size_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() {
+    size_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() {
+    size_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;
+    size_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() {
+    size_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;
+    size_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.
+ */
+uint8_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;
+    size_t data_loc = ULONG_MAX;
+
+    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 != ULONG_MAX) {
+        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;
+    size_t data_loc = findServiceData(index, &bytes);
+
+    if(data_loc != ULONG_MAX) {
+        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;
+    size_t  data_loc = findServiceData(index, &bytes);
+    size_t  plSize = m_payload.size() - 2;
+    uint8_t uuidBytes = uuid.bitSize() / 8;
+
+    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;
+    size_t data_loc = findServiceData(index, &bytes);
+
+    if(data_loc != ULONG_MAX) {
+        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, ULONG_MAX if not found.
+ */
+size_t NimBLEAdvertisedDevice::findServiceData(uint8_t index, uint8_t *bytes) {
+    size_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 ULONG_MAX;
+}
+
+
 /**
  * @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 NimBLEAdvertisedDevice::getServiceDataCount() {
+    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;
+    size_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
 
 
@@ -193,19 +433,33 @@ NimBLEUUID NimBLEAdvertisedDevice::getServiceUUID(uint8_t index) {
  * @brief Get the number of services advertised
  * @return The count of services in the advertising packet.
  */
-size_t NimBLEAdvertisedDevice::getServiceUUIDCount() {
-    return m_serviceUUIDs.size();
+uint8_t NimBLEAdvertisedDevice::getServiceUUIDCount() {
+    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;
+    size_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,114 @@ 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
 
 
+#if CONFIG_BT_NIMBLE_EXT_ADV
 /**
- * @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
+ * @brief Get the set ID of the extended advertisement.
+ * @return The set ID.
  */
- 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::getSetId() {
+    return m_sid;
+} // getSetId
 
-    m_payload = payload;
-    m_payloadLength = length;
 
-#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);
+/**
+ * @brief Get the primary PHY used by this advertisement.
+ * @return The PHY type, one of:
+ *  * BLE_HCI_LE_PHY_1M
+ *  * BLE_HCI_LE_PHY_CODED
+ */
+uint8_t NimBLEAdvertisedDevice::getPrimaryPhy() {
+    return m_primPhy;
+} // getPrimaryPhy
+
+
+/**
+ * @brief Get the primary PHY used by this advertisement.
+ * @return The PHY type, one of:
+ *  * BLE_HCI_LE_PHY_1M
+ *  * BLE_HCI_LE_PHY_2M
+ *  * BLE_HCI_LE_PHY_CODED
+ */
+uint8_t NimBLEAdvertisedDevice::getSecondaryPhy() {
+    return m_secPhy;
+} // getSecondaryPhy
+
+
+/**
+ * @brief Get the periodic interval of the advertisement.
+ * @return The periodic advertising interval, 0 if not periodic advertising.
+ */
+uint16_t NimBLEAdvertisedDevice::getPeriodicInterval() {
+    return m_periodicItvl;
+} // getPeriodicInterval
 #endif
 
-    if (fields.uuids16 != NULL) {
-        for (int i = 0; i < fields.num_uuids16; i++) {
-            setServiceUUID(NimBLEUUID(fields.uuids16[i].value));
+
+uint8_t NimBLEAdvertisedDevice::findAdvField(uint8_t type, uint8_t index, size_t * data_loc) {
+    ble_hs_adv_field *field = nullptr;
+    size_t  length = m_payload.size();
+    size_t  data   = 0;
+    uint8_t count  = 0;
+
+    if (length < 3) {
+        return count;
+    }
+
+    while (length > 2) {
+        field = (ble_hs_adv_field*)&m_payload[data];
+
+        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 +700,27 @@ 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) {
+void NimBLEAdvertisedDevice::setAdvType(uint8_t advType, bool isLegacyAdv) {
     m_advType = advType;
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    m_isLegacyAdv = isLegacyAdv;
+#else
+    (void)isLegacyAdv;
+#endif
 } // 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.
@@ -560,10 +753,10 @@ std::string NimBLEAdvertisedDevice::toString() {
         res += val;
     }
 
-    if(haveServiceData()) {
-        size_t count = getServiceDataCount();
+    if (haveServiceData()) {
+        uint8_t count = getServiceDataCount();
         res += "\nService Data:";
-        for(size_t i = 0; i < count; i++) {
+        for(uint8_t i = 0; i < count; i++) {
             res += "\nUUID: " + std::string(getServiceDataUUID(i));
             res += ", Data: " + getServiceData(i);
         }
@@ -579,10 +772,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,10 +828,37 @@ time_t NimBLEAdvertisedDevice::getTimestamp() {
  * @return The size of the payload in bytes.
  */
 size_t NimBLEAdvertisedDevice::getPayloadLength() {
-    return m_payloadLength;
+    return m_payload.size();
 } // getPayloadLength
 
 
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+/**
+ * @brief Check if this device is advertising as connectable.
+ * @return True if the device is connectable.
+ */
+bool NimBLEAdvertisedDevice::isConnectable() {
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    if (m_isLegacyAdv) {
+        return m_advType == BLE_HCI_ADV_RPT_EVTYPE_ADV_IND ||
+               m_advType == BLE_HCI_ADV_RPT_EVTYPE_DIR_IND;
+    }
+#endif
+    return (m_advType & BLE_HCI_ADV_CONN_MASK) ||
+           (m_advType & BLE_HCI_ADV_DIRECT_MASK);
+} // isConnectable
+
+
+/**
+ * @brief Check if this advertisement is a legacy or extended type
+ * @return True if legacy (Bluetooth 4.x), false if extended (bluetooth 5.x).
+ */
+bool NimBLEAdvertisedDevice::isLegacyAdvertisement() {
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    return m_isLegacyAdv;
+# else
+    return true;
+#endif
+} // isLegacyAdvertisement
+
+#endif /* CONFIG_BT_ENABLED  && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
 

src/NimBLEAdvertisedDevice.h

@@ -14,20 +14,22 @@
 
 #ifndef COMPONENTS_NIMBLEADVERTISEDDEVICE_H_
 #define COMPONENTS_NIMBLEADVERTISEDDEVICE_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 
 #include "NimBLEAddress.h"
 #include "NimBLEScan.h"
 #include "NimBLEUUID.h"
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_hs_adv.h"
+#else
+#include "nimble/nimble/host/include/host/ble_hs_adv.h"
+#endif
 
 #include <map>
 #include <vector>
+#include <time.h>
 
 
 class NimBLEScan;
@@ -44,7 +46,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\>.
@@ -65,9 +71,9 @@ public:
     std::string     getName();
     int             getRSSI();
     NimBLEScan*     getScan();
-    size_t          getServiceDataCount();
+    uint8_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>.
@@ -105,13 +111,16 @@ public:
 
     NimBLEUUID      getServiceDataUUID(uint8_t index = 0);
     NimBLEUUID      getServiceUUID(uint8_t index = 0);
-    size_t          getServiceUUIDCount();
+    uint8_t         getServiceUUIDCount();
+    NimBLEAddress   getTargetAddress(uint8_t index = 0);
+    uint8_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 +128,51 @@ public:
     bool            haveServiceData();
     bool            haveServiceUUID();
     bool            haveTXPower();
+    bool            haveConnParams();
+    bool            haveAdvInterval();
+    bool            haveTargetAddress();
+    bool            haveURI();
     std::string     toString();
+    bool            isConnectable();
+    bool            isLegacyAdvertisement();
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    uint8_t         getSetId();
+    uint8_t         getPrimaryPhy();
+    uint8_t         getSecondaryPhy();
+    uint16_t        getPeriodicInterval();
+#endif
 
 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, bool isLegacyAdv);
+    void    setPayload(const uint8_t *payload, uint8_t length, bool append);
+    void    setRSSI(int rssi);
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    void    setSetId(uint8_t sid)              { m_sid = sid; }
+    void    setPrimaryPhy(uint8_t phy)         { m_primPhy = phy; }
+    void    setSecondaryPhy(uint8_t phy)       { m_secPhy = phy; }
+    void    setPeriodicInterval(uint16_t itvl) { m_periodicItvl = itvl; }
+#endif
+    uint8_t findAdvField(uint8_t type, uint8_t index = 0, size_t * data_loc = nullptr);
+    size_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;
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    bool            m_isLegacyAdv;
+    uint8_t         m_sid;
+    uint8_t         m_primPhy;
+    uint8_t         m_secPhy;
+    uint16_t        m_periodicItvl;
+#endif
 
-    std::vector<NimBLEUUID> m_serviceUUIDs;
-    std::vector<std::pair<NimBLEUUID, std::string>>m_serviceDataVec;
+    std::vector<uint8_t>    m_payload;
 };
 
 /**
@@ -180,6 +194,5 @@ public:
     virtual void onResult(NimBLEAdvertisedDevice* advertisedDevice) = 0;
 };
 
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */
 #endif /* COMPONENTS_NIMBLEADVERTISEDDEVICE_H_ */

src/NimBLEAdvertising.h

@@ -14,13 +14,17 @@
 
 #ifndef MAIN_BLEADVERTISING_H_
 #define MAIN_BLEADVERTISING_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#if (defined(CONFIG_BT_ENABLED) && \
+    defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && \
+    !CONFIG_BT_NIMBLE_EXT_ADV) || defined(_DOXYGEN_)
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
+
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
@@ -50,18 +54,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,33 +90,52 @@ public:
     void addServiceUUID(const NimBLEUUID &serviceUUID);
     void addServiceUUID(const char* serviceUUID);
     void removeServiceUUID(const NimBLEUUID &serviceUUID);
-    void start();
-    void stop();
+    bool start(uint32_t duration = 0, void (*advCompleteCB)(NimBLEAdvertising *pAdv) = nullptr);
+    bool 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);
     void setAdvertisementData(NimBLEAdvertisementData& advertisementData);
-    void setScanFilter(bool scanRequertWhitelistOnly, bool connectWhitelistOnly);
+    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;
+    friend class NimBLEServer;
 
-    void                 onHostReset();
+    void                    onHostSync();
+    static int              handleGapEvent(struct ble_gap_event *event, void *arg);
 
-    ble_hs_adv_fields    m_advData;
-    ble_hs_adv_fields    m_scanData;
-    ble_gap_adv_params   m_advParams;
+    ble_hs_adv_fields       m_advData;
+    ble_hs_adv_fields       m_scanData;
+    ble_gap_adv_params      m_advParams;
     std::vector<NimBLEUUID> m_serviceUUIDs;
-    bool                 m_customAdvData = false;  // Are we using custom advertising data?
-    bool                 m_customScanResponseData = false;  // Are we using custom scan response data?
-    bool                 m_scanResp = true;
-    bool                 m_advDataSet = false;
-
+    bool                    m_customAdvData;
+    bool                    m_customScanResponseData;
+    bool                    m_scanResp;
+    bool                    m_advDataSet;
+    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)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER  && !CONFIG_BT_NIMBLE_EXT_ADV */
 #endif /* MAIN_BLEADVERTISING_H_ */

src/NimBLEAttValue.h

@@ -0,0 +1,447 @@
+/*
+ * NimBLEAttValue.h
+ *
+ *  Created: on March 18, 2021
+ *      Author H2zero
+ *
+ */
+
+#ifndef MAIN_NIMBLEATTVALUE_H_
+#define MAIN_NIMBLEATTVALUE_H_
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+#include <Arduino.h>
+#endif
+
+#include "NimBLELog.h"
+
+/****  FIX COMPILATION ****/
+#undef min
+#undef max
+/**************************/
+
+#include <string>
+#include <vector>
+
+#ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+#    define CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED 0
+#endif
+
+#if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+#    include <time.h>
+#endif
+
+#if !defined(CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH)
+#    define CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20
+#elif CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH > BLE_ATT_ATTR_MAX_LEN
+#    error CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be larger than 512 (BLE_ATT_ATTR_MAX_LEN)
+#elif CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH < 1
+#    error CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be less than 1; Range = 1 : 512
+#endif
+
+
+/* Used to determine if the type passed to a template has a c_str() and length() method. */
+template <typename T, typename = void, typename = void>
+struct Has_c_str_len : std::false_type {};
+
+template <typename T>
+struct Has_c_str_len<T, decltype(void(std::declval<T &>().c_str())),
+                     decltype(void(std::declval<T &>().length()))> : std::true_type {};
+
+
+/**
+ * @brief A specialized container class to hold BLE attribute values.
+ * @details This class is designed to be more memory efficient than using\n
+ * standard container types for value storage, while being convertable to\n
+ * many different container classes.
+ */
+class NimBLEAttValue
+{
+    uint8_t*     m_attr_value = nullptr;
+    uint16_t     m_attr_max_len = 0;
+    uint16_t     m_attr_len = 0;
+    uint16_t     m_capacity = 0;
+#if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+    time_t       m_timestamp = 0;
+#endif
+    void         deepCopy(const NimBLEAttValue & source);
+
+public:
+    /**
+     * @brief Default constructor.
+     * @param[in] init_len The initial size in bytes.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(uint16_t init_len = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH,
+                   uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
+
+    /**
+     * @brief Construct with an initial value from a buffer.
+     * @param value A pointer to the initial value to set.
+     * @param[in] len The size in bytes of the value to set.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(const uint8_t *value, uint16_t len,
+                   uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
+
+    /**
+     * @brief Construct with an initializer list.
+     * @param list An initializer list containing the initial value to set.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(std::initializer_list<uint8_t> list,
+                   uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+                   :NimBLEAttValue(list.begin(), (uint16_t)list.size(), max_len){}
+
+    /**
+     * @brief Construct with an initial value from a const char string.
+     * @param value A pointer to the initial value to set.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(const char *value, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+                   :NimBLEAttValue((uint8_t*)value, (uint16_t)strlen(value), max_len){}
+
+    /**
+     * @brief Construct with an initial value from a std::string.
+     * @param str A std::string containing to the initial value to set.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(const std::string str, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+                   :NimBLEAttValue((uint8_t*)str.data(), (uint16_t)str.length(), max_len){}
+
+    /**
+     * @brief Construct with an initial value from a std::vector<uint8_t>.
+     * @param vec A std::vector<uint8_t> containing to the initial value to set.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(const std::vector<uint8_t> vec, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+                   :NimBLEAttValue(&vec[0], (uint16_t)vec.size(), max_len){}
+
+#ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+    /**
+     * @brief Construct with an initial value from an Arduino String.
+     * @param str An Arduino String containing to the initial value to set.
+     * @param[in] max_len The max size in bytes that the value can be.
+     */
+    NimBLEAttValue(const String str, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
+                   :NimBLEAttValue((uint8_t*)str.c_str(), str.length(), max_len){}
+#endif
+
+    /** @brief Copy constructor */
+    NimBLEAttValue(const NimBLEAttValue & source) { deepCopy(source); }
+
+    /** @brief Move constructor */
+    NimBLEAttValue(NimBLEAttValue && source) { *this = std::move(source); }
+
+    /** @brief Destructor */
+    ~NimBLEAttValue();
+
+    /** @brief Returns the max size in bytes */
+    uint16_t        max_size()     const   { return m_attr_max_len; }
+
+    /** @brief Returns the currently allocated capacity in bytes */
+    uint16_t        capacity()     const   { return m_capacity; }
+
+    /** @brief Returns the current length of the value in bytes */
+    uint16_t        length()       const   { return m_attr_len; }
+
+    /** @brief Returns the current size of the value in bytes */
+    uint16_t        size()         const   { return m_attr_len; }
+
+    /** @brief Returns a pointer to the internal buffer of the value */
+    const uint8_t*  data()         const   { return m_attr_value; }
+
+    /** @brief Returns a pointer to the internal buffer of the value as a const char* */
+    const char*     c_str()        const   { return (const char*)m_attr_value; }
+
+    /** @brief Iterator begin */
+    const uint8_t*  begin()        const   { return m_attr_value; }
+
+    /** @brief Iterator end */
+    const uint8_t*  end()          const   { return m_attr_value + m_attr_len; }
+
+#if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+    /** @brief Returns a timestamp of when the value was last updated */
+    time_t          getTimeStamp() const   { return m_timestamp; }
+
+    /** @brief Set the timestamp to the current time */
+    void            setTimeStamp()         { m_timestamp = time(nullptr); }
+
+    /**
+     * @brief Set the timestamp to the specified time
+     * @param[in] t The timestamp value to set
+     */
+    void            setTimeStamp(time_t t) { m_timestamp = t; }
+#else
+    time_t          getTimeStamp() const   { return 0; }
+    void            setTimeStamp()         { }
+    void            setTimeStamp(time_t t) { }
+#endif
+
+    /**
+     * @brief Set the value from a buffer
+     * @param[in] value A ponter to a buffer containing the value.
+     * @param[in] len The length of the value in bytes.
+     * @returns True if successful.
+     */
+    bool            setValue(const uint8_t *value, uint16_t len);
+
+    /**
+     * @brief Set value to the value of const char*.
+     * @param [in] s A ponter to a const char value to set.
+     */
+    bool            setValue(const char* s) {
+                         return setValue((uint8_t*)s, (uint16_t)strlen(s)); }
+
+    /**
+     * @brief Get a pointer to the value buffer with timestamp.
+     * @param[in] timestamp A ponter to a time_t variable to store the timestamp.
+     * @returns A pointer to the internal value buffer.
+     */
+    const uint8_t*  getValue(time_t *timestamp);
+
+    /**
+     * @brief Append data to the value.
+     * @param[in] value A ponter to a data buffer with the value to append.
+     * @param[in] len The length of the value to append in bytes.
+     * @returns A reference to the appended NimBLEAttValue.
+     */
+    NimBLEAttValue& append(const uint8_t *value, uint16_t len);
+
+
+    /*********************** Template Functions ************************/
+
+    /**
+     * @brief Template to set value to the value of <type\>val.
+     * @param [in] s The <type\>value to set.
+     * @details Only used for types without a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    bool
+#else
+    typename std::enable_if<!Has_c_str_len<T>::value, bool>::type
+#endif
+    setValue(const T &s) {
+        return setValue((uint8_t*)&s, sizeof(T));
+    }
+
+    /**
+     * @brief Template to set value to the value of <type\>val.
+     * @param [in] s The <type\>value to set.
+     * @details Only used if the <type\> has a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    bool
+#else
+    typename std::enable_if<Has_c_str_len<T>::value, bool>::type
+#endif
+    setValue(const T & s) {
+        return setValue((uint8_t*)s.c_str(), (uint16_t)s.length());
+    }
+
+    /**
+     * @brief Template to return the value as a <type\>.
+     * @tparam T The type to convert the data to.
+     * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
+     * @param [in] skipSizeCheck If true it will skip checking if the data size is less than\n
+     * <tt>sizeof(<type\>)</tt>.
+     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is\n
+     * less than <tt>sizeof(<type\>)</tt>.
+     * @details <b>Use:</b> <tt>getValue<type>(&timestamp, skipSizeCheck);</tt>
+     */
+    template<typename T>
+    T   getValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
+            if(!skipSizeCheck && size() < sizeof(T)) {
+                return T();
+            }
+            return *((T *)getValue(timestamp));
+    }
+
+
+    /*********************** Operators ************************/
+
+    /** @brief Subscript operator */
+    uint8_t operator [](int pos) const {
+        assert(pos < m_attr_len && "out of range"); return m_attr_value[pos]; }
+
+    /** @brief Operator; Get the value as a std::vector<uint8_t>. */
+    operator std::vector<uint8_t>() const {
+        return std::vector<uint8_t>(m_attr_value, m_attr_value + m_attr_len); }
+
+    /** @brief Operator; Get the value as a std::string. */
+    operator std::string() const {
+        return std::string((char*)m_attr_value, m_attr_len); }
+
+    /** @brief Operator; Get the value as a const uint8_t*. */
+    operator const uint8_t*() const { return m_attr_value; }
+
+    /** @brief Operator; Append another NimBLEAttValue. */
+    NimBLEAttValue& operator  +=(const NimBLEAttValue & source) {
+        return append(source.data(), source.size()); }
+
+    /** @brief Operator; Set the value from a std::string source. */
+    NimBLEAttValue& operator  =(const std::string & source) {
+        setValue((uint8_t*)source.data(), (uint16_t)source.size()); return *this; }
+
+    /** @brief Move assignment operator */
+    NimBLEAttValue& operator  =(NimBLEAttValue && source);
+
+    /** @brief Copy assignment operator */
+    NimBLEAttValue& operator  =(const NimBLEAttValue & source);
+
+    /** @brief Equality operator */
+    bool operator  ==(const NimBLEAttValue & source) {
+        return (m_attr_len == source.size()) ?
+                memcmp(m_attr_value, source.data(), m_attr_len) == 0 : false; }
+
+    /** @brief Inequality operator */
+    bool operator  !=(const NimBLEAttValue & source){ return !(*this == source); }
+
+#ifdef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+    /** @brief Operator; Get the value as an Arduino String value. */
+    operator String() const { return String((char*)m_attr_value); }
+#endif
+
+};
+
+
+inline NimBLEAttValue::NimBLEAttValue(uint16_t init_len, uint16_t max_len) {
+    m_attr_value   = (uint8_t*)calloc(init_len + 1, 1);
+    assert(m_attr_value && "No Mem");
+    m_attr_max_len = std::min(BLE_ATT_ATTR_MAX_LEN, (int)max_len);
+    m_attr_len     = 0;
+    m_capacity     = init_len;
+    setTimeStamp(0);
+}
+
+inline NimBLEAttValue::NimBLEAttValue(const uint8_t *value, uint16_t len, uint16_t max_len)
+: NimBLEAttValue(len, max_len) {
+    memcpy(m_attr_value, value, len);
+    m_attr_value[len] = '\0';
+    m_attr_len        = len;
+}
+
+inline NimBLEAttValue::~NimBLEAttValue() {
+    if(m_attr_value != nullptr) {
+        free(m_attr_value);
+    }
+}
+
+inline NimBLEAttValue& NimBLEAttValue::operator =(NimBLEAttValue && source) {
+    if (this != &source){
+        free(m_attr_value);
+
+        m_attr_value   = source.m_attr_value;
+        m_attr_max_len = source.m_attr_max_len;
+        m_attr_len     = source.m_attr_len;
+        m_capacity     = source.m_capacity;
+        setTimeStamp(source.getTimeStamp());
+        source.m_attr_value = nullptr;
+    }
+    return *this;
+}
+
+inline NimBLEAttValue& NimBLEAttValue::operator =(const NimBLEAttValue & source) {
+    if (this != &source) {
+        deepCopy(source);
+    }
+    return *this;
+}
+
+inline void NimBLEAttValue::deepCopy(const NimBLEAttValue & source) {
+    uint8_t* res = (uint8_t*)realloc( m_attr_value, source.m_capacity + 1);
+    assert(res && "deepCopy: realloc failed");
+
+    ble_npl_hw_enter_critical();
+    m_attr_value   = res;
+    m_attr_max_len = source.m_attr_max_len;
+    m_attr_len     = source.m_attr_len;
+    m_capacity     = source.m_capacity;
+    setTimeStamp(source.getTimeStamp());
+    memcpy(m_attr_value, source.m_attr_value, m_attr_len + 1);
+    ble_npl_hw_exit_critical(0);
+}
+
+inline const uint8_t*  NimBLEAttValue::getValue(time_t *timestamp) {
+    if(timestamp != nullptr) {
+#if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+        *timestamp = m_timestamp;
+#else
+        *timestamp = 0;
+#endif
+    }
+    return m_attr_value;
+}
+
+inline bool NimBLEAttValue::setValue(const uint8_t *value, uint16_t len) {
+    if (len > m_attr_max_len) {
+        NIMBLE_LOGE("NimBLEAttValue", "value exceeds max, len=%u, max=%u",
+                     len, m_attr_max_len);
+        return false;
+    }
+
+    uint8_t *res = m_attr_value;
+    if (len > m_capacity) {
+        res = (uint8_t*)realloc(m_attr_value, (len + 1));
+        m_capacity = len;
+    }
+    assert(res && "setValue: realloc failed");
+
+#if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+    time_t t = time(nullptr);
+#else
+    time_t t = 0;
+#endif
+
+    ble_npl_hw_enter_critical();
+    m_attr_value = res;
+    memcpy(m_attr_value, value, len);
+    m_attr_value[len] = '\0';
+    m_attr_len = len;
+    setTimeStamp(t);
+    ble_npl_hw_exit_critical(0);
+    return true;
+}
+
+inline NimBLEAttValue& NimBLEAttValue::append(const uint8_t *value, uint16_t len) {
+    if (len < 1) {
+        return *this;
+    }
+
+    if ((m_attr_len + len) > m_attr_max_len) {
+        NIMBLE_LOGE("NimBLEAttValue", "val > max, len=%u, max=%u",
+                    len, m_attr_max_len);
+        return *this;
+    }
+
+    uint8_t* res = m_attr_value;
+    uint16_t new_len = m_attr_len + len;
+    if (new_len > m_capacity) {
+        res = (uint8_t*)realloc(m_attr_value, (new_len + 1));
+        m_capacity = new_len;
+    }
+    assert(res && "append: realloc failed");
+
+#if CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
+    time_t t = time(nullptr);
+#else
+    time_t t = 0;
+#endif
+
+    ble_npl_hw_enter_critical();
+    m_attr_value = res;
+    memcpy(m_attr_value + m_attr_len, value, len);
+    m_attr_len = new_len;
+    m_attr_value[m_attr_len] = '\0';
+    setTimeStamp(t);
+    ble_npl_hw_exit_critical(0);
+
+    return *this;
+}
+
+#endif /*(CONFIG_BT_ENABLED) */
+#endif /* MAIN_NIMBLEATTVALUE_H_ */

src/NimBLEBeacon.cpp

@@ -11,7 +11,7 @@
  *  Created on: Jan 4, 2018
  *      Author: kolban
  */
-#include "sdkconfig.h"
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include <string.h>

src/NimBLECharacteristic.cpp

@@ -9,11 +9,9 @@
  *  Created on: Jun 22, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLECharacteristic.h"
 #include "NimBLE2904.h"
@@ -32,28 +30,30 @@ static const char* LOG_TAG = "NimBLECharacteristic";
  * @brief Construct a characteristic
  * @param [in] uuid - UUID (const char*) for the characteristic.
  * @param [in] properties - Properties for the characteristic.
+ * @param [in] max_len - The maximum length in bytes that the characteristic value can hold. (Default: 512 bytes for esp32, 20 for all others).
  * @param [in] pService - pointer to the service instance this characteristic belongs to.
  */
-NimBLECharacteristic::NimBLECharacteristic(const char* uuid, uint16_t properties, NimBLEService* pService)
-: NimBLECharacteristic(NimBLEUUID(uuid), properties, pService) {
+NimBLECharacteristic::NimBLECharacteristic(const char* uuid, uint16_t properties,
+                                           uint16_t max_len, NimBLEService* pService)
+: NimBLECharacteristic(NimBLEUUID(uuid), properties, max_len, pService) {
 }
 
 /**
  * @brief Construct a characteristic
  * @param [in] uuid - UUID for the characteristic.
  * @param [in] properties - Properties for the characteristic.
+ * @param [in] max_len - The maximum length in bytes that the characteristic value can hold. (Default: 512 bytes for esp32, 20 for all others).
  * @param [in] pService - pointer to the service instance this characteristic belongs to.
  */
-NimBLECharacteristic::NimBLECharacteristic(const NimBLEUUID &uuid, uint16_t properties, NimBLEService* pService) {
-    m_uuid       = uuid;
-    m_handle     = NULL_HANDLE;
-    m_properties = properties;
-    m_pCallbacks = &defaultCallback;
-    m_pService   = pService;
-    m_value      = "";
-    m_valMux     = portMUX_INITIALIZER_UNLOCKED;
-    m_pTaskData  = nullptr;
-    m_timestamp  = 0;
+NimBLECharacteristic::NimBLECharacteristic(const NimBLEUUID &uuid, uint16_t properties,
+                                           uint16_t max_len, NimBLEService* pService)
+:   m_value(std::min(CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH , (int)max_len), max_len) {
+    m_uuid        = uuid;
+    m_handle      = NULL_HANDLE;
+    m_properties  = properties;
+    m_pCallbacks  = &defaultCallback;
+    m_pService    = pService;
+    m_removed     = 0;
 } // NimBLECharacteristic
 
 /**
@@ -95,15 +95,68 @@ 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] pDescriptor A pointer to the descriptor to add.
+ */
+void NimBLECharacteristic::addDescriptor(NimBLEDescriptor *pDescriptor) {
+    bool foundRemoved = false;
+
+    if(pDescriptor->m_removed > 0) {
+        for(auto& it : m_dscVec) {
+            if(it == pDescriptor) {
+                foundRemoved = true;
+                pDescriptor->m_removed = 0;
+            }
+        }
+    }
+
+    if(!foundRemoved) {
+        m_dscVec.push_back(pDescriptor);
+    }
+
+    pDescriptor->setCharacteristic(this);
+    NimBLEDevice::getServer()->serviceChanged();
+}
+
+
+/**
+ * @brief Remove a descriptor from the characterisitc.
+ * @param[in] pDescriptor A pointer to the descriptor instance to remove from the characterisitc.
+ * @param[in] deleteDsc If true it will delete the descriptor instance and free it's resources.
+ */
+void NimBLECharacteristic::removeDescriptor(NimBLEDescriptor *pDescriptor, bool deleteDsc) {
+    // Check if the descriptor was already removed and if so, check if this
+    // is being called to delete the object and do so if requested.
+    // Otherwise, ignore the call and return.
+    if(pDescriptor->m_removed > 0) {
+        if(deleteDsc) {
+            for(auto it = m_dscVec.begin(); it != m_dscVec.end(); ++it) {
+                if ((*it) == pDescriptor) {
+                    delete *it;
+                    m_dscVec.erase(it);
+                    break;
+                }
+            }
+        }
+
+        return;
+    }
+
+    pDescriptor->m_removed = deleteDsc ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE;
+    NimBLEDevice::getServer()->serviceChanged();
+} // removeDescriptor
+
+
+/**
+ * @brief Return the BLE Descriptor for the given UUID.
+ * @param [in] uuid The UUID of the descriptor.
+ * @return A pointer to the descriptor object or nullptr if not found.
  */
 NimBLEDescriptor* NimBLECharacteristic::getDescriptorByUUID(const char* uuid) {
     return getDescriptorByUUID(NimBLEUUID(uuid));
@@ -111,9 +164,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 +177,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 +218,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.
@@ -162,17 +234,14 @@ NimBLEUUID NimBLECharacteristic::getUUID() {
 
 /**
  * @brief Retrieve the current value of the characteristic.
- * @return A std::string containing the current characteristic value.
+ * @return The NimBLEAttValue containing the current characteristic value.
  */
-std::string NimBLECharacteristic::getValue(time_t *timestamp) {
-    portENTER_CRITICAL(&m_valMux);
-    std::string retVal = m_value;
+NimBLEAttValue NimBLECharacteristic::getValue(time_t *timestamp) {
     if(timestamp != nullptr) {
-        *timestamp = m_timestamp;
+        m_value.getValue(timestamp);
     }
-    portEXIT_CRITICAL(&m_valMux);
 
-    return retVal;
+    return m_value;
 } // getValue
 
 
@@ -181,11 +250,7 @@ std::string NimBLECharacteristic::getValue(time_t *timestamp) {
  * @return The length of the current characteristic data.
  */
 size_t NimBLECharacteristic::getDataLength() {
-    portENTER_CRITICAL(&m_valMux);
-    size_t len = m_value.length();
-    portEXIT_CRITICAL(&m_valMux);
-
-    return len;
+    return m_value.size();
 }
 
 
@@ -217,27 +282,27 @@ int NimBLECharacteristic::handleGapEvent(uint16_t conn_handle, uint16_t attr_han
                     pCharacteristic->m_pCallbacks->onRead(pCharacteristic, &desc);
                 }
 
-                portENTER_CRITICAL(&pCharacteristic->m_valMux);
-                rc = os_mbuf_append(ctxt->om, (uint8_t*)pCharacteristic->m_value.data(),
-                                    pCharacteristic->m_value.length());
-                portEXIT_CRITICAL(&pCharacteristic->m_valMux);
-
+                ble_npl_hw_enter_critical();
+                rc = os_mbuf_append(ctxt->om, pCharacteristic->m_value.data(), pCharacteristic->m_value.size());
+                ble_npl_hw_exit_critical(0);
                 return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
             }
 
             case BLE_GATT_ACCESS_OP_WRITE_CHR: {
-                if (ctxt->om->om_len > BLE_ATT_ATTR_MAX_LEN) {
+                uint16_t att_max_len = pCharacteristic->m_value.max_size();
+
+                if (ctxt->om->om_len > att_max_len) {
                     return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
                 }
 
-                uint8_t buf[BLE_ATT_ATTR_MAX_LEN];
+                uint8_t buf[att_max_len];
                 size_t len = ctxt->om->om_len;
                 memcpy(buf, ctxt->om->om_data,len);
 
                 os_mbuf *next;
                 next = SLIST_NEXT(ctxt->om, om_next);
                 while(next != NULL){
-                    if((len + next->om_len) > BLE_ATT_ATTR_MAX_LEN) {
+                    if((len + next->om_len) > att_max_len) {
                         return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
                     }
                     memcpy(&buf[len], next->om_data, next->om_len);
@@ -287,16 +352,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);
+                          event->subscribe.conn_handle, subVal);
+
+    if(!event->subscribe.cur_indicate && event->subscribe.prev_indicate) {
+       NimBLEDevice::getServer()->clearIndicateWait(event->subscribe.conn_handle);
+    }
 
-    m_pCallbacks->onSubscribe(this, &desc, subVal);
 
     auto it = m_subscribedVec.begin();
     for(;it != m_subscribedVec.end(); ++it) {
@@ -308,40 +370,72 @@ 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);
 }
 
 
 /**
- * @brief Send an indication.\n
- * An indication is a transmission of up to the first 20 bytes of the characteristic value.\n
- * An indication will block waiting for a positive confirmation from the client.
+ * @brief Send an indication.
  */
 void NimBLECharacteristic::indicate() {
-    NIMBLE_LOGD(LOG_TAG, ">> indicate: length: %d", getDataLength());
     notify(false);
-    NIMBLE_LOGD(LOG_TAG, "<< indicate");
 } // indicate
 
+
 /**
- * @brief Send a notification.\n
- * A notification is a transmission of up to the first 20 bytes of the characteristic value.\n
- * A notification will not block; it is a fire and forget.
+ * @brief Send an indication.
+ * @param[in] value A pointer to the data to send.
+ * @param[in] length The length of the data to send.
+ */
+void NimBLECharacteristic::indicate(const uint8_t* value, size_t length) {
+    notify(value, length, false);
+} // indicate
+
+
+/**
+ * @brief Send an indication.
+ * @param[in] value A std::vector<uint8_t> containing the value to send as the notification value.
+ */
+void NimBLECharacteristic::indicate(const std::vector<uint8_t>& value) {
+    notify(value.data(), value.size(), false);
+} // indicate
+
+
+/**
+ * @brief Send a notification or indication.
  * @param[in] is_notification if true sends a notification, false sends an indication.
  */
 void NimBLECharacteristic::notify(bool is_notification) {
-    NIMBLE_LOGD(LOG_TAG, ">> notify: length: %d", getDataLength());
+    notify(m_value.data(), m_value.length(), is_notification);
+} // notify
 
 
+/**
+ * @brief Send a notification or indication.
+ * @param[in] value A std::vector<uint8_t> containing the value to send as the notification value.
+ * @param[in] is_notification if true sends a notification, false sends an indication.
+ */
+void NimBLECharacteristic::notify(const std::vector<uint8_t>& value, bool is_notification) {
+    notify(value.data(), value.size(), is_notification);
+} // notify
+
+
+/**
+ * @brief Send a notification or indication.
+ * @param[in] value A pointer to the data to send.
+ * @param[in] length The length of the data to send.
+ * @param[in] is_notification if true sends a notification, false sends an indication.
+ */
+void NimBLECharacteristic::notify(const uint8_t* value, size_t length, bool is_notification) {
+    NIMBLE_LOGD(LOG_TAG, ">> notify: length: %d", length);
+
     if(!(m_properties & NIMBLE_PROPERTY::NOTIFY) &&
        !(m_properties & NIMBLE_PROPERTY::INDICATE))
     {
@@ -357,15 +451,13 @@ void NimBLECharacteristic::notify(bool is_notification) {
 
     m_pCallbacks->onNotify(this);
 
-    std::string value = getValue();
-    size_t length = value.length();
     bool reqSec = (m_properties & BLE_GATT_CHR_F_READ_AUTHEN) ||
                   (m_properties & BLE_GATT_CHR_F_READ_AUTHOR) ||
                   (m_properties & BLE_GATT_CHR_F_READ_ENC);
     int rc = 0;
 
     for (auto &it : m_subscribedVec) {
-        uint16_t _mtu = getService()->getServer()->getPeerMTU(it.first);
+        uint16_t _mtu = getService()->getServer()->getPeerMTU(it.first) - 3;
 
         // check if connected and subscribed
         if(_mtu == 0 || it.second == 0) {
@@ -381,8 +473,8 @@ void NimBLECharacteristic::notify(bool is_notification) {
             }
         }
 
-        if (length > _mtu - 3) {
-            NIMBLE_LOGW(LOG_TAG, "- Truncating to %d bytes (maximum notify size)", _mtu - 3);
+        if (length > _mtu) {
+            NIMBLE_LOGW(LOG_TAG, "- Truncating to %d bytes (maximum notify size)", _mtu);
         }
 
         if(is_notification && (!(it.second & NIMBLE_SUB_NOTIFY))) {
@@ -400,42 +492,22 @@ void NimBLECharacteristic::notify(bool is_notification) {
         // don't create the m_buf until we are sure to send the data or else
         // we could be allocating a buffer that doesn't get released.
         // 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;
+        os_mbuf *om = ble_hs_mbuf_from_flat(value, length);
 
         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,41 +527,39 @@ 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.
- * @param [in] data The data to set for the characteristic.
- * @param [in] length The length of the data in bytes.
+ * @brief Set the value of the characteristic from a data buffer .
+ * @param [in] data The data buffer to set for the characteristic.
+ * @param [in] length The number of bytes in the data buffer.
  */
 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_NIMBLE_CPP_LOG_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());
+    NIMBLE_LOGD(LOG_TAG, ">> setValue: length=%d, data=%s, characteristic UUID=%s",
+                length, pHex, getUUID().toString().c_str());
     free(pHex);
 #endif
 
-    if (length > BLE_ATT_ATTR_MAX_LEN) {
-        NIMBLE_LOGE(LOG_TAG, "Size %d too large, must be no bigger than %d", length, BLE_ATT_ATTR_MAX_LEN);
-        return;
-    }
-
-    portENTER_CRITICAL(&m_valMux);
-    m_value = std::string((char*)data, length);
-    m_timestamp = time(nullptr);
-    portEXIT_CRITICAL(&m_valMux);
-
+    m_value.setValue(data, length);
     NIMBLE_LOGD(LOG_TAG, "<< setValue");
 } // setValue
 
 
 /**
- * @brief Set the value of the characteristic from string data.\n
- * We set the value of the characteristic from the bytes contained in the string.
- * @param [in] value the std::string value of the characteristic.
+ * @brief Set the value of the characteristic from a `std::vector<uint8_t>`.\n
+ * @param [in] vec The std::vector<uint8_t> reference to set the characteristic value from.
  */
-void NimBLECharacteristic::setValue(const std::string &value) {
-    setValue((uint8_t*)(value.data()), value.length());
-} // setValue
+void NimBLECharacteristic::setValue(const std::vector<uint8_t>& vec) {
+    return setValue((uint8_t*)&vec[0], vec.size());
+}// setValue
 
 
 /**
@@ -586,6 +656,4 @@ void NimBLECharacteristicCallbacks::onSubscribe(NimBLECharacteristic* pCharacter
     NIMBLE_LOGD("NimBLECharacteristicCallbacks", "onSubscribe: default");
 }
 
-
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLECharacteristic.h

@@ -13,13 +13,15 @@
 
 #ifndef MAIN_NIMBLECHARACTERISTIC_H_
 #define MAIN_NIMBLECHARACTERISTIC_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_hs.h"
+#else
+#include "nimble/nimble/host/include/host/ble_hs.h"
+#endif
+
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
@@ -42,6 +44,7 @@ typedef enum {
 
 #include "NimBLEService.h"
 #include "NimBLEDescriptor.h"
+#include "NimBLEAttValue.h"
 
 #include <string>
 #include <vector>
@@ -59,79 +62,118 @@ class NimBLECharacteristicCallbacks;
  */
 class NimBLECharacteristic {
 public:
-    NimBLEDescriptor* createDescriptor(const char* uuid,
-                                       uint32_t properties =
-                                       NIMBLE_PROPERTY::READ |
-                                       NIMBLE_PROPERTY::WRITE,
-                                       uint16_t max_len = 100);
-    NimBLEDescriptor* createDescriptor(const NimBLEUUID &uuid,
-                                       uint32_t properties =
-                                       NIMBLE_PROPERTY::READ |
-                                       NIMBLE_PROPERTY::WRITE,
-                                       uint16_t max_len = 100);
-
-    NimBLEDescriptor* getDescriptorByUUID(const char* uuid);
-    NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID &uuid);
-    NimBLEUUID        getUUID();
-    std::string       getValue(time_t *timestamp = nullptr);
-
-    /**
-     * @brief A template to convert the characteristic data to <type\>.
-     * @tparam T The type to convert the data to.
-     * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
-     * @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
-     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
-     * less than <tt>sizeof(<type\>)</tt>.
-     * @details <b>Use:</b> <tt>getValue<type>(&timestamp, skipSizeCheck);</tt>
-     */
-    template<typename T>
-    T                 getValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
-        std::string value = getValue();
-        if(!skipSizeCheck && value.size() < sizeof(T)) return T();
-        const char *pData = value.data();
-        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) {
-        setValue((uint8_t*)&s, sizeof(T));
-    }
-
-    std::string       toString();
-    uint16_t          getHandle();
-    size_t            getSubscribedCount();
-
-private:
-
-    friend class      NimBLEServer;
-    friend class      NimBLEService;
-
     NimBLECharacteristic(const char* uuid,
                          uint16_t properties =
                          NIMBLE_PROPERTY::READ |
                          NIMBLE_PROPERTY::WRITE,
+                         uint16_t max_len = BLE_ATT_ATTR_MAX_LEN,
                          NimBLEService* pService = nullptr);
     NimBLECharacteristic(const NimBLEUUID &uuid,
                          uint16_t properties =
                          NIMBLE_PROPERTY::READ |
                          NIMBLE_PROPERTY::WRITE,
+                         uint16_t max_len = BLE_ATT_ATTR_MAX_LEN,
                          NimBLEService* pService = nullptr);
 
     ~NimBLECharacteristic();
 
-    NimBLEService*  getService();
-    uint16_t        getProperties();
+    uint16_t          getHandle();
+    NimBLEUUID        getUUID();
+    std::string       toString();
+    void              indicate();
+    void              indicate(const uint8_t* value, size_t length);
+    void              indicate(const std::vector<uint8_t>& value);
+    void              notify(bool is_notification = true);
+    void              notify(const uint8_t* value, size_t length, bool is_notification = true);
+    void              notify(const std::vector<uint8_t>& value, bool is_notification = true);
+    size_t            getSubscribedCount();
+    void              addDescriptor(NimBLEDescriptor *pDescriptor);
+    NimBLEDescriptor* getDescriptorByUUID(const char* uuid);
+    NimBLEDescriptor* getDescriptorByUUID(const NimBLEUUID &uuid);
+    NimBLEDescriptor* getDescriptorByHandle(uint16_t handle);
+    void              removeDescriptor(NimBLEDescriptor *pDescriptor, bool deleteDsc = false);
+    NimBLEService*    getService();
+    uint16_t          getProperties();
+    NimBLEAttValue    getValue(time_t *timestamp = nullptr);
+    size_t            getDataLength();
+    void              setValue(const uint8_t* data, size_t size);
+    void              setValue(const std::vector<uint8_t>& vec);
+    void              setCallbacks(NimBLECharacteristicCallbacks* pCallbacks);
+    NimBLEDescriptor* createDescriptor(const char* uuid,
+                                       uint32_t properties =
+                                       NIMBLE_PROPERTY::READ |
+                                       NIMBLE_PROPERTY::WRITE,
+                                       uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);;
+    NimBLEDescriptor* createDescriptor(const NimBLEUUID &uuid,
+                                       uint32_t properties =
+                                       NIMBLE_PROPERTY::READ |
+                                       NIMBLE_PROPERTY::WRITE,
+                                       uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
+
+    NimBLECharacteristicCallbacks* getCallbacks();
+
+
+    /*********************** Template Functions ************************/
+
+    /**
+     * @brief Template to set the characteristic value to <type\>val.
+     * @param [in] s The value to set.
+     */
+    template<typename T>
+    void              setValue(const T &s) { m_value.setValue<T>(s); }
+
+    /**
+     * @brief Template to convert the characteristic data to <type\>.
+     * @tparam T The type to convert the data to.
+     * @param [in] timestamp (Optional) A pointer to a time_t struct to store the time the value was read.
+     * @param [in] skipSizeCheck (Optional) If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
+     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is less than <tt>sizeof(<type\>)</tt>.
+     * @details <b>Use:</b> <tt>getValue<type>(&timestamp, skipSizeCheck);</tt>
+     */
+    template<typename T>
+    T   getValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
+        return m_value.getValue<T>(timestamp, skipSizeCheck);
+    }
+
+    /**
+     * @brief Template to send a notification from a class type that has a c_str() and length() method.
+     * @tparam T The a reference to a class containing the data to send.
+     * @param[in] value The <type\>value to set.
+     * @param[in] is_notification if true sends a notification, false sends an indication.
+     * @details Only used if the <type\> has a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    void
+#else
+    typename std::enable_if<Has_c_str_len<T>::value, void>::type
+#endif
+    notify(const T& value, bool is_notification = true) {
+        notify((uint8_t*)value.c_str(), value.length(), is_notification);
+    }
+
+    /**
+     * @brief Template to send an indication from a class type that has a c_str() and length() method.
+     * @tparam T The a reference to a class containing the data to send.
+     * @param[in] value The <type\>value to set.
+     * @details Only used if the <type\> has a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    void
+#else
+    typename std::enable_if<Has_c_str_len<T>::value, void>::type
+#endif
+    indicate(const T& value) {
+        indicate((uint8_t*)value.c_str(), value.length());
+    }
+
+private:
+
+    friend class    NimBLEServer;
+    friend class    NimBLEService;
+
+    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);
@@ -141,11 +183,9 @@ private:
     uint16_t                       m_properties;
     NimBLECharacteristicCallbacks* m_pCallbacks;
     NimBLEService*                 m_pService;
-    std::string                    m_value;
+    NimBLEAttValue                 m_value;
     std::vector<NimBLEDescriptor*> m_dscVec;
-    ble_task_data_t                *m_pTaskData;
-    portMUX_TYPE                   m_valMux;
-    time_t                         m_timestamp;
+    uint8_t                        m_removed;
 
     std::vector<std::pair<uint16_t, uint16_t>>  m_subscribedVec;
 }; // NimBLECharacteristic
@@ -177,7 +217,7 @@ public:
         ERROR_INDICATE_FAILURE
     }Status;
 
-    virtual ~NimBLECharacteristicCallbacks();
+    virtual      ~NimBLECharacteristicCallbacks();
     virtual void onRead(NimBLECharacteristic* pCharacteristic);
     virtual void onRead(NimBLECharacteristic* pCharacteristic, ble_gap_conn_desc* desc);
     virtual void onWrite(NimBLECharacteristic* pCharacteristic);
@@ -187,6 +227,5 @@ public:
     virtual void onSubscribe(NimBLECharacteristic* pCharacteristic, ble_gap_conn_desc* desc, uint16_t subValue);
 };
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED  && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
 #endif /*MAIN_NIMBLECHARACTERISTIC_H_*/

src/NimBLEClient.cpp

@@ -11,11 +11,8 @@
  *      Author: kolban
  */
 
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLEClient.h"
 #include "NimBLEDevice.h"
@@ -23,6 +20,13 @@
 
 #include <string>
 #include <unordered_set>
+#include <climits>
+
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#include "nimble/nimble_port.h"
+#else
+#include "nimble/porting/nimble/include/nimble/nimble_port.h"
+#endif
 
 static const char* LOG_TAG = "NimBLEClient";
 static NimBLEClientCallbacks defaultCallbacks;
@@ -56,11 +60,16 @@ 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_lastErr          = 0;
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    m_phyMask          = BLE_GAP_LE_PHY_1M_MASK |
+                         BLE_GAP_LE_PHY_2M_MASK |
+                         BLE_GAP_LE_PHY_CODED_MASK;
+#endif
 
     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 +79,10 @@ 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
+
+    memset(&m_dcTimer, 0, sizeof(m_dcTimer));
+    ble_npl_callout_init(&m_dcTimer, nimble_port_get_dflt_eventq(),
+                         NimBLEClient::dcTimerCb, this);
 } // NimBLEClient
 
 
@@ -86,9 +99,25 @@ NimBLEClient::~NimBLEClient() {
         delete m_pClientCallbacks;
     }
 
+    ble_npl_callout_deinit(&m_dcTimer);
+
 } // ~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 +193,140 @@ 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};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 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 {
+#if CONFIG_BT_NIMBLE_EXT_ADV
+        rc = ble_gap_ext_connect(NimBLEDevice::m_own_addr_type,
+                                 &peerAddr_t,
+                                 m_connectTimeout,
+                                 m_phyMask,
+                                 &m_pConnParams,
+                                 &m_pConnParams,
+                                 &m_pConnParams,
+                                 NimBLEClient::handleGapEvent,
+                                 this);
 
-    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));
+#else
+        rc = ble_gap_connect(NimBLEDevice::m_own_addr_type, &peerAddr_t,
+                             m_connectTimeout, &m_pConnParams,
+                             NimBLEClient::handleGapEvent, this);
+#endif
+        switch (rc) {
+            case 0:
+                break;
+
+            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);
+
+    m_lastErr = rc;
+
+    if(rc != 0) {
         m_pTaskData = nullptr;
-        m_waitingToConnect = false;
         return false;
     }
 
-    m_waitingToConnect = true;
+#ifdef ulTaskNotifyValueClear
+    // Clear the task notification value to ensure we block
+    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
+    // Wait for the connect timeout time +1 second for the connection to complete
+    if(ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(m_connectTimeout + 1000)) == pdFALSE) {
+        m_pTaskData = nullptr;
+        // 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){
+        m_lastErr = taskData.rc;
+        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
 
 
@@ -237,7 +336,8 @@ bool NimBLEClient::connect(const NimBLEAddress &address, bool deleteAttibutes) {
  * @return True on success.
  */
 bool NimBLEClient::secureConnection() {
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
 
     int retryCount = 1;
 
@@ -246,14 +346,20 @@ bool NimBLEClient::secureConnection() {
 
         int rc = NimBLEDevice::startSecurity(m_conn_id);
         if(rc != 0){
+            m_lastErr = rc;
             m_pTaskData = nullptr;
             return false;
         }
 
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
     } while (taskData.rc == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING) && retryCount--);
 
     if(taskData.rc != 0){
+        m_lastErr = taskData.rc;
         return false;
     }
 
@@ -268,27 +374,70 @@ 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()");
+    m_lastErr = rc;
     return rc;
 } // disconnect
 
 
+#if CONFIG_BT_NIMBLE_EXT_ADV
+/**
+ * @brief Set the PHY types to use when connecting to a server.
+ * @param [in] mask A bitmask indicating what PHYS to connect with.\n
+ * The available bits are:
+ * * 0x01 BLE_GAP_LE_PHY_1M_MASK
+ * * 0x02 BLE_GAP_LE_PHY_2M_MASK
+ * * 0x04 BLE_GAP_LE_PHY_CODED_MASK
+ */
+void NimBLEClient::setConnectPhy(uint8_t mask) {
+    m_phyMask = mask;
+}
+#endif
+
+
 /**
  * @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 +464,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 +490,47 @@ void NimBLEClient::updateConnParams(uint16_t minInterval, uint16_t maxInterval,
 } // updateConnParams
 
 
+/**
+ * @brief Request an update of the data packet length.
+ * * Can only be used after a connection has been established.
+ * @details Sends a data length update request to the server the client is connected to.
+ * The Data Length Extension (DLE) allows to increase the Data Channel Payload from 27 bytes to up to 251 bytes.
+ * The server needs to support the Bluetooth 4.2 specifications, to be capable of DLE.
+ * @param [in] tx_octets The preferred number of payload octets to use (Range 0x001B-0x00FB).
+ */
+void NimBLEClient::setDataLen(uint16_t tx_octets) {
+#if defined(CONFIG_NIMBLE_CPP_IDF) && !defined(ESP_IDF_VERSION) || \
+  (ESP_IDF_VERSION_MAJOR * 100 + ESP_IDF_VERSION_MINOR * 10 + ESP_IDF_VERSION_PATCH) < 432
+    return;
+#else
+    uint16_t tx_time = (tx_octets + 14) * 8;
+
+    int rc = ble_gap_set_data_len(m_conn_id, tx_octets, tx_time);
+    if(rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Set data length error: %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
+    }
+#endif
+} // setDataLen
+
+
+/**
+ * @brief Get detailed information about the current peer connection.
+ */
+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.
@@ -399,6 +589,7 @@ int NimBLEClient::getRssi() {
     if(rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "Failed to read RSSI error code: %d, %s",
                                 rc, NimBLEUtils::returnCodeToString(rc));
+        m_lastErr = rc;
         return 0;
     }
 
@@ -454,6 +645,33 @@ 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 uuid 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();
+            if(retrieveServices(&uuid128)) {
+                if(m_servicesVector.size() > prev_size) {
+                    return m_servicesVector.back();
+                }
+            }
+        } else {
+            // If the request was successful but the 128 bit uuid not found
+            // try again with the 16 bit uuid.
+            NimBLEUUID uuid16(uuid);
+            uuid16.to16();
+            // if the uuid was 128 bit but not of the BLE base type this check will fail
+            if (uuid16.bitSize() == BLE_UUID_TYPE_16) {
+                if(retrieveServices(&uuid16)) {
+                    if(m_servicesVector.size() > prev_size) {
+                        return m_servicesVector.back();
+                    }
+                }
+            }
+        }
     }
 
     NIMBLE_LOGD(LOG_TAG, "<< getService: not found");
@@ -510,13 +728,14 @@ 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;
     }
 
     int rc = 0;
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
 
     if(uuid_filter == nullptr) {
         rc = ble_gattc_disc_all_svcs(m_conn_id, NimBLEClient::serviceDiscoveredCB, &taskData);
@@ -527,11 +746,18 @@ bool NimBLEClient::retrieveServices(const NimBLEUUID *uuid_filter) {
 
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "ble_gattc_disc_all_svcs: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
+        m_lastErr = rc;
         return false;
     }
 
+#ifdef ulTaskNotifyValueClear
+    // Clear the task notification value to ensure we block
+    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
+
     // wait until we have all the services
     ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+    m_lastErr = taskData.rc;
 
     if(taskData.rc == 0){
         NIMBLE_LOGD(LOG_TAG, "<< retrieveServices");
@@ -575,7 +801,7 @@ int NimBLEClient::serviceDiscoveredCB(
     if(error->status == BLE_HS_EDONE) {
         pTaskData->rc = 0;
     } else {
-        NIMBLE_LOGE(LOG_TAG, "characteristicDiscCB() rc=%d %s",
+        NIMBLE_LOGE(LOG_TAG, "serviceDiscoveredCB() rc=%d %s",
                              error->status,
                              NimBLEUtils::returnCodeToString(error->status));
         pTaskData->rc = error->status;
@@ -583,7 +809,7 @@ int NimBLEClient::serviceDiscoveredCB(
 
     xTaskNotifyGive(pTaskData->task);
 
-    NIMBLE_LOGD(LOG_TAG,"<< << Service Discovered");
+    NIMBLE_LOGD(LOG_TAG,"<< Service Discovered");
     return error->status;
 }
 
@@ -594,11 +820,11 @@ int NimBLEClient::serviceDiscoveredCB(
  * @param [in] characteristicUUID The characteristic whose value we wish to read.
  * @returns characteristic value or an empty string if not found
  */
-std::string NimBLEClient::getValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID) {
+NimBLEAttValue NimBLEClient::getValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID) {
     NIMBLE_LOGD(LOG_TAG, ">> getValue: serviceUUID: %s, characteristicUUID: %s",
                          serviceUUID.toString().c_str(), characteristicUUID.toString().c_str());
 
-    std::string ret = "";
+    NimBLEAttValue ret;
     NimBLERemoteService* pService = getService(serviceUUID);
 
     if(pService != nullptr) {
@@ -608,7 +834,7 @@ std::string NimBLEClient::getValue(const NimBLEUUID &serviceUUID, const NimBLEUU
         }
     }
 
-    NIMBLE_LOGD(LOG_TAG, "<<getValue");
+    NIMBLE_LOGD(LOG_TAG, "<< getValue");
     return ret;
 } // getValue
 
@@ -618,10 +844,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 NimBLEAttValue &value, bool response)
 {
     NIMBLE_LOGD(LOG_TAG, ">> setValue: serviceUUID: %s, characteristicUUID: %s",
                          serviceUUID.toString().c_str(), characteristicUUID.toString().c_str());
@@ -632,7 +859,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 +868,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 +908,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 +918,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 +986,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 +997,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 +1014,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,19 +1024,17 @@ 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());
 
-                    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);
-                    portEXIT_CRITICAL(&(*characteristic)->m_valMux);
+                    uint32_t data_len = OS_MBUF_PKTLEN(event->notify_rx.om);
+                    (*characteristic)->m_value.setValue(event->notify_rx.om->om_data, data_len);
 
                     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);
+                                                            data_len, !event->notify_rx.indication);
                     }
                     break;
                 }
@@ -790,10 +1050,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 +1087,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 +1132,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: %" PRIu32, 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 +1184,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 +1199,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
 
 
@@ -970,6 +1234,15 @@ std::string NimBLEClient::toString() {
 } // toString
 
 
+/**
+ * @brief Get the last error code reported by the NimBLE host
+ * @return int, the NimBLE error code.
+ */
+int NimBLEClient::getLastError() {
+    return m_lastErr;
+} // getLastError
+
+
 void NimBLEClientCallbacks::onConnect(NimBLEClient* pClient) {
     NIMBLE_LOGD("NimBLEClientCallbacks", "onConnect: default");
 }
@@ -1004,5 +1277,4 @@ bool NimBLEClientCallbacks::onConfirmPIN(uint32_t pin){
     return true;
 }
 
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif // CONFIG_BT_ENABLED
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */

src/NimBLEClient.h

@@ -14,15 +14,14 @@
 #ifndef MAIN_NIMBLECLIENT_H_
 #define MAIN_NIMBLECLIENT_H_
 
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLEAddress.h"
 #include "NimBLEUUID.h"
 #include "NimBLEUtils.h"
+#include "NimBLEConnInfo.h"
+#include "NimBLEAttValue.h"
 #include "NimBLEAdvertisedDevice.h"
 #include "NimBLERemoteService.h"
 
@@ -30,6 +29,7 @@
 #include <string>
 
 class NimBLERemoteService;
+class NimBLERemoteCharacteristic;
 class NimBLEClientCallbacks;
 class NimBLEAdvertisedDevice;
 
@@ -52,9 +52,10 @@ public:
     NimBLERemoteService*                        getService(const NimBLEUUID &uuid);
     void                                        deleteServices();
     size_t                                      deleteService(const NimBLEUUID &uuid);
-    std::string                                 getValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID);
+    NimBLEAttValue                              getValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID);
     bool                                        setValue(const NimBLEUUID &serviceUUID, const NimBLEUUID &characteristicUUID,
-                                                         const std::string &value);
+                                                         const NimBLEAttValue &value, bool response = false);
+    NimBLERemoteCharacteristic*                 getCharacteristic(const uint16_t handle);
     bool                                        isConnected();
     void                                        setClientCallbacks(NimBLEClientCallbacks *pClientCallbacks,
                                                                    bool deleteCallbacks = true);
@@ -68,7 +69,13 @@ public:
                                                                     uint16_t scanInterval=16, uint16_t scanWindow=16);
     void                                        updateConnParams(uint16_t minInterval, uint16_t maxInterval,
                                                                  uint16_t latency, uint16_t timeout);
+    void                                        setDataLen(uint16_t tx_octets);
     void                                        discoverAttributes();
+    NimBLEConnInfo                              getConnInfo();
+    int                                         getLastError();
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    void                                        setConnectPhy(uint8_t mask);
+#endif
 
 private:
     NimBLEClient(const NimBLEAddress &peerAddress);
@@ -82,16 +89,21 @@ 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;
+    int                     m_lastErr;
     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;
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    uint8_t                 m_phyMask;
+#endif
 
     std::vector<NimBLERemoteService*> m_servicesVector;
 
@@ -153,6 +165,5 @@ public:
     virtual bool onConfirmPIN(uint32_t pin);
 };
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif // CONFIG_BT_ENABLED
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
 #endif /* MAIN_NIMBLECLIENT_H_ */

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

@@ -11,11 +11,9 @@
  *  Created on: Jun 22, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLEService.h"
 #include "NimBLEDescriptor.h"
@@ -30,28 +28,34 @@ static NimBLEDescriptorCallbacks defaultCallbacks;
 
 
 /**
- * @brief NimBLEDescriptor constructor.
+ * @brief Construct a descriptor
+ * @param [in] uuid - UUID (const char*) for the descriptor.
+ * @param [in] properties - Properties for the descriptor.
+ * @param [in] max_len - The maximum length in bytes that the descriptor value can hold. (Default: 512 bytes for esp32, 20 for all others).
+ * @param [in] pCharacteristic - pointer to the characteristic instance this descriptor belongs to.
  */
 NimBLEDescriptor::NimBLEDescriptor(const char* uuid, uint16_t properties, uint16_t max_len,
-                                    NimBLECharacteristic* pCharacteristic)
-: NimBLEDescriptor(NimBLEUUID(uuid), max_len, properties, pCharacteristic) {
+                                   NimBLECharacteristic* pCharacteristic)
+: NimBLEDescriptor(NimBLEUUID(uuid), properties, max_len, pCharacteristic) {
 }
 
+
 /**
- * @brief NimBLEDescriptor constructor.
+ * @brief Construct a descriptor
+ * @param [in] uuid - UUID (const char*) for the descriptor.
+ * @param [in] properties - Properties for the descriptor.
+ * @param [in] max_len - The maximum length in bytes that the descriptor value can hold. (Default: 512 bytes for esp32, 20 for all others).
+ * @param [in] pCharacteristic - pointer to the characteristic instance this descriptor belongs to.
  */
 NimBLEDescriptor::NimBLEDescriptor(NimBLEUUID uuid, uint16_t properties, uint16_t max_len,
                                     NimBLECharacteristic* pCharacteristic)
-{
+:   m_value(std::min(CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH , (int)max_len), max_len) {
     m_uuid               = uuid;
-    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;
     m_properties         = 0;
+    m_removed            = 0;
 
     if (properties & BLE_GATT_CHR_F_READ) {             // convert uint16_t properties to uint8_t
         m_properties |= BLE_ATT_F_READ;
@@ -85,7 +89,6 @@ NimBLEDescriptor::NimBLEDescriptor(NimBLEUUID uuid, uint16_t properties, uint16_
  * @brief NimBLEDescriptor destructor.
  */
 NimBLEDescriptor::~NimBLEDescriptor() {
-    free(m_value.attr_value);   // Release the storage we created in the constructor.
 } // ~NimBLEDescriptor
 
 /**
@@ -102,7 +105,7 @@ uint16_t NimBLEDescriptor::getHandle() {
  * @return The length (in bytes) of the value of this descriptor.
  */
 size_t NimBLEDescriptor::getLength() {
-    return m_value.attr_len;
+    return m_value.size();
 } // getLength
 
 
@@ -116,17 +119,40 @@ NimBLEUUID NimBLEDescriptor::getUUID() {
 
 /**
  * @brief Get the value of this descriptor.
- * @return A pointer to the value of this descriptor.
+ * @return The NimBLEAttValue of this descriptor.
  */
-uint8_t* NimBLEDescriptor::getValue() {
-    return m_value.attr_value;
+NimBLEAttValue NimBLEDescriptor::getValue(time_t *timestamp) {
+    if (timestamp != nullptr) {
+        m_value.getValue(timestamp);
+    }
+
+    return m_value;
 } // 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(m_value);
+}
+
+
+/**
+ * @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) {
+    (void)conn_handle;
+    (void)attr_handle;
+
     const ble_uuid_t *uuid;
     int rc;
     NimBLEDescriptor* pDescriptor = (NimBLEDescriptor*)arg;
@@ -143,27 +169,30 @@ int NimBLEDescriptor::handleGapEvent(uint16_t conn_handle, uint16_t attr_handle,
                 if(ctxt->om->om_pkthdr_len > 8) {
                     pDescriptor->m_pCallbacks->onRead(pDescriptor);
                 }
-                portENTER_CRITICAL(&pDescriptor->m_valMux);
-                rc = os_mbuf_append(ctxt->om, pDescriptor->getValue(), pDescriptor->getLength());
-                portEXIT_CRITICAL(&pDescriptor->m_valMux);
+
+                ble_npl_hw_enter_critical();
+                rc = os_mbuf_append(ctxt->om, pDescriptor->m_value.data(), pDescriptor->m_value.size());
+                ble_npl_hw_exit_critical(0);
                 return rc == 0 ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
             }
 
             case BLE_GATT_ACCESS_OP_WRITE_DSC: {
-                if (ctxt->om->om_len > pDescriptor->m_value.attr_max_len) {
+                uint16_t att_max_len = pDescriptor->m_value.max_size();
+
+                if (ctxt->om->om_len > att_max_len) {
                     return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
                 }
 
-                uint8_t buf[pDescriptor->m_value.attr_max_len];
+                uint8_t buf[att_max_len];
                 size_t len = ctxt->om->om_len;
                 memcpy(buf, ctxt->om->om_data,len);
                 os_mbuf *next;
                 next = SLIST_NEXT(ctxt->om, om_next);
                 while(next != NULL){
-                    if((len + next->om_len) > pDescriptor->m_value.attr_max_len) {
+                    if((len + next->om_len) > att_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);
                 }
@@ -212,26 +241,28 @@ void NimBLEDescriptor::setHandle(uint16_t handle) {
  * @param [in] length The length of the data in bytes.
  */
 void NimBLEDescriptor::setValue(const uint8_t* data, size_t length) {
-    if (length > m_value.attr_max_len) {
-        NIMBLE_LOGE(LOG_TAG, "Size %d too large, must be no bigger than %d", length, m_value.attr_max_len);
-        return;
-    }
-    portENTER_CRITICAL(&m_valMux);
-    m_value.attr_len = length;
-    memcpy(m_value.attr_value, data, length);
-    portEXIT_CRITICAL(&m_valMux);
+    m_value.setValue(data, length);
 } // setValue
 
 
 /**
- * @brief Set the value of the descriptor.
- * @param [in] value The value of the descriptor in string form.
+ * @brief Set the value of the descriptor from a `std::vector<uint8_t>`.\n
+ * @param [in] vec The std::vector<uint8_t> reference to set the descriptor value from.
  */
-void NimBLEDescriptor::setValue(const std::string &value) {
-    setValue((uint8_t*) value.data(), value.length());
+void NimBLEDescriptor::setValue(const std::vector<uint8_t>& vec) {
+    return setValue((uint8_t*)&vec[0], vec.size());
 } // 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.
  * @return A string representation of the descriptor.
@@ -251,6 +282,7 @@ NimBLEDescriptorCallbacks::~NimBLEDescriptorCallbacks() {}
  * @param [in] pDescriptor The descriptor that is the source of the event.
  */
 void NimBLEDescriptorCallbacks::onRead(NimBLEDescriptor* pDescriptor) {
+    (void)pDescriptor;
     NIMBLE_LOGD("NimBLEDescriptorCallbacks", "onRead: default");
 } // onRead
 
@@ -260,8 +292,8 @@ void NimBLEDescriptorCallbacks::onRead(NimBLEDescriptor* pDescriptor) {
  * @param [in] pDescriptor The descriptor that is the source of the event.
  */
 void NimBLEDescriptorCallbacks::onWrite(NimBLEDescriptor* pDescriptor) {
+    (void)pDescriptor;
     NIMBLE_LOGD("NimBLEDescriptorCallbacks", "onWrite: default");
 } // onWrite
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLEDescriptor.h

@@ -14,25 +14,16 @@
 
 #ifndef MAIN_NIMBLEDESCRIPTOR_H_
 #define MAIN_NIMBLEDESCRIPTOR_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLECharacteristic.h"
 #include "NimBLEUUID.h"
+#include "NimBLEAttValue.h"
 
 #include <string>
 
-
-typedef struct
-{
-    uint16_t attr_max_len;  /*!<  attribute max value length */
-    uint16_t attr_len;      /*!<  attribute current value length */
-    uint8_t  *attr_value;    /*!<  the pointer to attribute value */
-} attr_value_t;
-
 class NimBLEService;
 class NimBLECharacteristic;
 class NimBLEDescriptorCallbacks;
@@ -43,51 +34,68 @@ 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);
+    NimBLECharacteristic* getCharacteristic();
+
+    size_t                getLength();
+    NimBLEAttValue        getValue(time_t *timestamp = nullptr);
+    std::string           getStringValue();
+
+    void                  setValue(const uint8_t* data, size_t size);
+    void                  setValue(const std::vector<uint8_t>& vec);
+
+    /*********************** Template Functions ************************/
 
     /**
-     * @brief Convenience template to set the descriptor value to <type\>val.
+     * @brief Template to set the characteristic value to <type\>val.
      * @param [in] s The value to set.
      */
     template<typename T>
-    void setValue(const T &s) {
-        setValue((uint8_t*)&s, sizeof(T));
+    void setValue(const T &s) { m_value.setValue<T>(s); }
+
+    /**
+     * @brief Template to convert the descriptor data to <type\>.
+     * @tparam T The type to convert the data to.
+     * @param [in] timestamp (Optional) A pointer to a time_t struct to store the time the value was read.
+     * @param [in] skipSizeCheck (Optional) If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
+     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is less than <tt>sizeof(<type\>)</tt>.
+     * @details <b>Use:</b> <tt>getValue<type>(&timestamp, skipSizeCheck);</tt>
+     */
+    template<typename T>
+    T getValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
+        return m_value.getValue<T>(timestamp, skipSizeCheck);
     }
 
 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;
     NimBLEDescriptorCallbacks* m_pCallbacks;
     NimBLECharacteristic*      m_pCharacteristic;
     uint8_t                    m_properties;
-    attr_value_t               m_value;
-    portMUX_TYPE               m_valMux;
+    NimBLEAttValue             m_value;
+    uint8_t                    m_removed;
 }; // NimBLEDescriptor
 
 
@@ -107,6 +115,5 @@ public:
 
 #include "NimBLE2904.h"
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
 #endif /* MAIN_NIMBLEDESCRIPTOR_H_ */

src/NimBLEDevice.cpp

@@ -11,26 +11,45 @@
  *  Created on: Mar 16, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
 #include "NimBLEDevice.h"
 #include "NimBLEUtils.h"
 
-#include "esp_err.h"
-#include "esp_bt.h"
-#include "nvs_flash.h"
-#include "esp_nimble_hci.h"
-#include "nimble/nimble_port.h"
-#include "nimble/nimble_port_freertos.h"
-#include "host/ble_hs.h"
-#include "host/util/util.h"
-#include "services/gap/ble_svc_gap.h"
-#include "services/gatt/ble_svc_gatt.h"
+#ifdef ESP_PLATFORM
+#  include "esp_err.h"
+#  include "esp_bt.h"
+#  include "nvs_flash.h"
+#  if defined(CONFIG_NIMBLE_CPP_IDF)
+#    include "esp_nimble_hci.h"
+#    include "nimble/nimble_port.h"
+#    include "nimble/nimble_port_freertos.h"
+#    include "host/ble_hs.h"
+#    include "host/ble_hs_pvcy.h"
+#    include "host/util/util.h"
+#    include "services/gap/ble_svc_gap.h"
+#    include "services/gatt/ble_svc_gatt.h"
+#  else
+#    include "nimble/esp_port/esp-hci/include/esp_nimble_hci.h"
+#  endif
+#else
+#  include "nimble/nimble/controller/include/controller/ble_phy.h"
+#endif
 
-#ifdef ARDUINO_ARCH_ESP32
-#include "esp32-hal-bt.h"
+#ifndef CONFIG_NIMBLE_CPP_IDF
+#  include "nimble/porting/nimble/include/nimble/nimble_port.h"
+#  include "nimble/porting/npl/freertos/include/nimble/nimble_port_freertos.h"
+#  include "nimble/nimble/host/include/host/ble_hs.h"
+#  include "nimble/nimble/host/include/host/ble_hs_pvcy.h"
+#  include "nimble/nimble/host/util/include/host/util/util.h"
+#  include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
+#  include "nimble/nimble/host/services/gatt/include/services/gatt/ble_svc_gatt.h"
+#endif
+
+#if defined(ESP_PLATFORM) && defined(CONFIG_ENABLE_ARDUINO_DEPENDS)
+#  include "esp32-hal-bt.h"
 #endif
 
 #include "NimBLELog.h"
@@ -50,16 +69,51 @@ NimBLEServer*   NimBLEDevice::m_pServer = nullptr;
 uint32_t        NimBLEDevice::m_passkey = 123456;
 bool            NimBLEDevice::m_synced = false;
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#  if CONFIG_BT_NIMBLE_EXT_ADV
+NimBLEExtAdvertising* NimBLEDevice::m_bleAdvertising = nullptr;
+#  else
 NimBLEAdvertising* NimBLEDevice::m_bleAdvertising = nullptr;
+#  endif
 #endif
 
+NimBLEMeshNode*  NimBLEDevice::m_pMeshNode = nullptr;
+
 gap_event_handler           NimBLEDevice::m_customGapHandler = nullptr;
 ble_gap_event_listener      NimBLEDevice::m_listener;
 #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 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;
+#ifdef ESP_PLATFORM
+uint16_t                    NimBLEDevice::m_scanDuplicateSize = CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE;
+uint8_t                     NimBLEDevice::m_scanFilterMode = CONFIG_BTDM_SCAN_DUPL_TYPE;
+#endif
+
+/**
+ * @brief Create a new mesh node.
+ * @param [in] uuid The uuid to advertise before being provisioned.
+ * @param [in] type A bitmask of the node type to create.
+ * @return A point to new instance of the mesh node.
+ */
+NimBLEMeshNode* NimBLEDevice::createMeshNode(NimBLEUUID uuid, uint8_t type) {
+    if(m_pMeshNode == nullptr) {
+        m_pMeshNode = new NimBLEMeshNode(uuid, type);
+    }
+
+    return m_pMeshNode;
+}
+
+
+/**
+ * @brief Get the mesh node instance.
+ * @return a pointer to the mesh node instance or nullptr if no node exists.
+ */
+NimBLEMeshNode* NimBLEDevice::getMeshNode() {
+    return m_pMeshNode;
+}
 
 
 /**
@@ -90,6 +144,45 @@ NimBLESecurityCallbacks*    NimBLEDevice::m_securityCallbacks = nullptr;
 
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#  if CONFIG_BT_NIMBLE_EXT_ADV
+/**
+ * @brief Get the instance of the advertising object.
+ * @return A pointer to the advertising object.
+ */
+NimBLEExtAdvertising* NimBLEDevice::getAdvertising() {
+    if(m_bleAdvertising == nullptr) {
+        m_bleAdvertising = new NimBLEExtAdvertising();
+    }
+    return m_bleAdvertising;
+}
+
+
+/**
+ * @brief Convenience function to begin advertising.
+ * @param [in] inst_id The extended advertisement instance ID to start.
+ * @param [in] duration How long to advertise for in milliseconds, 0 = forever (default).
+ * @param [in] max_events Maximum number of advertisement events to send, 0 = no limit (default).
+ * @return True if advertising started successfully.
+ */
+bool NimBLEDevice::startAdvertising(uint8_t inst_id,
+                                    int duration,
+                                    int max_events) {
+    return getAdvertising()->start(inst_id, duration, max_events);
+} // startAdvertising
+
+
+/**
+ * @brief Convenience function to stop advertising a data set.
+ * @param [in] inst_id The extended advertisement instance ID to stop advertising.
+ * @return True if advertising stopped successfully.
+ */
+bool NimBLEDevice::stopAdvertising(uint8_t inst_id) {
+    return getAdvertising()->stop(inst_id);
+} // stopAdvertising
+
+#  endif
+
+#  if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
 /**
  * @brief Get the instance of the advertising object.
  * @return A pointer to the advertising object.
@@ -104,17 +197,19 @@ NimBLEAdvertising* NimBLEDevice::getAdvertising() {
 
 /**
  * @brief Convenience function to begin advertising.
+ * @return True if advertising started successfully.
  */
-void NimBLEDevice::startAdvertising() {
-    getAdvertising()->start();
+bool NimBLEDevice::startAdvertising() {
+    return getAdvertising()->start();
 } // startAdvertising
-
+#  endif
 
 /**
- * @brief Convenience function to stop advertising.
+ * @brief Convenience function to stop all advertising.
+ * @return True if advertising stopped successfully.
  */
-void NimBLEDevice::stopAdvertising() {
-    getAdvertising()->stop();
+bool NimBLEDevice::stopAdvertising() {
+    return getAdvertising()->stop();
 } // stopAdvertising
 #endif // #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
 
@@ -125,7 +220,8 @@ void NimBLEDevice::stopAdvertising() {
  * try and release/delete it.
  */
 #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
-/* STATIC */ NimBLEScan* NimBLEDevice::getScan() {
+/* STATIC */
+NimBLEScan* NimBLEDevice::getScan() {
     if (m_pScan == nullptr) {
         m_pScan = new NimBLEScan();
     }
@@ -142,10 +238,11 @@ void NimBLEDevice::stopAdvertising() {
  * @return A reference to the new client object.
  */
 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-/* STATIC */ NimBLEClient* NimBLEDevice::createClient(NimBLEAddress peerAddress) {
+/* STATIC */
+NimBLEClient* NimBLEDevice::createClient(NimBLEAddress peerAddress) {
     if(m_cList.size() >= NIMBLE_MAX_CONNECTIONS) {
-        NIMBLE_LOGW("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);
@@ -160,31 +257,37 @@ void NimBLEDevice::stopAdvertising() {
  * Checks if it is connected or trying to connect and disconnects/stops it first.
  * @param [in] pClient A pointer to the client object.
  */
-/* STATIC */ bool NimBLEDevice::deleteClient(NimBLEClient* pClient) {
+/* STATIC */
+bool NimBLEDevice::deleteClient(NimBLEClient* pClient) {
     if(pClient == nullptr) {
         return false;
     }
 
+    // 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();
         }
     }
 
@@ -199,7 +302,8 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Get the list of created client objects.
  * @return A pointer to the list of clients.
  */
-/* STATIC */std::list<NimBLEClient*>* NimBLEDevice::getClientList() {
+/* STATIC */
+std::list<NimBLEClient*>* NimBLEDevice::getClientList() {
     return &m_cList;
 } // getClientList
 
@@ -208,7 +312,8 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Get the number of created client objects.
  * @return Number of client objects created.
  */
-/* STATIC */size_t NimBLEDevice::getClientListSize() {
+/* STATIC */
+size_t NimBLEDevice::getClientListSize() {
     return m_cList.size();
 } // getClientList
 
@@ -218,7 +323,8 @@ void NimBLEDevice::stopAdvertising() {
  * @param [in] conn_id The client connection ID to search for.
  * @return A pointer to the client object with the spcified connection ID.
  */
-/* STATIC */NimBLEClient* NimBLEDevice::getClientByID(uint16_t conn_id) {
+/* STATIC */
+NimBLEClient* NimBLEDevice::getClientByID(uint16_t conn_id) {
     for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
         if((*it)->getConnId() == conn_id) {
             return (*it);
@@ -234,7 +340,8 @@ void NimBLEDevice::stopAdvertising() {
  * @param [in] peer_addr The address of the peer to search for.
  * @return A pointer to the client object with the peer address.
  */
-/* STATIC */NimBLEClient* NimBLEDevice::getClientByPeerAddress(const NimBLEAddress &peer_addr) {
+/* STATIC */
+NimBLEClient* NimBLEDevice::getClientByPeerAddress(const NimBLEAddress &peer_addr) {
     for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
         if((*it)->getPeerAddress().equals(peer_addr)) {
             return (*it);
@@ -248,7 +355,8 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Finds the first disconnected client in the list.
  * @return A pointer to the first client object that is not connected to a peer.
  */
-/* STATIC */NimBLEClient* NimBLEDevice::getDisconnectedClient() {
+/* STATIC */
+NimBLEClient* NimBLEDevice::getDisconnectedClient() {
     for(auto it = m_cList.cbegin(); it != m_cList.cend(); ++it) {
         if(!(*it)->isConnected()) {
             return (*it);
@@ -259,7 +367,7 @@ void NimBLEDevice::stopAdvertising() {
 
 #endif // #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
-
+#ifdef ESP_PLATFORM
 /**
  * @brief Set the transmission power.
  * @param [in] powerLevel The power level to set, can be one of:
@@ -285,18 +393,21 @@ void NimBLEDevice::stopAdvertising() {
  * *   ESP_BLE_PWR_TYPE_SCAN       = 10, For scan
  * *   ESP_BLE_PWR_TYPE_DEFAULT    = 11, For default, if not set other, it will use default value
  */
-/* STATIC */ void NimBLEDevice::setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType) {
+/* STATIC */
+void NimBLEDevice::setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType) {
     NIMBLE_LOGD(LOG_TAG, ">> setPower: %d (type: %d)", powerLevel, powerType);
+
     esp_err_t errRc = esp_ble_tx_power_set(powerType, powerLevel);
     if (errRc != ESP_OK) {
         NIMBLE_LOGE(LOG_TAG, "esp_ble_tx_power_set: rc=%d", errRc);
     }
+
     NIMBLE_LOGD(LOG_TAG, "<< setPower");
 } // setPower
 
 
 /**
- * @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
@@ -312,9 +423,8 @@ void NimBLEDevice::stopAdvertising() {
  * *   ESP_BLE_PWR_TYPE_DEFAULT    = 11, For default, if not set other, it will use default value
  * @return the power level currently used by the type specified.
  */
-
-/* STATIC */ int NimBLEDevice::getPower(esp_ble_power_type_t powerType) {
-
+/* STATIC */
+int NimBLEDevice::getPower(esp_ble_power_type_t powerType) {
     switch(esp_ble_tx_power_get(powerType)) {
         case ESP_PWR_LVL_N12:
             return -12;
@@ -335,15 +445,27 @@ void NimBLEDevice::stopAdvertising() {
         default:
             return BLE_HS_ADV_TX_PWR_LVL_AUTO;
     }
-} // setPower
+} // getPower
 
+#else
+
+void NimBLEDevice::setPower(int dbm) {
+    ble_phy_txpwr_set(dbm);
+}
+
+
+int NimBLEDevice::getPower() {
+    return ble_phy_txpwr_get();
+}
+#endif
 
 /**
  * @brief Get our device address.
  * @return A NimBLEAddress object of our public address if we have one,
  * if not then our current random address.
  */
-/* STATIC*/ NimBLEAddress NimBLEDevice::getAddress() {
+/* STATIC*/
+NimBLEAddress NimBLEDevice::getAddress() {
     ble_addr_t addr = {BLE_ADDR_PUBLIC, 0};
 
     if(BLE_HS_ENOADDR == ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, addr.val, NULL)) {
@@ -360,7 +482,8 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Return a string representation of the address of this device.
  * @return A string representation of this device address.
  */
-/* STATIC */ std::string NimBLEDevice::toString() {
+/* STATIC */
+std::string NimBLEDevice::toString() {
     return getAddress().toString();
 } // toString
 
@@ -370,7 +493,8 @@ void NimBLEDevice::stopAdvertising() {
  * @param [in] mtu Value to set local mtu:
  * * This should be larger than 23 and lower or equal to BLE_ATT_MTU_MAX = 527.
  */
-/* STATIC */int NimBLEDevice::setMTU(uint16_t mtu) {
+/* STATIC */
+int NimBLEDevice::setMTU(uint16_t mtu) {
     NIMBLE_LOGD(LOG_TAG, ">> setLocalMTU: %d", mtu);
 
     int rc =  ble_att_set_preferred_mtu(mtu);
@@ -388,16 +512,277 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Get local MTU value set.
  * @return The current preferred MTU setting.
  */
-/* STATIC */uint16_t NimBLEDevice::getMTU() {
+/* STATIC */
+uint16_t NimBLEDevice::getMTU() {
     return ble_att_preferred_mtu();
 }
 
 
+#ifdef ESP_PLATFORM
+/**
+ * @brief Set the duplicate filter cache size for filtering scanned devices.
+ * @param [in] cacheSize The number of advertisements filtered before the cache is reset.\n
+ * 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;
+}
+#endif
+
+#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.
+ */
+/*STATIC*/
+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.
+ */
+/*STATIC*/
+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.
+ */
+/*STATIC*/
+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.
+ */
+/*STATIC*/
+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.
+ */
+/*STATIC*/
+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.
  */
-/* STATIC */  void NimBLEDevice::onReset(int reason)
+/* STATIC */
+void NimBLEDevice::onReset(int reason)
 {
     if(!m_synced) {
         return;
@@ -405,37 +790,24 @@ 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
 
 
 /**
  * @brief Host resynced with controller, all clear to make calls to the stack.
  */
-/* STATIC */ void NimBLEDevice::onSync(void)
+/* STATIC */
+void NimBLEDevice::onSync(void)
 {
     NIMBLE_LOGI(LOG_TAG, "NimBle host synced.");
     // This check is needed due to potentially being called multiple times in succession
@@ -448,20 +820,30 @@ void NimBLEDevice::stopAdvertising() {
     int rc = ble_hs_util_ensure_addr(0);
     assert(rc == 0);
 
+#ifndef ESP_PLATFORM
+    rc = ble_hs_id_infer_auto(m_own_addr_type, &m_own_addr_type);
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "error determining address type; rc=%d", rc);
+        return;
+    }
+#endif
+
+    // Yield for houskeeping before returning to operations.
+    // Occasionally triggers exception without.
+    taskYIELD();
+
     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
     }
@@ -471,9 +853,11 @@ void NimBLEDevice::stopAdvertising() {
 /**
  * @brief The main host task.
  */
-/* STATIC */ void NimBLEDevice::host_task(void *param)
+/* STATIC */
+void NimBLEDevice::host_task(void *param)
 {
     NIMBLE_LOGI(LOG_TAG, "BLE Host Task Started");
+
     /* This function will return only when nimble_port_stop() is executed */
     nimble_port_run();
 
@@ -485,12 +869,14 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Initialize the %BLE environment.
  * @param [in] deviceName The device name of the device.
  */
-/* STATIC */ void NimBLEDevice::init(const std::string &deviceName) {
+/* STATIC */
+void NimBLEDevice::init(const std::string &deviceName) {
     if(!initialized){
         int rc=0;
+#ifdef ESP_PLATFORM
         esp_err_t errRc = ESP_OK;
 
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef CONFIG_ENABLE_ARDUINO_DEPENDS
         // make sure the linker includes esp32-hal-bt.c so ardruino init doesn't release BLE memory.
         btStarted();
 #endif
@@ -504,8 +890,22 @@ 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();
+#if  defined (CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
+        bt_cfg.bluetooth_mode = ESP_BT_MODE_BLE;
+#else
+        bt_cfg.mode = ESP_BT_MODE_BLE;
+        bt_cfg.ble_max_conn = CONFIG_BT_NIMBLE_MAX_CONNECTIONS;
+#endif
+        bt_cfg.normal_adv_size = m_scanDuplicateSize;
+        bt_cfg.scan_duplicate_type = m_scanFilterMode;
+
+        ESP_ERROR_CHECK(esp_bt_controller_init(&bt_cfg));
+        ESP_ERROR_CHECK(esp_bt_controller_enable(ESP_BT_MODE_BLE));
+        ESP_ERROR_CHECK(esp_nimble_hci_init());
+#endif
         nimble_port_init();
 
         // Setup callbacks for host events
@@ -530,9 +930,10 @@ void NimBLEDevice::stopAdvertising() {
 
         nimble_port_freertos_init(NimBLEDevice::host_task);
     }
+
     // Wait for host and controller to sync before returning and accepting new tasks
     while(!m_synced){
-        vTaskDelay(1 / portTICK_PERIOD_MS);
+        taskYIELD();
     }
 
     initialized = true; // Set the initialization flag to ensure we are only initialized once.
@@ -544,16 +945,17 @@ void NimBLEDevice::stopAdvertising() {
  * @param [in] clearAll If true, deletes all server/advertising/scan/client objects after deinitializing.
  * @note If clearAll is true when called, any references to the created objects become invalid.
  */
-/* STATIC */ void NimBLEDevice::deinit(bool clearAll) {
+/* STATIC */
+void NimBLEDevice::deinit(bool clearAll) {
     int ret = nimble_port_stop();
     if (ret == 0) {
         nimble_port_deinit();
-
+#ifdef ESP_PLATFORM
         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;
 
@@ -600,6 +1002,7 @@ void NimBLEDevice::stopAdvertising() {
  * @brief Check if the initialization is complete.
  * @return true if initialized.
  */
+/*STATIC*/
 bool NimBLEDevice::getInitialized() {
     return initialized;
 } // getInitialized
@@ -611,7 +1014,8 @@ bool NimBLEDevice::getInitialized() {
  * @param mitm If true we are capable of man in the middle protection, false if not.
  * @param sc If true we will perform secure connection pairing, false we will use legacy pairing.
  */
-/*STATIC*/ void NimBLEDevice::setSecurityAuth(bool bonding, bool mitm, bool sc) {
+/*STATIC*/
+void NimBLEDevice::setSecurityAuth(bool bonding, bool mitm, bool sc) {
     NIMBLE_LOGD(LOG_TAG, "Setting bonding: %d, mitm: %d, sc: %d",bonding,mitm,sc);
     ble_hs_cfg.sm_bonding = bonding;
     ble_hs_cfg.sm_mitm = mitm;
@@ -628,7 +1032,8 @@ bool NimBLEDevice::getInitialized() {
  * * 0x08 BLE_SM_PAIR_AUTHREQ_SC
  * * 0x10 BLE_SM_PAIR_AUTHREQ_KEYPRESS  - not yet supported.
  */
-/*STATIC*/void NimBLEDevice::setSecurityAuth(uint8_t auth_req) {
+/*STATIC*/
+void NimBLEDevice::setSecurityAuth(uint8_t auth_req) {
     NimBLEDevice::setSecurityAuth((auth_req & BLE_SM_PAIR_AUTHREQ_BOND)>0,
                                 (auth_req & BLE_SM_PAIR_AUTHREQ_MITM)>0,
                                 (auth_req & BLE_SM_PAIR_AUTHREQ_SC)>0);
@@ -644,7 +1049,8 @@ bool NimBLEDevice::getInitialized() {
  * * 0x03 BLE_HS_IO_NO_INPUT_OUTPUT      NoInputNoOutput IO capability
  * * 0x04 BLE_HS_IO_KEYBOARD_DISPLAY     KeyboardDisplay Only IO capability
  */
-/*STATIC*/ void NimBLEDevice::setSecurityIOCap(uint8_t iocap) {
+/*STATIC*/
+void NimBLEDevice::setSecurityIOCap(uint8_t iocap) {
     ble_hs_cfg.sm_io_cap = iocap;
 } // setSecurityIOCap
 
@@ -658,7 +1064,8 @@ bool NimBLEDevice::getInitialized() {
  * * 0x04: BLE_SM_PAIR_KEY_DIST_SIGN
  * * 0x08: BLE_SM_PAIR_KEY_DIST_LINK
  */
-/*STATIC*/void NimBLEDevice::setSecurityInitKey(uint8_t init_key) {
+/*STATIC*/
+void NimBLEDevice::setSecurityInitKey(uint8_t init_key) {
     ble_hs_cfg.sm_our_key_dist = init_key;
 } // setsSecurityInitKey
 
@@ -672,7 +1079,8 @@ bool NimBLEDevice::getInitialized() {
  * * 0x04: BLE_SM_PAIR_KEY_DIST_SIGN
  * * 0x08: BLE_SM_PAIR_KEY_DIST_LINK
  */
-/*STATIC*/void NimBLEDevice::setSecurityRespKey(uint8_t resp_key) {
+/*STATIC*/
+void NimBLEDevice::setSecurityRespKey(uint8_t resp_key) {
     ble_hs_cfg.sm_their_key_dist = resp_key;
 } // setsSecurityRespKey
 
@@ -681,7 +1089,8 @@ bool NimBLEDevice::getInitialized() {
  * @brief Set the passkey the server will ask for when pairing.
  * @param [in] pin The passkey to use.
  */
-/*STATIC*/void NimBLEDevice::setSecurityPasskey(uint32_t pin) {
+/*STATIC*/
+void NimBLEDevice::setSecurityPasskey(uint32_t pin) {
     m_passkey = pin;
 } // setSecurityPasskey
 
@@ -690,7 +1099,8 @@ bool NimBLEDevice::getInitialized() {
  * @brief Get the current passkey used for pairing.
  * @return The current passkey.
  */
-/*STATIC*/uint32_t NimBLEDevice::getSecurityPasskey() {
+/*STATIC*/
+uint32_t NimBLEDevice::getSecurityPasskey() {
     return m_passkey;
 } // getSecurityPasskey
 
@@ -700,21 +1110,56 @@ bool NimBLEDevice::getInitialized() {
  * @param [in] callbacks Pointer to NimBLESecurityCallbacks class
  * @deprecated For backward compatibility, New code should use client/server callback methods.
  */
+/*STATIC*/
 void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
     NimBLEDevice::m_securityCallbacks = callbacks;
 } // setSecurityCallbacks
 
 
+#ifdef ESP_PLATFORM
+/**
+ * @brief Set the own address type.
+ * @param [in] own_addr_type Own Bluetooth Device address type.\n
+ * 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.
+ */
+/*STATIC*/
+void NimBLEDevice::setOwnAddrType(uint8_t own_addr_type, bool useNRPA) {
+    m_own_addr_type = own_addr_type;
+    switch (own_addr_type) {
+#ifdef CONFIG_IDF_TARGET_ESP32
+        case BLE_OWN_ADDR_PUBLIC:
+            ble_hs_pvcy_rpa_config(NIMBLE_HOST_DISABLE_PRIVACY);
+            break;
+#endif
+        case BLE_OWN_ADDR_RANDOM:
+            setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+#ifdef CONFIG_IDF_TARGET_ESP32
+            ble_hs_pvcy_rpa_config(useNRPA ? NIMBLE_HOST_ENABLE_NRPA : NIMBLE_HOST_ENABLE_RPA);
+#endif
+            break;
+        case BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT:
+        case BLE_OWN_ADDR_RPA_RANDOM_DEFAULT:
+            setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+#ifdef CONFIG_IDF_TARGET_ESP32
+            ble_hs_pvcy_rpa_config(NIMBLE_HOST_ENABLE_RPA);
+#endif
+            break;
+    }
+} // setOwnAddrType
+#endif
+
 /**
  * @brief Start the connection securing and authorization for this connection.
  * @param conn_id The connection id of the peer device.
  * @returns NimBLE stack return code, 0 = success.
  */
-/* STATIC */int NimBLEDevice::startSecurity(uint16_t conn_id) {
-  /*  if(m_securityCallbacks != nullptr) {
-        m_securityCallbacks->onSecurityRequest();
-    }
-  */
+/* STATIC */
+int NimBLEDevice::startSecurity(uint16_t conn_id) {
     int rc = ble_gap_security_initiate(conn_id);
     if(rc != 0){
         NIMBLE_LOGE(LOG_TAG, "ble_gap_security_initiate: rc=%d %s", rc, NimBLEUtils::returnCodeToString(rc));
@@ -729,7 +1174,8 @@ void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
  * @param [in] address The address to look for.
  * @return True if ignoring.
  */
-/*STATIC*/ bool NimBLEDevice::isIgnored(const NimBLEAddress &address) {
+/*STATIC*/
+bool NimBLEDevice::isIgnored(const NimBLEAddress &address) {
     for(auto &it : m_ignoreList) {
         if(it.equals(address)){
             return true;
@@ -744,7 +1190,8 @@ void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
  * @brief Add a device to the ignore list.
  * @param [in] address The address of the device we want to ignore.
  */
-/*STATIC*/ void NimBLEDevice::addIgnored(const NimBLEAddress &address) {
+/*STATIC*/
+void NimBLEDevice::addIgnored(const NimBLEAddress &address) {
     m_ignoreList.push_back(address);
 }
 
@@ -753,7 +1200,8 @@ void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
  * @brief Remove a device from the ignore list.
  * @param [in] address The address of the device we want to remove from the list.
  */
-/*STATIC*/void  NimBLEDevice::removeIgnored(const NimBLEAddress &address) {
+/*STATIC*/
+void  NimBLEDevice::removeIgnored(const NimBLEAddress &address) {
     for(auto it = m_ignoreList.begin(); it != m_ignoreList.end(); ++it) {
         if((*it).equals(address)){
             m_ignoreList.erase(it);
@@ -767,6 +1215,7 @@ void NimBLEDevice::setSecurityCallbacks(NimBLESecurityCallbacks* callbacks) {
  * @brief Set a custom callback for gap events.
  * @param [in] handler The function to call when gap events occur.
  */
+/*STATIC*/
 void NimBLEDevice::setCustomGapHandler(gap_event_handler handler) {
     m_customGapHandler = handler;
     int rc = ble_gap_event_listener_register(&m_listener, m_customGapHandler, NULL);
@@ -778,5 +1227,4 @@ void NimBLEDevice::setCustomGapHandler(gap_event_handler handler) {
     }
 } // setCustomGapHandler
 
-
 #endif // CONFIG_BT_ENABLED

src/NimBLEDevice.h

@@ -14,17 +14,20 @@
 
 #ifndef MAIN_NIMBLEDEVICE_H_
 #define MAIN_NIMBLEDEVICE_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED)
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 #include "NimBLEScan.h"
 #endif
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
-#include "NimBLEAdvertising.h"
+#  if CONFIG_BT_NIMBLE_EXT_ADV
+#    include "NimBLEExtAdvertising.h"
+#  else
+#    include "NimBLEAdvertising.h"
+#  endif
 #endif
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
@@ -35,11 +38,15 @@
 #include "NimBLEServer.h"
 #endif
 
+#include "NimBLEMeshNode.h"
+
 #include "NimBLEUtils.h"
 #include "NimBLESecurity.h"
 #include "NimBLEAddress.h"
 
-#include "esp_bt.h"
+#ifdef ESP_PLATFORM
+#  include "esp_bt.h"
+#endif
 
 #include <map>
 #include <string>
@@ -95,6 +102,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();
@@ -105,8 +117,20 @@ public:
     static NimBLEServer*    getServer();
 #endif
 
+    static NimBLEMeshNode*  createMeshNode(NimBLEUUID uuid, uint8_t type);
+    static NimBLEMeshNode*  getMeshNode();
+
+#ifdef ESP_PLATFORM
     static void             setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType=ESP_BLE_PWR_TYPE_DEFAULT);
     static int              getPower(esp_ble_power_type_t powerType=ESP_BLE_PWR_TYPE_DEFAULT);
+    static void             setOwnAddrType(uint8_t own_addr_type, bool useNRPA=false);
+    static void             setScanDuplicateCacheSize(uint16_t cacheSize);
+    static void             setScanFilterMode(uint8_t type);
+#else
+    static void             setPower(int dbm);
+    static int              getPower();
+#endif
+
     static void             setCustomGapHandler(gap_event_handler handler);
     static void             setSecurityAuth(bool bonding, bool mitm, bool sc);
     static void             setSecurityAuth(uint8_t auth_req);
@@ -124,9 +148,18 @@ public:
     static void             removeIgnored(const NimBLEAddress &address);
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
-    static NimBLEAdvertising* getAdvertising();
-    static void               startAdvertising();
-    static void               stopAdvertising();
+#  if CONFIG_BT_NIMBLE_EXT_ADV
+    static NimBLEExtAdvertising* getAdvertising();
+    static bool                  startAdvertising(uint8_t inst_id,
+                                                  int duration = 0,
+                                                  int max_events = 0);
+    static bool                  stopAdvertising(uint8_t inst_id);
+    static bool                  stopAdvertising();
+#  else
+    static NimBLEAdvertising*    getAdvertising();
+    static bool                  startAdvertising();
+    static bool                  stopAdvertising();
+#  endif
 #endif
 
 #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
@@ -139,6 +172,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;
@@ -155,6 +196,10 @@ private:
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
     friend class NimBLEAdvertising;
+#  if CONFIG_BT_NIMBLE_EXT_ADV
+    friend class NimBLEExtAdvertising;
+    friend class NimBLEExtAdvertisement;
+#  endif
 #endif
 
     static void        onReset(int reason);
@@ -171,7 +216,11 @@ private:
 #endif
 
 #if defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER)
+#  if CONFIG_BT_NIMBLE_EXT_ADV
+    static NimBLEExtAdvertising*      m_bleAdvertising;
+#  else
     static NimBLEAdvertising*         m_bleAdvertising;
+#  endif
 #endif
 
 #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
@@ -182,6 +231,13 @@ 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;
+#ifdef ESP_PLATFORM
+    static uint16_t                   m_scanDuplicateSize;
+    static uint8_t                    m_scanFilterMode;
+#endif
+    static std::vector<NimBLEAddress> m_whiteList;
+    static NimBLEMeshNode*            m_pMeshNode;
 };
 
 

src/NimBLEEddystoneTLM.cpp

@@ -11,12 +11,14 @@
  *  Created on: Mar 12, 2018
  *      Author: pcbreflux
  */
-#include "sdkconfig.h"
+
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include "NimBLEEddystoneTLM.h"
 #include "NimBLELog.h"
 
+#include <stdio.h>
 #include <cstring>
 
 #define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00)>>8) + (((x)&0xFF)<<8))
@@ -124,30 +126,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), "%" PRIu32, 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), "%" PRIu32, rawsec/10);
   out += val;
   out += "\n";
 
   out += "Time ";
 
-  snprintf(val, sizeof(val), "%04d", rawsec / 864000);
+  snprintf(val, sizeof(val), "%04" PRIu32, rawsec / 864000);
   out += val;
   out += ".";
 
-  snprintf(val, sizeof(val), "%02d", (rawsec / 36000) % 24);
+  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 36000) % 24);
   out += val;
   out += ":";
 
-  snprintf(val, sizeof(val), "%02d", (rawsec / 600) % 60);
+  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 600) % 60);
   out += val;
   out += ":";
 
-  snprintf(val, sizeof(val), "%02d", (rawsec / 10) % 60);
+  snprintf(val, sizeof(val), "%02" PRIu32, (rawsec / 10) % 60);
   out += val;
   out += "\n";
 

src/NimBLEEddystoneTLM.h

@@ -14,6 +14,7 @@
 
 #ifndef _NimBLEEddystoneTLM_H_
 #define _NimBLEEddystoneTLM_H_
+
 #include "NimBLEUUID.h"
 
 #include <string>

src/NimBLEEddystoneURL.cpp

@@ -11,7 +11,7 @@
  *  Created on: Mar 12, 2018
  *      Author: pcbreflux
  */
-#include "sdkconfig.h"
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include "NimBLEEddystoneURL.h"

src/NimBLEExtAdvertising.cpp

@@ -0,0 +1,870 @@
+/*
+ * NimBLEExtAdvertising.cpp
+ *
+ *  Created: on February 6, 2022
+ *      Author H2zero
+ */
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED) && \
+    defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && \
+    CONFIG_BT_NIMBLE_EXT_ADV
+
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#include "services/gap/ble_svc_gap.h"
+#else
+#include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
+#endif
+#include "NimBLEExtAdvertising.h"
+#include "NimBLEDevice.h"
+#include "NimBLEServer.h"
+#include "NimBLEUtils.h"
+#include "NimBLELog.h"
+
+static NimBLEExtAdvertisingCallbacks defaultCallbacks;
+static const char* LOG_TAG = "NimBLEExtAdvertising";
+
+
+/**
+ * @brief Destructor: deletes callback instances if requested.
+ */
+NimBLEExtAdvertising::~NimBLEExtAdvertising() {
+    if(m_deleteCallbacks && m_pCallbacks != &defaultCallbacks) {
+        delete m_pCallbacks;
+    }
+}
+
+
+/**
+ * @brief Register the extended advertisement data.
+ * @param [in] inst_id The extended advertisement instance ID to assign to this data.
+ * @param [in] adv The extended advertisement instance with the data to set.
+ * @return True if advertising started successfully.
+ */
+bool NimBLEExtAdvertising::setInstanceData(uint8_t inst_id, NimBLEExtAdvertisement& adv) {
+    adv.m_params.sid = inst_id;
+
+    // Legacy advertising as connectable requires the scannable flag also.
+    if (adv.m_params.legacy_pdu && adv.m_params.connectable) {
+        adv.m_params.scannable = true;
+    }
+
+    // If connectable or not scannable disable the callback for scan response requests
+    if (adv.m_params.connectable || !adv.m_params.scannable) {
+        adv.m_params.scan_req_notif = false;
+    }
+
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+    NimBLEServer* pServer = NimBLEDevice::getServer();
+    if (pServer != nullptr) {
+        if (!pServer->m_gattsStarted) {
+            pServer->start();
+        }
+    }
+
+    int rc = ble_gap_ext_adv_configure(inst_id,
+                                       &adv.m_params,
+                                       NULL,
+                                       (pServer != nullptr) ? NimBLEServer::handleGapEvent :
+                                                              NimBLEExtAdvertising::handleGapEvent,
+                                       NULL);
+#else
+    int rc = ble_gap_ext_adv_configure(inst_id,
+                                       &data.m_params,
+                                       NULL,
+                                       NimBLEExtAdvertising::handleGapEvent,
+                                       NULL);
+#endif
+
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Advertising config error: rc = %d", rc);
+    } else {
+        os_mbuf *buf;
+        buf = os_msys_get_pkthdr(adv.m_payload.size(), 0);
+        if (!buf) {
+            NIMBLE_LOGE(LOG_TAG, "Data buffer allocation failed");
+            return false;
+        }
+
+        rc = os_mbuf_append(buf, &adv.m_payload[0], adv.m_payload.size());
+        if (rc != 0) {
+            NIMBLE_LOGE(LOG_TAG, "Unable to copy data: rc = %d", rc);
+            return false;
+        } else {
+            if (adv.m_params.scannable && !adv.m_params.legacy_pdu) {
+                rc = ble_gap_ext_adv_rsp_set_data(inst_id, buf);
+            } else {
+                rc = ble_gap_ext_adv_set_data(inst_id, buf);
+            }
+
+            if (rc != 0) {
+                NIMBLE_LOGE(LOG_TAG, "Invalid advertisement data: rc = %d", rc);
+            } else {
+                if (adv.m_advAddress != NimBLEAddress("")) {
+                    ble_addr_t addr;
+                    memcpy(&addr.val, adv.m_advAddress.getNative(), 6);
+                    // Custom advertising address must be random.
+                    addr.type = BLE_OWN_ADDR_RANDOM;
+                    rc = ble_gap_ext_adv_set_addr(inst_id, &addr);
+                }
+
+                if (rc != 0) {
+                    NIMBLE_LOGE(LOG_TAG, "Error setting advertisement address: rc = %d", rc);
+                    return false;
+                }
+            }
+        }
+    }
+
+    return (rc == 0);
+}
+
+
+/**
+ * @brief Set the scan response data for a legacy advertisement.
+ * @param [in] inst_id The extended advertisement instance ID to assign to this data.
+ * @param [in] lsr A reference to a NimBLEExtAdvertisement that contains the data.
+ */
+bool NimBLEExtAdvertising::setScanResponseData(uint8_t inst_id, NimBLEExtAdvertisement & lsr) {
+    os_mbuf *buf = os_msys_get_pkthdr(lsr.m_payload.size(), 0);
+    if (!buf) {
+        NIMBLE_LOGE(LOG_TAG, "Data buffer allocation failed");
+        return false;
+    }
+
+    int rc = os_mbuf_append(buf, &lsr.m_payload[0], lsr.m_payload.size());
+
+    if (rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Unable to copy scan data: rc = %d", rc);
+        return false;
+    } else {
+        rc = ble_gap_ext_adv_rsp_set_data(inst_id, buf);
+    }
+    return (rc == 0);
+}
+
+
+/**
+ * @brief Start extended advertising.
+ * @param [in] inst_id The extended advertisement instance ID to start.
+ * @param [in] duration How long to advertise for in milliseconds, 0 = forever (default).
+ * @param [in] max_events Maximum number of advertisement events to send, 0 = no limit (default).
+ * @return True if advertising started successfully.
+ */
+bool NimBLEExtAdvertising::start(uint8_t inst_id, int duration, int max_events) {
+    NIMBLE_LOGD(LOG_TAG, ">> Extended Advertising start");
+
+    // If Host is not synced we cannot start advertising.
+    if(!NimBLEDevice::m_synced) {
+        NIMBLE_LOGE(LOG_TAG, "Host reset, wait for sync.");
+        return false;
+    }
+
+    int rc = ble_gap_ext_adv_start(inst_id, duration / 10, max_events);
+
+    switch (rc) {
+        case 0:
+             m_advStatus[inst_id] = true;
+             break;
+
+        case BLE_HS_EINVAL:
+             NIMBLE_LOGE(LOG_TAG, "Unable to advertise - Value Error");
+             break;
+
+        case BLE_HS_EALREADY:
+             NIMBLE_LOGI(LOG_TAG, "Advertisement Already active");
+             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;
+    }
+
+    NIMBLE_LOGD(LOG_TAG, "<< Extended Advertising start");
+    return (rc == 0 || rc == BLE_HS_EALREADY);
+} // start
+
+
+/**
+ * @brief Stop and remove this instance data from the advertisement set.
+ * @param [in] inst_id The extended advertisement instance to stop advertising.
+ * @return True if successful.
+ */
+bool NimBLEExtAdvertising::removeInstance(uint8_t inst_id) {
+    if (stop(inst_id)) {
+        int rc =  ble_gap_ext_adv_remove(inst_id);
+        if (rc != 0 && rc != BLE_HS_EALREADY) {
+            NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_remove rc = %d %s",
+                        rc, NimBLEUtils::returnCodeToString(rc));
+            return false;
+        }
+        return true;
+    }
+
+    return false;
+} // removeInstance
+
+
+/**
+ * @brief Stop and remove all advertising instance data.
+ * @return True if successful.
+ */
+bool NimBLEExtAdvertising::removeAll() {
+    if (stop()) {
+        int rc = ble_gap_ext_adv_clear();
+        if (rc == 0 || rc == BLE_HS_EALREADY) {
+            return true;
+        } else {
+            NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_clear rc = %d %s",
+                        rc, NimBLEUtils::returnCodeToString(rc));
+        }
+    }
+
+    return false;
+} // removeAll
+
+
+/**
+ * @brief Stop advertising this instance data.
+ * @param [in] inst_id The extended advertisement instance to stop advertising.
+ * @return True if successful.
+ */
+bool NimBLEExtAdvertising::stop(uint8_t inst_id) {
+    int rc = ble_gap_ext_adv_stop(inst_id);
+    if (rc != 0 && rc != BLE_HS_EALREADY) {
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_stop rc = %d %s",
+                    rc, NimBLEUtils::returnCodeToString(rc));
+        return false;
+    }
+
+    m_advStatus[inst_id] = false;
+    return true;
+} // stop
+
+
+/**
+ * @brief Stop all advertisements.
+ * @return True if successful.
+ */
+bool NimBLEExtAdvertising::stop() {
+    int rc = ble_gap_ext_adv_clear();
+    if (rc != 0 && rc != BLE_HS_EALREADY) {
+        NIMBLE_LOGE(LOG_TAG, "ble_gap_ext_adv_stop rc = %d %s",
+                    rc, NimBLEUtils::returnCodeToString(rc));
+        return false;
+    }
+
+    for(auto it : m_advStatus) {
+        it = false;
+    }
+
+    return true;
+} // stop
+
+
+/**
+ * @brief Set a callback to call when the advertisement stops.
+ * @param [in] pCallbacks A pointer to a callback to be invoked when an advertisment stops.
+ * @param [in] deleteCallbacks if true callback class will be deleted when advertising is destructed.
+ */
+void NimBLEExtAdvertising::setCallbacks(NimBLEExtAdvertisingCallbacks* pCallbacks,
+                                        bool deleteCallbacks) {
+    if (pCallbacks != nullptr){
+        m_pCallbacks = pCallbacks;
+        m_deleteCallbacks = deleteCallbacks;
+    } else {
+        m_pCallbacks = &defaultCallbacks;
+    }
+} // setCallbacks
+
+
+/**
+ * @brief Check if currently advertising.
+ * @param [in] inst_id The instance ID of the advertised data to get the status of.
+ * @return True if advertising is active.
+ */
+bool NimBLEExtAdvertising::isActive(uint8_t inst_id) {
+    return m_advStatus[inst_id];
+} // isAdvertising
+
+
+/**
+ * @brief Check if any instances are currently advertising.
+ * @return True if any instance is active.
+ */
+bool NimBLEExtAdvertising::isAdvertising() {
+    for (auto it : m_advStatus) {
+        if (it) {
+            return true;
+        }
+    }
+    return false;
+} // isAdvertising
+
+
+/*
+ * Host reset seems to clear advertising data,
+ * we need clear the flag so it reloads it.
+ */
+void NimBLEExtAdvertising::onHostSync() {
+    NIMBLE_LOGD(LOG_TAG, "Host re-synced");
+    for(auto it : m_advStatus) {
+        it = false;
+    }
+} // onHostSync
+
+
+/**
+ * @brief Handler for gap events when not using peripheral role.
+ * @param [in] event the event data.
+ * @param [in] arg pointer to the advertising instance.
+ */
+/*STATIC*/
+int NimBLEExtAdvertising::handleGapEvent(struct ble_gap_event *event, void *arg) {
+    (void)arg;
+    NimBLEExtAdvertising* pAdv = NimBLEDevice::getAdvertising();
+
+    switch (event->type) {
+        case 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->m_advStatus[event->adv_complete.instance] = false;
+            pAdv->m_pCallbacks->onStopped(pAdv, event->adv_complete.reason,
+                                          event->adv_complete.instance);
+            break;
+        }
+
+        case BLE_GAP_EVENT_SCAN_REQ_RCVD: {
+            pAdv->m_pCallbacks->onScanRequest(pAdv, event->scan_req_rcvd.instance,
+                                              NimBLEAddress(event->scan_req_rcvd.scan_addr));
+            break;
+        }
+    }
+
+    return 0;
+} // handleGapEvent
+
+
+/** Default callback handlers */
+void NimBLEExtAdvertisingCallbacks::onStopped(NimBLEExtAdvertising *pAdv,
+                                              int reason, uint8_t inst_id) {
+    NIMBLE_LOGD("NimBLEExtAdvertisingCallbacks", "onStopped: Default");
+} // onStopped
+
+
+void NimBLEExtAdvertisingCallbacks::onScanRequest(NimBLEExtAdvertising *pAdv,
+                                                  uint8_t inst_id, NimBLEAddress addr) {
+    NIMBLE_LOGD("NimBLEExtAdvertisingCallbacks", "onScanRequest: Default");
+} // onScanRequest
+
+
+/**
+ * @brief Construct a BLE extended advertisement.
+ * @param [in] priPhy The primary Phy to advertise on, can be one of:
+ * * BLE_HCI_LE_PHY_1M
+ * * BLE_HCI_LE_PHY_CODED
+ * @param [in] secPhy The secondary Phy to advertise on, can be one of:
+ * * BLE_HCI_LE_PHY_1M
+ * * BLE_HCI_LE_PHY_2M
+ * * BLE_HCI_LE_PHY_CODED
+ */
+NimBLEExtAdvertisement::NimBLEExtAdvertisement(uint8_t priPhy, uint8_t secPhy)
+:   m_advAddress("")
+{
+    memset (&m_params, 0, sizeof(m_params));
+    m_params.own_addr_type = NimBLEDevice::m_own_addr_type;
+    m_params.primary_phy   = priPhy;
+    m_params.secondary_phy = secPhy;
+    m_params.tx_power      = 127;
+} // NimBLEExtAdvertisement
+
+
+/**
+ * @brief Sets wether the advertisement should use legacy (BLE 4.0, 31 bytes max) advertising.
+ * @param [in] val true = using legacy advertising.
+ */
+void NimBLEExtAdvertisement::setLegacyAdvertising(bool val) {
+    m_params.legacy_pdu = val;
+} // setLegacyAdvertising
+
+
+/**
+ * @brief Sets wether the advertisement has scan response data available.
+ * @param [in] val true = scan response is available.
+ */
+void NimBLEExtAdvertisement::setScannable(bool val) {
+    m_params.scannable = val;
+} // setScannable
+
+
+
+/**
+ * @brief Sets the transmission power level for this advertisement.
+ * @param [in] dbm the transmission power to use in dbm.
+ * @details The allowable value range depends on device hardware. \n
+ * The ESP32C3 and ESP32S3 have a range of -27 to +18.
+ */
+void NimBLEExtAdvertisement::setTxPower(int8_t dbm) {
+    m_params.tx_power = dbm;
+}
+
+
+/**
+ * @brief Sets wether this advertisement should advertise as a connectable device.
+ * @param [in] val True = connectable.
+ */
+void NimBLEExtAdvertisement::setConnectable(bool val) {
+#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+    m_params.connectable = val;
+#endif
+} // setConnectable
+
+
+/**
+ * @brief Set the address to use for this advertisement.
+ * @param [in] addr The address to use.
+ */
+void NimBLEExtAdvertisement::setAddress(const NimBLEAddress & addr) {
+    m_advAddress = addr;
+    // Must use random address type.
+    m_params.own_addr_type = BLE_OWN_ADDR_RANDOM;
+}
+
+
+/**
+ * @brief Sets The primary channels to advertise on.
+ * @param [in] ch37 Advertise on channel 37.
+ * @param [in] ch38 Advertise on channel 38.
+ * @param [in] ch39 Advertise on channel 39.
+ * @details This will set a bitmask using the input parameters to allow different \n
+ * combinations. If all inputs are false then all 3 channels will be used.
+ */
+void NimBLEExtAdvertisement::setPrimaryChannels(bool ch37, bool ch38, bool ch39) {
+    m_params.channel_map = (ch37 | (ch38 << 1) | (ch39 << 2));
+} // setPrimaryChannels
+
+
+/**
+ * @brief Set the filtering for the scan filter.
+ * @param [in] scanRequestWhitelistOnly If true, only allow scan requests from those on the white list.
+ * @param [in] connectWhitelistOnly If true, only allow connections from those on the white list.
+ */
+void NimBLEExtAdvertisement::setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly) {
+    if (!scanRequestWhitelistOnly && !connectWhitelistOnly) {
+        m_params.filter_policy = BLE_HCI_ADV_FILT_NONE;
+        return;
+    }
+    if (scanRequestWhitelistOnly && !connectWhitelistOnly) {
+        m_params.filter_policy = BLE_HCI_ADV_FILT_SCAN;
+        return;
+    }
+    if (!scanRequestWhitelistOnly && connectWhitelistOnly) {
+        m_params.filter_policy = BLE_HCI_ADV_FILT_CONN;
+        return;
+    }
+    if (scanRequestWhitelistOnly && connectWhitelistOnly) {
+        m_params.filter_policy = BLE_HCI_ADV_FILT_BOTH;
+        return;
+    }
+} // setScanFilter
+
+
+/**
+ * @brief Sets the peer to directly advertise to.
+ * @param [in] addr The address of the peer to direct the advertisements.
+ */
+void NimBLEExtAdvertisement::setDirectedPeer(const NimBLEAddress & addr) {
+    ble_addr_t peerAddr;
+    memcpy(&peerAddr.val, addr.getNative(), 6);
+    peerAddr.type = addr.getType();
+    m_params.peer = peerAddr;
+} // setDirectedPeer
+
+
+/**
+ * @brief Enable or disable direct advertisements to the peer set with `NimBLEExtAdvertisement::setDirectedPeer`
+ * @param [in] val true = send directed advertisements to peer.
+ * @param [in] high_duty true = use fast advertising rate, default - true.
+ */
+void NimBLEExtAdvertisement::setDirected(bool val, bool high_duty) {
+    m_params.directed = val;
+    m_params.high_duty_directed = high_duty;
+} // setDirected
+
+
+/**
+ * @brief Set the minimum advertising interval.
+ * @param [in] mininterval Minimum value for advertising interval in 0.625ms units, 0 = use default.
+ */
+void NimBLEExtAdvertisement::setMinInterval(uint32_t mininterval) {
+    m_params.itvl_min = mininterval;
+} // setMinInterval
+
+
+/**
+ * @brief Set the maximum advertising interval.
+ * @param [in] maxinterval Maximum value for advertising interval in 0.625ms units, 0 = use default.
+ */
+void NimBLEExtAdvertisement::setMaxInterval(uint32_t maxinterval) {
+    m_params.itvl_max = maxinterval;
+} // setMaxInterval
+
+
+/**
+ * @brief Set the primary advertising PHY to use
+ * @param [in] phy Can be one of following constants:
+ * * BLE_HCI_LE_PHY_1M
+ * * BLE_HCI_LE_PHY_CODED
+ */
+void NimBLEExtAdvertisement::setPrimaryPhy(uint8_t phy) {
+    m_params.primary_phy = phy;
+} // setPrimaryPhy
+
+
+/**
+ * @brief Set the secondary advertising PHY to use
+ * @param [in] phy Can be one of following constants:
+ * * BLE_HCI_LE_PHY_1M
+ * * BLE_HCI_LE_PHY_2M
+ * * BLE_HCI_LE_PHY_CODED
+ */
+void NimBLEExtAdvertisement::setSecondaryPhy(uint8_t phy) {
+    m_params.secondary_phy = phy;
+} // setSecondaryPhy
+
+
+/**
+ * @brief Sets whether the advertisement should be anonymous.
+ * @param [in] val Set to true to enable anonymous advertising.
+ *
+ * @details Anonymous advertising omits the device's address from the advertisement.
+ */
+void NimBLEExtAdvertisement::setAnonymous(bool val) {
+    m_params.anonymous = val;
+} // setAnonymous
+
+
+/**
+ * @brief Sets whether the scan response request callback should be called.
+ * @param [in] enable If true the scan response request callback will be called for this advertisement.
+ */
+void NimBLEExtAdvertisement::enableScanRequestCallback(bool enable) {
+    m_params.scan_req_notif = enable;
+} // enableScanRequestCallback
+
+
+/**
+ * @brief Clears the data stored in this instance, does not change settings.
+ * @details This will clear all data but preserves advertising parameter settings.
+ */
+void NimBLEExtAdvertisement::clearData() {
+    std::vector<uint8_t> swap;
+    std::swap(m_payload, swap);
+}
+
+
+/**
+ * @brief Get the size of the current data.
+ */
+size_t NimBLEExtAdvertisement::getDataSize() {
+    return m_payload.size();
+} // getDataSize
+
+
+/**
+ * @brief Set the advertisement data.
+ * @param [in] data The data to be set as the payload.
+ * @param [in] length The size of data.
+ * @details This will completely replace any data that was previously set.
+ */
+void NimBLEExtAdvertisement::setData(const uint8_t * data, size_t length) {
+    m_payload.assign(data, data + length);
+} // setData
+
+
+/**
+ * @brief Add data to the payload to be advertised.
+ * @param [in] data The data to be added to the payload.
+ */
+void NimBLEExtAdvertisement::addData(const std::string &data) {
+    addData((uint8_t*)data.data(), data.length());
+} // addData
+
+
+/**
+ * @brief Add data to the payload to be advertised.
+ * @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 NimBLEExtAdvertisement::addData(const uint8_t * data, size_t length) {
+    m_payload.insert(m_payload.end(), data, data + length);
+} // addData
+
+
+/**
+ * @brief Set the appearance.
+ * @param [in] appearance The appearance code value.
+ *
+ * See also:
+ * https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.characteristic.gap.appearance.xml
+ */
+void NimBLEExtAdvertisement::setAppearance(uint16_t appearance) {
+    char cdata[2];
+    cdata[0] = 3;
+    cdata[1] = BLE_HS_ADV_TYPE_APPEARANCE; // 0x19
+    addData(std::string(cdata, 2) + std::string((char*) &appearance, 2));
+} // setAppearance
+
+
+/**
+ * @brief Set the advertisement flags.
+ * @param [in] flag The flags to be set in the advertisement.
+ * * BLE_HS_ADV_F_DISC_LTD
+ * * BLE_HS_ADV_F_DISC_GEN
+ * * BLE_HS_ADV_F_BREDR_UNSUP - must always use with NimBLE
+ */
+void NimBLEExtAdvertisement::setFlags(uint8_t flag) {
+    char cdata[3];
+    cdata[0] = 2;
+    cdata[1] = BLE_HS_ADV_TYPE_FLAGS;  // 0x01
+    cdata[2] = flag | BLE_HS_ADV_F_BREDR_UNSUP;
+    addData(std::string(cdata, 3));
+} // setFlags
+
+
+/**
+ * @brief Set manufacturer specific data.
+ * @param [in] data The manufacturer data to advertise.
+ */
+void NimBLEExtAdvertisement::setManufacturerData(const std::string &data) {
+    char cdata[2];
+    cdata[0] = data.length() + 1;
+    cdata[1] = BLE_HS_ADV_TYPE_MFG_DATA ;  // 0xff
+    addData(std::string(cdata, 2) + data);
+} // setManufacturerData
+
+
+/**
+ * @brief Set the URI to advertise.
+ * @param [in] uri The uri to advertise.
+ */
+void NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::setName(const std::string &name) {
+    char cdata[2];
+    cdata[0] = name.length() + 1;
+    cdata[1] = BLE_HS_ADV_TYPE_COMP_NAME;  // 0x09
+    addData(std::string(cdata, 2) + name);
+} // setName
+
+
+/**
+ * @brief Set a single service to advertise as a complete list of services.
+ * @param [in] uuid The service to advertise.
+ */
+void NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::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 NimBLEExtAdvertisement::setServices(const bool complete, const uint8_t size,
+                                             const std::vector<NimBLEUUID> &v_uuid)
+{
+    char cdata[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:
+            cdata[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS32 : BLE_HS_ADV_TYPE_INCOMP_UUIDS32;
+            break;
+        case 128:
+            cdata[1] = complete ? BLE_HS_ADV_TYPE_COMP_UUIDS128 : BLE_HS_ADV_TYPE_INCOMP_UUIDS128;
+            break;
+        default:
+            return;
+    }
+
+    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
+
+
+/**
+ * @brief Set the service data (UUID + data)
+ * @param [in] uuid The UUID to set with the service data.
+ * @param [in] data The data to be associated with the service data advertised.
+ */
+void NimBLEExtAdvertisement::setServiceData(const NimBLEUUID &uuid, const std::string &data) {
+    char cdata[2];
+    switch (uuid.bitSize()) {
+        case 16: {
+            // [Len] [0x16] [UUID16] data
+            cdata[0] = data.length() + 3;
+            cdata[1] = BLE_HS_ADV_TYPE_SVC_DATA_UUID16;  // 0x16
+            addData(std::string(cdata, 2) + std::string((char*) &uuid.getNative()->u16.value, 2) + data);
+            break;
+        }
+
+        case 32: {
+            // [Len] [0x20] [UUID32] data
+            cdata[0] = data.length() + 5;
+            cdata[1] = BLE_HS_ADV_TYPE_SVC_DATA_UUID32; // 0x20
+            addData(std::string(cdata, 2) + std::string((char*) &uuid.getNative()->u32.value, 4) + data);
+            break;
+        }
+
+        case 128: {
+            // [Len] [0x21] [UUID128] data
+            cdata[0] = data.length() + 17;
+            cdata[1] = BLE_HS_ADV_TYPE_SVC_DATA_UUID128;  // 0x21
+            addData(std::string(cdata, 2) + std::string((char*) &uuid.getNative()->u128.value, 16) + data);
+            break;
+        }
+
+        default:
+            return;
+    }
+} // setServiceData
+
+
+/**
+ * @brief Set the short name.
+ * @param [in] name The short name of the device.
+ */
+void NimBLEExtAdvertisement::setShortName(const std::string &name) {
+    char cdata[2];
+    cdata[0] = name.length() + 1;
+    cdata[1] = BLE_HS_ADV_TYPE_INCOMP_NAME;  // 0x08
+    addData(std::string(cdata, 2) + name);
+} // setShortName
+
+
+/**
+ * @brief Adds Tx power level to the advertisement data.
+ */
+void NimBLEExtAdvertisement::addTxPower() {
+    m_params.include_tx_power = 1;
+} // addTxPower
+
+
+/**
+ * @brief Set the preferred connection interval parameters.
+ * @param [in] min The minimum interval desired.
+ * @param [in] max The maximum interval desired.
+ */
+void NimBLEExtAdvertisement::setPreferredParams(uint16_t min, uint16_t max) {
+    uint8_t data[6];
+    data[0] = BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN + 1;
+    data[1] = BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE;
+    data[2] = min;
+    data[3] = min >> 8;
+    data[4] = max;
+    data[5] = max >> 8;
+    addData(data, 6);
+} // setPreferredParams
+
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && CONFIG_BT_NIMBLE_EXT_ADV */

src/NimBLEExtAdvertising.h

@@ -0,0 +1,152 @@
+/*
+ * NimBLEExtAdvertising.h
+ *
+ *  Created: on February 6, 2022
+ *      Author H2zero
+ */
+
+#ifndef MAIN_BLEEXTADVERTISING_H_
+#define MAIN_BLEEXTADVERTISING_H_
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED) && \
+    defined(CONFIG_BT_NIMBLE_ROLE_BROADCASTER) && \
+    CONFIG_BT_NIMBLE_EXT_ADV
+
+#  if defined(CONFIG_NIMBLE_CPP_IDF)
+#    include "host/ble_gap.h"
+#  else
+#    include "nimble/nimble/host/include/host/ble_gap.h"
+#  endif
+
+/****  FIX COMPILATION ****/
+#undef min
+#undef max
+/**************************/
+
+#include "NimBLEAddress.h"
+#include "NimBLEUUID.h"
+
+#include <vector>
+
+class NimBLEExtAdvertisingCallbacks;
+
+
+/**
+ * @brief Extended advertisement data
+ */
+class NimBLEExtAdvertisement {
+public:
+    NimBLEExtAdvertisement(uint8_t priPhy = BLE_HCI_LE_PHY_1M,
+                           uint8_t secPhy = BLE_HCI_LE_PHY_1M);
+    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 flag);
+    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   setData(const uint8_t * data, size_t length);
+    void   addData(const std::string &data);
+    void   addData(const uint8_t * data, size_t length);
+    void   addTxPower();
+    void   setPreferredParams(uint16_t min, uint16_t max);
+    void   setLegacyAdvertising(bool val);
+    void   setConnectable(bool val);
+    void   setScannable(bool val);
+    void   setMinInterval(uint32_t mininterval);
+    void   setMaxInterval(uint32_t maxinterval);
+    void   setPrimaryPhy(uint8_t phy);
+    void   setSecondaryPhy(uint8_t phy);
+    void   setScanFilter(bool scanRequestWhitelistOnly, bool connectWhitelistOnly);
+    void   setDirectedPeer(const NimBLEAddress & addr);
+    void   setDirected(bool val, bool high_duty = true);
+    void   setAnonymous(bool val);
+    void   setPrimaryChannels(bool ch37, bool ch38, bool ch39);
+    void   setTxPower(int8_t dbm);
+    void   setAddress(const NimBLEAddress & addr);
+    void   enableScanRequestCallback(bool enable);
+    void   clearData();
+    size_t getDataSize();
+
+private:
+    friend class NimBLEExtAdvertising;
+
+    void setServices(const bool complete, const uint8_t size,
+                     const std::vector<NimBLEUUID> &v_uuid);
+
+    std::vector<uint8_t>    m_payload;
+    ble_gap_ext_adv_params  m_params;
+    NimBLEAddress           m_advAddress;
+};   // NimBLEExtAdvertisement
+
+
+/**
+ * @brief Extended advertising class.
+ */
+class NimBLEExtAdvertising {
+public:
+    /**
+     * @brief Construct an extended advertising object.
+     */
+    NimBLEExtAdvertising() :m_advStatus(CONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES + 1, false) {}
+    ~NimBLEExtAdvertising();
+    bool start(uint8_t inst_id, int duration = 0, int max_events = 0);
+    bool setInstanceData(uint8_t inst_id, NimBLEExtAdvertisement& adv);
+    bool setScanResponseData(uint8_t inst_id, NimBLEExtAdvertisement & data);
+    bool removeInstance(uint8_t inst_id);
+    bool removeAll();
+    bool stop(uint8_t inst_id);
+    bool stop();
+    bool isActive(uint8_t inst_id);
+    bool isAdvertising();
+    void setCallbacks(NimBLEExtAdvertisingCallbacks* callbacks,
+                      bool deleteCallbacks = true);
+
+private:
+    friend class NimBLEDevice;
+    friend class NimBLEServer;
+
+    void           onHostSync();
+    static int     handleGapEvent(struct ble_gap_event *event, void *arg);
+
+    bool                            m_scanResp;
+    bool                            m_deleteCallbacks;
+    NimBLEExtAdvertisingCallbacks*  m_pCallbacks;
+    ble_gap_ext_adv_params          m_advParams;
+    std::vector<bool>               m_advStatus;
+};
+
+
+/**
+ * @brief Callbacks associated with NimBLEExtAdvertising class.
+ */
+class NimBLEExtAdvertisingCallbacks {
+public:
+    virtual ~NimBLEExtAdvertisingCallbacks() {};
+
+    /**
+     * @brief Handle an advertising stop event.
+     * @param [in] pAdv A convenience pointer to the extended advertising interface.
+     * @param [in] reason The reason code for stopping the advertising.
+     * @param [in] inst_id The instance ID of the advertisement that was stopped.
+     */
+    virtual void onStopped(NimBLEExtAdvertising *pAdv, int reason, uint8_t inst_id);
+
+    /**
+     * @brief Handle a scan response request.
+     * This is called when a scanning device requests a scan response.
+     * @param [in] pAdv A convenience pointer to the extended advertising interface.
+     * @param [in] inst_id The instance ID of the advertisement that the scan response request was made.
+     * @param [in] addr The address of the device making the request.
+     */
+    virtual void onScanRequest(NimBLEExtAdvertising *pAdv, uint8_t inst_id, NimBLEAddress addr);
+}; // NimBLEExtAdvertisingCallbacks
+
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && CONFIG_BT_NIMBLE_EXT_ADV */
+#endif /* MAIN_BLEADVERTISING_H_ */

src/NimBLEHIDDevice.cpp

@@ -0,0 +1,248 @@
+/*
+ * NimBLEHIDDevice.cpp
+ *
+ *  Created: on Oct 06 2020
+ *      Author wakwak-koba
+ *
+ * Originally:
+ *
+ * BLEHIDDevice.cpp
+ *
+ *  Created on: Jan 03, 2018
+ *      Author: chegewara
+ */
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED) && 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));
+	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 /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLEHIDDevice.h

@@ -0,0 +1,86 @@
+/*
+ * 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 "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED) && 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_ENABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER */
+#endif /* _BLEHIDDEVICE_H_ */

src/NimBLELog.h

@@ -7,54 +7,74 @@
  */
 #ifndef MAIN_NIMBLELOG_H_
 #define MAIN_NIMBLELOG_H_
-#include "sdkconfig.h"
+
+#include "nimconfig.h"
+
 #if defined(CONFIG_BT_ENABLED)
 
-#include "syscfg/syscfg.h"
-#include "modlog/modlog.h"
+#if defined(CONFIG_NIMBLE_CPP_IDF) // using esp-idf
+#  include "esp_log.h"
+#  ifndef CONFIG_NIMBLE_CPP_LOG_LEVEL
+#    define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
+#  endif
 
+#  define NIMBLE_CPP_LOG_PRINT(level, tag, format, ...) do { \
+    if (CONFIG_NIMBLE_CPP_LOG_LEVEL >= level) \
+      ESP_LOG_LEVEL_LOCAL(level, tag, format, ##__VA_ARGS__); \
+    } while(0)
 
-// 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
+#  define NIMBLE_LOGD(tag, format, ...) \
+     NIMBLE_CPP_LOG_PRINT(ESP_LOG_DEBUG, tag, format, ##__VA_ARGS__)
 
-#if CORE_DEBUG_LEVEL >= 4
-#define NIMBLE_LOGD( tag, format, ... ) MODLOG_DFLT(ERROR,      "D %s: "#format"\n",tag,##__VA_ARGS__)
-#else
-#define NIMBLE_LOGD( tag, format, ... ) (void)tag
-#endif
+#  define NIMBLE_LOGI(tag, format, ...) \
+     NIMBLE_CPP_LOG_PRINT(ESP_LOG_INFO, tag, format, ##__VA_ARGS__)
 
-#if CORE_DEBUG_LEVEL >= 3
-#define NIMBLE_LOGI( tag, format, ... ) MODLOG_DFLT(ERROR,      "I %s: "#format"\n",tag,##__VA_ARGS__)
-#else
-#define NIMBLE_LOGI( tag, format, ... ) (void)tag
-#endif
+#  define NIMBLE_LOGW(tag, format, ...) \
+     NIMBLE_CPP_LOG_PRINT(ESP_LOG_WARN, tag, format, ##__VA_ARGS__)
 
-#if CORE_DEBUG_LEVEL >= 2
-#define NIMBLE_LOGW( tag, format, ... ) MODLOG_DFLT(ERROR,      "W %s: "#format"\n",tag,##__VA_ARGS__)
-#else
-#define NIMBLE_LOGW( tag, format, ... ) (void)tag
-#endif
+#  define NIMBLE_LOGE(tag, format, ...) \
+     NIMBLE_CPP_LOG_PRINT(ESP_LOG_ERROR, tag, format, ##__VA_ARGS__)
 
-#if CORE_DEBUG_LEVEL >= 1
-#define NIMBLE_LOGE( tag, format, ... ) MODLOG_DFLT(ERROR,      "E %s: "#format"\n",tag,##__VA_ARGS__)
-#else
-#define NIMBLE_LOGE( tag, format, ... ) (void)tag
-#endif
+#  define NIMBLE_LOGC(tag, format, ...) \
+     NIMBLE_CPP_LOG_PRINT(ESP_LOG_ERROR, tag, format, ##__VA_ARGS__)
 
-#define NIMBLE_LOGC( tag, format, ... ) MODLOG_DFLT(CRITICAL,   "CRIT %s: "#format"\n",tag,##__VA_ARGS__)
+#else // using Arduino
+#  include "nimble/porting/nimble/include/syscfg/syscfg.h"
+#  include "nimble/console/console.h"
+#  ifndef CONFIG_NIMBLE_CPP_LOG_LEVEL
+#    if defined(ARDUINO_ARCH_ESP32) && defined(CORE_DEBUG_LEVEL)
+#      define CONFIG_NIMBLE_CPP_LOG_LEVEL CORE_DEBUG_LEVEL
+#    else
+#      define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
+#    endif
+#  endif
 
-#else
-#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__)
-#endif /*ARDUINO_ARCH_ESP32*/
+#  if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4
+#    define NIMBLE_LOGD( tag, format, ... ) console_printf("D %s: " format "\n", tag, ##__VA_ARGS__)
+#  else
+#    define NIMBLE_LOGD( tag, format, ... ) (void)tag
+#  endif
 
-#endif /*CONFIG_BT_ENABLED*/
-#endif /*MAIN_NIMBLELOG_H_*/
+#  if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 3
+#    define NIMBLE_LOGI( tag, format, ... ) console_printf("I %s: " format "\n", tag, ##__VA_ARGS__)
+#  else
+#    define NIMBLE_LOGI( tag, format, ... ) (void)tag
+#  endif
+
+#  if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 2
+#    define NIMBLE_LOGW( tag, format, ... ) console_printf("W %s: " format "\n", tag, ##__VA_ARGS__)
+#  else
+#    define NIMBLE_LOGW( tag, format, ... ) (void)tag
+#  endif
+
+#  if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 1
+#    define NIMBLE_LOGE( tag, format, ... ) console_printf("E %s: " format "\n", tag, ##__VA_ARGS__)
+#    define NIMBLE_LOGC( tag, format, ... ) console_printf("CRIT %s: " format "\n", tag, ##__VA_ARGS__)
+#  else
+#    define NIMBLE_LOGE( tag, format, ... ) (void)tag
+#    define NIMBLE_LOGC( tag, format, ... ) (void)tag
+#  endif
+
+#endif /* CONFIG_NIMBLE_CPP_IDF */
+#endif /* CONFIG_BT_ENABLED */
+#endif /* MAIN_NIMBLELOG_H_ */

src/NimBLEMeshCreateModel.c

@@ -0,0 +1,35 @@
+/*
+ * NimBLEMeshCreateModel.cpp
+ *
+ *  Created: on April 27 2022
+ *      Author H2zero
+ *
+ */
+
+#include "nimconfig.h"
+#if CONFIG_BT_NIMBLE_MESH
+
+#include "NimBLEMeshCreateModel.h"
+
+static struct bt_mesh_model_cb mod_cb = {
+    //.init = modelInitCallback
+};
+
+struct bt_mesh_model createConfigSrvModel(struct bt_mesh_cfg_srv* cfg) {
+    struct bt_mesh_model cmod = BT_MESH_MODEL_CFG_SRV(cfg);
+    return cmod;
+}
+
+struct bt_mesh_model createHealthModel(struct bt_mesh_health_srv* hsrv,
+                                       struct bt_mesh_model_pub* hpub) {
+    struct bt_mesh_model hmod = BT_MESH_MODEL_HEALTH_SRV(hsrv, hpub);
+    return hmod;
+}
+
+struct bt_mesh_model createGenModel(int16_t _id, struct bt_mesh_model_op* op,
+                                    struct bt_mesh_model_pub* pub, void* udata) {
+    struct bt_mesh_model mod = BT_MESH_MODEL_CB(_id, op, pub, udata, &mod_cb);
+    return mod;
+}
+
+#endif // CONFIG_BT_NIMBLE_MESH

src/NimBLEMeshCreateModel.h

@@ -0,0 +1,35 @@
+/*
+ * NimBLEMeshCreateModel.h
+ *
+ *  Created: on April 27 2022
+ *      Author H2zero
+ *
+ */
+
+#ifndef __NIMBLE_MESH_CREATE_MODEL_H
+#define __NIMBLE_MESH_CREATE_MODEL_H
+
+#include "nimconfig.h"
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include "mesh/mesh.h"
+#  include "mesh/cfg_srv.h"
+#else
+#  include "nimble/nimble/host/mesh/include/mesh/mesh.h"
+#  include "nimble/nimble/host/mesh/include/mesh/cfg_srv.h"
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+//int modelInitCallback(struct bt_mesh_model *model);
+struct bt_mesh_model createConfigSrvModel(struct bt_mesh_cfg_srv* cfg);
+struct bt_mesh_model createHealthModel(struct bt_mesh_health_srv* hsrv,
+                                       struct bt_mesh_model_pub* hpub);
+struct bt_mesh_model createGenModel(int16_t _id, struct bt_mesh_model_op* op,
+                                    struct bt_mesh_model_pub* pub, void* udata);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/NimBLEMeshElement.cpp

@@ -0,0 +1,145 @@
+/*
+ * NimBLEMeshElement.cpp
+ *
+ *  Created: on Aug 23 2020
+ *      Author H2zero
+ *
+ */
+
+#include "nimconfig.h"
+#if CONFIG_BT_NIMBLE_MESH
+
+#include "NimBLEMeshElement.h"
+#include "NimBLELog.h"
+#include "NimBLEMeshCreateModel.h"
+
+static const char* LOG_TAG = "NimBLEMeshElement";
+
+NimBLEMeshElement::NimBLEMeshElement() {
+    m_pElem = nullptr;
+    m_pHealthModel = nullptr;
+}
+
+
+NimBLEMeshElement::~NimBLEMeshElement() {
+    if(m_pElem != nullptr) {
+        delete m_pElem;
+    }
+
+    if(m_pHealthModel != nullptr) {
+        delete m_pHealthModel;
+    }
+
+    for(auto &it : m_modelsVec) {
+        if(it.id != BT_MESH_MODEL_ID_HEALTH_SRV) {
+            delete (NimBLEMeshModel*)it.user_data;
+        }
+    }
+
+    m_modelsVec.clear();
+}
+
+
+/**
+ * @brief Creates a model and adds it the the elements model vector.
+ * @param [in] type The type of model to create.
+ * @param [in] pCallbacks a pointer to a callback instance for this model.
+ */
+NimBLEMeshModel* NimBLEMeshElement::createModel(uint16_t type, NimBLEMeshModelCallbacks *pCallbacks) {
+    if(getModel(type) != nullptr) {
+        NIMBLE_LOGE(LOG_TAG, "Error: element already has a type %04x model", type);
+        return nullptr;
+    }
+
+    NIMBLE_LOGD(LOG_TAG, "Creating model type: %04x", type);
+
+    NimBLEMeshModel* pModel = nullptr;
+
+    switch(type)
+    {
+        case BT_MESH_MODEL_ID_GEN_ONOFF_SRV:
+            pModel = new NimBLEGenOnOffSrvModel(pCallbacks);
+            break;
+
+        case BT_MESH_MODEL_ID_GEN_LEVEL_SRV:
+            pModel = new NimBLEGenLevelSrvModel(pCallbacks);
+            break;
+
+        case BT_MESH_MODEL_ID_HEALTH_SRV:
+            m_pHealthModel = new NimBLEHealthSrvModel(pCallbacks);
+            pModel = m_pHealthModel;
+            m_modelsVec.push_back(createHealthModel(&m_pHealthModel->m_healthSrv, &pModel->m_opPub));
+            return pModel;
+
+        default:
+            NIMBLE_LOGE(LOG_TAG, "Error: model type %04x not supported", type);
+            return nullptr;
+    }
+
+    m_modelsVec.push_back(createGenModel(type, pModel->m_opList, &pModel->m_opPub, pModel));
+    return pModel;
+}
+
+
+/**
+ * @brief Adds a model created outside of element context to the elements model vector.
+ * @param [in] model A pointer to the model instance to add.
+ */
+void NimBLEMeshElement::addModel(const bt_mesh_model & model) {
+    m_modelsVec.push_back(model);
+}
+
+
+/**
+ * @brief Get a pointer to the model in the element with the type specified.
+ * @param [in] The model type requested.
+ * @returns A pointer to the model or nullptr if not found.
+ */
+NimBLEMeshModel* NimBLEMeshElement::getModel(uint16_t type) {
+    if(type == BT_MESH_MODEL_ID_HEALTH_SRV) {
+        return m_pHealthModel;
+    }
+
+    for(auto &it : m_modelsVec) {
+        if(it.id == type) {
+            return (NimBLEMeshModel*)it.user_data;
+        }
+    }
+
+    return nullptr;
+}
+
+
+/**
+ * @brief Get a pointer to a model with matching type and ID.
+ * @param [in] eidx The element ID to compare.
+ * @param [in] midx The model ID to compare.
+ * @param [in] The model type requested.
+ * @returns A pointer to the model or nullptr if not found.
+ */
+NimBLEMeshModel* NimBLEMeshElement::getModelByIdx(uint8_t eidx, uint8_t midx, uint16_t type) {
+    for(auto &it : m_modelsVec) {
+        if(it.elem_idx == eidx && it.mod_idx == midx) {
+            if(type == BT_MESH_MODEL_ID_HEALTH_SRV) {
+                return m_pHealthModel;
+            } else {
+                return (NimBLEMeshModel*)it.user_data;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+
+/**
+ * @brief Creates a bt_mesh_elem for registering with the nimble stack.
+ * @returns A pointer to the bt_mesh_elem created.
+ * @details Must not be called until all models have been added.
+ */
+bt_mesh_elem* NimBLEMeshElement::start() {
+    m_pElem = new bt_mesh_elem{0, 0, uint8_t(m_modelsVec.size()), 0, &m_modelsVec[0], NULL};
+    return m_pElem;
+}
+
+#endif // CONFIG_BT_NIMBLE_MESH

src/NimBLEMeshElement.h

@@ -0,0 +1,46 @@
+/*
+ * NimBLEMeshElement.h
+ *
+ *  Created: on Aug 23 2020
+ *      Author H2zero
+ *
+ */
+
+#ifndef MAIN_NIMBLE_MESH_ELEMENT_H_
+#define MAIN_NIMBLE_MESH_ELEMENT_H_
+
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+#include "nimconfig.h"
+
+#include "NimBLEMeshNode.h"
+#include "NimBLEMeshModel.h"
+
+#include <vector>
+
+class NimBLEMeshModelCallbacks;
+class NimBLEMeshModel;
+class NimBLEHealthSrvModel;
+
+class NimBLEMeshElement {
+public:
+    NimBLEMeshModel* createModel(uint16_t type, NimBLEMeshModelCallbacks* pCallbacks=nullptr);
+    NimBLEMeshModel* getModel(uint16_t type);
+    NimBLEMeshModel* getModelByIdx(uint8_t eidx, uint8_t midx, uint16_t type);
+
+private:
+    friend class NimBLEMeshNode;
+
+    NimBLEMeshElement();
+    ~NimBLEMeshElement();
+    void addModel(const bt_mesh_model & model);
+    bt_mesh_elem* start();
+
+    bt_mesh_elem *m_pElem;
+    NimBLEHealthSrvModel*      m_pHealthModel;
+    std::vector<bt_mesh_model> m_modelsVec;
+};
+
+
+#endif // CONFIG_BT_ENABLED
+#endif // MAIN_NIMBLE_MESH_ELEMENT_H_

src/NimBLEMeshModel.cpp

@@ -0,0 +1,700 @@
+/*
+ * NimBLEMeshModel.cpp
+ *
+ *  Created: on Aug 25 2020
+ *      Author H2zero
+ *
+ */
+
+#include "nimconfig.h"
+#if CONFIG_BT_NIMBLE_MESH
+
+#include "NimBLEMeshModel.h"
+#include "NimBLEUtils.h"
+#include "NimBLELog.h"
+
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include "nimble/nimble_port.h"
+#else
+#  include "nimble/porting/nimble/include/nimble/nimble_port.h"
+#endif
+
+#include "NimBLEDevice.h"
+
+#define CID_VENDOR 0x05C3
+#define STANDARD_TEST_ID 0x00
+
+static const char* LOG_TAG = "NimBLEMeshModel";
+
+static NimBLEMeshModelCallbacks defaultCallbacks;
+
+static const struct bt_mesh_health_srv_cb health_srv_cb = {
+    NimBLEHealthSrvCallbacks::faultGetCurrent,
+    NimBLEHealthSrvCallbacks::faultGetRegistered,
+    NimBLEHealthSrvCallbacks::faultClear,
+    NimBLEHealthSrvCallbacks::faultTest,
+    NimBLEHealthSrvCallbacks::attentionOn,
+    NimBLEHealthSrvCallbacks::attentionOff
+};
+
+/**
+ * @brief base model constructor
+ * @param [in] pCallbacks, a pointer to a callback instance for model operations
+ */
+NimBLEMeshModel::NimBLEMeshModel(NimBLEMeshModelCallbacks *pCallbacks,
+                                 uint16_t initDataSize, uint16_t maxDataSize)
+:   m_value(initDataSize, maxDataSize),
+    m_targetValue(initDataSize, maxDataSize)
+{
+    if(pCallbacks == nullptr) {
+        m_callbacks = &defaultCallbacks;
+    } else {
+        m_callbacks = pCallbacks;
+    }
+
+    m_opList        = nullptr;
+    m_lastTid     = 0;
+    m_lastSrcAddr = 0;
+    m_lastDstAddr = 0;
+    m_lastMsgTime = 0;
+    m_transTime   = 0;
+    m_delayTime   = 0;
+    m_transStep   = 0;
+
+    memset(&m_opPub, 0, sizeof(m_opPub));
+    memset(&m_tdTimer, 0, sizeof(m_tdTimer));
+    memset(&m_pubTimer, 0, sizeof(m_pubTimer));
+}
+
+
+/**
+ * @brief destructor
+ */
+NimBLEMeshModel::~NimBLEMeshModel() {
+    if(m_opList != nullptr) {
+        delete[] m_opList;
+    }
+}
+
+
+int NimBLEMeshModel::extractTransTimeDelay(os_mbuf *buf)
+{
+    switch(buf->om_len) {
+        case 0x00:
+             m_transTime = 0;
+             m_delayTime = 0;
+             return 0;
+        case 0x02:
+            m_transTime = buf->om_data[0];
+            if((m_transTime & 0x3F) == 0x3F) {
+                // unknown transition time
+                m_transTime = 0;
+                m_delayTime = 0;
+                return BLE_HS_EINVAL;
+            }
+            m_delayTime = buf->om_data[1];
+            return 0;
+        default:
+            return BLE_HS_EMSGSIZE;
+    }
+}
+
+
+bool NimBLEMeshModel::checkRetransmit(uint8_t tid, bt_mesh_msg_ctx *ctx) {
+    time_t now = time(nullptr);
+
+    if(m_lastTid == tid &&
+       m_lastSrcAddr == ctx->addr &&
+       m_lastDstAddr == ctx->recv_dst &&
+        (now - m_lastMsgTime <= 6)) {
+        NIMBLE_LOGD(LOG_TAG, "Ignoring retransmit");
+        return true;
+    }
+
+    m_lastTid = tid;
+    m_lastSrcAddr = ctx->addr;
+    m_lastDstAddr = ctx->recv_dst;
+    m_lastMsgTime = now;
+
+    return false;
+}
+
+
+void NimBLEMeshModel::sendMessage(bt_mesh_model *model, bt_mesh_msg_ctx *ctx, os_mbuf *msg) {
+    if (bt_mesh_model_send(model, ctx, msg, NULL, NULL)) {
+        NIMBLE_LOGE(LOG_TAG, "Send status failed");
+    }
+
+    os_mbuf_free_chain(msg);
+}
+
+
+void NimBLEMeshModel::startTdTimer(ble_npl_time_t timerMs) {
+    ble_npl_time_t ticks;
+    ble_npl_time_ms_to_ticks(timerMs, &ticks);
+    ble_npl_callout_reset(&m_tdTimer, ticks);
+}
+
+
+void NimBLEMeshModel::publish() {
+    ble_npl_callout_reset(&m_pubTimer, 1);
+}
+
+
+uint32_t NimBLEMeshModel::getTransTime() {
+    return (m_transTime & 0x3F) * NimBLEUtils::meshTransTimeMs(m_transTime);
+}
+
+
+uint16_t NimBLEMeshModel::getDelayTime() {
+    return m_delayTime * 5;
+}
+
+
+/**
+ * @brief Generic on/off server model constructor
+ * @param [in] pCallbacks, a pointer to a callback instance for model operations
+ */
+NimBLEGenOnOffSrvModel::NimBLEGenOnOffSrvModel(NimBLEMeshModelCallbacks *pCallbacks)
+:NimBLEMeshModel(pCallbacks, 1, 1)
+{
+    // Register the opcodes for this model with the required callbacks
+    m_opList = new bt_mesh_model_op[4]{
+    { BT_MESH_MODEL_OP_2(0x82, 0x01), 0, NimBLEGenOnOffSrvModel::getOnOff },
+    { BT_MESH_MODEL_OP_2(0x82, 0x02), 2, NimBLEGenOnOffSrvModel::setOnOff },
+    { BT_MESH_MODEL_OP_2(0x82, 0x03), 2, NimBLEGenOnOffSrvModel::setOnOffUnack },
+    BT_MESH_MODEL_OP_END};
+
+    ble_npl_callout_init(&m_tdTimer, nimble_port_get_dflt_eventq(),
+                         NimBLEGenOnOffSrvModel::tdTimerCb, this);
+    ble_npl_callout_init(&m_pubTimer, nimble_port_get_dflt_eventq(),
+                         NimBLEGenOnOffSrvModel::pubTimerCb, this);
+
+    m_opPub.msg = NET_BUF_SIMPLE(2 + 3);
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to get the on/off status of the model
+ */
+void NimBLEGenOnOffSrvModel::getOnOff(bt_mesh_model *model,
+                                      bt_mesh_msg_ctx *ctx,
+                                      os_mbuf *buf)
+{
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)model->user_data;
+    if(pModel->m_callbacks != &defaultCallbacks) {
+        pModel->setValue(pModel->m_callbacks->getOnOff(pModel));
+    }
+    pModel->setPubMsg();
+
+    if (bt_mesh_model_send(model, ctx, pModel->m_opPub.msg, NULL, NULL)) {
+        NIMBLE_LOGE(LOG_TAG, "Send status failed");
+    }
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to set the status of the model with acknowledgement.
+ */
+void NimBLEGenOnOffSrvModel::setOnOff(bt_mesh_model *model,
+                                      bt_mesh_msg_ctx *ctx,
+                                      os_mbuf *buf)
+{
+    // Rather than duplicate code just call the unack function then send the status
+    NimBLEGenOnOffSrvModel::setOnOffUnack(model,ctx,buf);
+    NimBLEGenOnOffSrvModel::getOnOff(model,ctx,buf);
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to set the status of the model without acknowledgement.
+ */
+void NimBLEGenOnOffSrvModel::setOnOffUnack(bt_mesh_model *model,
+                                           bt_mesh_msg_ctx *ctx,
+                                           os_mbuf *buf)
+{
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)model->user_data;
+    uint8_t newval = net_buf_simple_pull_u8(buf);
+    uint8_t tid = net_buf_simple_pull_u8(buf);
+
+    if(pModel->checkRetransmit(tid, ctx)) {
+        return;
+    }
+
+    if(pModel->extractTransTimeDelay(buf) != 0) {
+        NIMBLE_LOGI(LOG_TAG, "Transition time / delay data error");
+        return;
+    }
+
+    // stop the transition timer to handle the new input
+    ble_npl_callout_stop(&pModel->m_tdTimer);
+
+    // Mesh spec says transition to "ON state" happens immediately
+    // after delay, so ignore the transition time.
+    if(newval == 1) {
+        pModel->m_transTime = 0;
+    }
+
+    ble_npl_time_t timerMs = 0;
+
+    if(newval != pModel->m_value[0]) {
+       pModel->m_targetValue.setValue(&newval, sizeof(newval));
+
+        if(pModel->m_delayTime > 0) {
+            timerMs = 5 * pModel->m_delayTime;
+        } else if(pModel->m_transTime & 0x3F) {
+            timerMs = NimBLEUtils::meshTransTimeMs(pModel->m_transTime);
+            pModel->m_transTime -= 1;
+        }
+    }
+
+    if(timerMs > 0) {
+        pModel->startTdTimer(timerMs);
+    } else {
+        pModel->m_value = pModel->m_targetValue;
+        pModel->m_callbacks->setOnOff(pModel, pModel->m_value[0]);
+    }
+}
+
+
+void NimBLEGenOnOffSrvModel::tdTimerCb(ble_npl_event *event) {
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)event->arg;
+    if(pModel->m_delayTime > 0) {
+        pModel->m_delayTime = 0;
+    }
+
+    if((pModel->m_transTime & 0x3F) && pModel->m_targetValue[0] == 0) {
+        pModel->startTdTimer(NimBLEUtils::meshTransTimeMs(pModel->m_transTime));
+        pModel->m_transTime -= 1;
+        pModel->publish();
+        return;
+    }
+
+    pModel->m_transTime = 0;
+    pModel->m_value = pModel->m_targetValue;
+    pModel->m_callbacks->setOnOff(pModel, pModel->m_value[0]);
+}
+
+
+void NimBLEGenOnOffSrvModel::pubTimerCb(ble_npl_event *event) {
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)event->arg;
+    pModel->setPubMsg();
+
+    int err = bt_mesh_model_publish(pModel->m_opPub.mod);
+    if(err != 0) {
+        NIMBLE_LOGD(LOG_TAG, "Publish rc: %d",err);
+    }
+}
+
+
+void NimBLEGenOnOffSrvModel::setPubMsg() {
+    bt_mesh_model_msg_init(m_opPub.msg, BT_MESH_MODEL_OP_2(0x82, 0x04));
+    net_buf_simple_add_u8(m_opPub.msg, m_value[0]);
+    if(m_transTime > 0) {
+        net_buf_simple_add_u8(m_opPub.msg, m_targetValue[0]);
+        // If we started the transition timer in setOnOff we need to correct the reported remaining time.
+        net_buf_simple_add_u8(m_opPub.msg, (m_delayTime > 0) ?
+                                   m_transTime : m_transTime + 1);
+    }
+}
+
+
+void NimBLEGenOnOffSrvModel::setValue(uint8_t *val, size_t len) {
+    if(len != sizeof(uint8_t)) {
+        NIMBLE_LOGE(LOG_TAG, "NimBLEGenOnOffSrvModel: Incorrect value length");
+        return;
+    }
+    m_value.setValue(val, len);
+}
+
+
+void NimBLEGenOnOffSrvModel::setTargetValue(uint8_t *val, size_t len) {
+    if(len != sizeof(uint8_t)) {
+        NIMBLE_LOGE(LOG_TAG, "NimBLEGenOnOffSrvModel: Incorrect target value length");
+        return;
+    }
+    m_targetValue.setValue(val, len);
+}
+
+
+/**
+ * @brief Generic level server model constructor
+ * @param [in] pCallbacks, a pointer to a callback instance for model operations
+ */
+NimBLEGenLevelSrvModel::NimBLEGenLevelSrvModel(NimBLEMeshModelCallbacks *pCallbacks)
+:NimBLEMeshModel(pCallbacks, 2, 2)
+{
+    // Register the opcodes for this model with the required callbacks
+    m_opList = new bt_mesh_model_op[8]{
+    { BT_MESH_MODEL_OP_2(0x82, 0x05), 0, NimBLEGenLevelSrvModel::getLevel },
+    { BT_MESH_MODEL_OP_2(0x82, 0x06), 3, NimBLEGenLevelSrvModel::setLevel },
+    { BT_MESH_MODEL_OP_2(0x82, 0x07), 3, NimBLEGenLevelSrvModel::setLevelUnack },
+    { BT_MESH_MODEL_OP_2(0x82, 0x09), 5, NimBLEGenLevelSrvModel::setDelta },
+    { BT_MESH_MODEL_OP_2(0x82, 0x0a), 5, NimBLEGenLevelSrvModel::setDeltaUnack },
+    { BT_MESH_MODEL_OP_2(0x82, 0x0b), 3, NimBLEGenLevelSrvModel::setMove },
+    { BT_MESH_MODEL_OP_2(0x82, 0x0c), 3, NimBLEGenLevelSrvModel::setMoveUnack },
+    BT_MESH_MODEL_OP_END};
+
+    ble_npl_callout_init(&m_tdTimer, nimble_port_get_dflt_eventq(),
+                         NimBLEGenLevelSrvModel::tdTimerCb, this);
+    ble_npl_callout_init(&m_pubTimer, nimble_port_get_dflt_eventq(),
+                         NimBLEGenLevelSrvModel::pubTimerCb, this);
+    m_opPub.msg = NET_BUF_SIMPLE(2 + 5);
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to get the level value of the model.
+ */
+void NimBLEGenLevelSrvModel::getLevel(bt_mesh_model *model,
+                                      bt_mesh_msg_ctx *ctx,
+                                      os_mbuf *buf)
+{
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)model->user_data;
+    if(pModel->m_callbacks != &defaultCallbacks) {
+        pModel->setValue(pModel->m_callbacks->getLevel(pModel));
+    }
+    pModel->setPubMsg();
+
+    if (bt_mesh_model_send(model, ctx, pModel->m_opPub.msg, NULL, NULL)) {
+        NIMBLE_LOGE(LOG_TAG, "Send status failed");
+    }
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to set the level value of the model.
+ */
+void NimBLEGenLevelSrvModel::setLevel(bt_mesh_model *model,
+                                      bt_mesh_msg_ctx *ctx,
+                                      os_mbuf *buf)
+{
+    NimBLEGenLevelSrvModel::setLevelUnack(model, ctx, buf);
+    NimBLEGenLevelSrvModel::getLevel(model, ctx, buf);
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to set the level value of the model without acknowledgement.
+ */
+void NimBLEGenLevelSrvModel::setLevelUnack(bt_mesh_model *model,
+                                           bt_mesh_msg_ctx *ctx,
+                                           os_mbuf *buf)
+{
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)model->user_data;
+    int16_t newval = (int16_t) net_buf_simple_pull_le16(buf);
+    uint8_t tid = net_buf_simple_pull_u8(buf);
+
+    if(pModel->checkRetransmit(tid, ctx)) {
+        return;
+    }
+
+    if(pModel->extractTransTimeDelay(buf) != 0) {
+        NIMBLE_LOGI(LOG_TAG, "Transition time / delay data error");
+        return;
+    }
+
+    // stop the transition timer to handle the new input
+    ble_npl_callout_stop(&pModel->m_tdTimer);
+
+    ble_npl_time_t timerMs = 0;
+
+    int16_t curval = pModel->m_value.getValue<int16_t>(nullptr, true);
+
+    if(newval != curval) {
+        pModel->m_targetValue.setValue(newval);
+
+        if(pModel->m_delayTime > 0) {
+            timerMs = 5 * pModel->m_delayTime;
+        }
+
+        if(pModel->m_transTime & 0x3F) {
+            pModel->m_transStep = -1 * ((curval - newval) / (pModel->m_transTime & 0x3F));
+            if(timerMs == 0) {
+                timerMs = NimBLEUtils::meshTransTimeMs(pModel->m_transTime);
+                pModel->m_transTime -= 1;
+            }
+        }
+    }
+
+    if(timerMs > 0) {
+        pModel->startTdTimer(timerMs);
+    } else {
+        pModel->m_value = pModel->m_targetValue;
+        pModel->m_callbacks->setLevel(pModel, newval);
+    }
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to set the level value by delta of the model.
+ */
+void NimBLEGenLevelSrvModel::setDelta(bt_mesh_model *model,
+                                      bt_mesh_msg_ctx *ctx,
+                                      os_mbuf *buf)
+{
+    NimBLEGenLevelSrvModel::setDeltaUnack(model, ctx, buf);
+    NimBLEGenLevelSrvModel::getLevel(model, ctx, buf);
+}
+
+
+/**
+ * @brief Called by the NimBLE stack to set the level value by delta without acknowledgement.
+ */
+void NimBLEGenLevelSrvModel::setDeltaUnack(bt_mesh_model *model,
+                                           bt_mesh_msg_ctx *ctx,
+                                           os_mbuf *buf)
+{
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)model->user_data;
+    int32_t delta = (int32_t) net_buf_simple_pull_le32(buf);
+
+    int32_t temp32 = pModel->m_value.getValue<int16_t>(nullptr, true) + delta;
+    if (temp32 < INT16_MIN) {
+        temp32 = INT16_MIN;
+    } else if (temp32 > INT16_MAX) {
+        temp32 = INT16_MAX;
+    }
+
+    net_buf_simple_push_le16(buf, (uint16_t)temp32);
+    NimBLEGenLevelSrvModel::setLevelUnack(model, ctx, buf);
+}
+
+
+void NimBLEGenLevelSrvModel::setMove(bt_mesh_model *model,
+                                     bt_mesh_msg_ctx *ctx,
+                                     os_mbuf *buf)
+{
+    NimBLEGenLevelSrvModel::setMoveUnack(model, ctx, buf);
+    NimBLEGenLevelSrvModel::getLevel(model, ctx, buf);
+}
+
+
+void NimBLEGenLevelSrvModel::setMoveUnack(bt_mesh_model *model,
+                                          bt_mesh_msg_ctx *ctx,
+                                          os_mbuf *buf)
+{
+    int16_t delta = (int16_t) net_buf_simple_pull_le16(buf);
+    // Check if a transition time is present, if not then ignore this message.
+    // See: bluetooth mesh specifcation
+    if(buf->om_len < 3) {
+        return;
+    }
+    put_le32(net_buf_simple_push(buf, 4), (int32_t)delta);
+    NimBLEGenLevelSrvModel::setDeltaUnack(model, ctx, buf);
+}
+
+
+void NimBLEGenLevelSrvModel::tdTimerCb(ble_npl_event *event) {
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)event->arg;
+    if(pModel->m_delayTime > 0) {
+        pModel->m_delayTime = 0;
+    }
+
+    if(pModel->m_transTime & 0x3F) {
+        int16_t newval = pModel->m_value.getValue<int16_t>(nullptr, true) + pModel->m_transStep;
+        pModel->m_value.setValue(newval);
+        pModel->m_callbacks->setLevel(pModel, newval);
+        pModel->startTdTimer(NimBLEUtils::meshTransTimeMs(pModel->m_transTime));
+        pModel->m_transTime -= 1;
+        return;
+    }
+
+    pModel->m_transTime = 0;
+    pModel->m_value = pModel->m_targetValue;
+    pModel->m_callbacks->setLevel(pModel, pModel->m_value.getValue<int16_t>(nullptr, true));
+}
+
+
+void NimBLEGenLevelSrvModel::pubTimerCb(ble_npl_event *event) {
+    NimBLEMeshModel *pModel = (NimBLEMeshModel*)event->arg;
+    pModel->setPubMsg();
+
+    int err = bt_mesh_model_publish(pModel->m_opPub.mod);
+    if(err != 0) {
+        NIMBLE_LOGD(LOG_TAG, "Publish rc: %d",err);
+    }
+}
+
+
+void NimBLEGenLevelSrvModel::setPubMsg() {
+    bt_mesh_model_msg_init(m_opPub.msg, BT_MESH_MODEL_OP_2(0x82, 0x08));
+    net_buf_simple_add_le16(m_opPub.msg, m_value.getValue<int16_t>(nullptr, true));
+    if(m_transTime > 0) {
+        net_buf_simple_add_le16(m_opPub.msg, m_targetValue.getValue<int16_t>(nullptr, true));
+        // If we started the transition timer in setOnOff we need to correct the reported remaining time.
+        net_buf_simple_add_u8(m_opPub.msg, (m_delayTime > 0) ?
+                                   m_transTime : m_transTime + 1);
+    }
+}
+
+
+void NimBLEGenLevelSrvModel::setValue(uint8_t *val, size_t len) {
+    if(len != sizeof(int16_t)) {
+        NIMBLE_LOGE(LOG_TAG, "NimBLEGenLevelSrvModel: Incorrect value length");
+        return;
+    }
+    m_value.setValue(val, len);
+}
+
+
+void NimBLEGenLevelSrvModel::setTargetValue(uint8_t *val, size_t len) {
+    if(len != sizeof(int16_t)) {
+        NIMBLE_LOGE(LOG_TAG, "NimBLEGenLevelSrvModel: Incorrect target value length");
+        return;
+    }
+    m_targetValue.setValue(val, len);
+}
+
+
+/**
+ * @brief Health server model constructor
+ * @param [in] pCallbacks, a pointer to a callback instance for model operations
+ */
+NimBLEHealthSrvModel::NimBLEHealthSrvModel(NimBLEMeshModelCallbacks *pCallbacks)
+:NimBLEMeshModel(pCallbacks, 1, 1)
+{
+    memset(&m_healthSrv, 0, sizeof(m_healthSrv));
+    m_healthSrv.cb  = &health_srv_cb;
+    m_opPub.msg     = NET_BUF_SIMPLE(1 + 3);
+    m_hasFault      = false;
+    m_testId        = 0;
+}
+
+
+void NimBLEHealthSrvModel::setFault(uint8_t fault) {
+    m_faults.push_back(fault);
+    m_hasFault = true;
+}
+
+
+void NimBLEHealthSrvModel::clearFaults() {
+    m_faults.clear();
+    m_hasFault = false;
+}
+
+
+/**
+ * Default model callbacks
+ */
+NimBLEMeshModelCallbacks::~NimBLEMeshModelCallbacks() {}
+
+void NimBLEMeshModelCallbacks::setOnOff(NimBLEMeshModel *pModel, uint8_t val) {
+    NIMBLE_LOGD(LOG_TAG, "Gen On/Off set val: %d", val);
+}
+
+uint8_t NimBLEMeshModelCallbacks::getOnOff(NimBLEMeshModel *pModel) {
+    NIMBLE_LOGD(LOG_TAG, "Gen On/Off get");
+    return 0;
+}
+
+void NimBLEMeshModelCallbacks::setLevel(NimBLEMeshModel *pModel, int16_t val) {
+    NIMBLE_LOGD(LOG_TAG, "Gen Level set val: %d", val);
+}
+
+int16_t NimBLEMeshModelCallbacks::getLevel(NimBLEMeshModel *pModel) {
+    NIMBLE_LOGD(LOG_TAG, "Gen Level get");
+    return 0;
+}
+
+void NimBLEMeshModelCallbacks::attentionOn(NimBLEMeshModel *pModel) {
+    NIMBLE_LOGD(LOG_TAG, "Attention On Default");
+}
+
+void NimBLEMeshModelCallbacks::attentionOff(NimBLEMeshModel *pModel) {
+    NIMBLE_LOGD(LOG_TAG, "Attention Off Default");
+}
+
+void NimBLEMeshModelCallbacks::faultTest(NimBLEMeshModel *pModel) {
+    NIMBLE_LOGD(LOG_TAG, "Fault Test");
+}
+
+void NimBLEMeshModelCallbacks::faultClear(NimBLEMeshModel *pModel) {
+    NIMBLE_LOGD(LOG_TAG, "Fault Clear");
+}
+
+
+/**
+ * @brief Health server callbacks
+ */
+int NimBLEHealthSrvCallbacks::faultGetCurrent(bt_mesh_model *model, uint8_t *test_id,
+                                              uint16_t *company_id, uint8_t *faults,
+                                              uint8_t *fault_count)
+{
+    NIMBLE_LOGD(LOG_TAG, "faultGetCurrent");
+
+    NimBLEHealthSrvModel* pModel = (NimBLEHealthSrvModel*)NimBLEDevice::getMeshNode()->getHealthModel(model);
+    *test_id = pModel->m_testId;
+    *company_id = CID_VENDOR;
+    *fault_count = std::min(*(size_t*)fault_count, pModel->m_faults.size());
+    memcpy(faults, &pModel->m_faults[0], *fault_count);
+    return 0;
+}
+
+int NimBLEHealthSrvCallbacks::faultGetRegistered(bt_mesh_model *model, uint16_t company_id,
+                                                 uint8_t *test_id, uint8_t *faults,
+                                                 uint8_t *fault_count)
+{
+    NIMBLE_LOGD(LOG_TAG, "faultGetRegistered");
+
+    if (company_id != CID_VENDOR) {
+        return -BLE_HS_EINVAL;
+    }
+
+    NimBLEHealthSrvModel* pModel = (NimBLEHealthSrvModel*)NimBLEDevice::getMeshNode()->getHealthModel(model);
+    *test_id = pModel->m_testId;
+    *fault_count = std::min(*(size_t*)fault_count, pModel->m_faults.size());
+    memcpy(faults, &pModel->m_faults[0], *fault_count);
+
+    return 0;
+}
+
+int NimBLEHealthSrvCallbacks::faultClear(bt_mesh_model *model, uint16_t company_id)
+{
+    NIMBLE_LOGD(LOG_TAG, "faultClear - default");
+
+    if (company_id != CID_VENDOR) {
+        return -BLE_HS_EINVAL;
+    }
+
+    NimBLEHealthSrvModel* pModel = (NimBLEHealthSrvModel*)NimBLEDevice::getMeshNode()->getHealthModel(model);
+    pModel->m_callbacks->faultClear(pModel);
+    pModel->clearFaults();
+
+    return 0;
+}
+
+int NimBLEHealthSrvCallbacks::faultTest(bt_mesh_model *model, uint8_t test_id, uint16_t company_id)
+{
+    NIMBLE_LOGD(LOG_TAG, "faultTest - default");
+
+    if (company_id != CID_VENDOR) {
+        return -BLE_HS_EINVAL;
+    }
+
+    if (test_id != STANDARD_TEST_ID) {
+        return -BLE_HS_EINVAL;
+    }
+
+    NimBLEHealthSrvModel* pModel = (NimBLEHealthSrvModel*)NimBLEDevice::getMeshNode()->getHealthModel(model);
+    pModel->setFault(0);
+    pModel->m_testId = test_id;
+    pModel->m_callbacks->faultTest(pModel);
+
+    return 0;
+}
+
+void NimBLEHealthSrvCallbacks::attentionOn(bt_mesh_model *model)
+{
+    NIMBLE_LOGD(LOG_TAG, "attentionOn - default");
+    NimBLEMeshModel* pModel = NimBLEDevice::getMeshNode()->getHealthModel(model);
+    pModel->m_callbacks->attentionOn(pModel);
+}
+
+void NimBLEHealthSrvCallbacks::attentionOff(bt_mesh_model *model)
+{
+    NIMBLE_LOGD(LOG_TAG, "attentionOff - default");
+    NimBLEMeshModel* pModel = NimBLEDevice::getMeshNode()->getHealthModel(model);
+    pModel->m_callbacks->attentionOff(pModel);
+}
+
+#endif // CONFIG_BT_NIMBLE_MESH

src/NimBLEMeshModel.h

@@ -0,0 +1,197 @@
+/*
+ * NimBLEMeshModel.h
+ *
+ *  Created: on Aug 25 2020
+ *      Author H2zero
+ *
+ */
+
+#ifndef MAIN_NIMBLE_MESH_MODEL_H_
+#define MAIN_NIMBLE_MESH_MODEL_H_
+
+#include "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+#include "nimconfig.h"
+
+#include "NimBLEMeshElement.h"
+#include "NimBLEAttValue.h"
+
+#include <vector>
+
+class NimBLEMeshModelCallbacks;
+
+class NimBLEMeshModel {
+public:
+    NimBLEMeshModel(NimBLEMeshModelCallbacks* pCallbacks,
+                    uint16_t initDataSize = CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH,
+                    uint16_t maxDataSize = BLE_ATT_ATTR_MAX_LEN);
+    virtual ~NimBLEMeshModel();
+    int extractTransTimeDelay(os_mbuf *buf);
+    bool checkRetransmit(uint8_t tid, bt_mesh_msg_ctx *ctx);
+    void sendMessage(bt_mesh_model *model, bt_mesh_msg_ctx *ctx, os_mbuf *msg);
+    void startTdTimer(ble_npl_time_t timerMs);
+    void publish();
+    uint32_t getTransTime();
+    uint16_t getDelayTime();
+    virtual void setPubMsg(){};
+    virtual void setValue(uint8_t *val, size_t len){};
+    virtual void setTargetValue(uint8_t *val, size_t len){};
+    virtual void setFault(uint8_t){};
+    virtual void clearFaults(){};
+
+    template<typename T>
+    void setValue(const T &s) {
+        setValue((uint8_t*)&s, sizeof(T));
+    }
+
+    template<typename T>
+    void setTargetValue(const T &s) {
+        setTargetValue((uint8_t*)&s, sizeof(T));
+    }
+
+    template<typename T>
+    void getValue(T &s) {
+        s = (T)m_value[0];
+    }
+
+    template<typename T>
+    void getTargetValue(T &s) {
+        s = (T)m_targetValue[0];
+    }
+
+    bt_mesh_model_op*         m_opList;
+    bt_mesh_model_pub         m_opPub;
+    NimBLEMeshModelCallbacks* m_callbacks;
+    uint8_t                   m_lastTid;
+    uint16_t                  m_lastSrcAddr;
+    uint16_t                  m_lastDstAddr;
+    time_t                    m_lastMsgTime;
+    uint8_t                   m_transTime;
+    uint8_t                   m_delayTime;
+    NimBLEAttValue            m_value;
+    NimBLEAttValue            m_targetValue;
+    int16_t                   m_transStep;
+
+    ble_npl_callout           m_tdTimer;
+    ble_npl_callout           m_pubTimer;
+};
+
+
+class NimBLEGenOnOffSrvModel : NimBLEMeshModel {
+    friend class NimBLEMeshElement;
+    friend class NimBLEMeshNode;
+
+    NimBLEGenOnOffSrvModel(NimBLEMeshModelCallbacks *pCallbacks);
+    ~NimBLEGenOnOffSrvModel(){};
+
+    static void getOnOff(bt_mesh_model *model,
+                         bt_mesh_msg_ctx *ctx,
+                         os_mbuf *buf);
+    static void setOnOff(bt_mesh_model *model,
+                         bt_mesh_msg_ctx *ctx,
+                         os_mbuf *buf);
+    static void setOnOffUnack(bt_mesh_model *model,
+                              bt_mesh_msg_ctx *ctx,
+                              os_mbuf *buf);
+    static void tdTimerCb(ble_npl_event *event);
+    static void pubTimerCb(ble_npl_event *event);
+
+    void setPubMsg() override;
+    void setValue(uint8_t *val, size_t len) override;
+    void setTargetValue(uint8_t *val, size_t len) override;
+};
+
+
+class NimBLEGenLevelSrvModel : NimBLEMeshModel {
+    friend class NimBLEMeshElement;
+    friend class NimBLEMeshNode;
+
+    NimBLEGenLevelSrvModel(NimBLEMeshModelCallbacks *pCallbacks);
+    ~NimBLEGenLevelSrvModel(){};
+
+    static void getLevel(bt_mesh_model *model,
+                         bt_mesh_msg_ctx *ctx,
+                         os_mbuf *buf);
+    static void setLevel(bt_mesh_model *model,
+                         bt_mesh_msg_ctx *ctx,
+                         os_mbuf *buf);
+    static void setLevelUnack(bt_mesh_model *model,
+                              bt_mesh_msg_ctx *ctx,
+                              os_mbuf *buf);
+    static void setDelta(bt_mesh_model *model,
+                         bt_mesh_msg_ctx *ctx,
+                         os_mbuf *buf);
+    static void setDeltaUnack(bt_mesh_model *model,
+                              bt_mesh_msg_ctx *ctx,
+                              os_mbuf *buf);
+    static void setMove(bt_mesh_model *model,
+                        bt_mesh_msg_ctx *ctx,
+                        os_mbuf *buf);
+    static void setMoveUnack(bt_mesh_model *model,
+                             bt_mesh_msg_ctx *ctx,
+                             os_mbuf *buf);
+    static void tdTimerCb(ble_npl_event *event);
+    static void pubTimerCb(ble_npl_event *event);
+
+    void setPubMsg() override;
+    void setValue(uint8_t *val, size_t len) override;
+    void setTargetValue(uint8_t *val, size_t len) override;
+};
+
+
+class NimBLEHealthSrvModel : NimBLEMeshModel {
+    friend class NimBLEMeshElement;
+    friend class NimBLEMeshNode;
+    friend class NimBLEHealthSrvCallbacks;
+
+    NimBLEHealthSrvModel(NimBLEMeshModelCallbacks *pCallbacks);
+    ~NimBLEHealthSrvModel(){};
+
+public:
+    void         setFault(uint8_t) override;
+    void         clearFaults() override;
+
+private:
+    bt_mesh_health_srv    m_healthSrv;
+    bool                  m_hasFault;
+    uint8_t               m_testId;
+    std::vector<uint8_t>  m_faults;
+};
+
+
+class NimBLEMeshModelCallbacks {
+public:
+    virtual ~NimBLEMeshModelCallbacks();
+    virtual void    setOnOff(NimBLEMeshModel *pModel, uint8_t val);
+    virtual uint8_t getOnOff(NimBLEMeshModel *pModel);
+    virtual void    setLevel(NimBLEMeshModel *pModel, int16_t val);
+    virtual int16_t getLevel(NimBLEMeshModel *pModel);
+    virtual void    attentionOn(NimBLEMeshModel *pModel);
+    virtual void    attentionOff(NimBLEMeshModel *pModel);
+    virtual void    faultTest(NimBLEMeshModel *pModel);
+    virtual void    faultClear(NimBLEMeshModel *pModel);
+
+};
+
+
+class NimBLEHealthSrvCallbacks {
+public:
+    static int faultGetCurrent(bt_mesh_model *model, uint8_t *test_id,
+                               uint16_t *company_id, uint8_t *faults,
+                               uint8_t *fault_count);
+
+    static int faultGetRegistered(bt_mesh_model *model, uint16_t company_id,
+                                  uint8_t *test_id, uint8_t *faults,
+                                  uint8_t *fault_count);
+
+    static int faultClear(bt_mesh_model *model, uint16_t company_id);
+
+    static int faultTest(bt_mesh_model *model, uint8_t test_id, uint16_t company_id);
+
+    static void attentionOn(bt_mesh_model *model);
+
+    static void attentionOff(bt_mesh_model *model);
+};
+
+#endif // CONFIG_BT_ENABLED
+#endif // MAIN_NIMBLE_MESH_MODEL_H_

src/NimBLEMeshNode.cpp

@@ -0,0 +1,209 @@
+/*
+ * NimBLEMeshNode.cpp
+ *
+ *  Created: on July 22 2020
+ *      Author H2zero
+ *
+ */
+
+#include "nimconfig.h"
+#if CONFIG_BT_NIMBLE_MESH
+
+#include "NimBLEMeshNode.h"
+#include "NimBLELog.h"
+#include "NimBLEDevice.h"
+#include "NimBLEMeshCreateModel.h"
+
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include "services/gap/ble_svc_gap.h"
+#  include "services/gatt/ble_svc_gatt.h"
+#else
+#  include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
+#  include "nimble/nimble/host/services/gatt/include/services/gatt/ble_svc_gatt.h"
+#endif
+
+
+
+#define CID_VENDOR 0x05C3
+
+static const char* LOG_TAG = "NimBLEMeshNode";
+
+
+/**
+ * @brief Construct a mesh node.
+ * @param [in] uuid The uuid used to advertise for provisioning.
+ * @param [in] type Bitmask of the node features supported.
+ */
+NimBLEMeshNode::NimBLEMeshNode(const NimBLEUUID &uuid, uint8_t type) {
+    assert(uuid.bitSize() == 128);
+
+    memset(&m_serverConfig, 0, sizeof(m_serverConfig));
+    memset(&m_prov, 0, sizeof(m_prov));
+    memset(&m_comp, 0, sizeof(m_comp));
+
+    // Default server config
+    m_serverConfig.relay = BT_MESH_RELAY_DISABLED;/*(type & NIMBLE_MESH::RELAY) ?
+                           BT_MESH_RELAY_ENABLED :
+                           BT_MESH_RELAY_DISABLED;*/
+
+    m_serverConfig.beacon = BT_MESH_BEACON_ENABLED;
+    m_serverConfig.frnd = BT_MESH_FRIEND_DISABLED;/*(type & NIMBLE_MESH::FRIEND) ?
+                          BT_MESH_FRIEND_ENABLED :
+                          BT_MESH_FRIEND_DISABLED;*/
+
+    m_serverConfig.gatt_proxy = BT_MESH_GATT_PROXY_ENABLED; /*(type & NIMBLE_MESH::RELAY) ?
+                                BT_MESH_GATT_PROXY_ENABLED :
+                                BT_MESH_GATT_PROXY_DISABLED;*/
+
+    m_serverConfig.default_ttl = 7;
+
+    // 3 transmissions with 20ms interval
+    m_serverConfig.net_transmit = BT_MESH_TRANSMIT(2, 20);
+    m_serverConfig.relay_retransmit = BT_MESH_TRANSMIT(2, 20);
+
+    // Provisioning config
+    m_uuid          = uuid;
+    m_prov.uuid     = m_uuid.getNative()->u128.value;
+    m_prov.complete = NimBLEMeshNode::provComplete;
+    m_prov.reset    = NimBLEMeshNode::provReset;
+
+    // Create the primary element
+    m_elemVec.push_back(new NimBLEMeshElement());
+}
+
+
+/**
+ * @brief Destructor, cleanup any resources created.
+ */
+NimBLEMeshNode::~NimBLEMeshNode() {
+    if(m_comp.elem != nullptr) {
+        free (m_comp.elem);
+    }
+}
+
+
+/**
+ * @brief Called from the callbacks when provisioning changes.
+ */
+void NimBLEMeshNode::setProvData(uint16_t netIdx, uint16_t addr) {
+    m_primAddr = addr;
+    m_primNetIdx = netIdx;
+}
+
+
+/**
+ * @brief callback, Called by NimBLE stack when provisioning is complete.
+ */
+void NimBLEMeshNode::provComplete(uint16_t netIdx, uint16_t addr) {
+    NIMBLE_LOGI(LOG_TAG,
+                "provisioning complete for netIdx 0x%04x addr 0x%04x",
+                netIdx, addr);
+    NimBLEDevice::getMeshNode()->setProvData(netIdx, addr);
+}
+
+
+/**
+ * @brief callback, Called by NimBLE stack when provisioning is reset.
+ */
+void NimBLEMeshNode::provReset() {
+        NIMBLE_LOGI(LOG_TAG, "provisioning reset");
+        NimBLEDevice::getMeshNode()->setProvData(0, 0);
+}
+
+
+/**
+ * @brief get a pointer an element.
+ * @param [in] index The element vector index of the element.
+ * @returns a pointer to the element requested.
+ */
+NimBLEMeshElement* NimBLEMeshNode::getElement(uint8_t index) {
+    return m_elemVec[index];
+}
+
+/**
+ * @brief Create a new mesh element.
+ * @returns a pointer to the newly created element.
+ */
+NimBLEMeshElement* NimBLEMeshNode::createElement() {
+    m_elemVec.push_back(new NimBLEMeshElement());
+    return m_elemVec.back();
+}
+
+
+/**
+ * @brief Get a pointer to the health model instance that matches the ID's of the input model.
+ * @param [in] model A pointer to the NimBLE internal model instance.
+ * @returns A pointer to the model.
+ */
+NimBLEMeshModel* NimBLEMeshNode::getHealthModel(bt_mesh_model *model) {
+    NimBLEMeshModel* pModel;
+
+    for(auto &it : m_elemVec) {
+        pModel = it->getModelByIdx(model->elem_idx, model->mod_idx, BT_MESH_MODEL_ID_HEALTH_SRV);
+        if(pModel != nullptr) {
+            return pModel;
+        }
+    }
+
+    return nullptr;
+}
+
+
+/**
+ * @brief Start the Mesh mode.
+ * @returns true on success.
+ */
+bool NimBLEMeshNode::start() {
+    // Reset and restart gatts so we can register mesh gatt
+    ble_gatts_reset();
+    ble_svc_gap_init();
+    ble_svc_gatt_init();
+    bt_mesh_register_gatt();
+    ble_gatts_start();
+
+    // Config server and primary health models are required in the primary element
+    // create them here and add them as the first models.
+    m_elemVec[0]->addModel(createConfigSrvModel(&m_serverConfig));
+
+    if(m_elemVec[0]->getModel(BT_MESH_MODEL_ID_HEALTH_SRV) == nullptr) {
+        m_elemVec[0]->createModel(BT_MESH_MODEL_ID_HEALTH_SRV);
+    }
+
+    // setup node composition
+    m_comp.cid = CID_VENDOR;
+    m_comp.elem = (bt_mesh_elem*)calloc(m_elemVec.size(), sizeof(bt_mesh_elem));
+
+    if(m_comp.elem == nullptr) {
+        NIMBLE_LOGE(LOG_TAG, "Error: No Mem");
+        return false;
+    }
+
+    for(size_t i = 0; i < m_elemVec.size(); i++) {
+        memcpy((void*)&m_comp.elem[i], (void*)m_elemVec[i]->start(), sizeof(bt_mesh_elem));
+    }
+    m_comp.elem_count = (uint8_t)m_elemVec.size();
+
+    // Use random address
+    ble_addr_t addr;
+    int err = ble_hs_id_gen_rnd(1, &addr);
+    assert(err == 0);
+    err = ble_hs_id_set_rnd(addr.val);
+    assert(err == 0);
+
+    err = bt_mesh_init(addr.type, &m_prov, &m_comp);
+    if (err) {
+        NIMBLE_LOGE(LOG_TAG, "Initializing mesh failed (err %d)", err);
+        return false;
+    }
+    if (IS_ENABLED(CONFIG_SETTINGS)) {
+        settings_load();
+    }
+
+    if (bt_mesh_is_provisioned()) {
+        NIMBLE_LOGI(LOG_TAG, "Mesh network restored from flash");
+    }
+
+    return true;
+}
+
+#endif // CONFIG_BT_NIMBLE_MESH

src/NimBLEMeshNode.h

@@ -0,0 +1,76 @@
+/*
+ * NimBLEMeshNode.h
+ *
+ *  Created: on July 22 2020
+ *      Author H2zero
+ *
+ */
+
+#ifndef MAIN_NIMBLE_MESH_NODE_H_
+#define MAIN_NIMBLE_MESH_NODE_H_
+
+#include "nimconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpointer-arith"
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include "mesh/glue.h"
+#  include "mesh/mesh.h"
+#else
+#  include "nimble/nimble/host/mesh/include/mesh/glue.h"
+#  include "nimble/nimble/host/mesh/include/mesh/mesh.h"
+#endif
+#pragma GCC diagnostic pop
+
+/****  FIX COMPILATION ****/
+#undef min
+#undef max
+/**************************/
+
+#include "NimBLEUUID.h"
+#include "NimBLEMeshElement.h"
+
+#include <vector>
+
+class NimBLEMeshModel;
+
+typedef enum {
+    RELAY        =  0x01 << 0,
+    BEACON       =  0x01 << 1,
+    FRIEND       =  0x01 << 2,
+    PROXY        =  0x01 << 3,
+} NIMBLE_MESH;
+
+class NimBLEMeshElement;
+
+class NimBLEMeshNode {
+public:
+    bool                      start();
+    NimBLEMeshElement*        createElement();
+    NimBLEMeshElement*        getElement(uint8_t index = 0);
+    NimBLEMeshModel*          getHealthModel(bt_mesh_model *model);
+
+private:
+    friend class NimBLEDevice;
+    friend class NimBLEMeshElement;
+
+    NimBLEMeshNode(const NimBLEUUID &uuid, uint8_t type);
+    ~NimBLEMeshNode();
+    static void            provComplete(uint16_t netIdx, uint16_t addr);
+    static void            provReset();
+    void                   setProvData(uint16_t netIdx, uint16_t addr);
+
+    bt_mesh_cfg_srv        m_serverConfig;
+    bt_mesh_prov           m_prov;
+    bt_mesh_comp           m_comp;
+    uint16_t               m_primAddr;
+    uint16_t               m_primNetIdx;
+    NimBLEUUID             m_uuid;
+
+    std::vector<NimBLEMeshElement*> m_elemVec;
+};
+
+
+#endif // CONFIG_BT_ENABLED
+#endif // MAIN_NIMBLE_MESH_NODE_H_

src/NimBLERemoteCharacteristic.cpp

@@ -12,16 +12,15 @@
  *      Author: kolban
  */
 
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLERemoteCharacteristic.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
 
+#include <climits>
+
 static const char* LOG_TAG = "NimBLERemoteCharacteristic";
 
 /**
@@ -38,7 +37,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 +49,17 @@ 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 +144,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 +172,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 +193,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 +232,71 @@ 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};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 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;
+        }
+
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
+        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+        if (taskData.rc != 0) {
+            NIMBLE_LOGE(LOG_TAG, "Could not retrieve end handle rc=%d", taskData.rc);
+            return false;
+        }
+    }
+
+    if (m_handle == m_endHandle) {
+        return true;
+    }
+
     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;
     }
 
+#ifdef ulTaskNotifyValueClear
+    // Clear the task notification value to ensure we block
+    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
     ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
 
-    if(taskData.rc != 0) {
-        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 +309,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 +319,35 @@ NimBLERemoteDescriptor* NimBLERemoteCharacteristic::getDescriptor(const NimBLEUU
         if(m_descriptorVector.size() > prev_size) {
             return m_descriptorVector.back();
         }
+
+        // If the request was successful but 16/32 bit uuid 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();
+            if(retrieveDescriptors(&uuid128)) {
+                if(m_descriptorVector.size() > prev_size) {
+                    return m_descriptorVector.back();
+                }
+            }
+        } else {
+            // If the request was successful but the 128 bit uuid not found
+            // try again with the 16 bit uuid.
+            NimBLEUUID uuid16(uuid);
+            uuid16.to16();
+            // if the uuid was 128 bit but not of the BLE base type this check will fail
+            if (uuid16.bitSize() == BLE_UUID_TYPE_16) {
+                if(retrieveDescriptors(&uuid16)) {
+                    if(m_descriptorVector.size() > prev_size) {
+                        return m_descriptorVector.back();
+                    }
+                }
+            }
+        }
     }
+
     NIMBLE_LOGD(LOG_TAG, "<< getDescriptor: Not found");
     return nullptr;
 } // getDescriptor
@@ -340,15 +434,12 @@ NimBLEUUID NimBLERemoteCharacteristic::getUUID() {
  * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
  * @return The value of the remote characteristic.
  */
-std::string NimBLERemoteCharacteristic::getValue(time_t *timestamp) {
-    portENTER_CRITICAL(&m_valMux);
-    std::string value = m_value;
+NimBLEAttValue NimBLERemoteCharacteristic::getValue(time_t *timestamp) {
     if(timestamp != nullptr) {
-        *timestamp = m_timestamp;
+        *timestamp = m_value.getTimeStamp();
     }
-    portEXIT_CRITICAL(&m_valMux);
 
-    return value;
+    return m_value;
 }
 
 
@@ -396,12 +487,12 @@ float NimBLERemoteCharacteristic::readFloat() {
  * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
  * @return The value of the remote characteristic.
  */
-std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
+NimBLEAttValue NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
     NIMBLE_LOGD(LOG_TAG, ">> readValue(): uuid: %s, handle: %d 0x%.2x",
                          getUUID().toString().c_str(), getHandle(), getHandle());
 
     NimBLEClient* pClient = getRemoteService()->getClient();
-    std::string value;
+    NimBLEAttValue value;
 
     if (!pClient->isConnected()) {
         NIMBLE_LOGE(LOG_TAG, "Disconnected");
@@ -410,7 +501,8 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
 
     int rc = 0;
     int retryCount = 1;
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(),0, &value};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, &value};
 
     do {
         rc = ble_gattc_read_long(pClient->getConnId(), m_handle, 0,
@@ -422,6 +514,10 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
             return value;
         }
 
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
         rc = taskData.rc;
 
@@ -447,13 +543,11 @@ std::string NimBLERemoteCharacteristic::readValue(time_t *timestamp) {
         }
     } while(rc != 0 && retryCount--);
 
-    portENTER_CRITICAL(&m_valMux);
+    value.setTimeStamp();
     m_value = value;
-    m_timestamp = time(nullptr);
     if(timestamp != nullptr) {
-        *timestamp = m_timestamp;
+        *timestamp = value.getTimeStamp();
     }
-    portEXIT_CRITICAL(&m_valMux);
 
     NIMBLE_LOGD(LOG_TAG, "<< readValue length: %d rc=%d", value.length(), rc);
     return value;
@@ -478,16 +572,17 @@ int NimBLERemoteCharacteristic::onReadCB(uint16_t conn_handle,
 
     NIMBLE_LOGI(LOG_TAG, "Read complete; status=%d conn_handle=%d", error->status, conn_handle);
 
-    std::string *strBuf = (std::string*)pTaskData->buf;
+    NimBLEAttValue *valBuf = (NimBLEAttValue*)pTaskData->buf;
     int rc = error->status;
 
     if(rc == 0) {
         if(attr) {
-            if(((*strBuf).length() + attr->om->om_len) > BLE_ATT_ATTR_MAX_LEN) {
+            uint16_t data_len = OS_MBUF_PKTLEN(attr->om);
+            if((valBuf->size() + data_len) > BLE_ATT_ATTR_MAX_LEN) {
                 rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             } else {
-                NIMBLE_LOGD(LOG_TAG, "Got %d bytes", attr->om->om_len);
-                (*strBuf) += std::string((char*) attr->om->om_data, attr->om->om_len);
+                NIMBLE_LOGD(LOG_TAG, "Got %u bytes", data_len);
+                valBuf->append(attr->om->om_data, data_len);
                 return 0;
             }
         }
@@ -506,19 +601,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 +626,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 +640,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);
@@ -638,22 +733,33 @@ std::string NimBLERemoteCharacteristic::toString() {
 
 
 /**
- * @brief Write the new value for the characteristic.
- * @param [in] newValue The new value to write.
- * @param [in] response Do we expect a response?
- * @return false if not connected or cant perform write for some reason.
+ * @brief Write a new value to the remote characteristic from a std::vector<uint8_t>.
+ * @param [in] vec A std::vector<uint8_t> value to write to the remote characteristic.
+ * @param [in] response Whether we require a response from the write.
+ * @return false if not connected or otherwise cannot perform write.
  */
-bool NimBLERemoteCharacteristic::writeValue(const std::string &newValue, bool response) {
-    return writeValue((uint8_t*)newValue.c_str(), strlen(newValue.c_str()), response);
+bool NimBLERemoteCharacteristic::writeValue(const std::vector<uint8_t>& vec, bool response) {
+    return writeValue((uint8_t*)&vec[0], vec.size(), response);
 } // writeValue
 
 
 /**
- * @brief Write the new value for the characteristic from a data buffer.
+ * @brief Write a new value to the remote characteristic from a const char*.
+ * @param [in] char_s A character string to write to the remote characteristic.
+ * @param [in] response Whether we require a response from the write.
+ * @return false if not connected or otherwise cannot perform write.
+ */
+bool NimBLERemoteCharacteristic::writeValue(const char* char_s, bool response) {
+    return writeValue((uint8_t*)char_s, strlen(char_s), response);
+} // writeValue
+
+
+/**
+ * @brief Write a new value to the remote characteristic from a data buffer.
  * @param [in] data A pointer to a data buffer.
  * @param [in] length The length of the data in the data buffer.
  * @param [in] response Whether we require a response from the write.
- * @return false if not connected or cant perform write for some reason.
+ * @return false if not connected or otherwise cannot perform write.
  */
 bool NimBLERemoteCharacteristic::writeValue(const uint8_t* data, size_t length, bool response) {
 
@@ -677,7 +783,8 @@ bool NimBLERemoteCharacteristic::writeValue(const uint8_t* data, size_t length,
         return (rc==0);
     }
 
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
 
     do {
         if(length > mtu) {
@@ -697,6 +804,10 @@ bool NimBLERemoteCharacteristic::writeValue(const uint8_t* data, size_t length,
             return false;
         }
 
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
         rc = taskData.rc;
 
@@ -751,6 +862,4 @@ int NimBLERemoteCharacteristic::onWriteCB(uint16_t conn_handle,
     return 0;
 }
 
-
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */

src/NimBLERemoteCharacteristic.h

@@ -14,17 +14,16 @@
 
 #ifndef COMPONENTS_NIMBLEREMOTECHARACTERISTIC_H_
 #define COMPONENTS_NIMBLEREMOTECHARACTERISTIC_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLERemoteService.h"
 #include "NimBLERemoteDescriptor.h"
 
 #include <vector>
 #include <functional>
+#include "NimBLELog.h"
 
 class NimBLERemoteService;
 class NimBLERemoteDescriptor;
@@ -62,47 +61,15 @@ public:
     uint16_t                                       getHandle();
     uint16_t                                       getDefHandle();
     NimBLEUUID                                     getUUID();
-    std::string                                    readValue(time_t *timestamp = nullptr);
-
-    /**
-     * @brief A template to convert the remote characteristic data to <type\>.
-     * @tparam T The type to convert the data to.
-     * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
-     * @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
-     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
-     * less than <tt>sizeof(<type\>)</tt>.
-     * @details <b>Use:</b> <tt>readValue<type>(&timestamp, skipSizeCheck);</tt>
-     */
-    template<typename T>
-    T                                              readValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
-        std::string value = readValue(timestamp);
-        if(!skipSizeCheck && value.size() < sizeof(T)) return T();
-        const char *pData = value.data();
-        return *((T *)pData);
-    }
+    NimBLEAttValue                                 readValue(time_t *timestamp = nullptr);
+    std::string                                    toString();
+    NimBLERemoteService*                           getRemoteService();
 
     uint8_t                                        readUInt8()  __attribute__ ((deprecated("Use template readValue<uint8_t>()")));
     uint16_t                                       readUInt16() __attribute__ ((deprecated("Use template readValue<uint16_t>()")));
     uint32_t                                       readUInt32() __attribute__ ((deprecated("Use template readValue<uint32_t>()")));
     float                                          readFloat()  __attribute__ ((deprecated("Use template readValue<float>()")));
-    std::string                                    getValue(time_t *timestamp = nullptr);
-
-    /**
-     * @brief A template to convert the remote characteristic data to <type\>.
-     * @tparam T The type to convert the data to.
-     * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
-     * @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
-     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
-     * less than <tt>sizeof(<type\>)</tt>.
-     * @details <b>Use:</b> <tt>getValue<type>(&timestamp, skipSizeCheck);</tt>
-     */
-    template<typename T>
-    T                                              getValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
-        std::string value = getValue(timestamp);
-        if(!skipSizeCheck && value.size() < sizeof(T)) return T();
-        const char *pData = value.data();
-        return *((T *)pData);
-    }
+    NimBLEAttValue                                 getValue(time_t *timestamp = nullptr);
 
     bool                                           subscribe(bool notifications = true,
                                                              notify_callback notifyCallback = nullptr,
@@ -115,20 +82,74 @@ public:
     bool                                           writeValue(const uint8_t* data,
                                                               size_t length,
                                                               bool response = false);
-    bool                                           writeValue(const std::string &newValue,
-                                                              bool response = false);
+    bool                                           writeValue(const std::vector<uint8_t>& v, bool response = false);
+    bool                                           writeValue(const char* s, bool response = false);
+
+
+    /*********************** Template Functions ************************/
+
     /**
-     * @brief Convenience template to set the remote characteristic value to <type\>val.
+     * @brief Template to set the remote characteristic value to <type\>val.
      * @param [in] s The value to write.
      * @param [in] response True == request write response.
+     * @details Only used for non-arrays and types without a `c_str()` method.
      */
     template<typename T>
-    bool writeValue(const T &s, bool response = false) {
+#ifdef _DOXYGEN_
+    bool
+#else
+    typename std::enable_if<!std::is_array<T>::value && !Has_c_str_len<T>::value, bool>::type
+#endif
+    writeValue(const T& s, bool response = false) {
         return writeValue((uint8_t*)&s, sizeof(T), response);
     }
 
-    std::string                                    toString();
-    NimBLERemoteService*                           getRemoteService();
+    /**
+     * @brief Template to set the remote characteristic value to <type\>val.
+     * @param [in] s The value to write.
+     * @param [in] response True == request write response.
+     * @details Only used if the <type\> has a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    bool
+#else
+    typename std::enable_if<Has_c_str_len<T>::value, bool>::type
+#endif
+    writeValue(const T& s, bool response = false) {
+        return writeValue((uint8_t*)s.c_str(), s.length(), response);
+    }
+
+    /**
+     * @brief Template to convert the remote characteristic data to <type\>.
+     * @tparam T The type to convert the data to.
+     * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
+     * @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
+     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
+     * less than <tt>sizeof(<type\>)</tt>.
+     * @details <b>Use:</b> <tt>getValue<type>(&timestamp, skipSizeCheck);</tt>
+     */
+    template<typename T>
+    T getValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
+        if(!skipSizeCheck && m_value.size() < sizeof(T)) return T();
+        return *((T *)m_value.getValue(timestamp));
+    }
+
+    /**
+     * @brief Template to convert the remote characteristic data to <type\>.
+     * @tparam T The type to convert the data to.
+     * @param [in] timestamp A pointer to a time_t struct to store the time the value was read.
+     * @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
+     * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
+     * less than <tt>sizeof(<type\>)</tt>.
+     * @details <b>Use:</b> <tt>readValue<type>(&timestamp, skipSizeCheck);</tt>
+     */
+    template<typename T>
+    T readValue(time_t *timestamp = nullptr, bool skipSizeCheck = false) {
+        NimBLEAttValue value = readValue();
+        if(!skipSizeCheck && value.size() < sizeof(T)) return T();
+        return *((T *)value.getValue(timestamp));
+    }
 
 private:
 
@@ -148,22 +169,22 @@ 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;
+    NimBLEAttValue          m_value;
     notify_callback         m_notifyCallback;
-    time_t                  m_timestamp;
-    portMUX_TYPE            m_valMux;
 
     // We maintain a vector of descriptors owned by this characteristic.
     std::vector<NimBLERemoteDescriptor*> m_descriptorVector;
 }; // NimBLERemoteCharacteristic
 
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
 #endif /* COMPONENTS_NIMBLEREMOTECHARACTERISTIC_H_ */

src/NimBLERemoteDescriptor.cpp

@@ -11,16 +11,16 @@
  *  Created on: Jul 8, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLERemoteDescriptor.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
 
+#include <climits>
+
 static const char* LOG_TAG = "NimBLERemoteDescriptor";
 
 /**
@@ -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());
 }
 
 
@@ -84,11 +86,7 @@ NimBLEUUID NimBLERemoteDescriptor::getUUID() {
  * @deprecated Use readValue<uint8_t>().
  */
 uint8_t NimBLERemoteDescriptor::readUInt8() {
-    std::string value = readValue();
-    if (value.length() >= 1) {
-        return (uint8_t) value[0];
-    }
-    return 0;
+    return readValue<uint8_t>();
 } // readUInt8
 
 
@@ -98,11 +96,7 @@ uint8_t NimBLERemoteDescriptor::readUInt8() {
  * @deprecated Use readValue<uint16_t>().
  */
 uint16_t NimBLERemoteDescriptor::readUInt16() {
-    std::string value = readValue();
-    if (value.length() >= 2) {
-        return *(uint16_t*) value.data();
-    }
-    return 0;
+    return readValue<uint16_t>();
 } // readUInt16
 
 
@@ -112,11 +106,7 @@ uint16_t NimBLERemoteDescriptor::readUInt16() {
  * @deprecated Use readValue<uint32_t>().
  */
 uint32_t NimBLERemoteDescriptor::readUInt32() {
-    std::string value = readValue();
-    if (value.length() >= 4) {
-        return *(uint32_t*) value.data();
-    }
-    return 0;
+    return readValue<uint32_t>();
 } // readUInt32
 
 
@@ -124,11 +114,11 @@ uint32_t NimBLERemoteDescriptor::readUInt32() {
  * @brief Read the value of the remote descriptor.
  * @return The value of the remote descriptor.
  */
-std::string NimBLERemoteDescriptor::readValue() {
+NimBLEAttValue NimBLERemoteDescriptor::readValue() {
     NIMBLE_LOGD(LOG_TAG, ">> Descriptor readValue: %s", toString().c_str());
 
     NimBLEClient* pClient = getRemoteCharacteristic()->getRemoteService()->getClient();
-    std::string value;
+    NimBLEAttValue value;
 
     if (!pClient->isConnected()) {
         NIMBLE_LOGE(LOG_TAG, "Disconnected");
@@ -137,7 +127,8 @@ std::string NimBLERemoteDescriptor::readValue() {
 
     int rc = 0;
     int retryCount = 1;
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(),0, &value};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, &value};
 
     do {
         rc = ble_gattc_read_long(pClient->getConnId(), m_handle, 0,
@@ -149,6 +140,10 @@ std::string NimBLERemoteDescriptor::readValue() {
             return value;
         }
 
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
         rc = taskData.rc;
 
@@ -173,7 +168,7 @@ std::string NimBLERemoteDescriptor::readValue() {
         }
     } while(rc != 0 && retryCount--);
 
-    NIMBLE_LOGD(LOG_TAG, "<< Descriptor readValue(): length: %d rc=%d", value.length(), rc);
+    NIMBLE_LOGD(LOG_TAG, "<< Descriptor readValue(): length: %u rc=%d", value.length(), rc);
     return value;
 } // readValue
 
@@ -186,6 +181,7 @@ int NimBLERemoteDescriptor::onReadCB(uint16_t conn_handle,
                 const struct ble_gatt_error *error,
                 struct ble_gatt_attr *attr, void *arg)
 {
+    (void)attr;
     ble_task_data_t *pTaskData = (ble_task_data_t*)arg;
     NimBLERemoteDescriptor* desc = (NimBLERemoteDescriptor*)pTaskData->pATT;
     uint16_t conn_id = desc->getRemoteCharacteristic()->getRemoteService()->getClient()->getConnId();
@@ -196,16 +192,17 @@ int NimBLERemoteDescriptor::onReadCB(uint16_t conn_handle,
 
     NIMBLE_LOGD(LOG_TAG, "Read complete; status=%d conn_handle=%d", error->status, conn_handle);
 
-    std::string *strBuf = (std::string*)pTaskData->buf;
+    NimBLEAttValue *valBuf = (NimBLEAttValue*)pTaskData->buf;
     int rc = error->status;
 
     if(rc == 0) {
         if(attr) {
-            if(((*strBuf).length() + attr->om->om_len) > BLE_ATT_ATTR_MAX_LEN) {
+            uint16_t data_len = OS_MBUF_PKTLEN(attr->om);
+            if((valBuf->size() + data_len) > BLE_ATT_ATTR_MAX_LEN) {
                 rc = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             } else {
-                NIMBLE_LOGD(LOG_TAG, "Got %d bytes", attr->om->om_len);
-                (*strBuf) += std::string((char*) attr->om->om_data, attr->om->om_len);
+                NIMBLE_LOGD(LOG_TAG, "Got %u bytes", data_len);
+                valBuf->append(attr->om->om_data, data_len);
                 return 0;
             }
         }
@@ -258,11 +255,33 @@ int NimBLERemoteDescriptor::onWriteCB(uint16_t conn_handle,
 
 
 /**
- * @brief Write data to the BLE Remote Descriptor.
+ * @brief Write a new value to a remote descriptor from a std::vector<uint8_t>.
+ * @param [in] vec A std::vector<uint8_t> value to write to the remote descriptor.
+ * @param [in] response Whether we require a response from the write.
+ * @return false if not connected or otherwise cannot perform write.
+ */
+bool NimBLERemoteDescriptor::writeValue(const std::vector<uint8_t>& vec, bool response) {
+    return writeValue((uint8_t*)&vec[0], vec.size(), response);
+} // writeValue
+
+
+/**
+ * @brief Write a new value to the remote descriptor from a const char*.
+ * @param [in] char_s A character string to write to the remote descriptor.
+ * @param [in] response Whether we require a response from the write.
+ * @return false if not connected or otherwise cannot perform write.
+ */
+bool NimBLERemoteDescriptor::writeValue(const char* char_s, bool response) {
+    return writeValue((uint8_t*)char_s, strlen(char_s), response);
+} // writeValue
+
+
+/**
+ * @brief Write a new value to a remote descriptor.
  * @param [in] data The data to send to the remote descriptor.
  * @param [in] length The length of the data to send.
  * @param [in] response True if we expect a write response.
- * @return True if successful
+ * @return false if not connected or otherwise cannot perform write.
  */
 bool NimBLERemoteDescriptor::writeValue(const uint8_t* data, size_t length, bool response) {
 
@@ -287,7 +306,8 @@ bool NimBLERemoteDescriptor::writeValue(const uint8_t* data, size_t length, bool
         return (rc == 0);
     }
 
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
 
     do {
         if(length > mtu) {
@@ -308,6 +328,10 @@ bool NimBLERemoteDescriptor::writeValue(const uint8_t* data, size_t length, bool
             return false;
         }
 
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
         rc = taskData.rc;
 
@@ -338,15 +362,4 @@ bool NimBLERemoteDescriptor::writeValue(const uint8_t* data, size_t length, bool
 } // writeValue
 
 
-/**
- * @brief Write data represented as a string to the BLE Remote Descriptor.
- * @param [in] newValue The data to send to the remote descriptor.
- * @param [in] response True if we expect a response.
- * @return True if successful
- */
-bool NimBLERemoteDescriptor::writeValue(const std::string &newValue, bool response) {
-    return writeValue((uint8_t*) newValue.data(), newValue.length(), response);
-} // writeValue
-
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */

src/NimBLERemoteDescriptor.h

@@ -14,11 +14,9 @@
 
 #ifndef COMPONENTS_NIMBLEREMOTEDESCRIPTOR_H_
 #define COMPONENTS_NIMBLEREMOTEDESCRIPTOR_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLERemoteCharacteristic.h"
 
@@ -31,10 +29,53 @@ public:
     uint16_t                    getHandle();
     NimBLERemoteCharacteristic* getRemoteCharacteristic();
     NimBLEUUID                  getUUID();
-    std::string                 readValue();
+    NimBLEAttValue              readValue();
+
+    uint8_t                     readUInt8()  __attribute__ ((deprecated("Use template readValue<uint8_t>()")));
+    uint16_t                    readUInt16() __attribute__ ((deprecated("Use template readValue<uint16_t>()")));
+    uint32_t                    readUInt32() __attribute__ ((deprecated("Use template readValue<uint32_t>()")));
+    std::string                 toString(void);
+    bool                        writeValue(const uint8_t* data, size_t length, bool response = false);
+    bool                        writeValue(const std::vector<uint8_t>& v, bool response = false);
+    bool                        writeValue(const char* s, bool response = false);
+
+
+    /*********************** Template Functions ************************/
 
     /**
-     * @brief A template to convert the remote descriptor data to <type\>.
+     * @brief Template to set the remote descriptor value to <type\>val.
+     * @param [in] s The value to write.
+     * @param [in] response True == request write response.
+     * @details Only used for non-arrays and types without a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    bool
+#else
+    typename std::enable_if<!std::is_array<T>::value && !Has_c_str_len<T>::value, bool>::type
+#endif
+    writeValue(const T& s, bool response = false) {
+        return writeValue((uint8_t*)&s, sizeof(T), response);
+    }
+
+    /**
+     * @brief Template to set the remote descriptor value to <type\>val.
+     * @param [in] s The value to write.
+     * @param [in] response True == request write response.
+     * @details Only used if the <type\> has a `c_str()` method.
+     */
+    template<typename T>
+#ifdef _DOXYGEN_
+    bool
+#else
+    typename std::enable_if<Has_c_str_len<T>::value, bool>::type
+#endif
+    writeValue(const T& s, bool response = false) {
+        return writeValue((uint8_t*)s.c_str(), s.length(), response);
+    }
+
+    /**
+     * @brief Template to convert the remote descriptor data to <type\>.
      * @tparam T The type to convert the data to.
      * @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof(<type\>)</tt>.
      * @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
@@ -42,28 +83,10 @@ public:
      * @details <b>Use:</b> <tt>readValue<type>(skipSizeCheck);</tt>
      */
     template<typename T>
-    T                           readValue(bool skipSizeCheck = false) {
-        std::string value = readValue();
+    T readValue(bool skipSizeCheck = false) {
+        NimBLEAttValue value = readValue();
         if(!skipSizeCheck && value.size() < sizeof(T)) return T();
-        const char *pData = value.data();
-        return *((T *)pData);
-    }
-
-    uint8_t                     readUInt8()  __attribute__ ((deprecated("Use template readValue<uint8_t>()")));
-    uint16_t                    readUInt16() __attribute__ ((deprecated("Use template readValue<uint16_t>()")));
-    uint32_t                    readUInt32() __attribute__ ((deprecated("Use template readValue<uint32_t>()")));
-    std::string                 toString(void);
-    bool                        writeValue(const uint8_t* data, size_t length, bool response = false);
-    bool                        writeValue(const std::string &newValue, bool response = false);
-    
-    /**
-     * @brief Convenience template to set the remote descriptor value to <type\>val.
-     * @param [in] s The value to write.
-     * @param [in] response True == request write response.
-     */
-    template<typename T>
-    bool writeValue(const T &s, bool response = false) {
-        return writeValue((uint8_t*)&s, sizeof(T), response);
+        return *((T *)value.data());
     }
 
 private:
@@ -81,6 +104,5 @@ private:
     NimBLERemoteCharacteristic* m_pRemoteCharacteristic;
 };
 
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
 #endif /* COMPONENTS_NIMBLEREMOTEDESCRIPTOR_H_ */

src/NimBLERemoteService.cpp

@@ -11,17 +11,17 @@
  *  Created on: Jul 8, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLERemoteService.h"
 #include "NimBLEUtils.h"
 #include "NimBLEDevice.h"
 #include "NimBLELog.h"
 
+#include <climits>
+
 static const char* LOG_TAG = "NimBLERemoteService";
 
 /**
@@ -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,36 @@ NimBLERemoteCharacteristic* NimBLERemoteService::getCharacteristic(const NimBLEU
         if(m_characteristicVector.size() > prev_size) {
             return m_characteristicVector.back();
         }
+
+        // If the request was successful but 16/32 bit uuid 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();
+            if (retrieveCharacteristics(&uuid128)) {
+                if(m_characteristicVector.size() > prev_size) {
+                    return m_characteristicVector.back();
+                }
+            }
+        } else {
+            // If the request was successful but the 128 bit uuid not found
+            // try again with the 16 bit uuid.
+            NimBLEUUID uuid16(uuid);
+            uuid16.to16();
+            // if the uuid was 128 bit but not of the BLE base type this check will fail
+            if (uuid16.bitSize() == BLE_UUID_TYPE_16) {
+                if(retrieveCharacteristics(&uuid16)) {
+                    if(m_characteristicVector.size() > prev_size) {
+                        return m_characteristicVector.back();
+                    }
+                }
+            }
+        }
     }
 
+    NIMBLE_LOGD(LOG_TAG, "<< getCharacteristic: not found");
     return nullptr;
 } // getCharacteristic
 
@@ -185,7 +215,8 @@ bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID *uuid_filter)
     NIMBLE_LOGD(LOG_TAG, ">> retrieveCharacteristics() for service: %s", getUUID().toString().c_str());
 
     int rc = 0;
-    ble_task_data_t taskData = {this, xTaskGetCurrentTaskHandle(), 0, nullptr};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {this, cur_task, 0, nullptr};
 
     if(uuid_filter == nullptr) {
         rc = ble_gattc_disc_all_chrs(m_pClient->getConnId(),
@@ -207,9 +238,29 @@ bool NimBLERemoteService::retrieveCharacteristics(const NimBLEUUID *uuid_filter)
         return false;
     }
 
+#ifdef ulTaskNotifyValueClear
+    // Clear the task notification value to ensure we block
+    ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
     ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
 
     if(taskData.rc == 0){
+        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;
+                }
+            }
+
+            if (m_characteristicVector.size() > 0) {
+                m_characteristicVector.back()->m_endHandle = getEndHandle();
+            }
+        }
+
         NIMBLE_LOGD(LOG_TAG, "<< retrieveCharacteristics()");
         return true;
     }
@@ -359,6 +410,4 @@ std::string NimBLERemoteService::toString() {
     return res;
 } // toString
 
-
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */

src/NimBLERemoteService.h

@@ -14,11 +14,9 @@
 
 #ifndef COMPONENTS_NIMBLEREMOTESERVICE_H_
 #define COMPONENTS_NIMBLEREMOTESERVICE_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL)
 
 #include "NimBLEClient.h"
 #include "NimBLEUUID.h"
@@ -83,6 +81,5 @@ private:
     uint16_t            m_endHandle;
 }; // NimBLERemoteService
 
-#endif // #if defined( CONFIG_BT_NIMBLE_ROLE_CENTRAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
 #endif /* COMPONENTS_NIMBLEREMOTESERVICE_H_ */

src/NimBLEScan.cpp

@@ -11,17 +11,16 @@
  *  Created on: Jul 1, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 
 #include "NimBLEScan.h"
 #include "NimBLEDevice.h"
 #include "NimBLELog.h"
 
 #include <string>
+#include <climits>
 
 static const char* LOG_TAG = "NimBLEScan";
 
@@ -30,7 +29,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 +36,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;
 }
 
 
@@ -57,18 +56,27 @@ NimBLEScan::~NimBLEScan() {
  * @param [in] param Parameter data for this event.
  */
 /*STATIC*/int NimBLEScan::handleGapEvent(ble_gap_event* event, void* arg) {
-
-    NimBLEScan* pScan = (NimBLEScan*)arg;
+    (void)arg;
+    NimBLEScan* pScan = NimBLEDevice::getScan();
 
     switch(event->type) {
 
+        case BLE_GAP_EVENT_EXT_DISC:
         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;
             }
-
-            NimBLEAddress advertisedAddress(event->disc.addr);
+#if CONFIG_BT_NIMBLE_EXT_ADV
+            const auto& disc = event->ext_disc;
+            const bool isLegacyAdv = disc.props & BLE_HCI_ADV_LEGACY_MASK;
+            const auto event_type = isLegacyAdv ? disc.legacy_event_type : disc.props;
+#else
+            const auto& disc = event->disc;
+            const bool isLegacyAdv = true;
+            const auto event_type = disc.event_type;
+#endif
+            NimBLEAddress advertisedAddress(disc.addr);
 
             // Examine our list of ignored addresses and stop processing if we don't want to see it or are already connected
             if(NimBLEDevice::isIgnored(advertisedAddress)) {
@@ -80,7 +88,12 @@ NimBLEScan::~NimBLEScan() {
 
             // If we've seen this device before get a pointer to it from the vector
             for(auto &it: pScan->m_scanResults.m_advertisedDevicesVector) {
-                if(it->getAddress() == advertisedAddress) {
+#if CONFIG_BT_NIMBLE_EXT_ADV
+                // Same address but different set ID should create a new advertised device.
+                if (it->getAddress() == advertisedAddress && it->getSetId() == disc.sid) {
+#else
+                if (it->getAddress() == advertisedAddress) {
+#endif
                     advertisedDevice = it;
                     break;
                 }
@@ -88,34 +101,56 @@ 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 &&
+                (!isLegacyAdv || 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);
+                advertisedDevice->setAdvType(event_type, isLegacyAdv);
+#if CONFIG_BT_NIMBLE_EXT_ADV
+                advertisedDevice->setSetId(disc.sid);
+                advertisedDevice->setPrimaryPhy(disc.prim_phy);
+                advertisedDevice->setSecondaryPhy(disc.sec_phy);
+                advertisedDevice->setPeriodicInterval(disc.periodic_adv_itvl);
+#endif
                 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(disc.rssi);
+            advertisedDevice->setPayload(disc.data, disc.length_data, (isLegacyAdv &&
+                                         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
+                // or extended advertisement scanning, report the result to the callback now.
+                if(pScan->m_scan_params.passive || !isLegacyAdv ||
+                  (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 (isLegacyAdv && 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 +158,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 +194,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 +247,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 +264,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 +292,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 +304,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=%" PRIu32, duration);
 
     // Save the callback to be invoked when the scan completes.
     m_scanCompleteCB = scanCompleteCB;
@@ -281,32 +316,72 @@ 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);
+# if CONFIG_BT_NIMBLE_EXT_ADV
+    ble_gap_ext_disc_params scan_params;
+    scan_params.passive = m_scan_params.passive;
+    scan_params.itvl    = m_scan_params.itvl;
+    scan_params.window  = m_scan_params.window;
+    int rc = ble_gap_ext_disc(NimBLEDevice::m_own_addr_type,
+                              duration/10,
+                              0,
+                              m_scan_params.filter_duplicates,
+                              m_scan_params.filter_policy,
+                              m_scan_params.limited,
+                              &scan_params,
+                              &scan_params,
+                              NimBLEScan::handleGapEvent,
+                              NULL);
+#else
+    int rc = ble_gap_disc(NimBLEDevice::m_own_addr_type,
+                          duration,
+                          &m_scan_params,
+                          NimBLEScan::handleGapEvent,
+                          NULL);
+#endif
+    switch(rc) {
+        case 0:
+            if(!is_continue) {
+                clearResults();
+            }
+            break;
 
-    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;
+        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
 
@@ -322,10 +397,15 @@ NimBLEScanResults NimBLEScan::start(uint32_t duration, bool is_continue) {
         NIMBLE_LOGW(LOG_TAG, "Blocking scan called with duration = forever");
     }
 
-    ble_task_data_t taskData = {nullptr, xTaskGetCurrentTaskHandle(),0, nullptr};
+    TaskHandle_t cur_task = xTaskGetCurrentTaskHandle();
+    ble_task_data_t taskData = {nullptr, cur_task, 0, nullptr};
     m_pTaskData = &taskData;
 
     if(start(duration, nullptr, is_continue)) {
+#ifdef ulTaskNotifyValueClear
+        // Clear the task notification value to ensure we block
+        ulTaskNotifyValueClear(cur_task, ULONG_MAX);
+#endif
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
     }
 
@@ -343,11 +423,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 +444,23 @@ bool NimBLEScan::stop() {
 } // stop
 
 
+/**
+ * @brief Clears the duplicate scan filter cache.
+ */
+void NimBLEScan::clearDuplicateCache() {
+#ifdef CONFIG_IDF_TARGET_ESP32 // Not available for ESP32C3
+    esp_ble_scan_dupilcate_list_flush();
+#endif
+}
+
+
 /**
  * @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 +473,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 +509,7 @@ void NimBLEScan::clearResults() {
         delete it;
     }
     m_scanResults.m_advertisedDevicesVector.clear();
+    clearDuplicateCache();
 }
 
 
@@ -473,5 +578,4 @@ NimBLEAdvertisedDevice *NimBLEScanResults::getDevice(const NimBLEAddress &addres
     return nullptr;
 }
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */

src/NimBLEScan.h

@@ -13,16 +13,18 @@
  */
 #ifndef COMPONENTS_NIMBLE_SCAN_H_
 #define COMPONENTS_NIMBLE_SCAN_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 
 #include "NimBLEAdvertisedDevice.h"
 #include "NimBLEUtils.h"
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
 
 #include <vector>
 
@@ -70,9 +72,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,18 +87,17 @@ 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)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED CONFIG_BT_NIMBLE_ROLE_OBSERVER */
 #endif /* COMPONENTS_NIMBLE_SCAN_H_ */

src/NimBLESecurity.cpp

@@ -12,7 +12,7 @@
  *      Author: chegewara
  */
 
-#include "sdkconfig.h"
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include "NimBLESecurity.h"

src/NimBLESecurity.h

@@ -14,10 +14,16 @@
 
 #ifndef COMPONENTS_NIMBLESECURITY_H_
 #define COMPONENTS_NIMBLESECURITY_H_
-#include "sdkconfig.h"
+
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
+
 /****  FIX COMPILATION ****/
 #undef min
 #undef max

src/NimBLEServer.cpp

@@ -12,19 +12,20 @@
  *      Author: kolban
  */
 
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLEServer.h"
 #include "NimBLEDevice.h"
 #include "NimBLELog.h"
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "services/gap/ble_svc_gap.h"
 #include "services/gatt/ble_svc_gatt.h"
-
+#else
+#include "nimble/nimble/host/services/gap/include/services/gap/ble_svc_gap.h"
+#include "nimble/nimble/host/services/gatt/include/services/gatt/ble_svc_gatt.h"
+#endif
 
 static const char* LOG_TAG = "NimBLEServer";
 static NimBLEServerCallbacks defaultCallbacks;
@@ -37,10 +38,13 @@ 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;
+#if !CONFIG_BT_NIMBLE_EXT_ADV
     m_advertiseOnDisconnect = true;
+#endif
     m_svcChanged            = false;
     m_deleteCallbacks       = true;
 } // NimBLEServer
@@ -73,29 +77,20 @@ NimBLEService* NimBLEServer::createService(const char* uuid) {
 /**
  * @brief Create a %BLE Service.
  * @param [in] uuid The UUID of the new service.
- * @param [in] numHandles The maximum number of handles associated with this service.
- * @param [in] inst_id if we have multiple services with the same UUID we need
- *             to provide inst_id value different for each service.
  * @return A reference to the new service object.
  */
-NimBLEService* NimBLEServer::createService(const NimBLEUUID &uuid, uint32_t numHandles, uint8_t inst_id) {
+NimBLEService* NimBLEServer::createService(const NimBLEUUID &uuid) {
     NIMBLE_LOGD(LOG_TAG, ">> createService - %s", uuid.toString().c_str());
-    // TODO: add functionality to use inst_id for multiple services with same uuid
-    (void)inst_id;
+
     // Check that a service with the supplied UUID does not already exist.
     if(getServiceByUUID(uuid) != nullptr) {
         NIMBLE_LOGW(LOG_TAG, "Warning creating a duplicate service UUID: %s",
                              std::string(uuid).c_str());
     }
 
-    NimBLEService* pService = new NimBLEService(uuid, numHandles, this);
-    m_svcVec.push_back(pService); // Save a reference to this service being on this server.
-
-    if(m_gattsStarted) {
-        ble_svc_gatt_changed(0x0001, 0xffff);
-        m_svcChanged = true;
-        resetGATT();
-    }
+    NimBLEService* pService = new NimBLEService(uuid);
+    m_svcVec.push_back(pService);
+    serviceChanged();
 
     NIMBLE_LOGD(LOG_TAG, "<< createService");
     return pService;
@@ -104,37 +99,79 @@ 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;
+}
 
+
+#if CONFIG_BT_NIMBLE_EXT_ADV
+/**
+ * @brief Retrieve the advertising object that can be used to advertise the existence of the server.
+ * @return An advertising object.
+ */
+NimBLEExtAdvertising* NimBLEServer::getAdvertising() {
+    return NimBLEDevice::getAdvertising();
+} // getAdvertising
+#endif
+
+#if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
 /**
  * @brief Retrieve the advertising object that can be used to advertise the existence of the server.
- *
  * @return An advertising object.
  */
 NimBLEAdvertising* NimBLEServer::getAdvertising() {
     return NimBLEDevice::getAdvertising();
 } // getAdvertising
+#endif
+
+/**
+ * @brief Sends a service changed notification and resets the GATT server.
+ */
+void NimBLEServer::serviceChanged() {
+    if(m_gattsStarted) {
+        m_svcChanged = true;
+        ble_svc_gatt_changed(0x0001, 0xffff);
+        resetGATT();
+    }
+}
 
 
 /**
@@ -154,7 +191,7 @@ void NimBLEServer::start() {
         abort();
     }
 
-#if CONFIG_LOG_DEFAULT_LEVEL > 3 || (ARDUINO_ARCH_ESP32 && CORE_DEBUG_LEVEL >= 4)
+#if CONFIG_NIMBLE_CPP_LOG_LEVEL >= 4
     ble_gatts_show_local();
 #endif
 /*** Future use ***
@@ -216,6 +253,7 @@ int NimBLEServer::disconnect(uint16_t connId, uint8_t reason) {
 } // disconnect
 
 
+#if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
 /**
  * @brief Set the server to automatically start advertising when a client disconnects.
  * @param [in] aod true == advertise, false == don't advertise.
@@ -223,7 +261,7 @@ int NimBLEServer::disconnect(uint16_t connId, uint8_t reason) {
 void NimBLEServer::advertiseOnDisconnect(bool aod) {
     m_advertiseOnDisconnect = aod;
 } // advertiseOnDisconnect
-
+#endif
 
 /**
  * @brief Return the number of connected clients.
@@ -234,6 +272,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.
  *
@@ -242,8 +337,9 @@ size_t NimBLEServer::getConnectedCount() {
  * @param [in] param
  *
  */
-/*STATIC*/int NimBLEServer::handleGapEvent(struct ble_gap_event *event, void *arg) {
-    NimBLEServer* server = (NimBLEServer*)arg;
+/*STATIC*/
+int NimBLEServer::handleGapEvent(struct ble_gap_event *event, void *arg) {
+    NimBLEServer* server = NimBLEDevice::getServer();
     NIMBLE_LOGD(LOG_TAG, ">> handleGapEvent: %s",
                          NimBLEUtils::gapEventToString(event->type));
     int rc = 0;
@@ -255,13 +351,17 @@ size_t NimBLEServer::getConnectedCount() {
             if (event->connect.status != 0) {
                 /* Connection failed; resume advertising */
                 NIMBLE_LOGE(LOG_TAG, "Connection failed");
+#if !CONFIG_BT_NIMBLE_EXT_ADV
                 NimBLEDevice::startAdvertising();
+#endif
             }
             else {
                 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,10 +396,13 @@ size_t NimBLEServer::getConnectedCount() {
             }
 
             server->m_pServerCallbacks->onDisconnect(server);
+            server->m_pServerCallbacks->onDisconnect(server, &event->disconnect.conn);
 
+#if !CONFIG_BT_NIMBLE_EXT_ADV
             if(server->m_advertiseOnDisconnect) {
                 server->startAdvertising();
             }
+#endif
             return 0;
         } // BLE_GAP_EVENT_DISCONNECT
 
@@ -315,7 +418,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);
@@ -334,25 +439,67 @@ size_t NimBLEServer::getConnectedCount() {
             NIMBLE_LOGI(LOG_TAG, "mtu update event; conn_handle=%d mtu=%d",
                         event->mtu.conn_handle,
                         event->mtu.value);
+            rc = ble_gap_conn_find(event->mtu.conn_handle, &desc);
+            if (rc != 0) {
+                return 0;
+            }
+
+            server->m_pServerCallbacks->onMTUChange(event->mtu.value, &desc);
             return 0;
         } // BLE_GAP_EVENT_MTU
 
         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
 
+
+        case BLE_GAP_EVENT_ADV_COMPLETE:
+#if CONFIG_BT_NIMBLE_EXT_ADV
+        case BLE_GAP_EVENT_SCAN_REQ_RCVD:
+            return NimBLEExtAdvertising::handleGapEvent(event, arg);
+#else
+            return NimBLEAdvertising::handleGapEvent(event, arg);
+#endif
+        // BLE_GAP_EVENT_ADV_COMPLETE | BLE_GAP_EVENT_SCAN_REQ_RCVD
+
         case BLE_GAP_EVENT_CONN_UPDATE: {
             NIMBLE_LOGD(LOG_TAG, "Connection parameters updated.");
             return 0;
@@ -366,7 +513,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
@@ -407,7 +557,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: %" PRIu32, 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) {
@@ -507,7 +657,7 @@ void NimBLEServer::removeService(NimBLEService* service, bool deleteSvc) {
     if(service->m_removed > 0) {
         if(deleteSvc) {
             for(auto it = m_svcVec.begin(); it != m_svcVec.end(); ++it) {
-                if ((*it)->getUUID() == service->getUUID()) {
+                if ((*it) == service) {
                     delete *it;
                     m_svcVec.erase(it);
                     break;
@@ -523,32 +673,37 @@ void NimBLEServer::removeService(NimBLEService* service, bool deleteSvc) {
         return;
     }
 
-    service->m_removed = deleteSvc ? 2 : 1;
-    m_svcChanged = true;
-
-    ble_svc_gatt_changed(0x0001, 0xffff);
-    resetGATT();
+    service->m_removed = deleteSvc ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE;
+    serviceChanged();
+#if !CONFIG_BT_NIMBLE_EXT_ADV
     NimBLEDevice::getAdvertising()->removeServiceUUID(service->getUUID());
+#endif
 }
 
 
 /**
- * @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;
     }
 
     service->m_removed = 0;
-    m_svcChanged = true;
-
-    ble_svc_gatt_changed(0x0001, 0xffff);
-    resetGATT();
+    serviceChanged();
 }
 
 
@@ -567,7 +722,7 @@ void NimBLEServer::resetGATT() {
 
     for(auto it = m_svcVec.begin(); it != m_svcVec.end(); ) {
         if ((*it)->m_removed > 0) {
-            if ((*it)->m_removed == 2) {
+            if ((*it)->m_removed == NIMBLE_ATT_REMOVE_DELETE) {
                 delete *it;
                 it = m_svcVec.erase(it);
             } else {
@@ -585,23 +740,53 @@ void NimBLEServer::resetGATT() {
 }
 
 
+#if CONFIG_BT_NIMBLE_EXT_ADV
 /**
  * @brief Start advertising.
- *
- * Start the server advertising its existence.  This is a convenience function and is equivalent to
+ * @param [in] inst_id The extended advertisement instance ID to start.
+ * @param [in] duration How long to advertise for in milliseconds, 0 = forever (default).
+ * @param [in] max_events Maximum number of advertisement events to send, 0 = no limit (default).
+ * @return True if advertising started successfully.
+ * @details Start the server advertising its existence.  This is a convenience function and is equivalent to
  * retrieving the advertising object and invoking start upon it.
  */
-void NimBLEServer::startAdvertising() {
-    NimBLEDevice::startAdvertising();
+bool NimBLEServer::startAdvertising(uint8_t inst_id,
+                                    int duration,
+                                    int max_events) {
+    return getAdvertising()->start(inst_id, duration, max_events);
 } // startAdvertising
 
 
+/**
+ * @brief Convenience function to stop advertising a data set.
+ * @param [in] inst_id The extended advertisement instance ID to stop advertising.
+ * @return True if advertising stopped successfully.
+ */
+bool NimBLEServer::stopAdvertising(uint8_t inst_id) {
+    return getAdvertising()->stop(inst_id);
+} // stopAdvertising
+#endif
+
+#if !CONFIG_BT_NIMBLE_EXT_ADV|| defined(_DOXYGEN_)
+/**
+ * @brief Start advertising.
+ * @return True if advertising started successfully.
+ * @details Start the server advertising its existence.  This is a convenience function and is equivalent to
+ * retrieving the advertising object and invoking start upon it.
+ */
+bool NimBLEServer::startAdvertising() {
+    return getAdvertising()->start();
+} // startAdvertising
+#endif
+
+
 /**
  * @brief Stop advertising.
+ * @return True if advertising stopped successfully.
  */
-void NimBLEServer::stopAdvertising() {
-    NimBLEDevice::stopAdvertising();
-} // startAdvertising
+bool NimBLEServer::stopAdvertising() {
+    return getAdvertising()->stop();
+} // stopAdvertising
 
 
 /**
@@ -614,7 +799,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,
@@ -636,6 +827,51 @@ void NimBLEServer::updateConnParams(uint16_t conn_handle,
 } // updateConnParams
 
 
+/**
+ * @brief Request an update of the data packet length.
+ * * Can only be used after a connection has been established.
+ * @details Sends a data length update request to the peer.
+ * The Data Length Extension (DLE) allows to increase the Data Channel Payload from 27 bytes to up to 251 bytes.
+ * The peer needs to support the Bluetooth 4.2 specifications, to be capable of DLE.
+ * @param [in] conn_handle The connection handle of the peer to send the request to.
+ * @param [in] tx_octets The preferred number of payload octets to use (Range 0x001B-0x00FB).
+ */
+void NimBLEServer::setDataLen(uint16_t conn_handle, uint16_t tx_octets) {
+#if defined(CONFIG_NIMBLE_CPP_IDF) && !defined(ESP_IDF_VERSION) || \
+  (ESP_IDF_VERSION_MAJOR * 100 + ESP_IDF_VERSION_MINOR * 10 + ESP_IDF_VERSION_PATCH) < 432
+    return;
+#else
+    uint16_t tx_time = (tx_octets + 14) * 8;
+
+    int rc = ble_gap_set_data_len(conn_handle, tx_octets, tx_time);
+    if(rc != 0) {
+        NIMBLE_LOGE(LOG_TAG, "Set data length error: %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
+    }
+#endif
+} // setDataLen
+
+
+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 */
 
 void NimBLEServerCallbacks::onConnect(NimBLEServer* pServer) {
@@ -652,6 +888,14 @@ 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
+
+void NimBLEServerCallbacks::onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc) {
+    NIMBLE_LOGD("NimBLEServerCallbacks", "onMTUChange(): Default");
+} // onMTUChange
+
 uint32_t NimBLEServerCallbacks::onPassKeyRequest(){
     NIMBLE_LOGD("NimBLEServerCallbacks", "onPassKeyRequest: default: 123456");
     return 123456;
@@ -674,6 +918,4 @@ bool NimBLEServerCallbacks::onConfirmPIN(uint32_t pin){
     return true;
 }
 
-
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif // CONFIG_BT_ENABLED
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLEServer.h

@@ -14,17 +14,25 @@
 
 #ifndef MAIN_NIMBLESERVER_H_
 #define MAIN_NIMBLESERVER_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+
+#define NIMBLE_ATT_REMOVE_HIDE 1
+#define NIMBLE_ATT_REMOVE_DELETE 2
+
+#define onMtuChanged onMTUChange
 
 #include "NimBLEUtils.h"
 #include "NimBLEAddress.h"
+#if CONFIG_BT_NIMBLE_EXT_ADV
+#include "NimBLEExtAdvertising.h"
+#else
 #include "NimBLEAdvertising.h"
+#endif
 #include "NimBLEService.h"
 #include "NimBLESecurity.h"
+#include "NimBLEConnInfo.h"
 
 
 class NimBLEService;
@@ -39,39 +47,61 @@ class NimBLEServer {
 public:
     size_t                 getConnectedCount();
     NimBLEService*         createService(const char* uuid);
-    NimBLEService*         createService(const NimBLEUUID &uuid, uint32_t numHandles=15,
-                                         uint8_t inst_id=0);
+    NimBLEService*         createService(const NimBLEUUID &uuid);
     void                   removeService(NimBLEService* service, bool deleteSvc = false);
     void                   addService(NimBLEService* service);
-    NimBLEAdvertising*     getAdvertising();
     void                   setCallbacks(NimBLEServerCallbacks* pCallbacks,
                                         bool deleteCallbacks = true);
-    void                   startAdvertising();
-    void                   stopAdvertising();
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    NimBLEExtAdvertising*  getAdvertising();
+    bool                   startAdvertising(uint8_t inst_id,
+                                            int duration = 0,
+                                            int max_events = 0);
+    bool                   stopAdvertising(uint8_t inst_id);
+#else
+    NimBLEAdvertising*     getAdvertising();
+    bool                   startAdvertising();
+#endif
+    bool                   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);
+    void                   setDataLen(uint16_t conn_handle, uint16_t tx_octets);
     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);
+#if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
     void                   advertiseOnDisconnect(bool);
+#endif
 
 private:
     NimBLEServer();
     ~NimBLEServer();
     friend class           NimBLECharacteristic;
+    friend class           NimBLEService;
     friend class           NimBLEDevice;
     friend class           NimBLEAdvertising;
+#if CONFIG_BT_NIMBLE_EXT_ADV
+    friend class           NimBLEExtAdvertising;
+    friend class           NimBLEExtAdvertisementData;
+#endif
 
     bool                   m_gattsStarted;
+#if !CONFIG_BT_NIMBLE_EXT_ADV
     bool                   m_advertiseOnDisconnect;
+#endif
     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
@@ -80,7 +110,10 @@ private:
     std::vector<NimBLECharacteristic*> m_notifyChrVec;
 
     static int             handleGapEvent(struct ble_gap_event *event, void *arg);
+    void                   serviceChanged();
     void                   resetGATT();
+    bool                   setIndicateWait(uint16_t conn_handle);
+    void                   clearIndicateWait(uint16_t conn_handle);
 }; // NimBLEServer
 
 
@@ -114,6 +147,23 @@ 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 the connection MTU changes.
+     * @param [in] MTU The new MTU value.
+     * @param [in] desc A pointer to the connection description structure containig information
+     * about the connection.
+     */
+    virtual void onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc);
+
     /**
      * @brief Called when a client requests a passkey for pairing.
      * @return The passkey to be sent to the client.
@@ -138,7 +188,5 @@ public:
     virtual bool onConfirmPIN(uint32_t pin);
 }; // NimBLEServerCallbacks
 
-
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif /* CONFIG_BT_ENABLED */
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
 #endif /* MAIN_NIMBLESERVER_H_ */

src/NimBLEService.cpp

@@ -14,12 +14,10 @@
 
 // A service is identified by a UUID.  A service is also the container for one or more characteristics.
 
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
+#include "NimBLEDevice.h"
 #include "NimBLEService.h"
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
@@ -34,25 +32,19 @@ static const char* LOG_TAG = "NimBLEService"; // Tag for logging.
 /**
  * @brief Construct an instance of the NimBLEService
  * @param [in] uuid The UUID of the service.
- * @param [in] numHandles The maximum number of handles associated with the service.
- * @param [in] a pointer to the server instance that this service belongs to.
  */
-NimBLEService::NimBLEService(const char* uuid, uint16_t numHandles, NimBLEServer* pServer)
-: NimBLEService(NimBLEUUID(uuid), numHandles, pServer) {
+NimBLEService::NimBLEService(const char* uuid)
+: NimBLEService(NimBLEUUID(uuid)) {
 }
 
 
 /**
  * @brief Construct an instance of the BLEService
  * @param [in] uuid The UUID of the service.
- * @param [in] numHandles The maximum number of handles associated with the service.
- * @param [in] a pointer to the server instance that this service belongs to.
  */
-NimBLEService::NimBLEService(const NimBLEUUID &uuid, uint16_t numHandles, NimBLEServer* pServer) {
+NimBLEService::NimBLEService(const NimBLEUUID &uuid) {
     m_uuid         = uuid;
     m_handle       = NULL_HANDLE;
-    m_pServer      = pServer;
-    m_numHandles   = numHandles;
     m_pSvcDef      = nullptr;
     m_removed      = 0;
 
@@ -118,7 +110,18 @@ NimBLEUUID NimBLEService::getUUID() {
  */
 bool NimBLEService::start() {
     NIMBLE_LOGD(LOG_TAG, ">> start(): Starting service: %s", toString().c_str());
-    int rc = 0;
+
+    // Rebuild the service definition if the server attributes have changed.
+    if(getServer()->m_svcChanged && m_pSvcDef != nullptr) {
+        if(m_pSvcDef[0].characteristics) {
+            if(m_pSvcDef[0].characteristics[0].descriptors) {
+                delete(m_pSvcDef[0].characteristics[0].descriptors);
+            }
+            delete(m_pSvcDef[0].characteristics);
+        }
+        delete(m_pSvcDef);
+        m_pSvcDef = nullptr;
+    }
 
     if(m_pSvcDef == nullptr) {
         // Nimble requires an array of services to be sent to the api
@@ -132,8 +135,23 @@ bool NimBLEService::start() {
         svc[0].uuid = &m_uuid.getNative()->u;
         svc[0].includes = NULL;
 
-        size_t numChrs = m_chrVec.size();
+        int removedCount = 0;
+        for(auto it = m_chrVec.begin(); it != m_chrVec.end(); ) {
+            if ((*it)->m_removed > 0) {
+                if ((*it)->m_removed == NIMBLE_ATT_REMOVE_DELETE) {
+                    delete *it;
+                    it = m_chrVec.erase(it);
+                } else {
+                    ++removedCount;
+                    ++it;
+                }
+                continue;
+            }
 
+            ++it;
+        }
+
+        size_t numChrs = m_chrVec.size() - removedCount;
         NIMBLE_LOGD(LOG_TAG,"Adding %d characteristics for service %s", numChrs, toString().c_str());
 
         if(!numChrs){
@@ -142,40 +160,60 @@ bool NimBLEService::start() {
             // Nimble requires the last characteristic to have it's uuid = 0 to indicate the end
             // of the characteristics for the service. We create 1 extra and set it to null
             // for this purpose.
-            pChr_a = new ble_gatt_chr_def[numChrs+1];
-            NimBLECharacteristic* pCharacteristic = *m_chrVec.begin();
+            pChr_a = new ble_gatt_chr_def[numChrs + 1];
+            uint8_t i = 0;
+            for(auto chr_it = m_chrVec.begin(); chr_it != m_chrVec.end(); ++chr_it) {
+                if((*chr_it)->m_removed > 0) {
+                    continue;
+                }
 
-            for(uint8_t i=0; i < numChrs;) {
-                uint8_t numDscs = pCharacteristic->m_dscVec.size();
+                removedCount = 0;
+                for(auto it = (*chr_it)->m_dscVec.begin(); it != (*chr_it)->m_dscVec.end(); ) {
+                    if ((*it)->m_removed > 0) {
+                        if ((*it)->m_removed == NIMBLE_ATT_REMOVE_DELETE) {
+                            delete *it;
+                            it = (*chr_it)->m_dscVec.erase(it);
+                        } else {
+                            ++removedCount;
+                            ++it;
+                        }
+                        continue;
+                    }
+
+                    ++it;
+                }
+
+                size_t numDscs = (*chr_it)->m_dscVec.size() - removedCount;
 
                 if(!numDscs){
                     pChr_a[i].descriptors = NULL;
                 } else {
                     // Must have last descriptor uuid = 0 so we have to create 1 extra
                     pDsc_a = new ble_gatt_dsc_def[numDscs+1];
-                    NimBLEDescriptor* pDescriptor = *pCharacteristic->m_dscVec.begin();
-                    for(uint8_t d=0; d < numDscs;) {
-                        pDsc_a[d].uuid = &pDescriptor->m_uuid.getNative()->u;
-                        pDsc_a[d].att_flags = pDescriptor->m_properties;
+                    uint8_t d = 0;
+                    for(auto dsc_it = (*chr_it)->m_dscVec.begin(); dsc_it != (*chr_it)->m_dscVec.end(); ++dsc_it ) {
+                        if((*dsc_it)->m_removed > 0) {
+                            continue;
+                        }
+                        pDsc_a[d].uuid = &(*dsc_it)->m_uuid.getNative()->u;
+                        pDsc_a[d].att_flags = (*dsc_it)->m_properties;
                         pDsc_a[d].min_key_size = 0;
                         pDsc_a[d].access_cb = NimBLEDescriptor::handleGapEvent;
-                        pDsc_a[d].arg = pDescriptor;
-                        d++;
-                        pDescriptor = *(pCharacteristic->m_dscVec.begin() + d);
+                        pDsc_a[d].arg = (*dsc_it);
+                        ++d;
                     }
 
                     pDsc_a[numDscs].uuid = NULL;
                     pChr_a[i].descriptors = pDsc_a;
                 }
 
-                pChr_a[i].uuid = &pCharacteristic->m_uuid.getNative()->u;
+                pChr_a[i].uuid = &(*chr_it)->m_uuid.getNative()->u;
                 pChr_a[i].access_cb = NimBLECharacteristic::handleGapEvent;
-                pChr_a[i].arg = pCharacteristic;
-                pChr_a[i].flags = pCharacteristic->m_properties;
+                pChr_a[i].arg = (*chr_it);
+                pChr_a[i].flags = (*chr_it)->m_properties;
                 pChr_a[i].min_key_size = 0;
-                pChr_a[i].val_handle = &pCharacteristic->m_handle;
-                i++;
-                pCharacteristic = *(m_chrVec.begin() + i);
+                pChr_a[i].val_handle = &(*chr_it)->m_handle;
+                ++i;
             }
 
             pChr_a[numChrs].uuid = NULL;
@@ -187,7 +225,7 @@ bool NimBLEService::start() {
         m_pSvcDef = svc;
     }
 
-    rc = ble_gatts_count_cfg((const ble_gatt_svc_def*)m_pSvcDef);
+    int rc = ble_gatts_count_cfg((const ble_gatt_svc_def*)m_pSvcDef);
     if (rc != 0) {
         NIMBLE_LOGE(LOG_TAG, "ble_gatts_count_cfg failed, rc= %d, %s", rc, NimBLEUtils::returnCodeToString(rc));
         return false;
@@ -218,10 +256,11 @@ uint16_t NimBLEService::getHandle() {
  * @brief Create a new BLE Characteristic associated with this service.
  * @param [in] uuid - The UUID of the characteristic.
  * @param [in] properties - The properties of the characteristic.
+ * @param [in] max_len - The maximum length in bytes that the characteristic value can hold.
  * @return The new BLE characteristic.
  */
-NimBLECharacteristic* NimBLEService::createCharacteristic(const char* uuid, uint32_t properties) {
-    return createCharacteristic(NimBLEUUID(uuid), properties);
+NimBLECharacteristic* NimBLEService::createCharacteristic(const char* uuid, uint32_t properties, uint16_t max_len) {
+    return createCharacteristic(NimBLEUUID(uuid), properties, max_len);
 }
 
 
@@ -229,48 +268,144 @@ NimBLECharacteristic* NimBLEService::createCharacteristic(const char* uuid, uint
  * @brief Create a new BLE Characteristic associated with this service.
  * @param [in] uuid - The UUID of the characteristic.
  * @param [in] properties - The properties of the characteristic.
+ * @param [in] max_len - The maximum length in bytes that the characteristic value can hold.
  * @return The new BLE characteristic.
  */
-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.
+NimBLECharacteristic* NimBLEService::createCharacteristic(const NimBLEUUID &uuid, uint32_t properties, uint16_t max_len) {
+    NimBLECharacteristic* pCharacteristic = new NimBLECharacteristic(uuid, properties, max_len, this);
+
     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());
     }
 
-    // Remember this characteristic in our vector of characteristics.
-    m_chrVec.push_back(pCharacteristic);
-
+    addCharacteristic(pCharacteristic);
     return pCharacteristic;
 } // 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.
+ * @brief Add a characteristic to the service.
+ * @param[in] pCharacteristic A pointer to the characteristic instance to add to the service.
  */
-NimBLECharacteristic* NimBLEService::getCharacteristic(const char* uuid) {
-    return getCharacteristic(NimBLEUUID(uuid));
-}
+void NimBLEService::addCharacteristic(NimBLECharacteristic* pCharacteristic) {
+    bool foundRemoved = false;
+
+    if(pCharacteristic->m_removed > 0) {
+        for(auto& it : m_chrVec) {
+            if(it == pCharacteristic) {
+                foundRemoved = true;
+                pCharacteristic->m_removed = 0;
+            }
+        }
+    }
+
+    if(!foundRemoved) {
+        m_chrVec.push_back(pCharacteristic);
+    }
+
+    pCharacteristic->setService(this);
+    getServer()->serviceChanged();
+} // addCharacteristic
+
+
+/**
+ * @brief Remove a characteristic from the service.
+ * @param[in] pCharacteristic A pointer to the characteristic instance to remove from the service.
+ * @param[in] deleteChr If true it will delete the characteristic instance and free it's resources.
+ */
+void NimBLEService::removeCharacteristic(NimBLECharacteristic* pCharacteristic, bool deleteChr) {
+    // Check if the characteristic was already removed and if so, check if this
+    // is being called to delete the object and do so if requested.
+    // Otherwise, ignore the call and return.
+    if(pCharacteristic->m_removed > 0) {
+        if(deleteChr) {
+            for(auto it = m_chrVec.begin(); it != m_chrVec.end(); ++it) {
+                if ((*it) == pCharacteristic) {
+                    m_chrVec.erase(it);
+                    delete *it;
+                    break;
+                }
+            }
+        }
+
+        return;
+    }
+
+    pCharacteristic->m_removed = deleteChr ? NIMBLE_ATT_REMOVE_DELETE : NIMBLE_ATT_REMOVE_HIDE;
+    getServer()->serviceChanged();
+} // removeCharacteristic
 
 
 /**
  * @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 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, 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.
@@ -294,8 +429,7 @@ std::string NimBLEService::toString() {
  * @return The BLEServer associated with this service.
  */
 NimBLEServer* NimBLEService::getServer() {
-    return m_pServer;
-} // getServer
+    return NimBLEDevice::getServer();
+}// getServer
 
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif // CONFIG_BT_ENABLED
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */

src/NimBLEService.h

@@ -14,11 +14,9 @@
 
 #ifndef MAIN_NIMBLESERVICE_H_
 #define MAIN_NIMBLESERVICE_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
 
 #include "nimconfig.h"
-#if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
+#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
 #include "NimBLEServer.h"
 #include "NimBLECharacteristic.h"
@@ -35,44 +33,55 @@ class NimBLECharacteristic;
  */
 class NimBLEService {
 public:
+
+    NimBLEService(const char* uuid);
+    NimBLEService(const NimBLEUUID &uuid);
+    ~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 |
-                                              NIMBLE_PROPERTY::WRITE);
+                                              NIMBLE_PROPERTY::WRITE,
+                                              uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
 
     NimBLECharacteristic* createCharacteristic(const NimBLEUUID &uuid,
                                                uint32_t properties =
                                                NIMBLE_PROPERTY::READ |
-                                               NIMBLE_PROPERTY::WRITE);
+                                               NIMBLE_PROPERTY::WRITE,
+                                               uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
+
+    void                  addCharacteristic(NimBLECharacteristic* pCharacteristic);
+    void                  removeCharacteristic(NimBLECharacteristic* pCharacteristic, bool deleteChr = false);
+    NimBLECharacteristic* getCharacteristic(const char* uuid, uint16_t instanceId = 0);
+    NimBLECharacteristic* getCharacteristic(const NimBLEUUID &uuid, uint16_t instanceId = 0);
+    NimBLECharacteristic* getCharacteristicByHandle(uint16_t handle);
+
+    std::vector<NimBLECharacteristic*> getCharacteristics();
+    std::vector<NimBLECharacteristic*> getCharacteristics(const char* uuid);
+    std::vector<NimBLECharacteristic*> getCharacteristics(const NimBLEUUID &uuid);
 
-    void                  dump();
-    NimBLECharacteristic* getCharacteristic(const char* uuid);
-    NimBLECharacteristic* getCharacteristic(const NimBLEUUID &uuid);
-    NimBLEUUID            getUUID();
-    NimBLEServer*         getServer();
-    bool                  start();
-    std::string           toString();
-    uint16_t              getHandle();
 
 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;
 
     uint16_t              m_handle;
-    NimBLEServer*         m_pServer;
     NimBLEUUID            m_uuid;
-    uint16_t              m_numHandles;
     ble_gatt_svc_def*     m_pSvcDef;
     uint8_t               m_removed;
     std::vector<NimBLECharacteristic*> m_chrVec;
 
 }; // NimBLEService
 
-
-#endif // #if defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
-#endif // CONFIG_BT_ENABLED
+#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
 #endif /* MAIN_NIMBLESERVICE_H_ */

src/NimBLEUUID.cpp

@@ -11,7 +11,8 @@
  *  Created on: Jun 21, 2017
  *      Author: kolban
  */
-#include "sdkconfig.h"
+
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include "NimBLEUtils.h"
@@ -65,29 +66,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
@@ -221,8 +235,8 @@ const ble_uuid_any_t* NimBLEUUID::getNative() const {
 
 /**
  * @brief Convert a UUID to its 128 bit representation.
- * @details A UUID can be internally represented as 16bit, 32bit or the full 128bit.  This method
- * will convert 16 or 32 bit representations to the full 128bit.
+ * @details A UUID can be internally represented as 16bit, 32bit or the full 128bit.
+ * This method will convert 16 or 32bit representations to the full 128bit.
  * @return The NimBLEUUID converted to 128bit.
  */
 const NimBLEUUID &NimBLEUUID::to128() {
@@ -243,6 +257,29 @@ const NimBLEUUID &NimBLEUUID::to128() {
 } // to128
 
 
+/**
+ * @brief Convert 128 bit UUID to its 16 bit representation.
+ * @details A UUID can be internally represented as 16bit, 32bit or the full 128bit.
+ * This method will convert a 128bit uuid to 16bit if it contains the ble base uuid.
+ * @return The NimBLEUUID converted to 16bit if successful, otherwise the original uuid.
+ */
+const NimBLEUUID& NimBLEUUID::to16() {
+    if (!m_valueSet || m_uuid.u.type == BLE_UUID_TYPE_16) {
+        return *this;
+    }
+
+    if (m_uuid.u.type == BLE_UUID_TYPE_128) {
+        uint8_t base128[] = {0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00,
+                             0x00, 0x80, 0x00, 0x10, 0x00, 0x00};
+        if (memcmp(m_uuid.u128.value, base128, sizeof(base128)) == 0 ) {
+            *this = NimBLEUUID(*(uint16_t*)(m_uuid.u128.value + 12));
+        }
+    }
+
+    return *this;
+}
+
+
 /**
  * @brief Get a string representation of the UUID.
  * @details
@@ -264,6 +301,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

@@ -14,10 +14,16 @@
 
 #ifndef COMPONENTS_NIMBLEUUID_H_
 #define COMPONENTS_NIMBLEUUID_H_
-#include "sdkconfig.h"
+
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_uuid.h"
+#else
+#include "nimble/nimble/host/include/host/ble_uuid.h"
+#endif
+
 /****  FIX COMPILATION ****/
 #undef min
 #undef max
@@ -42,6 +48,7 @@ public:
     bool                  equals(const NimBLEUUID &uuid) const;
     const ble_uuid_any_t* getNative() const;
     const NimBLEUUID &    to128();
+    const NimBLEUUID&     to16();
     std::string           toString() const;
     static NimBLEUUID     fromString(const std::string &uuid);
 

src/NimBLEUtils.cpp

@@ -6,12 +6,13 @@
  *
  */
 
-#include "sdkconfig.h"
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
 #include "NimBLEUtils.h"
 #include "NimBLELog.h"
-#include "nimconfig.h"
+
+#include <stdlib.h>
 
 static const char* LOG_TAG = "NimBLEUtils";
 
@@ -53,6 +54,22 @@ int NimBLEUtils::checkConnParams(ble_gap_conn_params* params) {
     return 0;
 }
 
+ble_npl_time_t NimBLEUtils::meshTransTimeMs(uint8_t tt) {
+    switch(tt >> 6) {
+        case 0:
+            return 100;
+        case 1:
+            return 1000;
+        case 2:
+            return 10000;
+        case 3:
+            return 600000;
+        default:
+            return 0;
+    }
+}
+
+
 
 /**
  * @brief Converts a return code from the NimBLE stack to a text string.
@@ -342,6 +359,7 @@ const char* NimBLEUtils::returnCodeToString(int rc) {
             return "Unknown";
     }
 #else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
+    (void)rc;
     return "";
 #endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT)
 }
@@ -369,6 +387,7 @@ const char* NimBLEUtils::advTypeToString(uint8_t advType) {
             return "Unknown flag";
     }
 #else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT)
+    (void)advType;
     return "";
 #endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT)
 } // adFlagsToString
@@ -416,8 +435,11 @@ char* NimBLEUtils::buildHexData(uint8_t* target, const uint8_t* source, uint8_t
  * @param [in] arg Unused.
  */
 void NimBLEUtils::dumpGapEvent(ble_gap_event *event, void *arg){
+    (void)arg;
 #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
     NIMBLE_LOGD(LOG_TAG, "Received a GAP event: %s", gapEventToString(event->type));
+#else
+    (void)event;
 #endif
 }
 
@@ -504,6 +526,7 @@ const char* NimBLEUtils::gapEventToString(uint8_t eventType) {
             return "Unknown event type";
     }
 #else // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
+    (void)eventType;
     return "";
 #endif // #if defined(CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT)
 } // gapEventToString

src/NimBLEUtils.h

@@ -8,10 +8,15 @@
 
 #ifndef COMPONENTS_NIMBLEUTILS_H_
 #define COMPONENTS_NIMBLEUTILS_H_
-#include "sdkconfig.h"
+
+#include "nimconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 
+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
 
 /****  FIX COMPILATION ****/
 #undef min
@@ -24,7 +29,7 @@ typedef struct {
     void *pATT;
     TaskHandle_t task;
     int rc;
-    std::string *buf;
+    void *buf;
 } ble_task_data_t;
 
 
@@ -39,6 +44,7 @@ public:
     static const char*          advTypeToString(uint8_t advType);
     static const char*          returnCodeToString(int rc);
     static int                  checkConnParams(ble_gap_conn_params* params);
+    static ble_npl_time_t       meshTransTimeMs(uint8_t tt);
 };
 
 

src/mesh_config_store/base64/base64.h

@@ -0,0 +1,295 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+#ifndef __UTIL_BASE64_H
+#define __UTIL_BASE64_H
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct base64_decoder {
+    /*** public */
+    const char *src;
+    void *dst;
+    int src_len; /* <=0 if src ends with '\0' */
+    int dst_len; /* <=0 if dst unbounded */
+
+    /*** private */
+    char buf[4];
+    int buf_len;
+};
+
+static const char base64_chars[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static int
+pos(char c)
+{
+    const char *p;
+    for (p = base64_chars; *p; p++)
+        if (*p == c)
+            return p - base64_chars;
+    return -1;
+}
+
+int
+base64_encode(const void *data, int size, char *s, uint8_t should_pad)
+{
+    char *p;
+    int i;
+    int c;
+    const unsigned char *q;
+    char *last;
+    int diff;
+
+    p = s;
+
+    q = (const unsigned char *) data;
+    last = NULL;
+    i = 0;
+    while (i < size) {
+        c = q[i++];
+        c *= 256;
+        if (i < size)
+            c += q[i];
+        i++;
+        c *= 256;
+        if (i < size)
+            c += q[i];
+        i++;
+        p[0] = base64_chars[(c & 0x00fc0000) >> 18];
+        p[1] = base64_chars[(c & 0x0003f000) >> 12];
+        p[2] = base64_chars[(c & 0x00000fc0) >> 6];
+        p[3] = base64_chars[(c & 0x0000003f) >> 0];
+        last = p;
+        p += 4;
+    }
+
+    if (last) {
+        diff = i - size;
+        if (diff > 0) {
+            if (should_pad) {
+                memset(last + (4 - diff), '=', diff);
+            } else {
+                p = last + (4 - diff);
+            }
+        }
+    }
+
+    *p = 0;
+
+    return (p - s);
+}
+
+int
+base64_pad(char *buf, int len)
+{
+    int remainder;
+
+    remainder = len % 4;
+    if (remainder == 0) {
+        return (0);
+    }
+
+    memset(buf, '=', 4 - remainder);
+
+    return (4 - remainder);
+}
+
+#define DECODE_ERROR -1
+
+static unsigned int
+token_decode(const char *token, int len)
+{
+    int i;
+    unsigned int val = 0;
+    int marker = 0;
+
+    if (len < 4) {
+        return DECODE_ERROR;
+    }
+
+    for (i = 0; i < 4; i++) {
+        val *= 64;
+        if (token[i] == '=') {
+            marker++;
+        } else if (marker > 0) {
+            return DECODE_ERROR;
+        } else {
+            val += pos(token[i]);
+        }
+    }
+
+    if (marker > 2) {
+        return DECODE_ERROR;
+    }
+
+    return (marker << 24) | val;
+}
+
+int
+base64_decoder_go(struct base64_decoder *dec)
+{
+    unsigned int marker;
+    unsigned int val;
+    uint8_t *dst;
+    char sval;
+    int read_len;
+    int src_len;
+    int src_rem;
+    int src_off;
+    int dst_len;
+    int dst_off;
+    int i;
+
+    dst = dec->dst;
+    dst_off = 0;
+    src_off = 0;
+
+    /* A length <= 0 means "unbounded". */
+    if (dec->src_len <= 0) {
+        src_len = INT_MAX;
+    } else {
+        src_len = dec->src_len;
+    }
+    if (dec->dst_len <= 0) {
+        dst_len = INT_MAX;
+    } else {
+        dst_len = dec->dst_len;
+    }
+
+    while (1) {
+        src_rem = src_len - src_off;
+        if (src_rem == 0) {
+            /* End of source input. */
+            break;
+        }
+
+        if (dec->src[src_off] == '\0') {
+            /* End of source string. */
+            break;
+        }
+
+        /* Account for possibility of partial token from previous call. */
+        read_len = 4 - dec->buf_len;
+
+        /* Detect invalid input. */
+        for (i = 0; i < read_len; i++) {
+            sval = dec->src[src_off + i];
+            if (sval == '\0') {
+                /* Incomplete input. */
+                return -1;
+            }
+            if (sval != '=' && strchr(base64_chars, sval) == NULL) {
+                /* Invalid base64 character. */
+                return -1;
+            }
+        }
+
+        if (src_rem < read_len) {
+            /* Input contains a partial token.  Stash it for use during the
+             * next call.
+             */
+            memcpy(&dec->buf[dec->buf_len], &dec->src[src_off], src_rem);
+            dec->buf_len += src_rem;
+            break;
+        }
+
+        /* Copy full token into buf and decode it. */
+        memcpy(&dec->buf[dec->buf_len], &dec->src[src_off], read_len);
+        val = token_decode(dec->buf, read_len);
+        if (val == DECODE_ERROR) {
+            return -1;
+        }
+        src_off += read_len;
+        dec->buf_len = 0;
+
+        marker = (val >> 24) & 0xff;
+
+        if (dst_off >= dst_len) {
+            break;
+        }
+        dst[dst_off] = (val >> 16) & 0xff;
+        dst_off++;
+
+        if (marker < 2) {
+            if (dst_off >= dst_len) {
+                break;
+            }
+            dst[dst_off] = (val >> 8) & 0xff;
+            dst_off++;
+        }
+
+        if (marker < 1) {
+            if (dst_off >= dst_len) {
+                break;
+            }
+            dst[dst_off] = val & 0xff;
+            dst_off++;
+        }
+    }
+
+    return dst_off;
+}
+
+int
+base64_decode(const char *str, void *data)
+{
+    struct base64_decoder dec = {
+        .src = str,
+        .dst = data,
+    };
+
+    return base64_decoder_go(&dec);
+}
+
+int
+base64_decode_maxlen(const char *str, void *data, int len)
+{
+    struct base64_decoder dec = {
+        .src = str,
+        .dst = data,
+        .dst_len = len,
+    };
+
+    return base64_decoder_go(&dec);
+}
+
+int
+base64_decode_len(const char *str)
+{
+    int len;
+
+    len = strlen(str);
+    while (len && str[len - 1] == '=') {
+        len--;
+    }
+    return len * 3 / 4;
+}
+
+#define BASE64_ENCODE_SIZE(__size) (((((__size) - 1) / 3) * 4) + 4)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __UTIL_BASE64_H__ */

src/mesh_config_store/config/config.h

@@ -0,0 +1,238 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+#ifndef __SYS_CONFIG_H_
+#define __SYS_CONFIG_H_
+
+#include "../../nimconfig.h"
+#if defined(CONFIG_NIMBLE_CPP_IDF)
+#  include <os/queue.h>
+#else
+#  include "nimble/porting/nimble/include/os/queue.h"
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONF_MAX_DIR_DEPTH	8	/* max depth of config tree */
+#define CONF_MAX_NAME_LEN	(8 * CONF_MAX_DIR_DEPTH)
+
+/**
+ * Type of configuration value.
+ */
+typedef enum conf_type {
+    CONF_NONE = 0,
+    CONF_DIR,
+    /** 8-bit signed integer */
+    CONF_INT8,
+    /** 16-bit signed integer */
+    CONF_INT16,
+    /** 32-bit signed integer */
+    CONF_INT32,
+    /** 64-bit signed integer */
+    CONF_INT64,
+    /** String */
+    CONF_STRING,
+    /** Bytes */
+    CONF_BYTES,
+    /** Floating point */
+    CONF_FLOAT,
+    /** Double precision */
+    CONF_DOUBLE,
+    /** Boolean */
+    CONF_BOOL,
+    /** 8-bit unsigned integer */
+    CONF_UINT8,
+    /** 16-bit unsigned integer */
+    CONF_UINT16,
+    /** 32-bit unsigned integer */
+    CONF_UINT32,
+    /** 64-bit unsigned integer */
+    CONF_UINT64,
+} __attribute__((__packed__)) conf_type_t;
+
+/**
+ * Parameter to commit handler describing where data is going to.
+ */
+enum conf_export_tgt {
+    /** Value is to be persisted */
+    CONF_EXPORT_PERSIST,
+    /** Value is to be display */
+    CONF_EXPORT_SHOW
+};
+
+typedef enum conf_export_tgt conf_export_tgt_t;
+
+/**
+ * Handler for getting configuration items, this handler is called
+ * per-configuration section.  Configuration sections are delimited
+ * by '/', for example:
+ *
+ *  - section/name/value
+ *
+ * Would be passed as:
+ *
+ *  - argc = 3
+ *  - argv[0] = section
+ *  - argv[1] = name
+ *  - argv[2] = value
+ *
+ * The handler returns the value into val, null terminated, up to
+ * val_len_max.
+ *
+ * @param argc          The number of sections in the configuration variable
+ * @param argv          The array of configuration sections
+ * @param val           A pointer to the buffer to return the configuration
+ *                      value into.
+ * @param val_len_max   The maximum length of the val buffer to copy into.
+ *
+ * @return A pointer to val or NULL if error.
+ */
+typedef char *(*conf_get_handler_t)(int argc, char **argv, char *val, int val_len_max);
+typedef char *(*conf_get_handler_ext_t)(int argc, char **argv, char *val, int val_len_max, void *arg);
+
+/**
+ * Set the configuration variable pointed to by argc and argv.  See
+ * description of ch_get_handler_t for format of these variables.  This sets the
+ * configuration variable to the shadow value, but does not apply the configuration
+ * change.  In order to apply the change, call the ch_commit() handler.
+ *
+ * @param argc   The number of sections in the configuration variable.
+ * @param argv   The array of configuration sections
+ * @param val    The value to configure that variable to
+ *
+ * @return 0 on success, non-zero error code on failure.
+ */
+typedef int (*conf_set_handler_t)(int argc, char **argv, char *val);
+typedef int (*conf_set_handler_ext_t)(int argc, char **argv, char *val, void *arg);
+
+/**
+ * Commit shadow configuration state to the active configuration.
+ *
+ * @return 0 on success, non-zero error code on failure.
+ */
+typedef int (*conf_commit_handler_t)(void);
+typedef int (*conf_commit_handler_ext_t)(void *arg);
+
+/**
+ * Called per-configuration variable being exported.
+ *
+ * @param name The name of the variable to export
+ * @param val  The value of the variable to export
+ */
+typedef void (*conf_export_func_t)(char *name, char *val);
+
+/**
+ * Export all of the configuration variables, calling the export_func
+ * per variable being exported.
+ *
+ * @param export_func  The export function to call.
+ * @param tgt          The target of the export, either for persistence or display.
+ *
+ * @return 0 on success, non-zero error code on failure.
+ */
+typedef int (*conf_export_handler_t)(conf_export_func_t export_func,
+                                     conf_export_tgt_t tgt);
+typedef int (*conf_export_handler_ext_t)(conf_export_func_t export_func,
+                                         conf_export_tgt_t tgt, void *arg);
+
+/**
+ * Configuration handler, used to register a config item/subtree.
+ */
+struct conf_handler {
+    SLIST_ENTRY(conf_handler) ch_list;
+    /**
+     * The name of the conifguration item/subtree
+     */
+    char *ch_name;
+
+    /**
+     * Whether to use the extended callbacks.
+     * false: standard
+     * true:  extended
+     */
+    bool ch_ext;
+
+    /** Get configuration value */
+    union {
+        conf_get_handler_t ch_get;
+        conf_get_handler_ext_t ch_get_ext;
+    };
+
+    /** Set configuration value */
+    union {
+        conf_set_handler_t ch_set;
+        conf_set_handler_ext_t ch_set_ext;
+    };
+
+    /** Commit configuration value */
+    union {
+        conf_commit_handler_t ch_commit;
+        conf_commit_handler_ext_t ch_commit_ext;
+    };
+
+    /** Export configuration value */
+    union {
+        conf_export_handler_t ch_export;
+        conf_export_handler_ext_t ch_export_ext;
+    };
+
+    /** Custom argument that gets passed to the extended callbacks */
+    void *ch_arg;
+};
+
+/**
+ * Register a handler for configurations items.
+ *
+ * @param cf Structure containing registration info.
+ *
+ * @return 0 on success, non-zero on failure.
+ */
+int conf_register(struct conf_handler *cf);
+
+/**
+ * Load configuration from registered persistence sources. Handlers for
+ * configuration subtrees registered earlier will be called for encountered
+ * values.
+ *
+ * @return 0 on success, non-zero on failure.
+ */
+int conf_load(void);
+
+/**
+ * Write a single configuration value to persisted storage (if it has
+ * changed value).
+ *
+ * @param name Name/key of the configuration item.
+ * @param var Value of the configuration item.
+ *
+ * @return 0 on success, non-zero on failure.
+ */
+int conf_save_one(const char *name, char *var);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define SYSINIT_PANIC_ASSERT_MSG(rc, msg) assert(rc)
+
+#endif /* __SYS_CONFIG_H_ */

src/mesh_config_store/config/config_store.c

@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "nimconfig.h"
+#ifdef ESP_PLATFORM
+#if CONFIG_BT_NIMBLE_MESH && CONFIG_NIMBLE_CPP_PERSIST_MESH_SETTINGS
+
+#include "config.h"
+#include "nvs.h"
+
+#include <string.h>
+
+static struct conf_handler* config_handler;
+
+int conf_parse_name(char *name, int *name_argc, char *name_argv[])
+{
+    char *tok;
+    char *tok_ptr;
+    const char *sep = "/";
+    int i;
+
+    tok = strtok_r(name, sep, &tok_ptr);
+
+    i = 0;
+    while (tok) {
+        name_argv[i++] = tok;
+        tok = strtok_r(NULL, sep, &tok_ptr);
+    }
+    *name_argc = i;
+
+    return 0;
+}
+
+int conf_load(void)
+{
+    esp_err_t err;
+    nvs_handle handle;
+
+    err = nvs_open(config_handler->ch_name, NVS_READONLY, &handle);
+    if (err != ESP_OK) return err;
+
+    nvs_iterator_t it = nvs_entry_find("nvs", config_handler->ch_name, NVS_TYPE_ANY);
+
+    while (it != NULL) {
+        nvs_entry_info_t info;
+        nvs_entry_info(it, &info);
+        it = nvs_entry_next(it);
+
+        size_t required_size = 0;
+        err = nvs_get_str(handle, info.key, NULL, &required_size);
+        if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) return err;
+
+        char* val = malloc(required_size);
+        if (required_size > 0) {
+            err = nvs_get_str(handle, info.key, val, &required_size);
+            if (err != ESP_OK) {
+                free(val);
+                return err;
+            }
+        }
+
+        int name_argc;
+        char *name_argv[8];
+        conf_parse_name(info.key, &name_argc, name_argv);
+
+        config_handler->ch_set(name_argc, &name_argv[0], val);
+        free(val);
+    }
+
+    nvs_close(handle);
+    config_handler->ch_commit();
+    return ESP_OK;
+}
+
+int conf_save_one(const char *name, char *var)
+{
+    esp_err_t err;
+    nvs_handle_t handle;
+    int name_argc;
+    char *name_argv[CONF_MAX_DIR_DEPTH];
+    char n[CONF_MAX_NAME_LEN];
+
+    strcpy(n, name);
+    conf_parse_name(n, &name_argc, name_argv);
+
+    err = nvs_open(name_argv[0], NVS_READWRITE, &handle);
+    if (err != ESP_OK) return err;
+
+    const char* key = name_argv[1];
+    if (name_argc > 2) {
+        key = name;
+        while (*key != '/') {
+            key++;
+        }
+        key++;
+    }
+
+    if (var) {
+        err = nvs_set_str(handle, key, var);
+        if (err != ESP_OK) return err;
+    } else {
+        err = nvs_erase_key(handle, key);
+        if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) return err;
+    }
+
+    err = nvs_commit(handle);
+    if (err != ESP_OK) return err;
+
+    nvs_close(handle);
+    return ESP_OK;
+}
+
+int conf_register(struct conf_handler *cf)
+{
+    config_handler = cf;
+    return 0;
+}
+
+#endif // CONFIG_BT_NIMBLE_MESH && MYNEWT_VAL_BLE_MESH_SETTINGS
+#endif // ESP_PLATFORM

src/nimconfig.h

@@ -1,194 +1,19 @@
-/** @file 
- * 
+/** @file
+ *
  * 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.
- */
-
-/* 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) 
- * @details To increase max connections in Arduino it is also required to change the
- * controller max connections defined in sdkconfig.h.\n
- *
- * This is located in your Arduino/hardware/espressif/esp32/tools/sdk/include/config folder.\n\n
- *
- * The values in sdkconfig.h you will need to change are:\n\n
- * `CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN 3`\n
- * `CONFIG_BTDM_CONTROLLER_BLE_MAX_CONN_EFF 3`
- */
-#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 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 */
-#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 Default MTU size */
-#define CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU 256
-
-/** @brief Default GAP appearance */
-#define CONFIG_BT_NIMBLE_SVC_GAP_APPEARANCE 0x0
-
-/** @brief ACL Buffer count */
-#define CONFIG_BT_NIMBLE_ACL_BUF_COUNT 12
-
-/** @brief ACL Buffer size */
-#define CONFIG_BT_NIMBLE_ACL_BUF_SIZE 255
-
-/** @brief HCI Event Buffer size */
-#define CONFIG_BT_NIMBLE_HCI_EVT_BUF_SIZE 70
-
-/** @brief Number of high priority HCI event buffers */
-#define CONFIG_BT_NIMBLE_HCI_EVT_HI_BUF_COUNT 30
-
-/** @brief Number of low priority HCI event buffers */
-#define CONFIG_BT_NIMBLE_HCI_EVT_LO_BUF_COUNT 8
-
-/**
- * @brief Sets 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 Random address refresh time in seconds */
-#define CONFIG_BT_NIMBLE_RPA_TIMEOUT 900
-
-/** @brief Maximum number of connection oriented channels */
-#define CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM 0
-
-/* 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
-**********************************/
+#if defined(CONFIG_BT_ENABLED)
 
+// Allows cpp wrapper to select the correct include paths when using esp-idf
+#define CONFIG_NIMBLE_CPP_IDF
 
 /* Cannot use client without scan */
 #if defined(CONFIG_BT_NIMBLE_ROLE_CENTRAL) && !defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
@@ -200,26 +25,117 @@
 #define CONFIG_BT_NIMBLE_ROLE_BROADCASTER
 #endif
 
+/* Enables the use of Arduino String class for attribute values */
+#if defined __has_include
+#  if __has_include (<Arduino.h>)
+#    define NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
+#  endif
+#endif
 
+#endif /* CONFIG_BT_ENABLED */
 
 #ifdef _DOXYGEN_
-/** @brief Uncomment to see debug log messages from the NimBLE host \n
+
+/** @brief Un-comment to change the number of simultaneous connections (esp controller max is 9) */
+#define CONFIG_BT_NIMBLE_MAX_CONNECTIONS 3
+
+/** @brief Un-comment to enable storing the timestamp when an attribute value is updated\n
+ *  This allows for checking the last update time using getTimeStamp() or getValue(time_t*)\n
+ *  If disabled, the timestamp returned from these functions will be 0.\n
+ *  Disabling timestamps will reduce the memory used for each value.\n
+ *  1 = Enabled, 0 = Disabled; Default = Disabled
+ */
+#define CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED 0
+
+/** @brief Uncomment to set the default allocation size (bytes) for each attribute if\n
+ *  not specified when the constructor is called. This is also the size used when a remote\n
+ *  characteristic or descriptor is constructed before a value is read/notifed.\n
+ *  Increasing this will reduce reallocations but increase memory footprint.\n
+ *  Default value is 20. Range: 1 : 512 (BLE_ATT_ATTR_MAX_LEN)
+ */
+#define CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20
+
+/** @brief Un-comment to change the default MTU size */
+#define CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU 255
+
+/** @brief Un-comment to change default device name */
+#define CONFIG_BT_NIMBLE_SVC_GAP_DEVICE_NAME "nimble"
+
+/** @brief Un-comment to set the debug log messages level from the NimBLE host stack.\n
+ *  Values: 0 = DEBUG, 1 = INFO, 2 = WARNING, 3 = ERROR, 4 = CRITICAL, 5+ = NONE\n
  *  Uses approx. 32kB of flash memory.
  */
-#define CONFIG_BT_NIMBLE_DEBUG
+#define CONFIG_BT_NIMBLE_LOG_LEVEL 5
 
-/** @brief Uncomment to see NimBLE host return codes as text debug log messages. \n
+/** @brief Un-comment to set the debug log messages level from the NimBLE CPP Wrapper.\n
+ *  Values: 0 = NONE, 1 = ERROR, 2 = WARNING, 3 = INFO, 4+ = DEBUG\n
+ *  Uses approx. 32kB of flash memory.
+ */
+#define CONFIG_NIMBLE_CPP_LOG_LEVEL 0
+
+/** @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 Uncomment to see GAP event codes as text in debug log messages. \n
+/** @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 Uncomment to see advertisment types as text while scanning in debug log messages. \n
+/** @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 Un-comment if not using NimBLE Client functions \n
+ *  Reduces flash size by approx. 7kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
+
+/** @brief Un-comment if not using NimBLE Scan functions \n
+ *  Reduces flash size by approx. 26kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_OBSERVER_DISABLED
+
+/** @brief Un-comment if not using NimBLE Server functions \n
+ *  Reduces flash size by approx. 16kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_PERIPHERAL_DISABLED
+
+/** @brief Un-comment if not using NimBLE Advertising functions \n
+ *  Reduces flash size by approx. 5kB.
+ */
+#define CONFIG_BT_NIMBLE_ROLE_BROADCASTER_DISABLED
+
+/** @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 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 Un-comment to change the core NimBLE host runs on */
+#define CONFIG_BT_NIMBLE_PINNED_TO_CORE 0
+
+/** @brief Un-comment to change the stack size for the NimBLE host task */
+#define CONFIG_BT_NIMBLE_TASK_STACK_SIZE 4096
+
 #endif // _DOXYGEN_

src/nimconfig_rename.h

@@ -0,0 +1,61 @@
+/*
+ * 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_BT_CTRL_SCAN_DUPL_TYPE) && !defined(CONFIG_BTDM_SCAN_DUPL_TYPE)
+#define CONFIG_BTDM_SCAN_DUPL_TYPE CONFIG_BT_CTRL_SCAN_DUPL_TYPE
+#endif
+
+#if defined(CONFIG_DUPLICATE_SCAN_CACHE_SIZE) && !defined(CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE)
+#define CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE CONFIG_DUPLICATE_SCAN_CACHE_SIZE
+#endif
+
+#if defined(CONFIG_BT_CTRL_SCAN_DUPL_CACHE_SIZE) && !defined(CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE)
+#define CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE CONFIG_BT_CTRL_SCAN_DUPL_CACHE_SIZE
+#endif
+
+#if defined(CONFIG_NIMBLE_MAX_CONNECTIONS ) && !defined(CONFIG_BT_NIMBLE_MAX_CONNECTIONS)
+#define CONFIG_BT_NIMBLE_MAX_CONNECTIONS CONFIG_NIMBLE_MAX_CONNECTIONS
+#endif