Bluetooth Low Energy

Introduction

Bluetooth low energy wireless technology gives context to the environment around you.It perfect for devices that run for long periods on power sources, such as coin cell batteries. Native support for Bluetooth technology on every major operating system enables development for a broad range of connected devices.

Key Benefit

  • low power consumption.
  • small size.
  • connectivity to mobile phones.
  • low cost,robust,efficient.
  • multi-vendor interoperability.
  • global availability, license free.

How low power work?

BLE device remains in sleep mode constantly except for when a connection is initiated. The actual connection times are only a few ms, unlike Bluetooth which would take ~100mS. The reason the connections are so short, is that the data rates are so high at 1 Mb/s.

How achieved?

  • By keeping the radio off.
  • Lower standby time, Faster connection, Lower peak power.
  • BLE technology uses only 3 advertising channels.

Application of BLE

Bluetooth with its LE functionality powers the Internet of Things. You wake up and go for a run with a heart rate monitor that communicates with your smart watch, then listen to music through your shower head.

  • Transferring small amounts of data between nearby devices.
  • Interacting with proximity sensors like Google Beacons to give users a customized experience based on their current location.
  • It can enable proximity detection(I’m in the car).
  • It can enable presence detection (Turn the lights on when I walk around the house).
  • It can send data from anything to the Internet (I’ve walked 4,000 steps today)
  • It can control everything (Unlock doors)
  • It connects everything to the Internet (check if you switched the lights off)

Key Terms and Concepts

1.Generic Attribute Profile (GATT) : The GATT profile is a general specification for sending and receiving short pieces of data known as “attributes” over a BLE link. All current Low Energy application profiles are based on GATT.

  • The Bluetooth SIG defines many profiles for Low Energy devices. A profile is a specification for how a device works in a particular application. Device can implement more than one profile. For example, a device could contain a heart rate monitor and a battery level detector

 

2.Attribute Protocol (ATT)—GATT is built on top of the Attribute Protocol (ATT). This is also referred to as GATT/ATT. ATT is optimized to run on BLE devices. To this end, it uses as few bytes as possible. Each attribute is uniquely identified by a Universally Unique Identifier (UUID), which is a standardized 128-bit format for a string ID used to uniquely identify information. The attributes transported by ATT are formatted as characteristics and services.

3.Characteristic—A characteristic contains a single value and 0-n descriptors that describe the characteristic’s value. A characteristic can be thought of as a type, analogous to a class.

4.Descriptor—Descriptors are defined attributes that describe a characteristic value. For example, a descriptor might specify a human-readable description, an acceptable range for a characteristic’s value, or a unit of measure that is specific to a characteristic’s value.

5.Service—A service is a collection of characteristics. For example, you could have a service called “Heart Rate Monitor” that includes characteristics such as “heart rate measurement”. You can find a list of existing GATT-based profiles and services on bluetooth.org.

6.Central vs. peripheral : The device in the central role scans, looking for advertisement, and the device in the peripheral role makes the advertisement.For example , you have an phone and battery level detector that is a BLE device. The phone supports the central role and the activity tracker supports the peripheral role.

7.GATT server vs. GATT client This determines how two devices talk to each other once they’ve established the connection.For example , App is the GATT client. The app gets data from the GATT server, which is a BLE Battery Level Detector.

Android bluetooth low energy example

In the example, the Android app running on an Android device is the GATT client. The app gets data from the GATT server, which is a BLE Battery Level Detector that supports the Battery Level Service.

Key Classes

BluetoothDevice: Represents a remote Bluetooth device. You create a connection with the respective device or query information about it, such as the name, address, class, and bonding state. 

BluetoothAdapter: You perform fundamental Bluetooth tasks, such as initiate device discovery, query a list of paired devices, instantiate a BluetoothDevice using a known MAC address.getRemoteDevice(String) to create one representing a device of a known MAC address or get one from the set of bonded devices returned by getBondedDevices().Use getBluetoothLeScanner() to get an instance of BluetoothLeScanner.

BluetoothGatt: Provides Bluetooth GATT functionality to enable communication with Bluetooth Smart or Smart Ready devices.

BluetoothLeScanner: Class provides methods to perform scan related operations for Bluetooth LE devices. An application can scan for a particular type of Bluetooth LE devices using ScanFilter. It can also request different types of callbacks for delivering the result.

BLE Permissions

You need BLUETOOTH permission to perform requesting a connection, accepting a connection, and transferring data.You must also declare the BLUETOOTH_ADMIN permission for device discovery or manipulate Bluetooth settings.

Android 6.0 (API level 23), users grant permissions to apps while the app is running, not when they install the app.

Get the BluetoothAdapter

The BluetoothAdapter represents the device’s own Bluetooth adapter (the Bluetooth radio). There’s one Bluetooth adapter for the entire system, and your application can interact with it using this object.

Enable Bluetooth

If Bluetooth but disabled, then you can request that the user enable Bluetooth without leaving your application.

Scan BLE Devices

To scan BLE devices, you use the startScan() method.Scanning is battery-intensive, you should observe the following guidelines:

  • As soon as you find the desired device, stop scanning.
  • Never scan on a loop, and set a time limit on your scan. A device that was previously available may have moved out of range, and continuing to scan drains the battery.

startScan() method takes a ScanCallback as a parameter. You must implement this callback for results are returned.

The following snippet shows how to start and stop a scan

 

In this example, app provides an activity BluetoothDetectorActivity to connect, display data, and display GATT services and characteristics supported by the device.

Ble Client
Battery Level Detector

Connecting to a GATT Server(BLE Device)

Based on user input,DeviceControlActivity communicates with a Service called BluetoothLEService, which interacts with the BLE device via the Android BLE API

BluetoothGattCallback:Used to deliver results to the client, such as connection status, as well as any further GATT client operations. 

The first step in interacting with a BLE device is connecting to it (connecting to the GATT server on the device). To connect to a GATT server on a BLE device, you use the connectGatt() method. This method takes three parameters: a Context object,autoConnect, and a reference to a BluetoothGattCallback

When a particular callback is triggered, it calls the broadcastUpdate() helper method and passes it an action. Data parsing in this section is performed in accordance with the Bluetooth Battery Service Measurement profile specifications

 

To enable or disable notifications for a given characteristic setCharacteristicNotification to
BluetoothGatt.Reads the requested characteristic from the associated remote device set
readCharacteristic.

 

In BatteryDetectorActivity, these events are handled by a BroadcastReceiver.

The Following snippet show display Gatt connected service

Connect Bluetooth service

Closing the Client App

Once your app has finished using a BLE device, it should call close() so the app can release resources appropriately.

How to test BLE Client?

The BLE Peripheral Simulator is an Android app that allows developers to try out new features of app Bluetooth without the need for a BLE Peripheral Device.

BLE Peripheral with one of three services:

  • Battery Service
  • Heart Rate Service
  • Health Thermometer Service

Use the  Bluetooth features to connect to the app to Read and Write Characteristics, Subscribe to Notifications for when the Characteristics change, and Read and Write Descriptors.

The device in the central role scans, looking for advertisement of Battery Level Detector.

The device in the peripheral role makes the advertisement of Battery Level.

Download this project from GitHub.

 

Related Post

Android MQTT Client

Creating and Monitoring Geofences

 

 

Android MQTT Client

What is MQTT?

Message Queue Telemetry Transport(MQTT) is a machine-to-machine (M2M)/Internet of Things connectivity protocol. It was designed as an extremely lightweight publish-subscribe based messaging protocol for use on top of the TCP/IP protocol. It is designed for connections to remote locations where a small code footprint is required or the network bandwidth is limited. The publish-subscribe messaging pattern requires a message broker. The broker is responsible for distributing messages to interested clients based on the topic of a message.

Real world applications

MQTT has been used in sensors communicating to a broker via satellite link, over occasional dial-up connections with healthcare providers, and in a range of home automation and small device scenarios. It is also ideal for mobile applications because of its small size, low power usage, minimized data packets, and efficient distribution of information to one or many receivers.

MQTT Broker

The broker is primarily responsible for receiving all messages, filtering them, decide who is interested in it and then sending the message to all subscribed clients.It also holds the session of all persisted clients including subscriptions and missed messages.MQTT Mosquitto is a message broker that implements the MQTT 3.1/3.1.1.There is a publically accessible sandbox server for the Eclipse IoT projects available at iot.eclipse.org:1883.

Publish/Subscribe

Multiple clients connect to a broker and subscribe to topics that they are interested in. Clients also connect to the broker and publish messages to topics.

Android MQTT client

The Eclipse Paho project provides open-source client implementations of MQTT.Paho Android Service is an MQTT client library written in Java for developing applications on Android.The MQTT connection is encapsulated within an Android Service that runs in the background of the Android application, keeping it alive when the Android application is switching between different Activities.The Paho Android Service is an interface to the Paho Java MQTT Client library for the Android Platform.

Installation

The most convenient way to start a new Android Application is to use Android Studio. Download  Paho Android Service and Android MQTT Client library.Go to your libs folder inside app folder and paste all your .jar

To add the Paho Android Service as a dependency to you app add the following parts to your gradle file.

Permission

The Paho Android Service needs the following permissions to work

To be able to create a binding to the Paho Android Service, the service needs to be declared in the AndroidManifest.xml. Add the following within the <application> tag

MQTT Connection Option

MqttAndroidClient will connect with MQTT 3.1.1 by default. To intentionally connect with MQTT 3.1  MqttConnectOptions object can be supplied to the connect method

Clean session

On connection, a client sets the “clean session” flag.If the clean session is set to false, then the connection is treated as durable. This means that when the client disconnects, any subscriptions it has will remain and any subsequent QoS 1 or 2 messages will be stored until it connects again in the future. If the clean session is true, then all subscriptions will be removed from the client when it disconnects.

Automatic Reconnect

Sets whether the client will automatically attempt to reconnect to the server if the connection is lost.If set to true, in the event that the connection is lost, the client will attempt to reconnect to the server. It will initially wait 1 second before it attempts to reconnect, for every failed to reconnect attempt, the delay will double until it is at 2 minutes at which point the delay will stay at 2 minutes.

Wills

When a client connects to a broker, it may inform the broker that it has a will. This is a message that it wishes the broker to send when the client disconnects unexpectedly. The will message has a topic, QoS and retains status just the same as any other message.

Receive MQTT Message

Disconnect Options

Messages published to the topic if the connection is available, but if it disconnects and connects again offline messages send.Holds the set of options that govern the behavior of Offline (or Disconnected) buffering of messages.

Create MQTT Client

Creates an instance of an Android MQTT client, that will bind to the Paho Android Service. By calling the connect method of the MqttAndroidClient the client will asynchronously try to connect to the MQTT broker and return a token. That token can be used to register callbacks, to get notified when either the MQTT-connection gets connected or an error occurs

Topics

Messages in MQTT are published on topics. There is no need to configure a topic, publishing on it is enough. Topics are treated as a hierarchy, using a slash (/) as a separator much in the same way as a filesystem.

Clients can receive messages by creating subscriptions. A subscription may be to an explicit topic, in which case only messages to that topic will be received, or it may include wildcards. Two wildcards are available, +or.#

Quality of Service

MQTT defines 3 levels of Quality of Service (QoS). The QoS defines how hard the broker/client will try to ensure that a message is received. Messages may be sent at any QoS level, and clients may attempt to subscribe to topics at any QoS level.

  • 0: The broker/client will deliver the message once, with no confirmation.
  • 1: The broker/client will deliver the message at least once, with confirmation required.
  • 2: The broker/client will deliver the message exactly once by using a 4 step handshake.

Retained Messages

The broker will keep the message even after sending it to all current subscribers. If a new subscription is made that matches the topic of the retained message will be sent to the client. This is useful as a “last known good” mechanism. With a retained message, the client will receive an instant update.

Publish Message

The MqttAndroidClient allows messages to be published via its publish method.

Subscribe

Subscriptions can be created via the MqttAndroidClient.subscribe method, which takes the topic and the QOS as parameters and returns a IMqttToken.

Unsubscribe

Disconnect MQTT Client

Download this project from GitHub.

MQTTBox

MQTTBox enables you to create MQTT clients to publish or subscript topics, create MQTT virtual device networks, load test MQTT devices or brokers.

Config MQTT Client

1.Create MQTT client

2.Config MQTT client

Host : iot.eclipse.org:1883

Protocol : mqtt/tcp

3.Publish/Subscribe

Related Post

Android Bluetooth Low Energy Client

Creating and Monitoring Geofences

 

Creating and Monitoring Geofences

What is Geofence?

Geofencing is a location-based service that sends a notification to smartphone users who enter a defined geographic area. Some companies send promotions to customers’ smartphones when they enter a store, mall or neighborhood.

geofence viewApplications of Geofence

Marketers can use geofencing by geofencing a retail store and send a coupon to a customer with a mobile app crosses the boundary.

Geofencing is used by the human resource department to monitor employees working in special locations

Geofencing, used with child location services, can notify parents if a child leaves a designated area.

1.Overview

To use geofencing, start by defining the geofences you want to monitor.Each Geofence object contains the following information:

  1. Latitude, longitude, and radius
  2. Expiration time
  3. Transition type
  4. Geofence ID

2.Set up for Geofence Monitoring

To use geofencing, your app must request ACCESS_FINE_LOCATION.To request this permission, add the following element as a child element of the <manifest> element in your app manifest

3.Set Up Google Play Service

Access the location provider, the project must include Google Play services. Download and install the Google Play services component via the SDK Manager and add the library to your project. For details, see the guide to Setting Up Google Play Services.

4.Connect to Google Play Services

To connect to the API, you need to create an instance of the Google Play services API client. In your activity’s onCreate() method, create an instance of Google API Client, using the GoogleApiClient.Builderclass to add the LocationServices API, as the following code snippet shows.

Android 6.0 (API level 23), users grant permissions to apps while the app is running, not when they install the app.

Here is an example activity that implements the callback interfaces that adds  to the Google API Client

To connect, call connect() from the activity’s onStart() method. To disconnect, call disconnect() from the activity’s onStop() method.

5.Request Location Updates

Before requesting location updates, your app must connect to location services and make a location request.Once a location request is in place you can start the regular updates by calling requestLocationUpdates().

Do this in the onConnected() callback provided by Google API Client, which is called when the client is ready.

Stop Location Updates

whether you want to stop the location updates when the activity is no longer in focus.

6.Create geofence objects

To create geofence object we need Latitude, Longitude, and Radius, Expiration time, Transition type, Geofence ID

Your app needs to create and add geofences using the location API’s builder class for creating Geofence objects, and the convenience class for adding them.

Specify geofences and initial triggers

The following snippet uses the GeofencingRequest class and its nested GeofencingRequestBuilder class to specify the geofences to monitor and to set how related geofence events are triggered

Geofence triggers

GEOFENCE_TRANSITION_ENTER:Transition triggers when a device enters a geofence GEOFENCE_TRANSITION_EXIT:Transition triggers when a device exits a geofence. INITIAL_TRIGGER_ENTER: Tells Location services that  should be triggered if the the device is already inside the geofence.                                                       INITIAL_TRIGGER_DWELL:Triggers events only when the user stops for a defined duration within a geofence. This approach can help reduce “alert spam” resulting from large numbers notifications.

7.Handle Geofence Transitions

When Location Services detects that the user has entered or exited a geofence, it sends out the Intent contained in the PendingIntent you included in the request to add geofences. This Intent is received by a Service which obtains the geofencing event from the intent, determines the type of Geofence transition(s), and determines which of the defined geofences was triggered. It then sends a notification as the output.

IntentService to listen for geofence transitions, add an element specifying the service name. This element must be a child of the <application> element:

The following snippet shows how to define an IntentService that log when a geofence transition occurs. You can define notification . When the user clicks the notification, the app’s main activity appears

Define an Intent for geofence transitions

The Intent sent from Location Services can trigger various actions in your app.IntentService is a good way to handle the intent. An IntentService can post a notification, do long-running background work, send intents to other services, or send a broadcast intent. The following snippet shows how to define a PendingIntent that starts an IntentService:

Add geofences

To add geofences, use the GeofencingApi.addGeofences() method. Provide the Google API client, the GeofencingRequest object, and the PendingIntent. The following snippet, which processes the results in onResult(),  implements ResultCallback:

Stop Geofence Monitoring

The following snippet removes geofences by PendingIntent, stopping all further notification when the device enters or exits previously added geofences:

When geofences required  Re-register?

The app must re-register geofences if they’re still needed after the following events, since the system cannot recover the geofences in the following cases:

  • The device is rebooted.
  • The app is uninstalled and re-installed.
  • The app’s data is cleared.
  • Google Play services data is cleared.
  • The app has received a GEOFENCE_NOT_AVAILABLE alert. This typically happens after NLP (Android’s Network Location Provider) is disabled.

 

Registered geofences are kept in the com.google.process.location process owned by the com.google.android.gms package. The app doesn’t need to do anything to handle the following events, because the system restores geofences after these events:

  • Google Play services is upgraded.
  • Google Play services is killed and restarted by the system due resource restriction.
  • The location process crashes.

Download this project from GitHub.

Related Posts

Android Bluetooth Low Energy Client

Android MQTT Client