Implement supervision timeout setting for peripherals (arduino-libraries#101)

Peripherals having the supervision timeout set will execute a parameter update request when some central tries to connect to them.
Allowed supervisionTimeout value range: 0x000A to 0x0C80
Actual Timeout: (supervisionTimeout * 10 ms)
Warning: supervision timeout in milliseconds shall be larger than : (1 + Connection_Latency) * Connection_Interval_Max * 2, where Connection_Interval_Max is given in milliseconds.

Example scenario:
- peripheral has supervision timeout set to 1000 -> (actual timeout = 1000 * 10ms)
- central connects to the peripheral with a supervision timeout of 200.
- peripheral execute a parameter update request, putting supervision timeout at 1000.
- central eventually updates the connection parameters accordingly and sends a response containing the result of the update.

Author: Paolo Calao

src/local/BLELocalDevice.cpp

@@ -323,6 +323,11 @@ void BLELocalDevice::setConnectionInterval(uint16_t minimumConnectionInterval, u
   L2CAPSignaling.setConnectionInterval(minimumConnectionInterval, maximumConnectionInterval);
 }
 
+void BLELocalDevice::setSupervisionTimeout(uint16_t supervisionTimeout)
+{
+  L2CAPSignaling.setSupervisionTimeout(supervisionTimeout);
+}
+
 void BLELocalDevice::setConnectable(bool connectable)
 {
   GAP.setConnectable(connectable);

src/local/BLELocalDevice.h

@@ -69,6 +69,11 @@ class BLELocalDevice {
   virtual BLEDevice central();
   virtual BLEDevice available();
 
+  virtual void setAdvertisingInterval(uint16_t advertisingInterval);
+  virtual void setConnectionInterval(uint16_t minimumConnectionInterval, uint16_t maximumConnectionInterval);
+  virtual void setSupervisionTimeout(uint16_t supervisionTimeout);
+  virtual void setConnectable(bool connectable); 
+
   virtual void setEventHandler(BLEDeviceEvent event, BLEDeviceEventHandler eventHandler);
 
   virtual void setAdvertisingInterval(uint16_t advertisingInterval);

src/utility/L2CAPSignaling.cpp

@@ -26,7 +26,8 @@
 
 L2CAPSignalingClass::L2CAPSignalingClass() :
   _minInterval(0),
-  _maxInterval(0)
+  _maxInterval(0),
+  _supervisionTimeout(0)
 {
 }
 
@@ -36,36 +37,46 @@ L2CAPSignalingClass::~L2CAPSignalingClass()
 
 void L2CAPSignalingClass::addConnection(uint16_t handle, uint8_t role, uint8_t /*peerBdaddrType*/,
                                         uint8_t /*peerBdaddr*/[6], uint16_t interval,
-                                        uint16_t /*latency*/, uint16_t /*supervisionTimeout*/,
+                                        uint16_t /*latency*/, uint16_t supervisionTimeout,
                                         uint8_t /*masterClockAccuracy*/)
 {
   if (role != 1) {
     // ignore
     return;
   }
 
-  if (!_minInterval || !_maxInterval) {
-    // no connection intervale to request
-    return;
-  }
+  bool updateParameters = false;
+  uint16_t updatedMinInterval = interval;
+  uint16_t updatedMaxInterval = interval;
+  uint16_t updatedSupervisionTimeout = supervisionTimeout;
 
-  if (interval >= _minInterval && interval <= _maxInterval) {
-    // all good, within interval range
-    return;
+  if (_minInterval && _maxInterval) {
+    if (interval < _minInterval || interval > _maxInterval) {
+      updatedMinInterval = _minInterval;
+      updatedMaxInterval = _maxInterval;
+      updateParameters = true;
+    }
   }
 
-  struct __attribute__ ((packed)) L2CAPConnectionParameterUpdateRequest {
-    uint8_t code;
-    uint8_t identifier;
-    uint16_t length;
-    uint16_t minInterval;
-    uint16_t maxInterval;
-    uint16_t latency;
-    uint16_t supervisionTimeout;
-  } request = { CONNECTION_PARAMETER_UPDATE_REQUEST, 0x01, 8,
-                _minInterval, _maxInterval, 0x0000, 0x00c8 };
+  if (_supervisionTimeout && supervisionTimeout != _supervisionTimeout) {
+    updatedSupervisionTimeout = _supervisionTimeout;
+    updateParameters = true;
+  }
 
-  HCI.sendAclPkt(handle, SIGNALING_CID, sizeof(request), &request);
+  if (updateParameters) {
+    struct __attribute__ ((packed)) L2CAPConnectionParameterUpdateRequest {
+      uint8_t code;
+      uint8_t identifier;
+      uint16_t length;
+      uint16_t minInterval;
+      uint16_t maxInterval;
+      uint16_t latency;
+      uint16_t supervisionTimeout;
+    } request = { CONNECTION_PARAMETER_UPDATE_REQUEST, 0x01, 8,
+                  updatedMinInterval, updatedMaxInterval, 0x0000, updatedSupervisionTimeout };
+
+    HCI.sendAclPkt(handle, SIGNALING_CID, sizeof(request), &request);
+  }
 }
 
 void L2CAPSignalingClass::handleData(uint16_t connectionHandle, uint8_t dlen, uint8_t data[])
@@ -108,6 +119,11 @@ void L2CAPSignalingClass::setConnectionInterval(uint16_t minInterval, uint16_t m
   _maxInterval = maxInterval;
 }
 
+void L2CAPSignalingClass::setSupervisionTimeout(uint16_t supervisionTimeout)
+{
+  _supervisionTimeout = supervisionTimeout;
+}
+
 void L2CAPSignalingClass::connectionParameterUpdateRequest(uint16_t handle, uint8_t identifier, uint8_t dlen, uint8_t data[])
 {
   struct __attribute__ ((packed)) L2CAPConnectionParameterUpdateRequest {
@@ -135,6 +151,12 @@ void L2CAPSignalingClass::connectionParameterUpdateRequest(uint16_t handle, uint
     }
   }
 
+  if  (_supervisionTimeout) {
+    if (request->supervisionTimeout != _supervisionTimeout) {
+      response.value = 0x0001; // reject
+    }
+  }
+
   HCI.sendAclPkt(handle, SIGNALING_CID, sizeof(response), &response);
 
   if (response.value == 0x0000) {

src/utility/L2CAPSignaling.h

@@ -40,13 +40,16 @@ class L2CAPSignalingClass {
 
   virtual void setConnectionInterval(uint16_t minInterval, uint16_t maxInterval);
 
+  virtual void setSupervisionTimeout(uint16_t supervisionTimeout);
+
 private:
   virtual void connectionParameterUpdateRequest(uint16_t handle, uint8_t identifier, uint8_t dlen, uint8_t data[]);
   virtual void connectionParameterUpdateResponse(uint16_t handle, uint8_t identifier, uint8_t dlen, uint8_t data[]);
 
 private:
   uint16_t _minInterval;
   uint16_t _maxInterval;
+  uint16_t _supervisionTimeout;
 };
 
 extern L2CAPSignalingClass& L2CAPSignaling;