Add examples

examples/Advanced/NimBLE_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 esp32)
+project(NimBLE_Client)

examples/Advanced/NimBLE_Client/Makefile

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

examples/Advanced/NimBLE_Client/main/CMakeLists.txt

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

examples/Advanced/NimBLE_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/Advanced/NimBLE_Client/main/main.cpp

@@ -0,0 +1,372 @@
+
+/** NimBLE_Server Demo:
+ *
+ *  Demonstrates many of the available features of the NimBLE client library.
+ *  
+ *  Created: on March 24 2020
+ *      Author: H2zero
+ * 
+*/
+#include <NimBLEDevice.h>
+
+extern "C" {void app_main(void);}
+
+void scanEndedCB(NimBLEScanResults results);
+
+static NimBLEAdvertisedDevice* advDevice;
+
+static bool doConnect = false;
+static uint32_t scanTime = 0; /** 0 = scan forever */
+
+
+/**  None of these are required as they will be handled by the library with defaults. **
+ **                       Remove as you see fit for your needs                        */  
+class ClientCallbacks : public NimBLEClientCallbacks {
+    void onConnect(NimBLEClient* pClient) {
+        printf("Connected\n");
+        /** After connection we should change the parameters if we don't need fast response times.
+         *  These settings are 150ms interval, 0 latency, 450ms timout. 
+         *  Timeout should be a multiple of the interval, minimum is 100ms.
+         *  I find a multiple of 3-5 * the interval works best for quick response/reconnect.
+         *  Min interval: 120 * 1.25ms = 150, Max interval: 120 * 1.25ms = 150, 0 latency, 45 * 10ms = 450ms timeout 
+         */
+        pClient->updateConnParams(120,120,0,45);
+    };
+
+    void onDisconnect(NimBLEClient* pClient) {
+        printf("%s Disconnected - Starting scan\n", pClient->getPeerAddress().toString().c_str());
+        NimBLEDevice::getScan()->start(scanTime, scanEndedCB);
+    };
+    
+    /********************* Security handled here **********************
+    ****** Note: these are the same return values as defaults ********/
+    uint32_t onPassKeyRequest(){
+        printf("Client Passkey Request\n");
+        /** return the passkey to send to the server */
+        return 123456;
+    };
+
+    bool onConfirmPIN(uint32_t pass_key){
+        printf("The passkey YES/NO number: %d\n", pass_key);
+    /** Return false if passkeys don't match. */
+        return true;
+    };
+
+    /** Pairing process complete, we can check the results in ble_gap_conn_desc */
+    void onAuthenticationComplete(ble_gap_conn_desc* desc){
+        if(!desc->sec_state.encrypted) {
+            printf("Encrypt connection failed - disconnecting\n");
+            /** Find the client with the connection handle provided in desc */
+            NimBLEDevice::getClientByID(desc->conn_handle)->disconnect();
+            return;
+        }
+    };
+};
+
+
+/** Define a class to handle the callbacks when advertisments are received */
+class AdvertisedDeviceCallbacks: public NimBLEAdvertisedDeviceCallbacks {
+    
+    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
+        printf("Advertised Device found: %s\n", advertisedDevice->toString().c_str());
+        if(advertisedDevice->isAdvertisingService(NimBLEUUID("DEAD")))
+        {
+            printf("Found Our Service\n");
+            /** stop scan before connecting */
+            NimBLEDevice::getScan()->stop();
+            /** Save the device reference in a global for the client to use*/ 
+            advDevice = advertisedDevice;
+            /** Ready to connect now */ 
+            doConnect = true;
+        }
+    };
+};
+
+
+/** Notification / Indication receiving handler callback */
+void notifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify){
+    std::string str = (isNotify == true) ? "Notification" : "Indication"; 
+    str += " from ";
+    str += pRemoteCharacteristic->getRemoteService()->getClient()->getPeerAddress().toString();
+    str += ": Service = " + pRemoteCharacteristic->getRemoteService()->getUUID().toString();
+    str += ", Characteristic = " + pRemoteCharacteristic->getUUID().toString();
+    str += ", Value = " + std::string((char*)pData, length);
+    printf("%s\n", str.c_str());
+}
+
+/** Callback to process the results of the last scan or restart it */
+void scanEndedCB(NimBLEScanResults results){
+    printf("Scan Ended\n");
+}
+
+
+/** Create a single global instance of the callback class to be used by all clients */
+static ClientCallbacks clientCB;
+
+
+/** Handles the provisioning of clients and connects / interfaces with the server */
+bool connectToServer() {
+    NimBLEClient* pClient = nullptr;
+    
+    /** Check if we have a client we should reuse first **/
+    if(NimBLEDevice::getClientListSize()) {
+        /** Special case when we already know this device, we send false as the 
+         *  second argument in connect() to prevent refreshing the service database.
+         *  This saves considerable time and power.
+         */
+        pClient = NimBLEDevice::getClientByPeerAddress(advDevice->getAddress());
+        if(pClient){
+            if(!pClient->connect(advDevice, false)) {
+                printf("Reconnect failed\n");
+                return false;
+            }
+            printf("Reconnected client\n");
+        } 
+        /** We don't already have a client that knows this device,
+         *  we will check for a client that is disconnected that we can use.
+         */
+        else {
+            pClient = NimBLEDevice::getDisconnectedClient();
+        }
+    }
+    
+    /** No client to reuse? Create a new one. */
+    if(!pClient) {
+        if(NimBLEDevice::getClientListSize() >= NIMBLE_MAX_CONNECTIONS) {
+            printf("Max clients reached - no more connections available\n");
+            return false;
+        }
+        
+        pClient = NimBLEDevice::createClient();
+        
+        printf("New client created\n");
+    
+        pClient->setClientCallbacks(&clientCB, false);
+        /** Set initial connection parameters: These settings are 15ms interval, 0 latency, 120ms timout. 
+         *  These settings are safe for 3 clients to connect reliably, can go faster if you have less 
+         *  connections. Timeout should be a multiple of the interval, minimum is 100ms.
+         *  Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 12 * 10ms = 120ms timeout 
+         */
+        pClient->setConnectionParams(6,6,0,15);
+        /** Set how long we are willing to wait for the connection to complete (seconds), default is 30. */
+        pClient->setConnectTimeout(5);
+        
+
+        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;
+        }
+    }         
+    
+    if(!pClient->isConnected()) {
+        if (!pClient->connect(advDevice)) {
+            printf("Failed to connect\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;
+    NimBLERemoteDescriptor* pDsc = nullptr;
+    
+    pSvc = pClient->getService("DEAD");
+    if(pSvc) {     /** make sure it's not null */
+        pChr = pSvc->getCharacteristic("BEEF");
+    }
+
+    if(pChr) {     /** make sure it's not null */
+        if(pChr->canRead()) {
+            printf("%s Value: %s\n",
+            pChr->getUUID().toString().c_str(),
+            pChr->readValue().c_str());
+        }
+        
+        if(pChr->canWrite()) {
+            if(pChr->writeValue("Tasty")) {
+                printf("Wrote new value to: %s\n", pChr->getUUID().toString().c_str());
+            }
+            else {
+                /** Disconnect if write failed */ 
+                pClient->disconnect();
+                return false;
+            }
+            
+            if(pChr->canRead()) {
+                printf("The value of: %s is now: %s\n",
+                       pChr->getUUID().toString().c_str(),
+                       pChr->readValue().c_str());
+            }
+        }
+        
+        /** registerForNotify() has been deprecated and replaced with subscribe() / unsubscribe().
+         *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=false.
+         *  Unsubscribe parameter defaults are: response=false. 
+         */
+        if(pChr->canNotify()) {
+            //if(!pChr->registerForNotify(notifyCB)) {
+            if(!pChr->subscribe(true, notifyCB)) {
+                /** Disconnect if subscribe failed */ 
+                pClient->disconnect();
+                return false;
+            }
+        }
+        else if(pChr->canIndicate()) {
+            /** Send false as first argument to subscribe to indications instead of notifications */
+            //if(!pChr->registerForNotify(notifyCB, false)) {
+            if(!pChr->subscribe(false, notifyCB)) {
+                /** Disconnect if subscribe failed */ 
+                pClient->disconnect();
+                return false;
+            }
+        }
+    }
+    
+    else{
+        printf("DEAD service not found.\n");
+    }
+    
+    pSvc = pClient->getService("BAAD");
+    if(pSvc) {     /** make sure it's not null */
+        pChr = pSvc->getCharacteristic("F00D");
+    }
+
+    if(pChr) {     /** make sure it's not null */
+        if(pChr->canRead()) {
+            printf("%s Value: %s\n",
+            pChr->getUUID().toString().c_str(),
+            pChr->readValue().c_str());
+        }
+        
+        pDsc = pChr->getDescriptor(NimBLEUUID("C01D"));
+        if(pDsc) {   /** make sure it's not null */
+            printf("Descriptor: %s  Value: %s\n",
+                   pDsc->getUUID().toString().c_str(),
+                   pDsc->readValue().c_str());
+        }
+        
+        if(pChr->canWrite()) {
+            if(pChr->writeValue("No tip!")) {
+                printf("Wrote new value to: %s\n", pChr->getUUID().toString().c_str());
+            }
+            else {
+                /** Disconnect if write failed */ 
+                pClient->disconnect();
+                return false;
+            }
+            
+            if(pChr->canRead()) {
+                printf("The value of: %s is now: %s\n",
+                       pChr->getUUID().toString().c_str(),
+                       pChr->readValue().c_str());
+            }
+        }
+        
+        /** registerForNotify() has been deprecated and replaced with subscribe() / unsubscribe().
+         *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=false.
+         *  Unsubscribe parameter defaults are: response=false. 
+         */
+        if(pChr->canNotify()) {
+            //if(!pChr->registerForNotify(notifyCB)) {
+            if(!pChr->subscribe(true, notifyCB)) {
+                /** Disconnect if subscribe failed */ 
+                pClient->disconnect();
+                return false;
+            }
+        }
+        else if(pChr->canIndicate()) {
+            /** Send false as first argument to subscribe to indications instead of notifications */
+            //if(!pChr->registerForNotify(notifyCB, false)) {
+            if(!pChr->subscribe(false, notifyCB)) {
+                /** Disconnect if subscribe failed */ 
+                pClient->disconnect();
+                return false;
+            }
+        }    
+    }        
+
+    else{
+        printf("BAAD service not found.\n");
+    }
+    
+    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) {
+            doConnect = false;
+            /** Found a device we want to connect to, do it now */
+            if(connectToServer()) {
+                printf("Success! we should now be getting notifications, scanning for more!\n");
+            } else {
+                printf("Failed to connect, starting scan\n");
+            }
+    
+            NimBLEDevice::getScan()->start(scanTime,scanEndedCB);
+        }
+        vTaskDelay(10/portTICK_PERIOD_MS);
+    }
+    
+    vTaskDelete(NULL);
+}
+
+void app_main (void){
+    printf("Starting NimBLE Client\n");
+    /** Initialize NimBLE, no device name spcified as we are not advertising */
+    NimBLEDevice::init("");
+    
+    /** Set the IO capabilities of the device, each option will trigger a different pairing method.
+     *  BLE_HS_IO_KEYBOARD_ONLY    - Passkey pairing
+     *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
+     *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
+     */
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY); // use passkey
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
+  
+    /** 2 different ways to set security - both calls achieve the same result.
+     *  no bonding, no man in the middle protection, secure connections.
+     *     
+     *  These are the default values, only shown here for demonstration.   
+     */ 
+    //NimBLEDevice::setSecurityAuth(false, false, true); 
+    NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/ BLE_SM_PAIR_AUTHREQ_SC);
+  
+    /** Optional: set the transmit power, default is -3db */
+    NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** 12db */
+    
+    /** Optional: set any devices you don't want to get advertisments from */
+    // NimBLEDevice::addIgnored(NimBLEAddress ("aa:bb:cc:dd:ee:ff")); 
+  
+    /** create new scan */  
+    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(400);
+    pScan->setWindow(100);
+    
+    /** 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");
+    
+    xTaskCreate(connectTask, "connectTask", 5000, NULL, 1, NULL);
+}
+

examples/Advanced/NimBLE_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(NimBLE_Server)

examples/Advanced/NimBLE_Server/Makefile

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

examples/Advanced/NimBLE_Server/main/CMakeLists.txt

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

examples/Advanced/NimBLE_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/Advanced/NimBLE_Server/main/main.cpp

@@ -0,0 +1,226 @@
+
+/** NimBLE_Server Demo:
+ *
+ *  Demonstrates many of the available features of the NimBLE server library.
+ *  
+ *  Created: on March 22 2020
+ *      Author: H2zero
+ * 
+*/
+#include "NimBLEDevice.h"
+#include "NimBLELog.h"
+
+#include <stdio.h>
+
+extern "C" {void app_main(void);}
+
+static NimBLEServer* pServer;
+
+/**  None of these are required as they will be handled by the library with defaults. **
+ **                       Remove as you see fit for your needs                        */  
+class ServerCallbacks: public NimBLEServerCallbacks {
+    void onConnect(NimBLEServer* pServer) {
+        printf("Client connected\n");
+        NimBLEDevice::startAdvertising();
+    };
+    /** Alternative onConnect() method to extract details of the connection. 
+     *  See: src/ble_gap.h for the details of the ble_gap_conn_desc struct.
+     */  
+    void onConnect(NimBLEServer* pServer, ble_gap_conn_desc* desc) {
+        printf("Client address: %s\n", NimBLEAddress(desc->peer_ota_addr).toString().c_str());
+        /** We can use the connection handle here to ask for different connection parameters.
+         *  Args: connection handle, min connection interval, max connection interval
+         *  latency, supervision timeout.
+         *  Units; Min/Max Intervals: 1.25 millisecond increments.
+         *  Latency: number of intervals allowed to skip.
+         *  Timeout: 10 millisecond increments, try for 3x interval time for best results.  
+         */
+        pServer->updateConnParams(desc->conn_handle, 24, 48, 0, 18);
+    };
+    void onDisconnect(NimBLEServer* pServer) {
+        printf("Client disconnected - start advertising\n");
+        NimBLEDevice::startAdvertising();
+    };
+    
+/********************* Security handled here **********************
+****** Note: these are the same return values as defaults ********/
+    uint32_t onPassKeyRequest(){
+        printf("Server Passkey Request\n");
+        /** This should return a random 6 digit number for security 
+         *  or make your own static passkey as done here.
+         */
+        return 123456; 
+    };
+
+    bool onConfirmPIN(uint32_t pass_key){
+        printf("The passkey YES/NO number: %d\n", pass_key);
+        /** Return false if passkeys don't match. */
+        return true; 
+    };
+
+    void onAuthenticationComplete(ble_gap_conn_desc* desc){
+        /** Check that encryption was successful, if not we disconnect the client */  
+        if(!desc->sec_state.encrypted) {
+            /** NOTE: createServer returns the current server reference unless one is not already created */
+            NimBLEDevice::createServer()->disconnect(desc->conn_handle);
+            printf("Encrypt connection failed - disconnecting client\n");
+            return;
+        }
+        printf("Starting BLE work!");
+    };
+};
+
+/** Handler class for characteristic actions */
+class CharacteristicCallbacks: public NimBLECharacteristicCallbacks {
+    void onRead(NimBLECharacteristic* pCharacteristic){
+        printf("%s : onRead(), value: %s\n", 
+                            pCharacteristic->getUUID().toString().c_str(),
+                            pCharacteristic->getValue().c_str());
+    };
+
+    void onWrite(NimBLECharacteristic* pCharacteristic) {
+        printf("%s : onWrite(), value: %s\n", 
+                            pCharacteristic->getUUID().toString().c_str(),
+                            pCharacteristic->getValue().c_str());
+    };
+    /** Called before notification or indication is sent, 
+     *  the value can be changed here before sending if desired.
+     */
+    void onNotify(NimBLECharacteristic* pCharacteristic) {
+        printf("Sending notification to clients\n");
+    };
+
+
+    /** The status returned in status is defined in NimBLECharacteristic.h.
+     *  The value returned in code is the NimBLE host return code.
+     */
+    void onStatus(NimBLECharacteristic* pCharacteristic, Status status, int code) {
+        printf("Notification/Indication status code: %d , return code: %d, %s\n",
+                            status,
+                            code,
+                            NimBLEUtils::returnCodeToString(code));
+    };
+};
+    
+/** Handler class for descriptor actions */    
+class DescriptorCallbacks : public NimBLEDescriptorCallbacks {
+    void onWrite(NimBLEDescriptor* pDescriptor) {
+        std::string dscVal((char*)pDescriptor->getValue(), pDescriptor->getLength());
+        printf("Descriptor witten value: %s\n", dscVal.c_str());
+    };
+
+    void onRead(NimBLEDescriptor* pDescriptor) {
+        printf("%s Descriptor read\n", pDescriptor->getUUID().toString().c_str());
+    };;
+};
+
+
+/** Define callback instances globally to use for multiple Charateristics \ Descriptors */ 
+static DescriptorCallbacks dscCallbacks;
+static CharacteristicCallbacks chrCallbacks;
+
+void notifyTask(void * parameter){
+    for(;;) {
+        if(pServer->getConnectedCount()) {
+            NimBLEService* pSvc = pServer->getServiceByUUID("BAAD");
+            if(pSvc) {
+                NimBLECharacteristic* pChr = pSvc->getCharacteristic("F00D");
+                if(pChr) {
+                    pChr->notify(true);
+                }
+            }
+        }
+        vTaskDelay(2000/portTICK_PERIOD_MS);
+    }
+    
+    vTaskDelete(NULL);
+}
+
+void app_main(void) {
+    printf("Starting NimBLE Server\n");
+
+    /** sets device name */
+    NimBLEDevice::init("NimBLE");
+
+    /** Set the IO capabilities of the device, each option will trigger a different pairing method.
+     *  BLE_HS_IO_DISPLAY_ONLY    - Passkey pairing
+     *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
+     *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
+     */
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY); // use passkey
+    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
+
+    /** 2 different ways to set security - both calls achieve the same result.
+     *  no bonding, no man in the middle protection, secure connections.
+     *   
+     *  These are the default values, only shown here for demonstration.   
+     */ 
+    //NimBLEDevice::setSecurityAuth(false, false, true); 
+    NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/ BLE_SM_PAIR_AUTHREQ_SC);
+
+    pServer = NimBLEDevice::createServer();
+    pServer->setCallbacks(new ServerCallbacks());
+
+    NimBLEService* pDeadService = pServer->createService("DEAD");
+    NimBLECharacteristic* pBeefCharacteristic = pDeadService->createCharacteristic(
+                                               "BEEF",
+                                               NIMBLE_PROPERTY::READ |
+                                               NIMBLE_PROPERTY::WRITE |
+                               /** Require a secure connection for read and write access */
+                                               NIMBLE_PROPERTY::READ_ENC |  // only allow reading if paired / encrypted
+                                               NIMBLE_PROPERTY::WRITE_ENC   // only allow writing if paired / encrypted
+                                              );
+  
+    pBeefCharacteristic->setValue("Burger");
+    pBeefCharacteristic->setCallbacks(&chrCallbacks);
+
+    /** 2902 and 2904 descriptors are a special case, when createDescriptor is called with
+     *  either of those uuid's it will create the associated class with the correct properties
+     *  and sizes. However we must cast the returned reference to the correct type as the method
+     *  only returns a pointer to the base NimBLEDescriptor class.
+     */
+    NimBLE2904* pBeef2904 = (NimBLE2904*)pBeefCharacteristic->createDescriptor("2904"); 
+    pBeef2904->setFormat(NimBLE2904::FORMAT_UTF8);
+    pBeef2904->setCallbacks(&dscCallbacks);
+  
+
+    NimBLEService* pBaadService = pServer->createService("BAAD");
+    NimBLECharacteristic* pFoodCharacteristic = pBaadService->createCharacteristic(
+                                               "F00D",
+                                               NIMBLE_PROPERTY::READ |
+                                               NIMBLE_PROPERTY::WRITE |
+                                               NIMBLE_PROPERTY::NOTIFY
+                                              );
+
+    pFoodCharacteristic->setValue("Fries");
+    pFoodCharacteristic->setCallbacks(&chrCallbacks);
+
+    /** Custom descriptor: Arguments are UUID, Properties, max length in bytes of the value */
+    NimBLEDescriptor* pC01Ddsc = pFoodCharacteristic->createDescriptor(
+                                               "C01D",
+                                               NIMBLE_PROPERTY::READ | 
+                                               NIMBLE_PROPERTY::WRITE|
+                                               NIMBLE_PROPERTY::WRITE_ENC, // only allow writing if paired / encrypted
+                                               20
+                                              );
+    pC01Ddsc->setValue("Send it back!");
+    pC01Ddsc->setCallbacks(&dscCallbacks);
+
+    /** Start the services when finished creating all Characteristics and Descriptors */  
+    pDeadService->start();
+    pBaadService->start();
+
+    NimBLEAdvertising* pAdvertising = NimBLEDevice::getAdvertising();
+    /** Add the services to the advertisment data **/
+    pAdvertising->addServiceUUID(pDeadService->getUUID());
+    pAdvertising->addServiceUUID(pBaadService->getUUID());
+    /** If your device is battery powered you may consider setting scan response
+     *  to false as it will extend battery life at the expense of less data sent.
+     */
+    pAdvertising->setScanResponse(true);
+    pAdvertising->start();
+
+    printf("Advertising Started\n");
+    
+    xTaskCreate(notifyTask, "notifyTask", 5000, NULL, 1, NULL);
+}