Initial version

README.md

@@ -0,0 +1,27 @@
+# ArduinoBLE
+
+Enables BLE connectivity on the Arduino MKR WiFi 1010 and Arduino UNO WiFi Rev.2.
+
+This library currently supports creating a BLE peripheral.
+
+Requires the NINA module to be running [Arduino NINA-W102 firmware](https://github.com/arduino/nina-fw) v1.2.0 or later.
+
+## License
+
+```
+Copyright (c) 2018 Arduino SA. 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
+```

examples/Peripheral/BatteryMonitor/BatteryMonitor.ino

@@ -0,0 +1,101 @@
+/*
+  Battery Monitor
+
+  This example creates a BLE peripheral with the standard battery service and
+  level characteristic. The A0 pin is used to calculate the battery level.
+
+  The circuit:
+  - Arduino MKR WiFi 1010 or Arduino Uno WiFi Rev2 board
+
+  This example code is in the public domain.
+*/
+
+#include <ArduinoBLE.h>
+
+ // BLE Battery Service
+BLEService batteryService("180F");
+
+// 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
+
+int oldBatteryLevel = 0;  // last battery level reading from analog input
+long previousMillis = 0;  // last time the battery level was checked, in ms
+
+void setup() {
+  Serial.begin(9600);    // initialize serial communication
+  while (!Serial);
+
+  pinMode(LED_BUILTIN, OUTPUT); // initialize the built-in LED pin to indicate when a central is connected
+
+  // begin initialization
+  if (!BLE.begin()) {
+    Serial.println("starting BLE failed!");
+
+    while (1);
+  }
+
+  /* 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
+  */
+  BLE.setLocalName("BatteryMonitor");
+  BLE.setAdvertisedService(batteryService); // add the service UUID
+  batteryService.addCharacteristic(batteryLevelChar); // add the battery level characteristic
+  BLE.addService(batteryService); // Add the battery service
+  batteryLevelChar.writeValue(oldBatteryLevel); // set initial value for this characteristic
+
+  /* Start advertising BLE.  It will start continuously transmitting BLE
+     advertising packets and will be visible to remote BLE central devices
+     until it receives a new connection */
+
+  // start advertising
+  BLE.advertise();
+
+  Serial.println("Bluetooth device active, waiting for connections...");
+}
+
+void loop() {
+  // wait for a BLE central
+  BLEDevice central = BLE.central();
+
+  // if a central is connected to the peripheral:
+  if (central) {
+    Serial.print("Connected to central: ");
+    // print the central's BT address:
+    Serial.println(central.address());
+    // turn on the LED to indicate the connection:
+    digitalWrite(LED_BUILTIN, HIGH);
+
+    // check the battery level every 200ms
+    // while the central is connected:
+    while (central.connected()) {
+      long currentMillis = millis();
+      // if 200ms have passed, check the battery level:
+      if (currentMillis - previousMillis >= 200) {
+        previousMillis = currentMillis;
+        updateBatteryLevel();
+      }
+    }
+    // when the central disconnects, turn off the LED:
+    digitalWrite(LED_BUILTIN, LOW);
+    Serial.print("Disconnected from central: ");
+    Serial.println(central.address());
+  }
+}
+
+void updateBatteryLevel() {
+  /* Read the current voltage level on the A0 analog input pin.
+     This is used here to simulate the charge level of a battery.
+  */
+  int battery = analogRead(A0);
+  int batteryLevel = map(battery, 0, 1023, 0, 100);
+
+  if (batteryLevel != oldBatteryLevel) {      // if the battery level has changed
+    Serial.print("Battery Level % is now: "); // print it
+    Serial.println(batteryLevel);
+    batteryLevelChar.writeValue(batteryLevel);  // and update the battery level characteristic
+    oldBatteryLevel = batteryLevel;           // save the level for next comparison
+  }
+}

examples/Peripheral/ButtonLED/ButtonLED.ino

@@ -0,0 +1,88 @@
+/*
+  Button LED
+
+  This example creates a BLE peripheral with service that contains a
+  characteristic to control an LED and another characteristic that
+  represents the state of the button.
+
+  The circuit:
+  - Arduino MKR WiFi 1010 or Arduino Uno WiFi Rev2 board
+  - Button connected to pin 4
+
+  This example code is in the public domain.
+*/
+
+#include <ArduinoBLE.h>
+
+const int ledPin = LED_BUILTIN; // set ledPin to on-board LED
+const int buttonPin = 4; // set buttonPin to digital pin 4
+
+BLEService ledService("19B10010-E8F2-537E-4F6C-D104768A1214"); // create service
+
+// create switch characteristic and allow remote device to read and write
+BLEByteCharacteristic ledCharacteristic("19B10011-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
+// create button characteristic and allow remote device to get notifications
+BLEByteCharacteristic buttonCharacteristic("19B10012-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify);
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  pinMode(ledPin, OUTPUT); // use the LED as an output
+  pinMode(buttonPin, INPUT); // use button pin as an input
+
+  // begin initialization
+  if (!BLE.begin()) {
+    Serial.println("starting BLE failed!");
+
+    while (1);
+  }
+
+  // set the local name peripheral advertises
+  BLE.setLocalName("ButtonLED");
+  // set the UUID for the service this peripheral advertises:
+  BLE.setAdvertisedService(ledService);
+
+  // add the characteristics to the service
+  ledService.addCharacteristic(ledCharacteristic);
+  ledService.addCharacteristic(buttonCharacteristic);
+
+  // add the service
+  BLE.addService(ledService);
+
+  ledCharacteristic.writeValue(0);
+  buttonCharacteristic.writeValue(0);
+
+  // start advertising
+  BLE.advertise();
+
+  Serial.println("Bluetooth device active, waiting for connections...");
+}
+
+void loop() {
+  // poll for BLE events
+  BLE.poll();
+
+  // read the current button pin state
+  char buttonValue = digitalRead(buttonPin);
+
+  // has the value changed since the last read
+  boolean buttonChanged = (buttonCharacteristic.value() != buttonValue);
+
+  if (buttonChanged) {
+    // button state changed, update characteristics
+    ledCharacteristic.writeValue(buttonValue);
+    buttonCharacteristic.writeValue(buttonValue);
+  }
+
+  if (ledCharacteristic.written() || buttonChanged) {
+    // update LED, either central has written to characteristic or button state has changed
+    if (ledCharacteristic.value()) {
+      Serial.println("LED on");
+      digitalWrite(ledPin, HIGH);
+    } else {
+      Serial.println("LED off");
+      digitalWrite(ledPin, LOW);
+    }
+  }
+}

examples/Peripheral/CallbackLED/CallbackLED.ino

@@ -0,0 +1,90 @@
+/*
+  Callback LED
+
+  This example creates a BLE peripheral with service that contains a
+  characteristic to control an LED. The callback features of the
+  library are used.
+
+  The circuit:
+  - Arduino MKR WiFi 1010 or Arduino Uno WiFi Rev2 board
+
+  This example code is in the public domain.
+*/
+
+#include <ArduinoBLE.h>
+
+BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // create service
+
+// create switch characteristic and allow remote device to read and write
+BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
+
+const int ledPin = LED_BUILTIN; // pin to use for the LED
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  pinMode(ledPin, OUTPUT); // use the LED pin as an output
+
+  // begin initialization
+  if (!BLE.begin()) {
+    Serial.println("starting BLE failed!");
+
+    while (1);
+  }
+
+  // set the local name peripheral advertises
+  BLE.setLocalName("LEDCallback");
+  // set the UUID for the service this peripheral advertises
+  BLE.setAdvertisedService(ledService);
+
+  // add the characteristic to the service
+  ledService.addCharacteristic(switchCharacteristic);
+
+  // add service
+  BLE.addService(ledService);
+
+  // assign event handlers for connected, disconnected to peripheral
+  BLE.setEventHandler(BLEConnected, blePeripheralConnectHandler);
+  BLE.setEventHandler(BLEDisconnected, blePeripheralDisconnectHandler);
+
+  // assign event handlers for characteristic
+  switchCharacteristic.setEventHandler(BLEWritten, switchCharacteristicWritten);
+  // set an initial value for the characteristic
+  switchCharacteristic.setValue(0);
+
+  // start advertising
+  BLE.advertise();
+
+  Serial.println(("Bluetooth device active, waiting for connections..."));
+}
+
+void loop() {
+  // poll for BLE events
+  BLE.poll();
+}
+
+void blePeripheralConnectHandler(BLEDevice central) {
+  // central connected event handler
+  Serial.print("Connected event, central: ");
+  Serial.println(central.address());
+}
+
+void blePeripheralDisconnectHandler(BLEDevice central) {
+  // central disconnected event handler
+  Serial.print("Disconnected event, central: ");
+  Serial.println(central.address());
+}
+
+void switchCharacteristicWritten(BLEDevice central, BLECharacteristic characteristic) {
+  // central wrote new value to characteristic, update LED
+  Serial.print("Characteristic event, written: ");
+
+  if (switchCharacteristic.value()) {
+    Serial.println("LED on");
+    digitalWrite(ledPin, HIGH);
+  } else {
+    Serial.println("LED off");
+    digitalWrite(ledPin, LOW);
+  }
+}

examples/Peripheral/LED/LED.ino

@@ -0,0 +1,84 @@
+/*
+  LED
+
+  This example creates a BLE peripheral with service that contains a
+  characteristic to control an LED.
+
+  The circuit:
+  - Arduino MKR WiFi 1010 or Arduino Uno WiFi Rev2 board
+
+  This example code is in the public domain.
+*/
+
+#include <ArduinoBLE.h>
+
+BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // BLE LED Service
+
+// BLE LED Switch Characteristic - custom 128-bit UUID, read and writable by central
+BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
+
+const int ledPin = LED_BUILTIN; // pin to use for the LED
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  // set LED pin to output mode
+  pinMode(ledPin, OUTPUT);
+
+  // begin initialization
+  if (!BLE.begin()) {
+    Serial.println("starting BLE failed!");
+
+    while (1);
+  }
+
+  // set advertised local name and service UUID:
+  BLE.setLocalName("LED");
+  BLE.setAdvertisedService(ledService);
+
+  // add the characteristic to the service
+  ledService.addCharacteristic(switchCharacteristic);
+
+  // add service
+  BLE.addService(ledService);
+
+  // set the initial value for the characeristic:
+  switchCharacteristic.writeValue(0);
+
+  // start advertising
+  BLE.advertise();
+
+  Serial.println("BLE LED Peripheral");
+}
+
+void loop() {
+  // listen for BLE peripherals to connect:
+  BLEDevice central = BLE.central();
+
+  // if a central is connected to peripheral:
+  if (central) {
+    Serial.print("Connected to central: ");
+    // print the central's MAC address:
+    Serial.println(central.address());
+
+    // while the central is still connected to peripheral:
+    while (central.connected()) {
+      // if the remote device wrote to the characteristic,
+      // use the value to control the LED:
+      if (switchCharacteristic.written()) {
+        if (switchCharacteristic.value()) {   // any value other than 0
+          Serial.println("LED on");
+          digitalWrite(ledPin, HIGH);         // will turn the LED on
+        } else {                              // a 0 value
+          Serial.println(F("LED off"));
+          digitalWrite(ledPin, LOW);          // will turn the LED off
+        }
+      }
+    }
+
+    // when the central disconnects, print it out:
+    Serial.print(F("Disconnected from central: "));
+    Serial.println(central.address());
+  }
+}