Commit for 0.4.10

13 files changed, 204 insertions, 36 deletions

diff --git a/README.md b/README.md
index d7bcf50..e80fbe0 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # ESP32 BLE for Arduino
-The Arduino IDE provides an excellent library package managed where versions of libraries can be downloaded and installed.  This Github project provides the repository for the ESP32 BLE support for Arduino.
+The Arduino IDE provides an excellent library package manager where versions of libraries can be downloaded and installed.  This Github project provides the repository for the ESP32 BLE support for Arduino.
 
 The actual source of the project which is being maintained can be found here:
 
diff --git a/examples/BLE_iBeacon/BLE_iBeacon.ino b/examples/BLE_iBeacon/BLE_iBeacon.ino
new file mode 100644
index 0000000..5f6ed00
--- /dev/null
+++ b/examples/BLE_iBeacon/BLE_iBeacon.ino
@@ -0,0 +1,104 @@
+/*
+   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
+   Ported to Arduino ESP32 by pcbreflux
+*/
+
+ 
+/*
+   Create a BLE server that will send periodic iBeacon frames.
+   The design of creating the BLE server is:
+   1. Create a BLE Server
+   2. Create advertising data
+   3. Start advertising.
+   4. wait
+   5. Stop advertising.
+   6. deep sleep
+   
+*/
+#include "sys/time.h"
+
+#include "BLEDevice.h"
+#include "BLEServer.h"
+#include "BLEUtils.h"
+#include "BLEBeacon.h"
+#include "esp_sleep.h"
+
+#define GPIO_DEEP_SLEEP_DURATION     10  // sleep x seconds and then wake up
+RTC_DATA_ATTR static time_t last;        // remember last boot in RTC Memory
+RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint8_t temprature_sens_read();
+//uint8_t g_phyFuns;
+
+#ifdef __cplusplus
+}
+#endif
+
+// See the following for generating UUIDs:
+// https://www.uuidgenerator.net/
+BLEAdvertising *pAdvertising;
+struct timeval now;
+
+#define BEACON_UUID           "8ec76ea3-6668-48da-9866-75be8bc86f4d" // UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)
+
+void setBeacon() {
+
+  BLEBeacon oBeacon = BLEBeacon();
+  oBeacon.setManufacturerId(0x4C00); // fake Apple 0x004C LSB (ENDIAN_CHANGE_U16!)
+  oBeacon.setProximityUUID(BLEUUID(BEACON_UUID));
+  oBeacon.setMajor((bootcount & 0xFFFF0000) >> 16);
+  oBeacon.setMinor(bootcount&0xFFFF);
+  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
+  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
+  
+  oAdvertisementData.setFlags(0x04); // BR_EDR_NOT_SUPPORTED 0x04
+  
+  std::string strServiceData = "";
+  
+  strServiceData += (char)26;     // Len
+  strServiceData += (char)0xFF;   // Type
+  strServiceData += oBeacon.getData(); 
+  oAdvertisementData.addData(strServiceData);
+  
+  pAdvertising->setAdvertisementData(oAdvertisementData);
+  pAdvertising->setScanResponseData(oScanResponseData);
+
+}
+
+void setup() {
+
+    
+  Serial.begin(115200);
+  gettimeofday(&now, NULL);
+
+  Serial.printf("start ESP32 %d\n",bootcount++);
+
+  Serial.printf("deep sleep (%lds since last reset, %lds since last boot)\n",now.tv_sec,now.tv_sec-last);
+
+  last = now.tv_sec;
+  
+  // Create the BLE Device
+  BLEDevice::init("");
+
+  // Create the BLE Server
+  BLEServer *pServer = BLEDevice::createServer();
+
+  pAdvertising = pServer->getAdvertising();
+  
+  setBeacon();
+   // Start advertising
+  pAdvertising->start();
+  Serial.println("Advertizing started...");
+  delay(100);
+  pAdvertising->stop();
+  Serial.printf("enter deep sleep\n");
+  esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
+  Serial.printf("in deep sleep\n");
+}
+
+void loop() {
+}
diff --git a/examples/BLE_notify/BLE_notify.ino b/examples/BLE_notify/BLE_notify.ino
index 8d329c2..57ad7a7 100644
--- a/examples/BLE_notify/BLE_notify.ino
+++ b/examples/BLE_notify/BLE_notify.ino
@@ -23,8 +23,9 @@
 #include <BLEUtils.h>
 #include <BLE2902.h>
 
-BLECharacteristic *pCharacteristic;
+BLEServer *pServer = NULL;
 bool deviceConnected = false;
+bool oldDeviceConnected = false;
 uint8_t value = 0;
 
 // See the following for generating UUIDs:
@@ -53,14 +54,14 @@ void setup() {
   BLEDevice::init("MyESP32");
 
   // Create the BLE Server
-  BLEServer *pServer = BLEDevice::createServer();
+  pServer = BLEDevice::createServer();
   pServer->setCallbacks(new MyServerCallbacks());
 
   // Create the BLE Service
   BLEService *pService = pServer->createService(SERVICE_UUID);
 
   // Create a BLE Characteristic
-  pCharacteristic = pService->createCharacteristic(
+  BLECharacteristic * pCharacteristic = pService->createCharacteristic(
                       CHARACTERISTIC_UUID,
                       BLECharacteristic::PROPERTY_READ   |
                       BLECharacteristic::PROPERTY_WRITE  |
@@ -81,13 +82,23 @@ void setup() {
 }
 
 void loop() {
-
-  if (deviceConnected) {
-    Serial.printf("*** NOTIFY: %d ***\n", value);
-    pCharacteristic->setValue(&value, 1);
-    pCharacteristic->notify();
-    //pCharacteristic->indicate();
-    value++;
-  }
-  delay(2000);
+    // notify changed value
+    if (deviceConnected) {
+        pCharacteristic->setValue(&value, 1);
+        pCharacteristic->notify();
+        value++;
+        delay(10); // bluetooth stack will go into congestion, if too many packets are sent
+    }
+    // disconnecting
+    if (!deviceConnected && oldDeviceConnected) {
+        delay(500); // give the bluetooth stack the chance to get things ready
+        pServer->startAdvertising(); // restart advertising
+        Serial.println("start advertising");
+        oldDeviceConnected = deviceConnected;
+    }
+    // connecting
+    if (deviceConnected && !oldDeviceConnected) {
+        // do stuff here on connecting
+        oldDeviceConnected = deviceConnected;
+    }
 }
\ No newline at end of file
diff --git a/examples/BLE_uart/BLE_uart.ino b/examples/BLE_uart/BLE_uart.ino
index a348a66..35b570b 100644
--- a/examples/BLE_uart/BLE_uart.ino
+++ b/examples/BLE_uart/BLE_uart.ino
@@ -24,8 +24,10 @@
 #include <BLEUtils.h>
 #include <BLE2902.h>
 
-BLECharacteristic *pCharacteristic;
+BLEServer *pServer = NULL;
+BLECharacteristic * pTxCharacteristic;
 bool deviceConnected = false;
+bool oldDeviceConnected = false;
 uint8_t txValue = 0;
 
 // See the following for generating UUIDs:
@@ -70,26 +72,26 @@ void setup() {
   BLEDevice::init("UART Service");
 
   // Create the BLE Server
-  BLEServer *pServer = BLEDevice::createServer();
+  pServer = BLEDevice::createServer();
   pServer->setCallbacks(new MyServerCallbacks());
 
   // Create the BLE Service
   BLEService *pService = pServer->createService(SERVICE_UUID);
 
   // Create a BLE Characteristic
-  pCharacteristic = pService->createCharacteristic(
-                      CHARACTERISTIC_UUID_TX,
-                      BLECharacteristic::PROPERTY_NOTIFY
-                    );
+  pTxCharacteristic = pService->createCharacteristic(
+										CHARACTERISTIC_UUID_TX,
+										BLECharacteristic::PROPERTY_NOTIFY
+									);
                       
-  pCharacteristic->addDescriptor(new BLE2902());
+  pTxCharacteristic->addDescriptor(new BLE2902());
 
-  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
-                                         CHARACTERISTIC_UUID_RX,
-                                         BLECharacteristic::PROPERTY_WRITE
-                                       );
+  BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
+											 CHARACTERISTIC_UUID_RX,
+											BLECharacteristic::PROPERTY_WRITE
+										);
 
-  pCharacteristic->setCallbacks(new MyCallbacks());
+  pRxCharacteristic->setCallbacks(new MyCallbacks());
 
   // Start the service
   pService->start();
@@ -101,11 +103,23 @@ void setup() {
 
 void loop() {
 
-  if (deviceConnected) {
-    Serial.printf("*** Sent Value: %d ***\n", txValue);
-    pCharacteristic->setValue(&txValue, 1);
-    pCharacteristic->notify();
-    txValue++;
-  }
-  delay(1000);
+    if (deviceConnected) {
+        pTxCharacteristic->setValue(&txValue, 1);
+        pTxCharacteristic->notify();
+        txValue++;
+		delay(10); // bluetooth stack will go into congestion, if too many packets are sent
+	}
+
+    // disconnecting
+    if (!deviceConnected && oldDeviceConnected) {
+        delay(500); // give the bluetooth stack the chance to get things ready
+        pServer->startAdvertising(); // restart advertising
+        Serial.println("start advertising");
+        oldDeviceConnected = deviceConnected;
+    }
+    // connecting
+    if (deviceConnected && !oldDeviceConnected) {
+		// do stuff here on connecting
+        oldDeviceConnected = deviceConnected;
+    }
 }
diff --git a/library.properties b/library.properties
index fabbf2e..bd9e0f1 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=ESP32 BLE Arduino
-version=0.4.9
+version=0.4.10
 author=Neil Kolban <kolban1@kolban.com>
 maintainer=Neil Kolban <kolban1@kolban.com>
 sentence=BLE functions for ESP32
diff --git a/src/BLEAdvertising.cpp b/src/BLEAdvertising.cpp
index 9e01ab7..4b3cb8d 100644
--- a/src/BLEAdvertising.cpp
+++ b/src/BLEAdvertising.cpp
@@ -91,6 +91,16 @@ void BLEAdvertising::setAppearance(uint16_t appearance) {
 	m_advData.appearance = appearance;
 } // setAppearance
 
+void BLEAdvertising::setMinInterval(uint16_t mininterval) {
+	m_advData.min_interval = mininterval;
+	m_advParams.adv_int_min = mininterval;
+} // setMinInterval
+
+void BLEAdvertising::setMaxInterval(uint16_t maxinterval) {
+	m_advData.max_interval = maxinterval;
+	m_advParams.adv_int_max = maxinterval;
+} // setMaxInterval
+
 
 /**
  * @brief Set the filtering for the scan filter.
diff --git a/src/BLEAdvertising.h b/src/BLEAdvertising.h
index 003ad1a..d1fa3c7 100644
--- a/src/BLEAdvertising.h
+++ b/src/BLEAdvertising.h
@@ -52,6 +52,8 @@ public:
 	void start();
 	void stop();
 	void setAppearance(uint16_t appearance);
+	void setMaxInterval(uint16_t maxinterval);
+	void setMinInterval(uint16_t mininterval);
 	void setAdvertisementData(BLEAdvertisementData& advertisementData);
 	void setScanFilter(bool scanRequertWhitelistOnly, bool connectWhitelistOnly);
 	void setScanResponseData(BLEAdvertisementData& advertisementData);
diff --git a/src/BLEClient.cpp b/src/BLEClient.cpp
index 55af054..57ff4d2 100644
--- a/src/BLEClient.cpp
+++ b/src/BLEClient.cpp
@@ -110,6 +110,7 @@ bool BLEClient::connect(BLEAddress address) {
 	errRc = ::esp_ble_gattc_open(
 		getGattcIf(),
 		*getPeerAddress().getNative(), // address
+		BLE_ADDR_TYPE_PUBLIC,          // Note: This was added on 2018-04-03 when the latest ESP-IDF was detected to have changed the signature.
 		1                              // direct connection
 	);
 	if (errRc != ESP_OK) {
diff --git a/src/BLEDescriptor.cpp b/src/BLEDescriptor.cpp
index 1a72ef3..58ff78b 100644
--- a/src/BLEDescriptor.cpp
+++ b/src/BLEDescriptor.cpp
@@ -155,7 +155,7 @@ void BLEDescriptor::handleGATTServerEvent(
 					(uint32_t)m_pCharacteristic->getService()->getLastCreatedCharacteristic());
 					*/
 			if (m_pCharacteristic != nullptr &&
-					m_bleUUID.equals(BLEUUID(param->add_char_descr.char_uuid)) &&
+					m_bleUUID.equals(BLEUUID(param->add_char_descr.descr_uuid)) &&
 					m_pCharacteristic->getService()->getHandle() == param->add_char_descr.service_handle &&
 					m_pCharacteristic == m_pCharacteristic->getService()->getLastCreatedCharacteristic()) {
 				setHandle(param->add_char_descr.attr_handle);
diff --git a/src/BLEDevice.cpp b/src/BLEDevice.cpp
index b333ed7..1c6e6bb 100644
--- a/src/BLEDevice.cpp
+++ b/src/BLEDevice.cpp
@@ -99,9 +99,11 @@ uint16_t   BLEDevice::m_localMTU = 23;
 	switch(event) {
 		case ESP_GATTS_CONNECT_EVT: {
 			BLEDevice::m_localMTU = 23;
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			if(BLEDevice::m_securityLevel){
 				esp_ble_set_encryption(param->connect.remote_bda, BLEDevice::m_securityLevel);
 			}
+#endif	// CONFIG_BLE_SMP_ENABLE
 			break;
 		} // ESP_GATTS_CONNECT_EVT
 
@@ -148,9 +150,11 @@ uint16_t   BLEDevice::m_localMTU = 23;
 					ESP_LOGE(LOG_TAG, "esp_ble_gattc_send_mtu_req: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 				}
 			}
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			if(BLEDevice::m_securityLevel){
 				esp_ble_set_encryption(param->connect.remote_bda, BLEDevice::m_securityLevel);
 			}
+#endif	// CONFIG_BLE_SMP_ENABLE
 			break;
 		} // ESP_GATTC_CONNECT_EVT
 
@@ -190,16 +194,20 @@ uint16_t   BLEDevice::m_localMTU = 23;
 			 break;
 		 case ESP_GAP_BLE_NC_REQ_EVT:
 			 ESP_LOGI(LOG_TAG, "ESP_GAP_BLE_NC_REQ_EVT");
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			if(BLEDevice::m_securityCallbacks!=nullptr){
 			 	 esp_ble_confirm_reply(param->ble_security.ble_req.bd_addr, BLEDevice::m_securityCallbacks->onConfirmPIN(param->ble_security.key_notif.passkey));
 			}
+#endif	// CONFIG_BLE_SMP_ENABLE
 			 break;
 		 case ESP_GAP_BLE_PASSKEY_REQ_EVT:                           /* passkey request event */
 			ESP_LOGI(LOG_TAG, "ESP_GAP_BLE_PASSKEY_REQ_EVT: ");
 			// esp_log_buffer_hex(LOG_TAG, m_remote_bda, sizeof(m_remote_bda));
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			if(BLEDevice::m_securityCallbacks!=nullptr){
 				esp_ble_passkey_reply(param->ble_security.ble_req.bd_addr, true, BLEDevice::m_securityCallbacks->onPassKeyRequest());
 			}
+#endif	// CONFIG_BLE_SMP_ENABLE
 			break;
 			/*
 			 * TODO should we add white/black list comparison?
@@ -208,12 +216,14 @@ uint16_t   BLEDevice::m_localMTU = 23;
 			 /* send the positive(true) security response to the peer device to accept the security request.
 			 If not accept the security request, should sent the security response with negative(false) accept value*/
 			 ESP_LOGI(LOG_TAG, "ESP_GAP_BLE_SEC_REQ_EVT");
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			if(BLEDevice::m_securityCallbacks!=nullptr){
 				esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, BLEDevice::m_securityCallbacks->onSecurityRequest());
 			}
 			else{
 				esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true);
 			}
+#endif	// CONFIG_BLE_SMP_ENABLE
 			break;
 			 /*
 			  *
@@ -221,19 +231,27 @@ uint16_t   BLEDevice::m_localMTU = 23;
 		 case ESP_GAP_BLE_PASSKEY_NOTIF_EVT:  ///the app will receive this evt when the IO  has Output capability and the peer device IO has Input capability.
 			 ///show the passkey number to the user to input it in the peer deivce.
 			 ESP_LOGI(LOG_TAG, "ESP_GAP_BLE_PASSKEY_NOTIF_EVT");
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			if(BLEDevice::m_securityCallbacks!=nullptr){
 				ESP_LOGI(LOG_TAG, "passKey = %d", param->ble_security.key_notif.passkey);
 				BLEDevice::m_securityCallbacks->onPassKeyNotify(param->ble_security.key_notif.passkey);
 			}
+#endif	// CONFIG_BLE_SMP_ENABLE
 			 break;
 		 case ESP_GAP_BLE_KEY_EVT:
 			 //shows the ble key type info share with peer device to the user.
+			 ESP_LOGI(LOG_TAG, "ESP_GAP_BLE_KEY_EVT");
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			 ESP_LOGI(LOG_TAG, "key type = %s", BLESecurity::esp_key_type_to_str(param->ble_security.ble_key.key_type));
+#endif	// CONFIG_BLE_SMP_ENABLE
 			 break;
 		 case ESP_GAP_BLE_AUTH_CMPL_EVT:
+			 ESP_LOGI(LOG_TAG, "ESP_GAP_BLE_AUTH_CMPL_EVT");
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 			 if(BLEDevice::m_securityCallbacks!=nullptr){
 				 BLEDevice::m_securityCallbacks->onAuthenticationComplete(param->ble_security.auth_cmpl);
 			 }
+#endif	// CONFIG_BLE_SMP_ENABLE
 			 break;
 		default: {
 			break;
@@ -382,12 +400,14 @@ uint16_t   BLEDevice::m_localMTU = 23;
 			return;
 		};
 
+#ifdef CONFIG_BLE_SMP_ENABLE   // Check that BLE SMP (security) is configured in make menuconfig
 		esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE;
 		errRc = ::esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t));
 		if (errRc != ESP_OK) {
 			ESP_LOGE(LOG_TAG, "esp_ble_gap_set_security_param: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 			return;
 		};
+#endif // CONFIG_BLE_SMP_ENABLE
 	}
 	vTaskDelay(200/portTICK_PERIOD_MS); // Delay for 200 msecs as a workaround to an apparent Arduino environment issue.
 } // init
@@ -507,4 +527,8 @@ esp_err_t BLEDevice::setMTU(uint16_t mtu) {
 uint16_t BLEDevice::getMTU() {
 	return m_localMTU;
 }
+
+bool BLEDevice::getInitialized() {
+	return initialized;
+}
 #endif // CONFIG_BT_ENABLED
diff --git a/src/BLEDevice.h b/src/BLEDevice.h
index 7f33143..7a1b833 100644
--- a/src/BLEDevice.h
+++ b/src/BLEDevice.h
@@ -42,6 +42,7 @@ public:
 	static void		   setSecurityCallbacks(BLESecurityCallbacks* pCallbacks);
 	static esp_err_t   setMTU(uint16_t mtu);
 	static uint16_t	   getMTU();
+	static bool        getInitialized(); // Returns the state of the device, is it initialized or not?
 
 private:
 	static BLEServer *m_pServer;
diff --git a/src/BLEService.cpp b/src/BLEService.cpp
index 32bcc57..4e59c4a 100644
--- a/src/BLEService.cpp
+++ b/src/BLEService.cpp
@@ -72,6 +72,7 @@ void BLEService::executeCreate(BLEServer *pServer) {
 	m_semaphoreCreateEvt.take("executeCreate"); // Take the mutex and release at event ESP_GATTS_CREATE_EVT
 
 	esp_gatt_srvc_id_t srvc_id;
+	srvc_id.is_primary = true;
 	srvc_id.id.inst_id = 0;
 	srvc_id.id.uuid    = *m_uuid.getNative();
 	esp_err_t errRc = ::esp_ble_gatts_create_service(
@@ -192,7 +193,7 @@ void BLEService::addCharacteristic(BLECharacteristic* pCharacteristic) {
 
 	// Check that we don't add the same characteristic twice.
 	if (m_characteristicMap.getByUUID(pCharacteristic->getUUID()) != nullptr) {
-		ESP_LOGE(LOG_TAG, "<< Attempt to add a characteristic but we already have one with this UUID");
+		ESP_LOGW(LOG_TAG, "<< Adding a new characteristic with the same UUID as a previous one");
 		//return;
 	}
 
diff --git a/src/BLEUtils.cpp b/src/BLEUtils.cpp
index ff4ebfa..a33ee27 100644
--- a/src/BLEUtils.cpp
+++ b/src/BLEUtils.cpp
@@ -1654,7 +1654,7 @@ void BLEUtils::dumpGattServerEvent(
 				evtParam->add_char_descr.attr_handle,
 				evtParam->add_char_descr.service_handle,
 				evtParam->add_char_descr.service_handle,
-				BLEUUID(evtParam->add_char_descr.char_uuid).toString().c_str());
+				BLEUUID(evtParam->add_char_descr.descr_uuid).toString().c_str());
 			break;
 		} // ESP_GATTS_ADD_CHAR_DESCR_EVT