The Bluefruit nRF52 BSP codebase is undergoing active development based on customer feedback and testing. As such, the class documentation here is incomplete, and you should consult the Github repo for the latest code and API developments:

This base class is used when defining custom BLE Gatt Clients.

Unless you are implementing a custom GATT client service and characteristic, you normally won't use this base class directly, and would instantiate and call a higher level helper service or characteristic included in the Bluefruit nRF52 API.

Basic Usage

There are normally only threes operations required to use the BLEClientService class:

1.) You need to declare and instantiate the class with an appropriate 16-bit or 128-bit UUID in the constructor:

BLEClientService myService = BLEService(0x1234);

2.) You then need to call the .begin() method on the instance before adding any BLEClientCharacteristics to it (via the BLEClientCharacteristic's respective .begin() function call):


3) When connected e.g in connect callback, you should call .discover() to discover the service;


BLEClientService has the following overall class structure:

This documentation may be slightly out of date as bugs are fixed, and the API develops. You should always consult the Github repo for the definitive latest code release and class definitions!
BLEUuid uuid;

// Constructors
BLEClientService(BLEUuid bleuuid);

virtual bool     begin(void);

virtual bool     discover  (uint16_t conn_handle);
        bool     discovered(void);

        uint16_t connHandle(void);

        void             setHandleRange(ble_gattc_handle_range_t handle_range);
ble_gattc_handle_range_t getHandleRange(void);


The following example declares a HRM (Heart Rate Monitor) service, and assigns some characteristics to it:

 This is an example for our nRF52 based Bluefruit LE modules

 Pick one up today in the adafruit shop!

 Adafruit invests time and resources providing this open source code,
 please support Adafruit and open-source hardware by purchasing
 products from Adafruit!

 MIT license, check LICENSE for more information
 All text above, and the splash screen below must be included in
 any redistribution

/* This sketch show how to use BLEClientService and BLEClientCharacteristic
 * to implement a custom client that is used to talk with Gatt server on
 * peripheral.
 * Note: you will need another feather52 running peripheral/custom_HRM sketch
 * to test with.

#include <bluefruit.h>

/* HRM Service Definitions
 * Heart Rate Monitor Service:  0x180D
 * Heart Rate Measurement Char: 0x2A37 (Mandatory)
 * Body Sensor Location Char:   0x2A38 (Optional)

BLEClientService        hrms(UUID16_SVC_HEART_RATE);
BLEClientCharacteristic hrmc(UUID16_CHR_HEART_RATE_MEASUREMENT);
BLEClientCharacteristic bslc(UUID16_CHR_BODY_SENSOR_LOCATION);

void setup()

  Serial.println("Bluefruit52 Central Custom HRM Example");

  // Initialize Bluefruit with maximum connections as Peripheral = 0, Central = 1
  // SRAM usage required by SoftDevice will increase dramatically with number of connections
  Bluefruit.begin(0, 1);

  Bluefruit.setName("Bluefruit52 Central");

  // Initialize HRM client

  // Initialize client characteristics of HRM.
  // Note: Client Char will be added to the last service that is begin()ed.

  // set up callback for receiving measurement

  // Increase Blink rate to different from PrPh advertising mode

  // Callbacks for Central

  /* Start Central Scanning
   * - Enable auto scan if disconnected
   * - Interval = 100 ms, window = 80 ms
   * - Don't use active scan
   * - Filter only accept HRM service
   * - Start(timeout) with timeout = 0 will scan forever (until connected)
  Bluefruit.Scanner.setInterval(160, 80); // in unit of 0.625 ms
  Bluefruit.Scanner.start(0);                   // // 0 = Don't stop scanning after n seconds

void loop()
  // do nothing

 * Callback invoked when scanner pick up an advertising data
 * @param report Structural advertising data
void scan_callback(ble_gap_evt_adv_report_t* report)
  // Connect to device with HRM service in advertising

 * Callback invoked when an connection is established
 * @param conn_handle
void connect_callback(uint16_t conn_handle)
  Serial.print("Discovering HRM Service ... ");

  // If HRM is not found, disconnect and return
  if ( ! )
    Serial.println("Found NONE");

    // disconect since we couldn't find HRM service


  // Once HRM service is found, we continue to discover its characteristic
  Serial.println("Found it");

  Serial.print("Discovering Measurement characteristic ... ");
  if ( ! )
    // Measurement chr is mandatory, if it is not found (valid), then disconnect
    Serial.println("not found !!!");  
    Serial.println("Measurement characteristic is mandatory but not found");
  Serial.println("Found it");

  // Measurement is found, continue to look for option Body Sensor Location
  // Body Sensor Location is optional, print out the location in text if present
  Serial.print("Discovering Body Sensor Location characteristic ... ");
  if ( )
    Serial.println("Found it");
    // Body sensor location value is 8 bit
    const char* body_str[] = { "Other", "Chest", "Wrist", "Finger", "Hand", "Ear Lobe", "Foot" };

    // Read 8-bit BSLC value from peripheral
    uint8_t loc_value = bslc.read8();
    Serial.print("Body Location Sensor: ");
    Serial.println("Found NONE");

  // Reaching here means we are ready to go, let's enable notification on measurement chr
  if ( hrmc.enableNotify() )
    Serial.println("Ready to receive HRM Measurement value");
    Serial.println("Couldn't enable notify for HRM Measurement. Increase DEBUG LEVEL for troubleshooting");

 * Callback invoked when a connection is dropped
 * @param conn_handle
 * @param reason
void disconnect_callback(uint16_t conn_handle, uint8_t reason)
  (void) conn_handle;
  (void) reason;


 * Hooked callback that triggered when a measurement value is sent from peripheral
 * @param chr   Pointer client characteristic that even occurred,
 *              in this example it should be hrmc
 * @param data  Pointer to received data
 * @param len   Length of received data
void hrm_notify_callback(BLEClientCharacteristic* chr, uint8_t* data, uint16_t len)
  // Measurement contains of control byte0 and measurement (8 or 16 bit) + optional field
  // if byte0's bit0 is 0 --> measurement is 8 bit, otherwise 16 bit.

  Serial.print("HRM Measurement: ");

  if ( data[0] & bit(0) )
    uint16_t value;
    memcpy(&value, data+1, 2);


This guide was first published on Mar 11, 2020. It was last updated on Mar 11, 2020.

This page (BLEClientService) was last updated on May 05, 2021.

Text editor powered by tinymce.