1. Add central read/write example.

2. Fix some build error for refactor the peripheral code.

Author: sgbihu

libraries/CurieBLE/examples/CallbackLED/CallbackLED.ino

@@ -45,19 +45,19 @@ void loop() {
   blePeripheral.poll();
 }
 
-void blePeripheralConnectHandler(BLECentral& central) {
+void blePeripheralConnectHandler(BLEHelper& central) {
   // central connected event handler
   Serial.print("Connected event, central: ");
   Serial.println(central.address());
 }
 
-void blePeripheralDisconnectHandler(BLECentral& central) {
+void blePeripheralDisconnectHandler(BLEHelper& central) {
   // central disconnected event handler
   Serial.print("Disconnected event, central: ");
   Serial.println(central.address());
 }
 
-void switchCharacteristicWritten(BLECentral& central, BLECharacteristic& characteristic) {
+void switchCharacteristicWritten(BLEHelper& central, BLECharacteristic& characteristic) {
   // central wrote new value to characteristic, update LED
   Serial.print("Characteristic event, written: ");
 

libraries/CurieBLE/examples/LEDCentral/LEDCentral.ino

@@ -0,0 +1,158 @@
+/*
+  Copyright (c) 2016 Intel Corporation. All rights 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 Street, Fifth Floor, Boston, MA 02110-
+  1301 USA
+*/
+
+// This example can work with CallbackLED to show the profile read/write operation in central
+#include <CurieBLE.h>
+
+struct bt_le_conn_param conn_param = {0x18, 0x28, 0, 400};
+
+const int ledPin = 13; // set ledPin to use on-board LED
+BLECentral bleCentral; // create central instance
+BLEPeripheralHelper *blePeripheral1 = NULL;
+
+BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // create service
+// create switch characteristic and allow remote device to read and write
+BLECharCharacteristic switchChar("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
+
+
+void bleCentralConnectHandler(BLEHelper& peripheral)
+{
+    // peripheral connected event handler
+    blePeripheral1 = (BLEPeripheralHelper *)(&peripheral);
+    Serial.print("Connected event, peripheral: ");
+    Serial.println(peripheral.address());
+    // Start discovery the profiles in peripheral device
+    blePeripheral1->discover();
+}
+
+void bleCentralDisconnectHandler(BLEHelper& peripheral)
+{
+    // peripheral disconnected event handler
+    blePeripheral1 = NULL;
+    Serial.print("Disconnected event, peripheral: ");
+    Serial.println(peripheral.address());
+    bleCentral.startScan();
+}
+
+void switchCharacteristicWritten(BLEHelper& peripheral, BLECharacteristic& characteristic)
+{
+    // Read response/Notification wrote new value to characteristic, update LED
+    Serial.print("Characteristic event, written: ");
+
+    if (switchChar.value()) 
+    {
+        Serial.println("LED on");
+        digitalWrite(ledPin, HIGH);
+    }
+    else
+    {
+        Serial.println("LED off");
+        digitalWrite(ledPin, LOW);
+    }
+}
+
+bool adv_found(uint8_t type, 
+               const uint8_t *data, 
+               uint8_t data_len,
+               void *user_data)
+{
+    bt_addr_le_t *addr = (bt_addr_le_t *)user_data;
+    int i;
+
+    pr_debug(LOG_MODULE_APP, "[AD]: %u data_len %u\n", type, data_len);
+
+    switch (type)
+    {
+        case BT_DATA_UUID128_SOME:
+        case BT_DATA_UUID128_ALL:
+        {
+            if (data_len % MAX_UUID_SIZE != 0) 
+            {
+                pr_debug(LOG_MODULE_APP, "AD malformed\n");
+                return true;
+            }
+            struct bt_uuid * serviceuuid = ledService.uuid();
+            for (i = 0; i < data_len; i += MAX_UUID_SIZE)
+            {
+                if (memcmp (((struct bt_uuid_128*)serviceuuid)->val, &data[i], MAX_UUID_SIZE) != 0) 
+                {
+                    continue;
+                }
+                
+                // Accept the advertisement
+                if (!bleCentral.stopScan()) 
+                {
+                    pr_debug(LOG_MODULE_APP, "Stop LE scan failed\n");
+                    continue;
+                }
+                pr_debug(LOG_MODULE_APP, "Connecting\n");
+                // Connect to peripheral
+                bleCentral.connect(addr, &conn_param);
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+void setup() {
+    Serial1.begin(115200);
+	
+    Serial.begin(9600);
+    pinMode(ledPin, OUTPUT); // use the LED on pin 13 as an output
+
+    // add service and characteristic
+    bleCentral.addAttribute(ledService);
+    bleCentral.addAttribute(switchChar);
+
+    // assign event handlers for connected, disconnected to central
+    bleCentral.setEventHandler(BLEConnected, bleCentralConnectHandler);
+    bleCentral.setEventHandler(BLEDisconnected, bleCentralDisconnectHandler);
+
+    // advertise the service
+    bleCentral.setAdvertiseHandler(adv_found);
+
+    // assign event handlers for characteristic
+    switchChar.setEventHandler(BLEWritten, switchCharacteristicWritten);
+
+    bleCentral.begin();
+    Serial.println(("Bluetooth device active, waiting for connections..."));
+}
+
+void loop()
+{
+    static unsigned char counter = 0;
+    static char ledstate = 0;
+    delay(2000);
+    if (blePeripheral1)
+    {
+        counter++;
+
+        if (counter % 3)
+        {
+            switchChar.read(*blePeripheral1);
+        }
+        else
+        {
+            ledstate = !ledstate;
+            switchChar.write(*blePeripheral1, (unsigned char *)(&ledstate), sizeof (ledstate));
+        }
+    }
+}

libraries/CurieBLE/examples/MIDIBLE/MIDIBLE.ino

@@ -140,19 +140,19 @@ void loop() {
 }
 
 
-void midiDeviceConnectHandler(BLECentral& central) {
+void midiDeviceConnectHandler(BLEHelper& central) {
   // central connected event handler
   Serial.print("Connected event, central: ");
   Serial.println(central.address());
 }
 
-void midiDeviceDisconnectHandler(BLECentral& central) {
+void midiDeviceDisconnectHandler(BLEHelper& central) {
   // central disconnected event handler
   Serial.print("Disconnected event, central: ");
   Serial.println(central.address());
 }
 
-void midiCharacteristicWritten(BLECentral& central, BLECharacteristic& characteristic) {
+void midiCharacteristicWritten(BLEHelper& central, BLECharacteristic& characteristic) {
   // central wrote new value to characteristic, update LED
   Serial.print("Characteristic event, written: ");
 }

libraries/CurieBLE/src/BLECharacteristic.cpp

@@ -138,6 +138,7 @@ BLECharacteristic::setValue(BLEHelper& blehelper, const unsigned char* value, un
     _setValue(value, length);
 
     _written = true;
+    _reading = false;
 
     if (_event_handlers[BLEWritten]) {
         _event_handlers[BLEWritten](blehelper, *this);
@@ -300,6 +301,8 @@ void BLECharacteristic::discover(struct bt_gatt_discover_params *params)
     params->uuid = this->uuid();
     // Start discovering
     _discoverying = true;
+    // Re-Init the read/write parameter
+    _reading = false;
 }
 
 
@@ -318,8 +321,17 @@ void BLECharacteristic::discover(const struct bt_gatt_attr *attr,
     {
         // Set Discover CCCD parameter
         params->start_handle = attr->handle + 2;
-        params->type = BT_GATT_DISCOVER_DESCRIPTOR;
-        params->uuid = this->getClientCharacteristicConfigUuid();
+        if (subscribed())
+        {
+            // Include CCCD
+            params->type = BT_GATT_DISCOVER_DESCRIPTOR;
+            params->uuid = this->getClientCharacteristicConfigUuid();
+        }
+        else
+        {
+            // Complete the discover
+            _discoverying = false;
+        }
     }
     else if (params->uuid == this->getClientCharacteristicConfigUuid())
     {
@@ -347,6 +359,13 @@ bool BLECharacteristic::read(BLEPeripheralHelper &peripheral)
     _read_params.handle_count = 1;
     _read_params.single.handle = peripheral.valueHandle(this);
     _read_params.single.offset = 0;
+    
+    if (0 == _read_params.single.handle)
+    {
+        // Discover not complete
+        return false;
+    }
+    
     conn = bt_conn_lookup_addr_le(peripheral.bt_le_address());
     if (NULL == conn)
     {
@@ -363,38 +382,25 @@ bool BLECharacteristic::read(BLEPeripheralHelper &peripheral)
     return _reading;
 }
 
-#if 0
 bool BLECharacteristic::write(BLEPeripheralHelper &peripheral, 
                               const unsigned char value[], 
                               uint16_t length)
 {
     int retval = 0;
     struct bt_conn* conn = NULL;
-    if (_reading)
-    {
-        // Already in reading state
-        return false;
-    }
 
-    _read_params.func = profile_read_rsp_process;
-    _read_params.handle_count = 1;
-    _read_params.single.handle = _attr_chrc_value->handle;
-    _read_params.single.offset = 0;
     conn = bt_conn_lookup_addr_le(peripheral.bt_le_address());
     if (NULL == conn)
     {
         return false;
     }
 
     // Send read request
-    retval = bt_gatt_write_without_response(conn, &_read_params);
+    retval = bt_gatt_write_without_response(conn, 
+                                            peripheral.valueHandle(this),
+                                            value, length, false);
     bt_conn_unref(conn);
-    if (0 == retval)
-    {
-        _reading = true;
-    }
-    return _reading;
+    return (0 == retval);
 }
-#endif
 
 

libraries/CurieBLE/src/BLECharacteristic.h

@@ -173,7 +173,7 @@ class BLECharacteristic : public BLEAttribute {
     static unsigned char numNotifyAttributes(void);
 
     /**
-     * @brief   Schedue the read request to read the characteristic in peripheral
+     * @brief   Schedule the read request to read the characteristic in peripheral
      *
      * @param   peripheral  The peripheral device that want to read.
      *
@@ -182,6 +182,22 @@ class BLECharacteristic : public BLEAttribute {
      * @note  Only for central device
      */
     bool read(BLEPeripheralHelper &peripheral);
+    
+    /**
+     * @brief   Schedule the write request to update the characteristic in peripheral
+     *
+     * @param   peripheral   The peripheral device that want to be updated
+     * @param   value       New value to set, as a byte array.  Data is stored in internal copy.
+     * @param   length      Length, in bytes, of valid data in the array to write.
+     *                      Must not exceed maxLength set for this characteristic.
+     *
+     * @return  bool true set value success, false on error
+     *
+     * @note  none
+     */
+    bool write(BLEPeripheralHelper &peripheral, 
+               const unsigned char value[], 
+               uint16_t length);
 
 protected:
     friend class BLEProfile;

libraries/CurieBLE/src/BLERoleBase.cpp

@@ -18,6 +18,8 @@ void bleDisconnectEventHandler(struct bt_conn *conn,
                                 void *param)
 {
     BLERoleBase* p = (BLERoleBase*)param;
+    
+    pr_info(LOG_MODULE_BLE, "Connect lost. Reason: %d", reason);
 
     p->handleDisconnectEvent(conn, reason);
 }