Jira 671, Support Connection Interval updating.

sgbihu · SidLeung · commit bb5b7b4939e3 · 2017-03-26T21:27:17.000-07:00
Description:

  This feature enables a sketch to change the Connection
Interval, Timeout, and Latency.  The feature is applicable
to both Central and Peripheral mode.  A change in the
interval in the midst of a connection will terminate
the connection.  A re-connection is required.

File mods:

1. BLEDeviceManager.cpp:
   - Application facing Connection Interval updating APIs.
2. BLEDevice.cpp:
   - The execution of the interval changing command.

File addition:

1. connupdateperipheral.ino:
   - A demo sketch to show how a peripheral can change the
     Connection Interval.
diff --git a/libraries/CurieBLE/examples/test/connupdateperipheral/connupdateperipheral.ino b/libraries/CurieBLE/examples/test/connupdateperipheral/connupdateperipheral.ino
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2017 Intel Corporation.  All rights reserved.
+ * See the bottom of this file for the license terms.
+ */
+
+/*
+ * Sketch: connupdateperipheral.ino
+ *
+ * Description:
+ *     This is a Peripheral sketch that is based on the Arduino LED
+ *   control sketch.  The purpose of this sketch is to exercise
+ *   the changing of Connection Interval as a Peripheral.  The Central
+ *   writes to the Characteristic to turn the LED on and off similar
+ *   to the original sketch.  However, when the LED is turned off,
+ *   this sketch will change the connection interval to a new
+ *   value and, thus, forcing a re-connection.
+ *
+ * Notes:
+ *
+ *   - This sketch is based on the Arduino BLE Peripheral LED example.
+ *     Please refer to licensing info at the bottom of this file.
+ */
+
+#include <CurieBLE.h>
+
+// LED pin
+#define LED_PIN   13
+
+// create service
+BLEService               ledService("19b10000e8f2537e4f6cd104768a1214");
+
+// create switch characteristic
+BLECharCharacteristic    switchCharacteristic("19b10001e8f2537e4f6cd104768a1214", BLERead | BLEWrite);
+
+BLEDescriptor            switchDescriptor("2901", "switch");
+
+
+void bleCentralConnectionParameterUpdateHandler(BLEDevice central) {
+  Serial1.println("Updated connection parameter");
+  Serial1.println("-----------------------");
+
+  // print address
+  Serial1.print("Address: ");
+  Serial1.println(central.address());
+
+  Serial1.print("Interval: ");
+  Serial1.println(central.getConnectionInterval());
+  Serial1.print("Timeout: ");
+  Serial1.println(central.getConnectionTimeout());
+  Serial1.print("Latency: ");
+  Serial1.println(central.getConnectionLatency());
+
+  //Serial1.println();
+}
+
+void setup() {
+  Serial.begin(9600);
+  Serial1.begin(115200);
+
+  // set LED pin to output mode
+  pinMode(LED_PIN, OUTPUT);
+
+  // begin initialization
+  BLE.begin();
+  Serial1.println(BLE.address());
+
+  // set advertised local name and service UUID
+  BLE.setLocalName("LED");
+  BLE.setAdvertisedServiceUuid(ledService.uuid());
+
+  switchCharacteristic.addDescriptor(switchDescriptor);
+  ledService.addCharacteristic(switchCharacteristic);
+
+  // add service and characteristic
+  BLE.addService(ledService);
+  
+  //Register callbacks
+  BLE.setEventHandler(BLEConParamUpdate, bleCentralConnectionParameterUpdateHandler);
+
+  BLE.advertise();
+
+  Serial1.println(F("BLE LED Peripheral"));
+}
+
+void loop() {
+  BLEDevice central = BLE.central();
+
+  if (central) {
+    // central connected to peripheral
+    Serial1.print(F("Connected to central: "));
+    Serial1.println(central.address());
+    static int connection_interval = 15;
+
+    while (central.connected()) {
+      // central still connected to peripheral
+      if (switchCharacteristic.written()) {
+        // central wrote new value to characteristic, update LED
+        if (switchCharacteristic.value()) {
+          Serial1.println(F("LED on"));
+          digitalWrite(LED_PIN, HIGH);
+          connection_interval++;
+        } else {
+          Serial1.println(F("LED off"));
+          digitalWrite(LED_PIN, LOW);
+          delay(100);
+          // The peripheral update the connection interval
+          //  If want central update the connection interval
+          //  comment the below line
+          central.setConnectionInterval(connection_interval, connection_interval);
+        }
+      }
+    }
+
+    // central disconnected
+    Serial1.print(F("Disconnected from central: "));
+    Serial1.println(central.address());
+  }
+}
+
+/*
+  Arduino BLE Peripheral LED example
+  Copyright (c) 2016 Arduino LLC. All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
diff --git a/libraries/CurieBLE/src/BLEDevice.cpp b/libraries/CurieBLE/src/BLEDevice.cpp
@@ -19,6 +19,8 @@
 #include "CurieBLE.h"
 #include "BLEDevice.h"
 
+#include "./internal/ble_client.h"
+
 #include "./internal/BLEUtils.h"
 
 #include "./internal/BLEProfileManager.h"
@@ -51,6 +53,7 @@ BLEDevice::BLEDevice(const bt_addr_le_t* bleaddress):
     BLEDevice()
 {
     memcpy(&_bt_addr, bleaddress, sizeof(_bt_addr));
+    BLEDeviceManager::instance()->getConnectionInterval(this, &_conn_param);
 }
 
 BLEDevice::BLEDevice(const BLEDevice* bledevice)
@@ -154,11 +157,54 @@ void BLEDevice::setAdvertisingInterval(float advertisingInterval)
     BLEDeviceManager::instance()->setAdvertisingInterval(advertisingInterval);
 }
 
+void BLEDevice::setConnectionInterval(int minInterval, 
+                                      int maxInterval,
+                                      uint16_t latency,
+                                      uint16_t timeout)
+{
+    uint16_t minVal = (uint16_t)MSEC_TO_UNITS(minInterval, UNIT_1_25_MS);
+    uint16_t maxVal = (uint16_t)MSEC_TO_UNITS(maxInterval, UNIT_1_25_MS);
+    uint16_t timeoutVal = MSEC_TO_UNITS(timeout, UNIT_10_MS);
+    _conn_param.interval_min = minVal;
+    _conn_param.interval_max = maxVal;
+    _conn_param.timeout = timeoutVal;
+    _conn_param.latency = latency;
+    BLEDeviceManager::instance()->setConnectionInterval(this);
+}
+
 void BLEDevice::setConnectionInterval(int minimumConnectionInterval, 
                                       int maximumConnectionInterval)
 {
-    // TODO: Update the connection interval need more discussion
+    uint16_t minVal = (uint16_t)MSEC_TO_UNITS(minimumConnectionInterval, UNIT_1_25_MS);
+    uint16_t maxVal = (uint16_t)MSEC_TO_UNITS(maximumConnectionInterval, UNIT_1_25_MS);
+    _conn_param.interval_min = minVal;
+    _conn_param.interval_max = maxVal;
+    
+    BLEDeviceManager::instance()->setConnectionInterval(this);
+}
+
+int BLEDevice::getConnectionInterval()
+{
+    bt_le_conn_param_t conn_param;
+    
+    BLEDeviceManager::instance()->getConnectionInterval(this, &conn_param);
+    return UNITS_TO_MSEC((int)conn_param.interval_max, UNIT_1_25_MS);
+}
+
+int BLEDevice::getConnectionTimeout()
+{
+    bt_le_conn_param_t conn_param;
+    
+    BLEDeviceManager::instance()->getConnectionInterval(this, &conn_param);
+    return UNITS_TO_MSEC(conn_param.timeout, UNIT_10_MS);;
+}
 
+int BLEDevice::getConnectionLatency()
+{
+    bt_le_conn_param_t conn_param;
+    
+    BLEDeviceManager::instance()->getConnectionInterval(this, &conn_param);
+    return conn_param.latency;
 }
 
 bool BLEDevice::setTxPower(int txPower)
diff --git a/libraries/CurieBLE/src/BLEDevice.h b/libraries/CurieBLE/src/BLEDevice.h
@@ -232,10 +232,10 @@ class BLEDevice
      *
      * @note  none
      */
-    //void setConnectionInterval(int minimumConnectionInterval, 
-    //                           int maximumConnectionInterval,
-    //                           uint16_t latency, 
-    //                           uint16_t timeout);
+     void setConnectionInterval(int minimumConnectionInterval, 
+                                int maximumConnectionInterval,
+                                uint16_t latency, 
+                                uint16_t timeout);
     
     /**
      * @brief   Set the min and max connection interval and send connection 
@@ -252,6 +252,10 @@ class BLEDevice
     void setConnectionInterval(int minimumConnectionInterval, 
                                int maximumConnectionInterval);
     
+    int getConnectionInterval();
+    int getConnectionTimeout();
+    int getConnectionLatency();
+    
     /**
      * @brief   Set TX power of the radio in dBM
      *
@@ -689,7 +693,7 @@ class BLEDevice
 private:
     bt_addr_le_t _bt_addr;
     
-    bt_le_conn_param _conn_param;
+    bt_le_conn_param_t _conn_param;
 };
 
 #endif
diff --git a/libraries/CurieBLE/src/internal/BLEDeviceManager.cpp b/libraries/CurieBLE/src/internal/BLEDeviceManager.cpp
@@ -283,17 +283,31 @@ void BLEDeviceManager::setAdvertisingInterval(float advertisingInterval)
     _adv_param.interval_max = interval;
 }
 
-void BLEDeviceManager::setConnectionInterval(float minimumConnectionInterval, 
-                                      float maximumConnectionInterval,
-                                      uint16_t latency, 
-                                      uint16_t timeout)
+void BLEDeviceManager::getConnectionInterval(BLEDevice *device, 
+                                             bt_le_conn_param* conn_param)
 {
+    bt_conn_t* conn = bt_conn_lookup_addr_le(device->bt_le_address());
+    if (NULL != conn)
+    {
+        conn_param->interval_max = conn->le.interval;
+        conn_param->interval_min = conn->le.interval;
+        conn_param->latency = conn->le.latency;
+        conn_param->timeout = conn->le.timeout;
+        bt_conn_unref(conn);
+    }
 }
 
-void BLEDeviceManager::setConnectionInterval(float minimumConnectionInterval, 
-                                             float maximumConnectionInterval)
+int BLEDeviceManager::setConnectionInterval(BLEDevice *device)
 {
-    
+    bt_conn_t* conn = bt_conn_lookup_addr_le(device->bt_le_address());
+    int ret = 0;
+    if (NULL != conn)
+    {
+        ret = bt_conn_le_param_update(conn, device->bt_conn_param());
+        pr_debug(LOG_MODULE_BLE, "%s-ret:%d",__FUNCTION__, ret);
+        bt_conn_unref(conn);
+    }
+    return ret;
 }
 
 bool BLEDeviceManager::setTxPower(int txPower)
diff --git a/libraries/CurieBLE/src/internal/BLEDeviceManager.h b/libraries/CurieBLE/src/internal/BLEDeviceManager.h
@@ -181,26 +181,9 @@ class BLEDeviceManager
      *
      * @note  none
      */
-    void setConnectionInterval(float minimumConnectionInterval, 
-                               float maximumConnectionInterval,
-                               uint16_t latency, 
-                               uint16_t timeout);
-    
-    /**
-     * @brief   Set the min and max connection interval and send connection 
-     *           update request in both BLE peripheral and central
-     *
-     * @param[in]   intervalmin     Minimum Connection Interval (ms)
-     *
-     * @param[in]   intervalmax     Maximum Connection Interval (ms)
-     *
-     * @return  none
-     *
-     * @note  none
-     */
-    void setConnectionInterval(float minimumConnectionInterval, 
-                               float maximumConnectionInterval);
-    
+    int setConnectionInterval (BLEDevice *device);
+    void getConnectionInterval(BLEDevice *device, 
+                               bt_le_conn_param* conn_param);
     /**
      * @brief   Set TX power of the radio in dBM
      *
