Brand: Implementing a Custom Bluetooth LE GATT Service with Real-Time Data Throughput Optimization on Nordic nRF52840

Implementing a Custom Bluetooth LE GATT Service with Real-Time Data Throughput Optimization on Nordic nRF52840

In the rapidly evolving landscape of Bluetooth Low Energy (BLE) applications, achieving high real-time data throughput while maintaining robust and reliable communication is a critical challenge. The Nordic nRF52840, with its powerful ARM Cortex-M4F processor and advanced radio capabilities, is a prime candidate for such demanding applications. This article delves into the technical intricacies of implementing a custom GATT (Generic Attribute Profile) service on the nRF52840, optimized for real-time data throughput. We will draw upon established Bluetooth SIG specifications, such as the Ranging Service (RAS) and Reconnection Configuration Service (RCS), to inform our design principles, and supplement with practical embedded development insights.

Understanding the Core Components: GATT, Service, and Throughput

Before diving into implementation, it is essential to understand the foundational concepts. A GATT service is a collection of characteristics and relationships that define a specific functionality. For example, the Bluetooth SIG's Ranging Service (RAS), as described in RAS_v1.0.pdf, is designed to allow a distance-measurement application to read ranging data and configure ranging parameters. Similarly, the Reconnection Configuration Service (RCS) from RCS_1.0.1_showing_changes_from_RCS_1.0.pdf enables control of communication parameters of a BLE peripheral device. These examples illustrate that a well-defined service is the cornerstone of a structured BLE application.

Real-time data throughput optimization in BLE involves maximizing the amount of data transferred per unit time while minimizing latency. Key parameters that influence throughput include:

• Connection Interval: The interval between two consecutive connection events. A shorter interval increases throughput but also power consumption.
• PDU Size: The maximum size of a Protocol Data Unit (PDU) that can be transmitted in a single connection event. The nRF52840 supports the Data Length Extension (DLE), allowing PDUs up to 251 bytes.
• MTU Size: The Maximum Transmission Unit at the ATT (Attribute Protocol) layer. Increasing the MTU allows larger data packets to be sent, reducing overhead.
• Number of Packets per Connection Event: With the LE 2M PHY and LE Coded PHY, multiple packets can be transmitted in a single connection event.

Designing the Custom GATT Service

For our custom service, we will define a "High-Throughput Data Service" (HTDS). This service will contain two primary characteristics: a "Data Stream" characteristic for continuous real-time data, and a "Configuration" characteristic to adjust parameters like sampling rate. The design follows the same rigorous structure as the RAS and RCS specifications, ensuring compatibility and clarity.

The service UUID will be a custom 128-bit UUID, while the characteristics will use standard or custom UUIDs as needed. The "Data Stream" characteristic will be configured with the "Notify" property, allowing the peripheral to push data to the central device without polling. The "Configuration" characteristic will have "Write" and "Read" properties.

Implementation on Nordic nRF52840 using the SoftDevice S140

Nordic provides the SoftDevice S140, a qualified Bluetooth 5.1-compliant protocol stack, which handles the lower layers of the BLE stack. The application code runs on the nRF52840's main processor and interacts with the SoftDevice via API calls. Below is a simplified code example illustrating the service initialization and characteristic setup.

#include "ble_htds.h"
#include "nrf_log.h"
#include "nrf_ble_gatt.h"

static ble_htds_t m_htds;  // Custom service structure

// Custom UUID for the High-Throughput Data Service
#define BLE_UUID_HTDS_SERVICE  0x0001  // Example 16-bit UUID (in practice, use 128-bit)
#define BLE_UUID_HTDS_DATA_CHAR 0x0002
#define BLE_UUID_HTDS_CFG_CHAR  0x0003

// Initialize the custom service
uint32_t ble_htds_init(ble_htds_t * p_htds)
{
    uint32_t               err_code;
    ble_uuid_t             ble_uuid;
    ble_uuid128_t          base_uuid = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
                                        0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10};
    ble_add_char_params_t  add_char_params;

    // Add base UUID and get a 16-bit UUID for the service
    err_code = sd_ble_uuid_vs_add(&base_uuid, &p_htds->uuid_type);
    APP_ERROR_CHECK(err_code);

    ble_uuid.type = p_htds->uuid_type;
    ble_uuid.uuid = BLE_UUID_HTDS_SERVICE;

    // Add the service
    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_htds->service_handle);
    APP_ERROR_CHECK(err_code);

    // Add the Data Stream characteristic (Notify)
    memset(&add_char_params, 0, sizeof(add_char_params));
    add_char_params.uuid              = BLE_UUID_HTDS_DATA_CHAR;
    add_char_params.uuid_type         = p_htds->uuid_type;
    add_char_params.max_len           = 244; // Maximum payload for 251-byte PDU
    add_char_params.init_len          = 20;   // Initial MTU value
    add_char_params.char_props.notify = 1;
    add_char_params.char_props.read   = 1;
    add_char_params.char_props.write  = 0;

    err_code = characteristic_add(p_htds->service_handle, &add_char_params, &p_htds->data_char_handles);
    APP_ERROR_CHECK(err_code);

    // Add the Configuration characteristic (Write/Read)
    memset(&add_char_params, 0, sizeof(add_char_params));
    add_char_params.uuid              = BLE_UUID_HTDS_CFG_CHAR;
    add_char_params.uuid_type         = p_htds->uuid_type;
    add_char_params.max_len           = 4; // 4-byte configuration
    add_char_params.init_len          = 4;
    add_char_params.char_props.read   = 1;
    add_char_params.char_props.write  = 1;

    err_code = characteristic_add(p_htds->service_handle, &add_char_params, &p_htds->cfg_char_handles);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_INFO("HTDS Service initialized.");
    return NRF_SUCCESS;
}

This code sets up the service and its characteristics. The critical part is the `max_len` parameter for the Data Stream characteristic, which is set to 244 bytes. This is the maximum payload size when using a 251-byte PDU (3 bytes for ATT header). To achieve this, the MTU must be negotiated to at least 247 bytes during connection setup.

Optimizing Throughput: Techniques and Considerations

Real-time data throughput optimization goes beyond service definition. It involves configuring the BLE stack and the connection parameters appropriately. Key strategies include:

• Data Length Extension (DLE): Enable DLE to allow PDUs up to 251 bytes. This is done by calling `sd_ble_gap_data_length_update()` after connection.
• MTU Size Negotiation: Request an MTU of 247 bytes or higher using `sd_ble_gattc_exchange_mtu_request()` on the central side. The peripheral should support this by setting `BLE_GATTS_VAR_ATTR_LEN_MAX` appropriately.
• Connection Interval: Use a short connection interval (e.g., 7.5 ms) for high throughput. This is set by the central device, but the peripheral can influence it through the connection parameters in the advertising data.
• LE 2M PHY: If both devices support it, use the LE 2M PHY for double the data rate. The nRF52840 supports this natively.
• Packet Aggregation: Use the "Notify" property to send multiple notifications in a single connection event. The SoftDevice can queue up to 6 packets per connection event.

The following code snippet demonstrates how to enable DLE and request an MTU update after connection.

// After a successful connection (BLE_GAP_EVT_CONNECTED event)
static void on_connected(ble_evt_t const * p_ble_evt)
{
    uint32_t err_code;

    // Enable Data Length Extension
    err_code = sd_ble_gap_data_length_update(p_ble_evt->evt.gap_evt.conn_handle, NULL, NULL);
    APP_ERROR_CHECK(err_code);

    // Request MTU exchange (peripheral initiates)
    err_code = sd_ble_gattc_exchange_mtu_request(p_ble_evt->evt.gap_evt.conn_handle, 247);
    APP_ERROR_CHECK(err_code);
}

Performance Analysis and Protocol Details

To evaluate the optimization, consider a theoretical maximum throughput calculation. With a 7.5 ms connection interval, 6 packets per event, and 244 bytes of payload per packet, the raw throughput is:

Throughput = (6 packets/event) * (244 bytes/packet) * (1000 ms/s / 7.5 ms/event) ≈ 195,200 bytes/s ≈ 1.56 Mbps

This is close to the theoretical maximum for BLE 5.0 with 2M PHY. In practice, overhead from the stack, application processing, and radio retransmissions will reduce this to around 1.2-1.4 Mbps. For real-time data, latency is also critical. With a 7.5 ms connection interval, the worst-case latency is 7.5 ms, which is acceptable for many applications like audio streaming or sensor data.

It's important to note that the Bluetooth SIG specifications, such as the Ranging Service (RAS) and Reconnection Configuration Service (RCS), provide best practices for service design. For example, the RAS specification includes characteristics for ranging data and configuration, emphasizing the separation of data and control. Our HTDS follows this pattern. The RCS specification, on the other hand, focuses on reconnection parameters, which is relevant for optimizing connection setup and maintenance.

Conclusion

Implementing a custom Bluetooth LE GATT service with real-time data throughput optimization on the Nordic nRF52840 requires a deep understanding of both the BLE protocol and the hardware capabilities. By carefully designing the service structure, leveraging the SoftDevice's APIs, and tuning connection parameters like DLE, MTU, and connection interval, developers can achieve throughput rates close to 1.5 Mbps. This enables a wide range of real-time applications, from high-speed sensor data acquisition to audio streaming. The principles derived from Bluetooth SIG services like RAS and RCS provide a solid foundation for building robust, interoperable, and high-performance BLE applications.

💬 欢迎到论坛参与讨论： 点击这里分享您的见解或提问