Unify the advertising interval unit

1. Update the interval unit as millisecon.
2. Update the comments and API

Fix build error

Author: sgbihu

libraries/CurieBLE/src/BLECentral.cpp

@@ -20,6 +20,7 @@
 #include "BLECentralRole.h"
 
 #include "BLECentral.h"
+#include "internal/ble_client.h"
 
 bool BLECentral::startScan()
 {
@@ -42,9 +43,10 @@ bool BLECentral::connect(const bt_addr_le_t *addr, const ble_conn_param_t *param
     struct bt_le_conn_param conn_param;
 
     conn_param.latency = param->latency;
-    conn_param.interval_max = (uint16_t)(param->interval_max / 1.25);
-    conn_param.interval_min = (uint16_t)(param->interval_min / 1.25);
-    conn_param.timeout = param->timeout / 10;
+    conn_param.interval_max = (uint16_t)MSEC_TO_UNITS(param->interval_max, UNIT_1_25_MS);
+    conn_param.interval_min = (uint16_t)MSEC_TO_UNITS(param->interval_min, UNIT_1_25_MS);
+    conn_param.timeout = MSEC_TO_UNITS(param->timeout, UNIT_10_MS);
+    
     pr_debug(LOG_MODULE_BLE,"Latency-%d\r\nInterval min-%d, max-%d\r\ntimeout:%d",
             conn_param.latency,
             conn_param.interval_min,

libraries/CurieBLE/src/BLECommon.h

@@ -81,10 +81,10 @@ typedef bool (*ble_advertise_handle_cb_t)(uint8_t type, const uint8_t *data,
 
 
 typedef struct ble_conn_param {
-    float interval_min; // 7.5 - 4000ms
-    float interval_max; // 7.5 - 4000ms
+    float interval_min; // millisecond 7.5 - 4000ms
+    float interval_max; // millisecond 7.5 - 4000ms
     uint16_t latency;   // 0x0000 - 0x01F4
-    uint16_t timeout;   // 100 - 32000ms
+    uint16_t timeout;   // millisecond 100 - 32000ms
 }ble_conn_param_t;
 
 #endif // _BLE_COMMON_H_INCLUDED

libraries/CurieBLE/src/BLEPeripheral.cpp

@@ -30,9 +30,7 @@ BLEPeripheral::BLEPeripheral(void) :
     memset(_adv_data, 0x00, sizeof(_adv_data));
 
     // Default Advertising parameter
-    setAdvertisingParam(BT_LE_ADV_IND ,
-                        0xA0,
-                        0xF0);
+    setConnectable(true);
 }
 
 BLEPeripheral::~BLEPeripheral(void)
@@ -91,13 +89,30 @@ BLEPeripheral::setAdvertisedServiceData(const struct bt_uuid* serviceDataUuid,
     _service_data_length = serviceDataLength;
 }
 
-void BLEPeripheral::setAdvertisingParam(uint8_t  type, 
-                                        uint16_t interval_min,
-                                        uint16_t interval_max)
+void 
+BLEPeripheral::setAdvertisingInterval(float interval_min,
+                                      float interval_max)
 {
-    BLEPeripheralRole::instance()->setAdvertisingParam(type, 
-                                                       interval_min, 
-                                                       interval_max);
+    uint16_t max = (uint16_t) MSEC_TO_UNITS(interval_max, UNIT_0_625_MS);
+    uint16_t min = (uint16_t) MSEC_TO_UNITS(interval_min, UNIT_0_625_MS);
+    BLEPeripheralRole::instance()->setAdvertisingInterval(min, max);
+}
+
+void 
+BLEPeripheral::setAdvertisingInterval(float advertisingInterval)
+{
+    setAdvertisingInterval(advertisingInterval, advertisingInterval);
+}
+
+void
+BLEPeripheral::setConnectable(bool connectable)
+{
+    uint8_t type = BT_LE_ADV_IND;
+    if (connectable == false)
+    {
+        type = BT_LE_ADV_NONCONN_IND;
+    }
+    BLEPeripheralRole::instance()->setAdvertisingType(type);
 }
 
 void

libraries/CurieBLE/src/BLEPeripheral.h

@@ -88,26 +88,50 @@ class BLEPeripheral{
     void setAdvertisedServiceData(const struct bt_uuid* serviceDataUuid, 
                                   uint8_t* serviceData, 
                                   uint8_t serviceDataLength);
+    
     /**
-     * Set the ADV parameters about the ADV-Type and interval
+     * @brief   Set advertising interval
      *
-     * @param   type            Advertising types
+     * @param[in]   advertisingInterval    Advertising Interval (N * 0.625)
      *
-     * @param   interval_min    Minimum Advertising Interval (N * 0.625)
+     * @return  none
      *
-     * @param   interval_max    Maximum Advertising Interval (N * 0.625)
+     * @note  none
+     */
+    void setAdvertisingInterval(float advertisingInterval);
+    
+    /**
+     * @brief   Set advertising interval
      *
-     * @note    none
+     * @param[in]   interval_min    Minimum Advertising Interval (millisecond)
+     *
+     * @param[in]   interval_max    Maximum Advertising Interval (millisecond)
+     *
+     * @return  none
+     *
+     * @note  none
      */
-    void setAdvertisingParam(uint8_t  type, 
-                             uint16_t interval_min,
-                             uint16_t interval_max);
+    void setAdvertisingInterval(float interval_min,
+                                float interval_max);
+    
+    /**
+     * @brief   Set advertising type as connectable/non-connectable
+     *
+     * @param[in]   connectable     true  - The device connectable
+     *                              false - The device non-connectable
+     *
+     * @return  none
+     *
+     * @note  none
+     */
+    void setConnectable(bool connectable);
+    
     /**
      * Set the device name for the BLE Peripheral Device
      *
      * If device name is not set, a default name will be used instead
      *
-     * @param device  User-defined name string for this device.  Truncated if
+     * @param[in] device  User-defined name string for this device.  Truncated if
      *                   more than maximum allowed string length (20 bytes).
      *
      * @note This method must be called before the begin method

libraries/CurieBLE/src/BLEPeripheralRole.cpp

@@ -43,6 +43,11 @@ BLEPeripheralRole::BLEPeripheralRole(void) :
 {
     memset(_event_handlers, 0x00, sizeof(_event_handlers));
     _peripheral.setAddress(_local_bda);
+    
+    _adv_param.type = BT_LE_ADV_IND;
+    _adv_param.addr_type = _local_bda.type;
+    _adv_param.interval_min = 0xA0;
+    _adv_param.interval_max = 0xF0;
 }
 
 BLEPeripheralRole::~BLEPeripheralRole(void)
@@ -207,16 +212,24 @@ BLEPeripheralRole::startAdvertising(const struct bt_data *ad,
     return BLE_STATUS_SUCCESS;
 }
 
-void BLEPeripheralRole::setAdvertisingParam(uint8_t  type, 
-                                            uint16_t interval_min,
-                                            uint16_t interval_max)
+void BLEPeripheralRole::setAdvertisingInterval(uint16_t advertisingInterval)
+{
+    setAdvertisingInterval(advertisingInterval, advertisingInterval);
+}
+
+void BLEPeripheralRole::setAdvertisingInterval(uint16_t interval_min,
+                                               uint16_t interval_max)
 {
-    _adv_param.addr_type = _local_bda.type;
-    _adv_param.type = type;
     _adv_param.interval_min = interval_min;
     _adv_param.interval_max = interval_max;
 }
 
+void 
+BLEPeripheralRole::setAdvertisingType(uint8_t type)
+{
+    _adv_param.type = type;
+}
+
 BleStatus
 BLEPeripheralRole::stop(void)
 {

libraries/CurieBLE/src/BLEPeripheralRole.h

@@ -57,7 +57,7 @@ class BLEPeripheralRole: public BLERoleBase{
      * Set the min and max connection interval BLE Peripheral Device
      *
      * @param minConnInterval Minimum connection interval (1.25 ms units), minimum 0x0006 (7.5ms)
-     * @param maxConnInterval Maximum connection interval (1.25 ms units), maximum 0x095f (2998.75ms)
+     * @param maxConnInterval Maximum connection interval (1.25 ms units), maximum 0x0C80 (4000ms)
      *
      * @note This method must be called before the begin method
      */
@@ -139,34 +139,54 @@ class BLEPeripheralRole: public BLERoleBase{
                                size_t ad_len,
                                const struct bt_data *sd, 
                                size_t sd_len);
-	
-	/**
-	 * @brief   Stop send advertisement
-	 *
-	 * @param   none
-	 *
-	 * @return  none
-	 *
-	 * @note  none
-	 */
+    
+    /**
+     * @brief   Stop send advertisement
+     *
+     * @param   none
+     *
+     * @return  none
+     *
+     * @note  none
+     */
     BleStatus stopAdvertising();
-	
+    
+    /**
+     * @brief   Set advertising parameter
+     *
+     * @param[in]   advertisingInterval    Advertising Interval (N * 0.625)
+     *
+     * @return  none
+     *
+     * @note  none
+     */
+    void setAdvertisingInterval(uint16_t advertisingInterval);
+    
     /**
      * @brief   Set advertising parameter
      *
-     * @param   type            Advertising type
+     * @param[in]   interval_min    Minimum Advertising Interval (N * 0.625)
+     *
+     * @param[in]   interval_max    Maximum Advertising Interval (N * 0.625)
      *
-     * @param   interval_min    Minimum Advertising Interval (N * 0.625)
+     * @return  none
+     *
+     * @note  none
+     */
+    void setAdvertisingInterval(uint16_t interval_min,
+                                uint16_t interval_max);
+    
+    /**
+     * @brief   Set advertising type
      *
-     * @param   interval_max    Maximum Advertising Interval (N * 0.625)
+     * @param   type            Advertising type 
+     *                            BT_LE_ADV_IND, BT_LE_ADV_NONCONN_IND
      *
      * @return  none
      *
      * @note  none
      */
-    void setAdvertisingParam(uint8_t  type, 
-                             uint16_t interval_min,
-                             uint16_t interval_max);
+    void setAdvertisingType(uint8_t type);
 
     /**
      * @brief   Get BLE Peripheral instance.

libraries/CurieBLE/src/internal/ble_client.h

@@ -45,7 +45,7 @@ enum {
 #define DEFAULT_MIN_CONN_INTERVAL MSEC_TO_UNITS(80, UNIT_1_25_MS)
 #define DEFAULT_MAX_CONN_INTERVAL MSEC_TO_UNITS(150, UNIT_1_25_MS)
 #define MIN_CONN_INTERVAL 0x0006
-#define MAX_CONN_INTERVAL 0x095f
+#define MAX_CONN_INTERVAL 0x0C80
 #define SLAVE_LATENCY 0
 #define CONN_SUP_TIMEOUT MSEC_TO_UNITS(6000, UNIT_10_MS)