mbed-x
Library that exposes BLE characteristics as ordinary variables.
Dependents: SimpleBLE-Example-mbed-os-5 SimpleBLE-Example ObCP_ENSMM_Test SimpleBLE-ObCP_ENSMM_V2019_Test_BLE
Looking for example code? See SimpleBLE-Example.
Looking for the blog post about this library? See A new Bluetooth library: SimpleBLE.
SimpleBLE is a library which allows you to easily add Bluetooth Low Energy support to any application, without having to change the way you write code. It's goal is to expose any value or sensor over BLE in a single line of code. Let's say you're reading a sensor value every second from pin A0:
uint16_t lightValue;
AnalogIn light(A0);
void read() {
lightValue = light.read_u16();
printf("Value is now %d\n", lightValue);
}
Ticker t;
t.attach(&read, 1.0f);
Now we can expose this sensor to any BLE client using SimpleBLE:
SimpleChar<uint16_t> lightValue = ble.readOnly_u16(0x8000, 0x8001);
AnalogIn light(A0);
void read() {
lightValue = light.read_u16();
printf("Value is now %d\n", lightValue);
}
Ticker t;
t.attach(&read, 1.0f);
SimpleBLE will automatically gather services for you, bootstrap the BLE runtime, react to write callbacks and update the underlying BLE characteristic whenever the variable gets changed.
Setting up the library
First import this library to the application where you want to use it. Then load SimpleBLE like this:
#include "mbed.h"
#include "SimpleBLE.h"
SimpleBLE ble("DEVICE_NAME"); // second argument is the advertisement interval (default: 1000 ms.)
// variables here!
int main(int, char**) {
ble.start();
while (1) {
ble.waitForEvent();
}
}
You'll also need to import the BLE library for your platform (e.g. nrf51822 for nRF51-DK and micro:bit). If you grab the example program, all should be set.
After you build and flash this application the device will now show up as 'DEVICE_NAME' in any BLE scanner like nRF Master Control Panel.
Reading and writing values
Every variable that you declare after creating the `SimpleBLE` object, and calling `start()` will automatically be exposed over BLE. We have three different types of objects:
- readOnly - Variable can only be read over BLE.
- readWrite - Variable can be read and written over BLE.
- writeOnly - Variable can be written over BLE, but not read.
Creating a new variable is done by calling the respective function on the simpleBLE object, postfixed by the type you want the variable to have:
SimpleBLE ble("DEVICE_NAME");
SimpleChar<uint8_t> myVar = ble.readOnly_u8(0x8200, 0x8201); // creates uint8_t
The postfix has to be either: u8 (uint8_t), u16 (uint16_t), u32 (uint32_t), i8 (int8_t), i16 (int16_t), i32 (int32_t), bool (bool) or float (float).
The functions take four (non-write) or five (write) arguments:
- serviceUUID - Which service should this variable fall under. Either use a uint16_t (shorthand) or you can use a string (full UUID).
- characterUUID - Which character this variable should have. Also, use uint16_t or a string.
- observable - Whether a BLE client can subscribe to updates on this characteristic (default: true).
- defaultValue - Default value of the characteristic (default: 0 or 0.0f, depending on your type).
- callback - Function to be called whenever the value of your characteristic was updated over BLE (only available for variables that support writing).
For example, this is how we make a non-observable readWrite characteristic, with a default value of 100, and a callback function:
SimpleBLE ble("DEVICE_NAME");
void updated(uint32_t newValue) {
printf("My value was updated, and is now %d\n", newValue);
}
SimpleChar<uint32_t> myVar = ble.readWrite_u32(0x9341, 0x9342, false, 100, &updated);
Just like normal variables
SimpleBLE variables behave just like normal variables, you can read and write straight from them. For example, this will compile just fine:
SimpleChar<uint8_t> heartrate = ble.readOnly_u8(0x180d, 0x2a37, true, 100);
void updateHr() {
heartrate = heartrate + 1;
if (heartrate > 180) {
heartrate = 100;
}
}
Ticker t;
t.attach(updateHr, 1.0f);
What to use it for?
I wrote this library because I do quite a lot of workshops and hackathons, and I have seen that BLE_API is too complicated for people who do not do embedded development or C++ on a daily basis. Exposing a new sensor over Bluetooth should be a single line of code. So if you're running any workshops, give this lib a go and let me know your experiences.