Diving in BLE development



Bluetooth is playing a very important role in term of short long communication .such an important role push developers to improve it better and faster for new requirement of the market ,the success of BLE is similar to success of USB and its fast versioning .The main focus on this topic is to introduce the steps to design a costum BLE solution or add BLE support to your current application . 
[In this document when I mention BLE , i refer to BLUETOOTH LOW ENERGY 4.X]

According to standard specification the new version of BlueTooth technology relayed on the concept of Low Energy It means using a single cell coin battery as power source, a BLE device's life could be extended to sevral years.there are many advantages and a few weakness of BLE 4 , It dosn’t support audio streaming , so if you’re planning to support an audio streming device ,BLE is not a good solution for you, the way it works is based on transfering small packet data throgh signal events , but the good latency of signals  with fast transaction 3ms from start to finish probably recompense this low data rate in communication, it  sleeps when no event or communication is on going, in sleep mode it  consume less than 1 µA , and wakeup if necessary.From many aspects BLE is different from a Classic BT ,more connectivity range, low energy consumption ,in the table below you see those difference,BLE is low cost and easy to implement ,don't be suprised if I say the battery will cost more than the electronics!

To wrap up this overview ,before starting your project you have to know, BLE is designed for sending small chunks of data that's why BLE is not advised for File Transfer operation specially when processing big files,it cannot handle it as we expect and as we get used with WIFI, once again notice BLE is perfect for kind of devices based on command with small packet data to carry out,with minimum time processing, BLE is not designed to execute heavy calculation and math processing ,those things should be delegated to Master device rather than slave BLE , this point is very important your BLE device is there to hand you the data you need and not to process  or execute them , any mathmatical operation and/or presentation of this data is to be implemented on Master side.Later when you write and download your codes into device's firmware be carreful to not implement huge routines which make  processor busy for a relative long time. 

Below a list of known Use Cases

1- Proximity  detection,presence detection  2-Time  3-Emergency 4- Network availability  5- Personal User Interface  6- Simple remote control  7-Browse over Bluetooth

8- Temperature Sensor  9- Humidity Sensor  10- Generic I/O (automation)   11- Battery status   12- Heart rate monitor   13-Physical activity monitor

14-Blood glucose monitor  15- Cycling sensors    16-Pulse Oximeter    17-Body thermometer

As you see the volum of data transfered in each transaction in BLE is less than a classic BT! however you notice that even if BLE perform a smaller data packet in a single transaction , the transactions occurancy in BLE is higher than a classic BT , this acceptable latency makes the difference and put it on top of the short range communication protocol. 
In this topic we're not going to discover all those details in every corner of this marvelous technology but we need a minimum knowledge to start a successful project around BLE,things like how BLE communicates to outside world is the first step to implement it in our solution.

Bluetooth devices currently available in market either they support BLE or not, are divided by 3 categories:
Classic Bluetooth (Legacy):
is classic generation from 1.x to 3.x
Bluetooth Smart :
is new generation known as BLE v4.x,they are not backward-compatible with previous Classic Bluetooth 
Bluetooth Smart Ready:
 indicates a dual-mode device compatible with both Classic and low energy peripherals.

Bluetooth Smart indicates a low energy-only device which requires either a Smart Ready or another Smart device in order to function.In IT  Jargon,sometimes professional use "Central" and "peripheral" Centeral refers to any smartphone,tablette,...and peripheral is the BLE device attatched to it.other term usually in this jargon are [Master] and [slave], Master refer to Smartdevice ,tablette,...which control the device , and Slave is the BLE device
notice : A Slave cannot have two Master at the same time]
Other interessting feature unique to BLE device is the ability to get enough information about device even before connecting ,this feature is exploited by professional to push advertizing over it.Advertising is the primary way a peripheral device make its presence via Bluetooth LE.
Advertising packets are very small ,broadcasted by BLE device to nearby , this feature allow master devices (smartdevice)to be able to retreive enough information before connecting.notice that in any case the connection is initiated by Master , so it’s up to master device to decide wether to connect or not.Advertising packets contain useful data, such as the peripheral’s name. It can also include some extra data related to what the peripheral collects. For example, in the case of a heart rate monitor, the packet also provides heartbeats per minute (BPM) data.The job of a central is to scan for those advertising packets, identify any peripherals it finds relevant, and connect to individual devices for more information.
During the  lifecycle of connection or advertizing all communications are  asynchronous.

Topology :

As design classic Bluetooth Master can be connected to up to 7 slave devices simultaneously , however according to SIG specification  this limit is not defined  for Blue tooth Low Energy(BLE) but  it seems to have a practical limitation  since in Advertizing phase BLE consume  energy and by higher number of devices that may  be a major challanging to the principal of Low Energy, so from topology state , A Slave can only be  connected to one Master at a time  but a Master can be connected to an unlimited (undefined) number of Slaves , A Master could be playing the role of Slave at the same time, there is no any  direct communication between two slaves  , no direct connection , therefore for such a scenario  , Slave must use a Master as a bridge to  achieve  that as shown here:


Hardware design :

According to SIG (Special Interest Group ), BLE is using the same frequency range as Classic BT(and also WIFI) ,From 400 GHz to 2.4835 GHz ISM band=> delta =0.08GHz=80MH pass band , this 80MHZ is distributed as channels ,In BlueTooth classic this range is divided into 79*1MHz (79 channels) 
however In BLE this range is divided into 40*2MHz (40 channels) within these 2MHZ we can send or receive BLE data.channels (37,38,39) are used for advertizing & discovery service in different part of spectrs to ensure safety against interference, the rest are data channels , once connection established and initiated data channels are used instead.


BLE device communicates with smart devices (masters) trough events signals every transaction of data or advertizing occurs in the interval of around 3ms , data is dispatched on multiple channels  , advertizing are carried out by 3 channels  37,38,39, the following diagram taken by TI (Texas Instrument) show this communication


BLE device signals are transfered with GFSK modulation GAUSSIAN FREQUENCY SHIFT KEYING, I briefly describe the principal of GFSK modulation to better understand the signal pattern of a BLE device .GFSK is Gaussian FSK which mean it's derivation of FSK modulation by passing signals throgh a Low Pass Filter ,


GFSK  modulation is generated by previously filtering signals before sending it to FSK Modulator
A Gaussian Low Pass Filter get input sigals before sending it to FSK Modulator so the Frequency Resonse Function in more detail is shown here


The reason why GFSK has been adopted for BLE is the fact that it's well behaved in therm of usefull particularity of a Gaussian signal in which the frequency response impulse and time response both are Gaussian, by makin inverse Fourier we get what is shown below 


you see the result and comparaison of both modulation in Fig.As you see communication signal for a BLE


The data packets transferring profiles[Services+Characteristics+descriptors+...] (known as ATT/GATT) are carried by this Gaussian signal in  Physic Layer ,remember that in physic layer Logic BLE data packets(Services) are encapsulated with additional data , headres and CRC added by other layers  as shown here


This data is provided to physical support but we don't care about it , we should focus on data structure at Application level, at profile level, service retreiving ....etc our job is not to analyse the management of other layers such as Link ,Physic,.. , because each layer is managed separately by its own protocol manager , i wanted to show a full schema of what's going on in a real world just to let you figure out how is a real communication in action!

Logic layer:

In Networking & Communication ,stack of different layer to carry out data is represented as following figure:


GATT/ATT [Generic Attribute Profile/Attribute Protocol] 
This pair is the two main concept of BT4 transported data packet are named characteristics/services, Profils are a collection of services, a service a collection of Characteristics and a Characteristic a collection of descriptors and a value.BLE communication is based on exchange of atrributes between two devices through services, 

There services are kind of interfaces in form of data structures including profiles linked to a given function supported by the sensors A service contains one or more Charactersitics and each Charactersitic contains a value and one or more descriptors.Indeed Services are used to break data up into logic entities, and contain specific chunks of data called characteristics. A service can have one or more characteristics, and each service distinguishes itself from other services by means of a unique numeric ID called a UUID, which can be either 16-bit (for officially adopted BLE Services) or 128-bit (for custom services).


Charactersitics :
are generally the properties of the sensors, measured and reported by sensors , a Characteristic has many readable/writtable attributs but a single value, this value represents a real human physical value measured by a device's sensor , when an attribut of Characteristic is writtable it can be used both server or client in order to setup a handler,enable a notification or configuration or even to set a feature on device.Evry attribute has a UUID which is formated as a 16bit or 128 bits unique numbers, 16 bits are reserved and defined by Bluetooth SIG, however 128bits,are custom and free to be used for any purpose! if you're planning to provide a custom BLE device ,use 128 bits values ,  you will see later how to download a custom firmare on a BLE module.The lowest level concept in GATT transactions is the Characteristic, which encapsulates a single data point (though it may contain an array of related data, such as X/Y/Z values from a 3-axis accelerometer, etc.).

desriptors are informations related to characteristics value for example if this value is a tempreture, descriptors tell us a description of the value Ex:"Temperature"  another descriptor may return us the unity of this value Ex"°C" or "°F"

In Psudo code we can represent a Value as this data structure

struct values{
config cfg;


uuid are unique identifiers for every single Service or Characteristic implemented on the device,as I said they are either Custom or defined by the chip maker/provider , when a Master device or an application is connected to a BLE device , the first thing should be performed is to reteive all services and characteristics of BLE device , informations provided by BLE device at this time includes UUIDs of all services & characteristics, if later Application needs to communicate to a specific characteristic, it will do it by previously provided uuid of that specific Characteristics.Here an example from Nordic SemiConductor the following uuids are defined for measure of "Battery Level" , "Glucose" and "Heart rate" [by a medical device sensor] , "Temperature"


Suppose your device is a Medical smart sencor from Nordic SemiConductor ,and your application  is a smartphone application to read and display and probably calculate data As I mentioned 
Once you are connected to your medical device , to read GLUCOSE value or Heart rate value
you perform a READ request to related Service (which in turn linked by its own UUID) and you provide uuid of such a characteristic in your READ request (Refer to programming section). 

The concept of Servuice & Characteristics & Attributes are very similar to USB communication
In USB the channel of communication are based on Interface ,Endpoints … 

One of the most likely feature supported by some BLE devices chipsets is OTA downloading,OTA stands for Over_The_Air , so we can upgrade the BLE device's firmware wirelessly through the Bluetooth connection.generally the update is done by an application installed on a smartdevices (smartphone Android or IOS)


You can only scan for Bluetooth LE devices or scan for Classic Bluetooth devices, as described in Bluetooth. You cannot scan for both Bluetooth LE and classic devices at the same time.



When we are planning to support BLE in our products ,since a BLE device is used in a Client-Server environment , before making any decision we have to make things clear , are we going to develop a Client or A Server?,a Master device or a Slave device?
In both case we have  at least one of  3 scenarios as mentioned below:

1) We are a vendor of BLE modules so we are going to design a custom BLE module from scratch.

2) Our device is a BLE device we purchase an already existant module then we customize it by flashing Firmware

3)we purchase an already existant device then we support it on our own products, without any customization.

In the first case as a vendor our development consists of  design a new Hardware ,implements electronic components in full adequation with all communication protocols and compatible with major known OS in market.the vendor generally make thier own Bluetooth stack ex:Toshiba,Broadcom,TI,Microsoft....
In second case we're dealing with a device to be reprogrammed for a specific purpose.In this case we are on Slave mode or Server side ,our job consists of define our interface on the device ,those interface are  profile, Services and Characteristics which expose device functions to end user.The next step will be compiling and downloading those information to device.A compiler is required to customize the firmware , a Downloader is also required to download new firmware so called image to device.since OTA (over-the-Air) feature is available on the majority of BLE devices , even a smartphone could be playing this role to download codes to device. BLE devices generally have two memory location dedicated to firmware images used by Device Boot Loader,one location for current running version of firmware , the second one is for new version image.Once downloader sent new version , boot loader pick it up in the next time device restarts .The best Compiler in the market so far is 
IAR embedded workbench , expensive but very powerful with a rich IDE software allowing you write your firmware in C/C++  .
In the third scenario you are going to develop an application to handle communication with a specific BLE device.in this case developer is in Master mode or Clien side,here you're dealing mostly with a software  rather than a hardware, if your target OS is supposed to support BLE ,so the only task in your charge is how to use BLE API in order to perform Read/Write/Control operation . I've prepared a few basic operation you need to write your code in such a scenario at the end of this document. 
For Master side development there are two well known development kits available,one from 
Texas Instrument CC2541 SensorTag featured by 6 built-in censors :IR temperature Sensor,Humidity Sensor,Pressure Sensor,Accelerometer,Gyroscope,Magnetometer.

If you're planing to have at least of those features on your device this kit could help you to master the feature by explore all services and characteristics exposed by device,it would be a good starting point in your projectbut currently all demo and library provided by the company are only available for IOS , so if ios is not your host OS for your application, stay tuned to future update from Texas Instrument.
Notice TI solution allow you to compile  code for Master side , if your project is about a customized device with your own profile & services
You should purchase a third party compiler such as  
IAR embedded workbench  to write and download codes to firmware. 

The second one is WICED SMART from Broadcom ,also with the same built-in censors as TI,the good point with WICED SMART is they provide not only a kit to develop master side but also an IDE to develop Slave side and download codes on firmware after defining your services and characteristics of a customizable dongle device, this IDE automatically generates codes based on defined profile information you provide through wizard pages, so you don't need any additional compiler to customize your device.Broadcom IDE integrate to Eclipse and their sdk supports C/C++/Java for Android 

Both Broadcom and TI kit support OTA (Over-The Air) upgrade


Basic Steps in programming:

The codes i ‘ve prepared have been developed and tested under Android OS 4.4 using Java language , but if you’re targetting IOS ,Windows or any other OS the basic steps remain the same.I’ve also provided an example of a complet project attached to this document.
To start this section I present you few basic BLE API functions recently added to Android SDK 4.4  

BluetoothGattService : return the list of services included in devices

BluetoothGattCharacteristic :return the list of characteristics included in GATT(service)?

BluetoothGattDescriptor:return the list of descriptors in this characteristics


 1)first get a bluetooth adapter

 public static BluetoothAdapter getBluetoothAdapter(Context context) {

        // Initializes a Bluetooth adapter.  For API level 18 and above, get a reference to

        // BluetoothAdapter through BluetoothManager.

        final BluetoothManager bluetoothManager =

                (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);

        if (bluetoothManager == null)

            return null;

        return bluetoothManager.getAdapter();


2) checkout BLE

    public static int getBleStatus(Context context) {

        // Use this check to determine whether BLE is supported on the device.  Then you can

        // selectively disable BLE-related features.

        if (!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {            return STATUS_BLE_NOT_AVAILABLE;    }

        final BluetoothAdapter adapter = getBluetoothAdapter(context);
        // Checks if Bluetooth is supported on the device.
       if (adapter == null) {


        if (adapter.isEnabled())


        return STATUS_BLE_ENABLED;



you can also enable BT on your device using :
 Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);

 startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);


Then for proceesing here is the step you should perform:

1)Starting a device discovery /scan as below


given an adapter use API startLeScan to start discovery process something like that: 


 private void scanLeDevice(final boolean enable) {

        if (enable) {

            // Stops scanning after a pre-defined scan period.

            mHandler.postDelayed(new Runnable() {


                public void run() {

                    mScanning = false;




            }, SCAN_PERIOD);


            mScanning = true;


        } else {

            mScanning = false;






                 as you see there is a callback which is request answer back from your device, there you generaly retreive information back from BLE device 


                 // Device scan callback.

    private BluetoothAdapter.LeScanCallback mLeScanCallback =

            new BluetoothAdapter.LeScanCallback() {



        public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {

            runOnUiThread(new Runnable() {


                public void run() {








                 As you see this callback bring to you an object of BluetoothDevice class which inturn store whatever you need to know about all discovered devices including the one you want to connect to

                 BluetoothDevice object gives you " Name + Address" ,from the list of discovered deviced you select the one you're interesting to then 

                 the next step is to forward these two parameters (its name and address) to another activity through extra values in Intent like that:


                  final Intent intent = new Intent(this, DeviceControlActivity.class);

        intent.putExtra(DeviceControlActivity.EXTRAS_DEVICE_NAME, device.getName());

        intent.putExtra(DeviceControlActivity.EXTRAS_DEVICE_ADDRESS, device.getAddress());


                                  now it's the time of connection , from this new activity , 

                                  you're gonna to use ServiceConnection API to start a service which is in charge of connection




                  // Code to manage Service lifecycle.

    private final ServiceConnection mServiceConnection = new ServiceConnection() {



        public void onServiceConnected(ComponentName componentName, IBinder service) {

            mBluetoothLeService = ((BluetoothLeService.LocalBinder) service).getService();

            if (!mBluetoothLeService.initialize()) {

                Log.e(TAG, "Unable to initialize Bluetooth");



            // Automatically connects to the device upon successful start-up initialization.





        public void onServiceDisconnected(ComponentName componentName) {

            mBluetoothLeService = null;




         then using mBluetoothLeService.getSupportedGattServices() we get a list of all services within the selected device

         mBluetoothLeService is an instance of BluetoothLeService which manage connection , states, read/write operations....

        when a device founf wde can call connectGatt API by passing a callback in which we get all information of a service like that:

                 device.connectGatt(this, false, mGattCallback); 

                 in mGattCallback we perform onCharacteristicRead+....



                 private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {


        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {

            String intentAction;

            if (newState == BluetoothProfile.STATE_CONNECTED) {

                intentAction = ACTION_GATT_CONNECTED;

                mConnectionState = STATE_CONNECTED;


                Log.i(TAG, "Connected to GATT server.");

                // Attempts to discover services after successful connection.

                Log.i(TAG, "Attempting to start service discovery:" +



            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {

                intentAction = ACTION_GATT_DISCONNECTED;

                mConnectionState = STATE_DISCONNECTED;

                Log.i(TAG, "Disconnected from GATT server.");






        public void onServicesDiscovered(BluetoothGatt gatt, int status) {

            if (status == BluetoothGatt.GATT_SUCCESS) {


            } else {

                Log.w(TAG, "onServicesDiscovered received: " + status);





        public void onCharacteristicRead(BluetoothGatt gatt,

                                         BluetoothGattCharacteristic characteristic,

                                         int status) {

            if (status == BluetoothGatt.GATT_SUCCESS) {

                broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);





        public void onCharacteristicChanged(BluetoothGatt gatt,

                                            BluetoothGattCharacteristic characteristic) {

            broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);



Khosrov Boloorian – 2014






 © Xosrov 2016