Adding BLE Central feature

Author: calvinatintel

README.md

@@ -53,3 +53,21 @@ them to the [support forum](https://forum.arduino.cc/index.php?board=103).
 > "How do I use this library?"
 
 > "I can't get this example sketch to work. What am I doing wrong?"
+
+# Enable debug interface on Serail1
+
+* Default disable the debug interface.
+
+If you want to enable debug trace on Serial1 to debug corelib,  follow these instructions.
+
+1. Shut down the IDE
+2. Go to Arduino15 directory
+  * Windows: `C:\Users\<user>\AppData\Roaming\Arduino15`
+  * OS X: `~/Library/Arduino15`
+  * Linux: `~/.arduino15`
+3. Modify the platform.txt
+  * Find `compiler.c.flags` and add `-DCONFIGURE_DEBUG_CORELIB_ENABLED` at the end of this line
+  * Find `compiler.cpp.flags` and add `-DCONFIGURE_DEBUG_CORELIB_ENABLED` at the end of this line
+4. Initial Serial1 in your sketch
+  * Add `Serial1.begin(115200);` in your `setup()`
+5. Adjust the output level at log_init function in log.c

system/libarc32_arduino101/framework/src/nordic_interface.h renamed to cores/arduino/printk.cpp

@@ -28,13 +28,25 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef NORDIC_INTERFACE_H
-#define NORDIC_INTERFACE_H
-#include "infra/ipc_uart.h"
+#include <stdarg.h>
+#include <cstdio>
+#include "UARTClass.h"
 
-void uart_ipc_message_cback(uint8_t cpu_id, int channel, int len, void * p_data);
-int send_message_ipc_uart(struct message * message);
-void free_message_ipc_uart(struct message * message);
-int nordic_interface_init(T_QUEUE queue);
+extern "C" void printk(const char *fmt, va_list args);
+extern UARTClass Serial1;
+#define PRINTK_BUFSIZ 256
+
+void printk(const char *fmt, va_list args)
+{
+#ifdef CONFIGURE_DEBUG_CORELIB_ENABLED
+    int len = 0;
+
+    char tmp[PRINTK_BUFSIZ];
+
+    len = vsnprintf(tmp, PRINTK_BUFSIZ, fmt, args);
+    
+    tmp[len] = '\0';
+    Serial1.println(tmp);
+#endif
+}
 
-#endif // NORDIC_INTERFACE_H

libraries/CurieBLE/examples/BatteryAdvChange/BatteryAdvChange.ino

@@ -0,0 +1,113 @@
+/* Please see code cpyright at the bottom of this example code */
+/*
+   This sketch illustrates how to change the advertising data so that it is visible but not
+   connectable. Then after 10 seconds it changes to being connectable
+   This sketch example partially implements the standard Bluetooth Low-Energy Battery service.
+   
+   This sketch is not paired with a specific central example sketch, 
+   but to see how it works you need to use a BLE APP on your phone or central device 
+    and try connecting when it is either a connectable or not connectable state 
+    as displayed in the serial monitor.
+*/
+
+#include <CurieBLE.h>
+
+BLEPeripheral blePeripheral;       // BLE Peripheral Device (the board you're programming)
+BLEService batteryService("180F"); // BLE Battery Service
+int count = 0;
+// BLE Battery Level Characteristic"
+BLEUnsignedCharCharacteristic batteryLevelChar("2A19",  // standard 16-bit characteristic UUID
+    BLERead | BLENotify);     // remote clients will be able to
+// get notifications if this characteristic changes
+
+void setup() {
+  Serial.begin(9600);    // initialize serial communication
+  pinMode(13, OUTPUT);   // initialize the LED on pin 13 to indicate when a central is connected
+  while (!Serial) {
+    //wait for Serial to connect
+  }
+  /* Set a local name for the BLE device
+     This name will appear in advertising packets
+     and can be used by remote devices to identify this BLE device
+     The name can be changed but maybe be truncated based on space left in advertisement packet */
+  blePeripheral.setLocalName("BatteryAdvChangeSketch");
+  blePeripheral.setAdvertisedServiceUuid(batteryService.uuid());  // add the service UUID
+  blePeripheral.addAttribute(batteryService);   // Add the BLE Battery service
+  blePeripheral.addAttribute(batteryLevelChar); // add the battery level characteristic
+
+  /* Now activate the BLE device.  It will start continuously transmitting BLE
+     advertising packets and will be visible to remote BLE central devices
+     until it receives a new connection */
+
+  blePeripheral.begin();
+  Serial.println("Bluetooth device active, waiting for connections...");
+  Serial.println("Starts in Connectable mode");
+}
+
+void loop() {
+  // listen for BLE peripherals to connect:
+  BLECentralHelper central = blePeripheral.central();
+  // wait
+  Serial.print(". ");
+  if (count == 10) {
+    Serial.print("\nReached count ");
+    Serial.println(count);
+
+  }
+  delay (1000);
+  count++;
+  // Switch from Connectable to Non Connectable and vice versa
+  if (count > 10 ) {
+    static bool change_discover = false;
+    Serial.println("Stop Adv and pausing for 10 seconds. Device should be invisible");
+    // Some central devices (phones included) may cache previous scan inofrmation
+    // restart your central and it should not see this peripheral once stopAdvertising() is called
+    blePeripheral.stopAdvertising();
+    delay(10000);
+
+    if (change_discover)
+    {
+
+      // Using the function setConnectable we specify that it now NOT connectable
+      // The loop is for 10 seconds. Your central device may timeout later than that
+      // and may eventually connect when we set it back to connectable mode below
+      blePeripheral.setConnectable(false);
+      Serial.println("In Non Connectable mode");
+
+    }
+    else
+    {
+
+      //using the function setConnectable we specify that it now  connectable
+      blePeripheral.setConnectable(true);
+      Serial.println("In Connectable mode");
+    }
+    Serial.println("Start Adv");
+    blePeripheral.startAdvertising();
+    if (change_discover) {
+      Serial.println("Adding 5 second delay in Non Connect Mode");
+      delay(5000);
+    }
+    change_discover = !change_discover;
+    count = 0;
+  }
+}
+
+/*
+   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
+*/
+

libraries/CurieBLE/examples/BatteryMonitor/BatteryMonitor.ino

@@ -6,7 +6,10 @@
 #include <CurieBLE.h>
 
 /*
-   This sketch example partially implements the standard Bluetooth Low-Energy Battery service.
+   This sketch can work with UpdateConnectionInterval. 
+   You can also use an android or IOS app that supports notifications   
+   This sketch example partially implements the standard Bluetooth Low-Energy Battery service
+   and connection interval paramater update.
    For more information: https://developer.bluetooth.org/gatt/services/Pages/ServicesHome.aspx
 */
 
@@ -15,9 +18,9 @@ BLEPeripheral blePeripheral;       // BLE Peripheral Device (the board you're pr
 BLEService batteryService("180F"); // BLE Battery Service
 
 // BLE Battery Level Characteristic"
-BLEUnsignedCharCharacteristic batteryLevelChar("2A19",  // standard 16-bit characteristic UUID
+BLEUnsignedCharCharacteristic batteryLevelChar("2A19",  // standard 16-bit characteristic UUID  defined in the URL above
     BLERead | BLENotify);     // remote clients will be able to
-// get notifications if this characteristic changes
+                              // get notifications if this characteristic changes
 
 int oldBatteryLevel = 0;  // last battery level reading from analog input
 long previousMillis = 0;  // last time the battery level was checked, in ms
@@ -45,7 +48,7 @@ void setup() {
 
 void loop() {
   // listen for BLE peripherals to connect:
-  BLECentral central = blePeripheral.central();
+  BLECentralHelper central = blePeripheral.central();
 
   // if a central is connected to peripheral:
   if (central) {
@@ -63,6 +66,14 @@ void loop() {
       if (currentMillis - previousMillis >= 200) {
         previousMillis = currentMillis;
         updateBatteryLevel();
+
+        static unsigned short count = 0;  
+        count++;
+        // update the connection interval
+        if(count%5 == 0){
+          delay(1000);
+          updateIntervalParams(central);  
+        }
       }
     }
     // when the central disconnects, turn off the LED:
@@ -87,6 +98,31 @@ void updateBatteryLevel() {
   }
 }
 
+void updateIntervalParams(BLECentralHelper &central) {
+  // read and update the connection interval that peer central device
+  static unsigned short interval = 0x60;
+  ble_conn_param_t m_conn_param;
+  // Get connection interval that peer central device wanted
+  central.getConnParams(m_conn_param);
+  Serial.print("min interval = " );
+  Serial.println(m_conn_param.interval_min );
+  Serial.print("max interval = " );
+  Serial.println(m_conn_param.interval_max );
+  Serial.print("latency = " );
+  Serial.println(m_conn_param.latency );
+  Serial.print("timeout = " );
+  Serial.println(m_conn_param.timeout );
+        
+  //Update connection interval
+  Serial.println("set Connection Interval");
+  central.setConnectionInterval(interval,interval);
+
+  interval++;
+  if(interval<0x06)
+    interval = 0x06;
+  if(interval>0x100)
+    interval = 0x06; 
+}
 /*
    Copyright (c) 2016 Intel Corporation.  All rights reserved.
 

libraries/CurieBLE/examples/ButtonLED/ButtonLED.ino

@@ -3,19 +3,28 @@
  * See the bottom of this file for the license terms.
  */
 
+ /*  This examples needs a button connected similarly as described here
+     https://www.arduino.cc/en/Tutorial/Button
+	 The only difference is that instead of connecting to pin 2 connect to pin 4
+	 After the sketch starts connect to a BLE app on a phone and set notification to the Characteristic and you should see it update
+	 whenever the button is pressed. This sketch is not written to pair with any of the central examples. 
+ */	 
+ 
 #include <CurieBLE.h>
 
 const int ledPin = 13; // set ledPin to on-board LED
 const int buttonPin = 4; // set buttonPin to digital pin 4
 
 BLEPeripheral blePeripheral; // create peripheral instance
-BLEService ledService("19B10010-E8F2-537E-4F6C-D104768A1214"); // create service
+BLEService ledService("19B10010-E8F2-537E-4F6C-D104768A1214"); // create service with a 128-bit UUID (32 characters exclusive of dashes).
+                                                               // Long UUID denote custom user created UUID
 
 
 // create switch characteristic and allow remote device to read and write
 BLECharCharacteristic ledCharacteristic("19B10011-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
 // create button characteristic and allow remote device to get notifications
 BLECharCharacteristic buttonCharacteristic("19B10012-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify); // allows remote device to get notifications
+// Note use of Typed Characteristics. These previous 2  characeristics are of the type char
 
 void setup() {
   Serial.begin(9600);
@@ -32,6 +41,7 @@ void setup() {
   blePeripheral.addAttribute(ledCharacteristic);
   blePeripheral.addAttribute(buttonCharacteristic);
 
+  // set initial values for led and button characteristic
   ledCharacteristic.setValue(0);
   buttonCharacteristic.setValue(0);
 
@@ -59,10 +69,13 @@ void loop() {
 
   if (ledCharacteristic.written() || buttonChanged) {
     // update LED, either central has written to characteristic or button state has changed
+	// if you are using a phone or a BLE  central device that is aware of this characteristic, writing a value of 0x40 for example
+	// Will be interpreted as written
     if (ledCharacteristic.value()) {
       Serial.println("LED on");
       digitalWrite(ledPin, HIGH);
     } else {
+	// If central writes a 0 value then it is interpreted as no value and turns off the LED
       Serial.println("LED off");
       digitalWrite(ledPin, LOW);
     }

libraries/CurieBLE/examples/CallbackLED/CallbackLED.ino

@@ -2,13 +2,24 @@
  * Copyright (c) 2016 Intel Corporation.  All rights reserved.
  * See the bottom of this file for the license terms.
  */
+ 
+ // This example can work with LEDCentral
+ // You should see the LED blink on and off
+ // This example demonstrates the use of Callback or event Handlers responding to events
+ // BLECoonected, BLEDisconnected and BLEWritten are events.
+ // To test interactively use a Phone app like nrf Controller (Android) or Light Blue (iOS)
+ // Connect to BLE device named LEDCB and explore characteristic with UUID 19B10001-E8F2-537E-4F6C-D104768A1214
+ // Writing a byte value such as 0x40 should turn on the LED
+ // Writng a byte value of 0x00 should turn off the LED
 
 #include <CurieBLE.h>
 
 const int ledPin = 13; // set ledPin to use on-board LED
 BLEPeripheral blePeripheral; // create peripheral instance
+BLECentralHelper *bleCentral1 = NULL; // peer central device 
 
-BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // create service
+BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // create service with a 128-bit UUID (32 characters exclusive of dashes).
+                                                               // Long UUID denote custom user created UUID
 
 // create switch characteristic and allow remote device to read and write
 BLECharCharacteristic switchChar("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
@@ -45,19 +56,25 @@ void loop() {
   blePeripheral.poll();
 }
 
-void blePeripheralConnectHandler(BLECentral& central) {
+// The function parameter (BLEHelper& central) is for peripheral devices
+// This enable us to have access to the central's data like its bluetooth address
+
+void blePeripheralConnectHandler(BLEHelper& central) {
   // central connected event handler
+  bleCentral1 = blePeripheral.getPeerCentralBLE(central);
   Serial.print("Connected event, central: ");
-  Serial.println(central.address());
+  Serial.println(bleCentral1->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) {
+// In addtion to the BLECentral& central parameter, we also have to have to BLECharacteristic& characteristic parameter
+
+void switchCharacteristicWritten(BLEHelper& central, BLECharacteristic& characteristic) {
   // central wrote new value to characteristic, update LED
   Serial.print("Characteristic event, written: ");