December 21, 2023

Introduction to the nRF52 SoftDevice: Architecture and Concept

The nRF52 SoftDevice is a crucial component when working with Nordic Semiconductor’s nRF52 series of microcontrollers. It provides a software framework that allows for easy development and implementation of Bluetooth Low Energy (BLE) applications. In this blog post, we will explore the architecture and concept behind the nRF52 SoftDevice in detail, with extensive examples and explanations.

What is a SoftDevice?

A SoftDevice is essentially a Bluetooth protocol stack that runs on top of the microcontroller’s hardware abstraction layer (HAL). It provides a higher-level API for seamless BLE communication, making it easier for developers to create applications without having to worry about the low-level implementation details of the Bluetooth protocol.

The nRF52 SoftDevice consists of two main components:

1. The SoftDevice Controller, responsible for managing the radio and providing a set of APIs for BLE communication.
2. The SoftDevice Handler, which acts as an abstraction layer between the application and the SoftDevice Controller.

Architecture

The nRF52 SoftDevice architecture follows a layered approach. At the lowest level, we have the radio hardware, which is responsible for transmitting and receiving BLE packets. On top of that, we have the SoftDevice Controller, which controls the radio and provides the necessary APIs for BLE communication.

The SoftDevice Handler acts as a bridge between our application and the SoftDevice Controller. It handles initialization, events, and callbacks, making it easier for us to interact with the SoftDevice. This architecture allows for efficient utilization of the microcontroller’s resources while providing a simple and clean interface for application development.

Concepts

GAP (Generic Access Profile)

The Generic Access Profile defines how devices interact with one another in the Bluetooth ecosystem. It includes functionalities such as device discovery, connection establishment, and advertising. The SoftDevice provides APIs to interact with the GAP layer, allowing us to configure device behavior and handle connection events.

GATT (Generic Attribute Profile)

The Generic Attribute Profile defines the structure and organization of data that devices can exchange. It uses a client-server model to manage information, with attributes represented as services and characteristics. The SoftDevice provides APIs to establish GATT connections, discover services and characteristics, and read/write data.

Events and Callbacks

The SoftDevice generates various events and callbacks to notify the application about BLE-related activities. For example, it may generate an event when a new device is discovered during scanning, or when a connection is established. These events can be handled by the application to implement the desired functionality.

Example: Establishing a Connection

To demonstrate the usage of the nRF52 SoftDevice, let’s walk through an example of establishing a connection between two devices.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"

void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    // Event handling logic here
}

int main(void)
{
    // Initialize SoftDevice
    APP_ERROR_CHECK(nrf_sdh_enable_request());

    // Register BLE event handler
    NRF_SDH_BLE_OBSERVER(m_ble_observer, 1, ble_evt_handler, NULL);

    // Start scanning for devices
    nrf_ble_scan_t scan_param = {...};
    APP_ERROR_CHECK(nrf_ble_scan_start(&scan_param));

    // Enter main loop
    while (true)
    {
        // Application logic here
    }
}

In this example, we first include the necessary SoftDevice headers. We then define a BLE event handler function, which will be called whenever a BLE event occurs. Inside our main function, we enable the SoftDevice by calling nrf_sdh_enable_request(). Next, we register our BLE event handler using the macro NRF_SDH_BLE_OBSERVER, which ensures that our event handler gets called when a BLE event occurs.

We can then start scanning for devices by calling nrf_ble_scan_start() with the appropriate parameters. Finally, we enter the main application loop where we can implement the desired logic, such as handling connection events or processing received data.

Conclusion

The nRF52 SoftDevice provides a powerful and flexible framework for developing BLE applications on Nordic Semiconductor’s nRF52 series of microcontrollers. By understanding the architecture and concepts behind the SoftDevice, developers can harness its capabilities to build robust and efficient Bluetooth-enabled applications.

In this blog post, we covered the basic architecture of the nRF52 SoftDevice, its key concepts such as GAP and GATT, and demonstrated an example of establishing a connection between devices. With this knowledge in hand, you are now equipped to dive deeper into the nRF52 SoftDevice and explore its full potential. Happy coding!

➡️ Exploring power management techniques on the nRF52

⬅️ Over-the-Air (OTA) firmware updates using the nRF52

Go back to Posts.