Bluetooth LE Protocol Basics and Beyond

Bluetooth LE is a low-power variant of the Bluetooth standard, designed for use in mobile and embedded devices. It's perfect for applications that require low energy consumption.

The Bluetooth LE protocol is built on top of the Bluetooth 4.0 standard, which introduced a new low-energy radio mode. This mode allows devices to communicate with each other while consuming much less power.

Bluetooth LE devices can operate in two main modes: advertising and scanning. In advertising mode, a device sends out a signal to other devices in range, while in scanning mode, a device searches for nearby devices that are advertising.

The Bluetooth LE protocol stack is the backbone of any Bluetooth LE implementation. It's a complex system, but understanding the basics can help you navigate its intricacies.

The TI BLE Protocol stack is built around a single library file, which contains most of the protocol stack's object code. This is because TI doesn't provide the source code for the protocol stack as a matter of policy. As a result, developers must understand how the various protocol stack layers interact with the application and profiles.

The protocol stack is designed to implement the Bluetooth low energy protocol, which operates at a speed of 1-Mbps. This speed is achieved through a 1-Mbps adaptive frequency-hopping GFSK (Gaussian frequency-shift keying) radio operating in the unlicensed 2.4-GHz ISM (industrial, scientific, and medical) band.

If this caught your attention, see: Bluetooth Le Frequency

Bluetooth LE, or Bluetooth low energy, is a wireless technology designed to transmit small packets of data while consuming significantly less power than its BR/EDR counterpart.

The TI BLE Protocol stack supports several features, including LE Secure Connections, LE Data Length extension, and LE Privacy 1.2.

Optional features can be selectively enabled at build time, which is useful for optimizing memory usage in Bluetooth LE devices.

The main function, contained in the source file main.c, is responsible for bringing up the target with interrupts disabled, drivers initialized, power management on, TI-RTOS tasks created or constructed, and starting the SYS/BIOS kernel scheduler with interrupts enabled.

This function does not return, as it is the starting point at run time and is responsible for initializing the device.

A key feature of Bluetooth LE is its ability to change the Bluetooth device address on a frequent basis, reducing the ability to track an LE device over a period of time.

This is achieved through the LE Privacy 1.2 feature, which extends privacy to the controller by allowing it to both resolve peer and generate local resolvable private addresses (RPAs).

Here's a summary of the key terms related to the privacy feature:

The Bluetooth LE protocol stack is a crucial component of any Bluetooth LE device. It's essentially a framework that enables devices to communicate with each other.

The protocol stack consists of several layers, each with its own specific function. These layers include the Generic Access Profile (GAP), the Link Manager Protocol (LMP), the Logical Link Control and Adaptation Protocol (L2CAP), the Security Manager (SM), and the Generic Attribute Profile (GATT).

The GAP layer is responsible for controlling the RF state of the device, which can be in one of five states: Standby, Advertising, Scanning, Initiating, or Connected.

A device in Standby state is not actively transmitting or receiving data, while a device in Advertising state is transmitting its presence to other devices. A device in Scanning state is searching for nearby devices, and a device in Initiating state is attempting to connect to another device.

The L2CAP layer provides data encapsulation services to the upper layers, allowing for logical end-to-end communication of data.

The Security Manager layer defines the methods for pairing and key distribution, and provides functions for the other layers of the protocol stack to securely connect and exchange data with another device.

The GATT layer is a service framework that defines the sub-procedures for using the Attribute Protocol (ATT). Data communications that occur between two devices in a Bluetooth LE connection are handled through GATT sub-procedures.

The TI BLE Protocol stack also supports the physical layer (PHY), which is a 1-Mbps adaptive frequency-hopping GFSK radio operating in the unlicensed 2.4-GHz ISM band.

Here's a quick rundown of the five states a device can be in, as defined by the GAP layer:

Bluetooth LE Protocol Components are the building blocks of the Bluetooth Low Energy protocol. They enable devices to communicate with each other efficiently.

The three main components of Bluetooth LE are the Controller, Host, and Link Manager. The Controller is responsible for managing the Bluetooth LE radio, while the Host is the application that uses the Bluetooth LE connection.

The Link Manager is responsible for setting up and managing the connection between devices. It handles tasks such as pairing, authentication, and encryption.

Here's an interesting read: Link Bluetooth Headset to Pc

Bluetooth Low Energy technology operates in the same spectrum range as classic Bluetooth, but uses a different set of channels. It has 40 2-MHz channels, compared to classic Bluetooth's 79 1-MHz channels.

The bit rate for Bluetooth Low Energy is 1 Mbit/s, with an option of 2 Mbit/s in Bluetooth 5. This is a significant improvement over classic Bluetooth's Basic Rate scheme.

Bluetooth Low Energy uses frequency hopping to counteract narrowband interference problems. This is a more efficient method than classic Bluetooth's frequency hopping.

Here's a comparison of the specifications for Bluetooth Low Energy and classic Bluetooth:

Bluetooth Low Energy uses Gaussian frequency shift modulation, similar to classic Bluetooth's Basic Rate scheme. This ensures reliable data transmission over the air.

HID connectivity is a crucial aspect of Bluetooth LE protocol components. It enables devices like wireless mice and keyboards to connect to your device using Bluetooth Low Energy technology.

One of the key features of HID connectivity is the use of HOGP, or HID over GATT Profile. This allows devices to offer long-lasting battery life.

HOGP is a protocol that enables devices to communicate with each other using a standardized set of commands. This makes it easy for devices to connect and work together seamlessly.

Here are some benefits of HOGP:

The Peripheral Role is a crucial component of the Bluetooth LE protocol stack. It's responsible for managing the peripheral device's behavior and interactions with other devices.

To use the Peripheral Role, you need to initialize its parameters in the application initialization function. This involves setting up the GAP Peripheral Role Profile, which includes configurable parameters, events, and callbacks.

The initialization process is straightforward: set the GAP Role Parameters using the GAPRole_setParameter function. This function takes four arguments: the parameter ID, the data type, and a pointer to the data value. For example, you can set the initial advertisement enable flag to TRUE using the following code:

```c

GAPRole_setParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &initialAdvertEnable);

```

Once the parameters are initialized, you can proceed with the next step: initializing the GAPRole task and passing application callback functions to it. This is also done in the application initialization function.

The GAPRole task processes most of the GAP-related events passed to it from the Bluetooth low energy protocol stack. It also forwards some events to the application, such as the link termination event, which is automatically restarted by the GAPRole task.

Here's a summary of the steps to use the Peripheral Role:

The Central Role is a crucial part of Bluetooth Low Energy (BLE) communication, and it's defined in the central.c and central.h files. This module handles the full API, including commands, configurable parameters, events, and callbacks.

To use the Central Role, you need to initialize the GAPRole parameters in your application's initialization function. This is where you set up the GAP parameters as well.

The Central Role task has three main steps: initializing the GAPRole parameters, starting the GAPRole task, and sending GAPRole commands from your application.

Broaden your view: Wireless Application Protocol

Here are the steps in more detail:

1. Initialize the GAPRole parameters in your application's initialization function.

2. Start the GAPRole task by passing function pointers to your application's callback function to the central GAPRole.

3. Send GAPRole commands from your application, such as GAPCentralRole_StartDiscovery(), to initiate device discovery.

The return value from the protocol stack only indicates whether the attempt to perform device discovery was initiated, so you need to wait for the device to be discovered asynchronously as a GAP event forwarded through the central GAPRole callbacks.

The GAPRole task processes the GAP events it receives from the protocol stack and forwards some events to your application, allowing you to handle device discovery and other events in your application code.

Bluetooth LE Protocol Features are a crucial aspect of Bluetooth Low Energy technology, and they can be configured to suit specific use cases. The TI Bluetooth Low Energy Protocol Stack Features can be summarized in Table 15, which lists the available features that can be included or excluded in the stack project.

Some features are always enabled, such as V41_CTRL_CFG, EXT_DATA_LEN_CFG, and PRIVACY_1_2_CFG. The HOST_CONFIG feature configures the stack's host layer based on its targeted GAP role, and it includes combo roles such as PERIPHERAL_CFG+OBSERVER_CFG and CENTRAL_CFG+BROADCASTER_CFG.

To conserve memory, it's essential to exclude certain Bluetooth Low Energy protocol stack features that may not be required. For example, if directed advertisements are not needed, the GAP bond manager's GATT client features can be disabled by commenting out the #defineGBM_GATT_NO_CLIENT preprocessor option in gapbondmgr.c.

Here is a summary of the configurable features:

Bluetooth Low Energy is a distinct protocol from classic Bluetooth, but devices can support both. This is possible thanks to the Bluetooth 4.0 specification, which allows for dual-mode devices that can implement either or both LE and BR/EDR systems.

Dual-mode devices can share a single radio antenna, which is convenient. They use the same 2.4 GHz radio frequencies as classic Bluetooth, but with a simpler modulation system.

Suggestion: Radio Bluetooth Philips

Here are the different types of Bluetooth devices:

Bluetooth Low Energy devices have some great features, including low power requirements that allow them to operate for "months or years" on a button cell. They're also small in size and low in cost, making them a great option for many applications.

Consider reading: What Is Bluetooth Le Audio

The Bluetooth LE protocol has several application profiles that define how a device works in a particular application. These profiles are based on the Generic Attribute Profile (GATT), which is a general specification for sending and receiving short pieces of data over a low energy link.

Manufacturers are expected to implement the appropriate specifications for their device to ensure compatibility. A device may contain implementations of multiple profiles.

The majority of current low energy application profiles are based on GATT, but the Bluetooth mesh profile is an exception, being based on the General Access Profile (GAP).

Recommended read: List of Bluetooth Profiles

Proximity sensing is a key feature of Bluetooth LE technology, allowing devices to detect each other's presence and proximity. This is made possible by the long battery life of 'always-on' devices, which can continuously monitor their surroundings.

Manufacturers of iBeacon devices implement the necessary specifications to utilize proximity sensing capabilities supported by Apple's iOS devices. This enables a range of applications, including those that rely on proximity monitoring.

The proximity profile, or PXP, allows a proximity monitor to detect whether a proximity reporter is within a close range. This can be estimated using the radio receiver's RSSI value, although it doesn't provide an absolute calibration of distances.

An alarm may be sounded when the distance between the devices exceeds a set threshold. This is useful for applications such as finding a misplaced device.

Some relevant application profiles include:

Privacy 1.2 is a feature that's always enabled in the BLE-Stack 3.00.00, and it's used to enhance the security of Bluetooth Low Energy connections. Most of the privacy features are handled by the GAP bond manager in the stack.

The GAP bond manager doesn't enable GATT client features by default, which means it won't query the Central Address Resolution characteristic of the remote device. This is done to conserve flash memory.

To perform a directed advertisement when the initiator's address is set to Private Resolvable Address, the peripheral device must read the Central Address Resolution characteristic of its remote device first. This is a requirement to ensure address resolution is supported, as specified in the 4.2 Bluetooth specification.

To add this functionality, you can simply comment out the #defineGBM_GATT_NO_CLIENT preprocessor option in gapbondmgr.c. This will allow the GAP bond manager to query the Central Address Resolution characteristic.

Here's a code snippet that enables auto-syncing of the white list after bonding:

```

uint8_t autoSyncWhiteList = TRUE;

GAPBondMgr_SetParameter(GAPBOND_AUTO_SYNC_WL, sizeof(uint8_t), &autoSyncWhiteList);

```

This will automatically add devices to the white list after bonding, making it easier to manage connections.

For your interest: List of Web Service Protocols

The Bluetooth LE protocol implementation involves several key components, including the L2CAP layer, which provides data encapsulation services to the upper layers, allowing for logical end-to-end communication of data. This layer is responsible for protocol multiplexing capability, segmentation, and reassembly operation for data exchanged between the host and the protocol stack.

The HCI layer provides communication between the host and controller through a standardized interface, which can be implemented either through a software API or by a hardware interface such as UART, SPI, or USB. The Specification of the Bluetooth System describes Standard HCI commands and events.

The Generic Access Profile (GAP) layer directly interfaces with the application and/or profiles, to handle device discovery and connection-related services for the device. It controls the RF state of the device, with the device in one of five states: Standby, Advertising, Scanning, Initiating, and Connected.

Here's a brief overview of the Bluetooth LE protocol stack architecture:

Bluetooth Low Energy integrated circuits, which enable the technology, were announced by various manufacturers starting in late 2009. These ICs are designed to be upgradable through firmware.

The ICs commonly use software radio, allowing updates to the Bluetooth LE specification to be accommodated through a simple firmware upgrade. This makes it easier to implement new features and improvements to the technology.

Curious to learn more? Check out: Define Bluetooth Technology

To implement a Bluetooth LE protocol, you need to understand the system architecture, application, and Bluetooth LE stack framework. A system designer must have a firm grasp on these concepts to implement a custom Bluetooth LE application.

The BLE-Stack supports a network processor configuration (host_test) that allows an application to run on an external MCU to interface to the BLE-Stack. This configuration can accept all LE HCI commands.

Standard LE HCI Commands and Events are documented in Volume 2, Part E, Section 7 of the 4.2 Core Spec. These commands are used to transport commands and events between the host and controller elements of the Bluetooth protocol stack.

To use these commands, you need to find the command in the core spec, map it to a BLE stack command, fill in the parameters, and call the command from somewhere in the application. For example, the Read RSSI Command is implemented as HCI_ReadRssiCmd(0x0000);.

The HCI layer provides communication between the host and controller through a standardized interface. This layer can be implemented either through a software API or by a hardware interface such as UART, SPI, or USB.

The BLE-Stack API Reference provides a detailed description of the Bluetooth LE protocol stack APIs, including the HCI layer, L2CAP layer, Security Manager layer, GAP layer, ATT layer, and GATT layer.

To define the system behavior, you need to use the Bluetooth LE protocol stack APIs to add profiles, define the GATT database, configure the security model, and so forth. The Generic Attribute Profile (GATT) layer is a service framework that defines the sub-procedures for using ATT.

The Bluetooth LE protocol stack consists of the controller and the host. The controller is a subsystem that consists of the lower layer protocols in the LE stack, including the physical radio that can generate and receive radio waves in the 2.4 GHz band.

The host is typically a software stack made up of the topmost layers of the LE stack as well as what are known as profiles. A profile offers details on how each protocol in the stack should communicate with one another and work together for a certain usage model.

Expand your knowledge: Bluetooth Software Linux

Here are the primary components or subsystems of the LE protocol stack:

The controller consists of the lower layer protocols in the LE stack, including the physical radio. The host is typically a software stack made up of the topmost layers of the LE stack as well as what are known as profiles.

Task events are set by the BLE-Stack through the Events Module. The BLE-Stack sets an event in the application task using the Events Module.

The HCI_EXT_ConnEventNoticeCmd() function is an example of a task event that indicates the end of a connection event. This event is set when the connection is terminated.

In the simple_peripheral task function, an example of a task event that signals the end of a connection event is shown. The event is checked by comparing the pEvt->signature to 0xFFFF.

The pEvt->signature is always equal to 0xFFFF if the event is coming from the BLE-Stack. This is a unique identifier for events coming from the BLE-Stack.

Inter-task events must be unique for the given task and must be a power of 2, so only 1 bit is set. The pEvt->event variable is initialized as a uint16_t, allowing for a maximum of 16 events.

The following event values cannot be used for inter-task events: GAP_EVENT_SIGN_COUNTER_CHANGED (0x4000), GAP_EVENT_SIGN_COUNTER_CHANGED 0x4001, GAP_EVENT_SIGN_COUNTER_CHANGED 0x4002, GAP_EVENT_SIGN_COUNTER_CHANGED 0x4003, and GAP_EVENT_SIGN_COUNTER_CHANGED 0x4004.

The Maximum Transmission Unit (MTU) plays a crucial role in Bluetooth LE protocol implementation.

The Bluetooth low energy stack supports fragmentation and recombination of L2CAP PDUs at the link layer.

By default, LE devices assume the size of the L2CAP PDU is 27 bytes, which corresponds to the maximum size of the LE packet that can transmit in a single connection event packet.

The L2CAP protocol header is 4 bytes, resulting in a default size for ATT_MTU of 23.

Using the LE Data Length Extension feature, the length of the LE packet can be up to 251 bytes.

Optimize stack memory by configuring the Bluetooth low energy protocol stack to maximize RAM and flash memory for the application. This involves setting parameters that impact runtime RAM usage, such as the maximum allowable size and number of PDUs.

The TI Bluetooth low energy protocol stack is designed to use a small RAM footprint, allowing the application to control the stack's behavior through the runtime ICall heap. For example, an application that sends only one GATT notification per connection event must store only one PDU in the heap.

Minimize flash usage of the protocol stack by including only the Bluetooth low energy features required to implement the device's defined role. This will increase the amount of flash memory allocated to the application project.

The available protocol stack configurable features are described in Stack Configurations, where you can find the features that can be added or removed to optimize stack memory.

Bluetooth LE Protocol Security is a robust feature that ensures the integrity and confidentiality of data transmitted over Bluetooth Low Energy.

Bluetooth LE has a built-in mechanism to prevent data tampering, thanks to the Cyclic Redundancy Check (CRC) that's recalculated and checked by the receiving device.

The Encrypted Advertising Data (EAD) feature allows some or all of the application data payload to be encrypted, providing an additional layer of security.

A standard mechanism for sharing key material between broadcasting devices and intended receivers is also defined, making it possible for data to be decrypted when received.

Intriguing read: Bluetooth Security Risks

Bluetooth Low Energy has a robust security feature called Encrypted Advertising Data (EAD), which allows some or all of the application data payload to be encrypted.

This encryption ensures that sensitive data transmitted in advertising packets is protected from unauthorized access.

A standard mechanism for sharing key material between broadcasting devices and intended recipients is also defined, enabling secure data exchange.

All transmitted Bluetooth LE PDUs include a Cyclic Redundancy Check (CRC) that is recalculated and checked by the receiving device to detect any changes during transmission.

This CRC mechanism provides an additional layer of security, helping to prevent tampering or data corruption.

Additional reading: Internet Security Protocols

Bluetooth Low Energy devices have a built-in feature that adds devices to a white list after bonding, which can be enabled using the code: uint8_t autoSyncWhiteList = TRUE; GAPBondMgr_SetParameter(GAPBOND_AUTO_SYNC_WL, sizeof(uint8_t), &autoSyncWhiteList);

The address of a Bluetooth LE device changes when advertising, and this change can be verified with a sniffer. The default timeout value between private (resolvable) address changes is 15 minutes.

To test the privacy with white list feature, follow these steps:

Bluetooth LE protocol configuration is a crucial aspect of developing Bluetooth Low Energy applications. The Generic Access Profile (GAP) defines devices' roles in Bluetooth LE communication, including Broadcaster, Observer, Peripheral, and Central roles.

The GAP layer functionality is mostly defined in library code, and most of its functions are used by the GAPRole. To configure the GAP layer, you can use the GAP_SetParamValue() and GAP_GetParamValue() functions to set or get parameters such as advertising and scanning intervals.

To optimize memory usage, you can configure the Bluetooth Low Energy protocol stack to include only the required features. This can be done by selecting the correct stack configuration in the build_config.opt file, which affects the amount of flash memory available to the application.

The Bluetooth Low Energy protocol stack can be configured to include or exclude certain features by changing the library configuration in the stack project. This is done through the build_config.opt file, which defines the available Bluetooth Low Energy features.

To configure the stack's host layer, you can use the HOST_CONFIG option in the build_config.opt file. This option configures the stack's host layer based on its targeted GAP role, such as Peripheral, Central, or Broadcaster.

Here are some of the configurable features in the Bluetooth Low Energy protocol stack:

To increase the available flash memory allocated to the application project, minimize the flash usage of the protocol stack by including only the required features. This can be done by selecting the correct stack configuration and excluding unnecessary features.

The Bluetooth LE protocol data transfer is a crucial aspect of Bluetooth Low Energy technology. It allows devices to send data channel packet data units (PDUs) with payloads of up to 251 bytes of application data.

The data length extension feature is a significant improvement, increasing the data rate by around 2.5 times compared to Bluetooth Core Specification version 4.0 and 4.1 devices.

This feature enables devices to send larger payloads, making it ideal for applications that require a high data transfer rate. The CC2640R2F supports these maximum values, making it a great choice for developers.

To give you a better idea of the maximum sizes and times supported, here's a table summarizing the data:

This table shows the maximum sizes and times supported for devices with and without the data length extension feature.

The Bluetooth LE protocol stack is broadly broken down into three primary components or subsystems: the application, host, and controller blocks. These subsystems work together to enable devices to communicate with each other.

The host and controller subsystems house different protocol layers. The host layer is responsible for controlling the device's behavior, while the controller layer handles the actual communication with other devices.

In Bluetooth LE, devices can communicate with each other in a variety of ways, including advertising and scanning. Advertising involves a device broadcasting its data, while scanning involves a device searching for advertised data.

One device is tasked with advertising, while the other is tasked with scanning. For example, beacons in a retail store might broadcast their data, which could be marketing notifications, to any LE-enabled smartphone in range. The beacon is the advertiser and the smartphone is the observer who is scanning.

LE Audio was announced in January 2020 and allows the protocol to carry sound, introducing features like one set of headphones connecting to multiple audio sources or multiple headphones connecting to one source, and also adds support for hearing aids.

Readers also liked: Bluetooth Technology in Headphones

This new protocol also introduces LC3 as its default codec, which offers longer battery life compared to standard Bluetooth audio.

Specifications on the implementation of Basic Audio Profile and Coordinated Set Identification were released in 2021, providing a clear outline of how to implement these features.

The Common Audio Profile and Service were specified in March 2022, offering a standardized way for devices to communicate and share audio content.

Readers also liked: Rcs Universal Profile

L2CAP connection-oriented channels are a type of channel used in Bluetooth low energy devices. They're used for bidirectional data transfer between two devices.

To create an L2CAP CO channel, you can use the APIs provided by the Bluetooth low energy stack SDK. This feature is enabled by default in the protocol stack.

A sample connection and data exchange process between a master and slave device using a L2CAP connection-oriented channel is shown in Figure 59. This figure illustrates how the L2CAP layer uses Credit Based Flow Control mode for Connection-Oriented Channels.

On a similar theme: Bluetooth Le Channels

In L2CAP CO channels, the local endpoint must be in the range from 0x0040 to 0xFFFF. This endpoint is used to identify the logical link and the local endpoint.

Here are some key terms related to L2CAP CO channels:

The largest application data payload size supported by the controller is referred to as the PDU size. This size does not include packet overhead, such as access address or preamble.

The Bluetooth Low Energy protocol stack is made up of three primary components or subsystems: the application, host, and controller blocks. These blocks work together to enable devices to communicate with each other.

The host and controller subsystems house different protocol layers. The host handles the application and profiles, while the controller handles the RF state of the device.

In Bluetooth LE, devices can communicate without connecting first, a process called advertising. The device that advertises is called the advertiser, while the device that scans for the advertisement is called the scanner.

The Generic Access Profile (GAP) layer controls the RF state of the device, with the device in one of five states: standby, advertising, scanning, initiating, or connected. Advertisers transmit data without connecting, while scanners scan for advertisers.

Here are the five states of the device, as defined by the GAP layer:

The HCI layer provides communication between the host and controller through a standardized interface. This layer can be implemented either through a software API or by a hardware interface such as UART, SPI, or USB.