Central — what it is, its role in BLE and how it scans devices

What is Central in BLE?

Central is a GATT client in the Bluetooth Low Energy architecture that initiates all communications. Unlike Peripheral, which passively waits for connections and advertises its services, Central actively scans the airwaves, discovers advertising packets, and initiates connections.

The asymmetric Central-Peripheral model is a fundamental feature of BLE. Central manages the interaction logic: it decides which device to connect to, which services to explore, and which characteristics to read and write. Peripheral acts as a data server — it stores services and characteristics but does not initiate connections.

According to the Bluetooth Core Specification 5.4 (2023), a device can simultaneously be both Central and Peripheral (dual role). For example, a smartphone can be a Central for a fitness band and a Peripheral for another smartphone transferring files. However, simultaneous operation in both roles increases power consumption and connection management complexity.

In the mobile development ecosystem, the Central role is the most common scenario. An app on a smartphone searches for BLE devices (sensors, headphones, bands), connects to them, and receives data. The developer uses the operating system API to work with Central: CBCentralManager on iOS, BluetoothLeScanner and BluetoothGatt on Android.

Device scanning process

Scanning is the first stage of Central's operation. The device listens on BLE radio channels (37, 38, 39) to detect advertising packets that Peripherals periodically send. Each advertising packet contains the device name, a list of Service UUIDs, and custom data.

Central can operate in two scanning modes: passive scanning (only receiving advertising packets) and active scanning (sending a scan request to get additional data via scan response). Passive scanning saves energy but provides less information. Active scanning allows getting full advertising packet data, including the device name and complete service list.

UUID filtering is an important optimization. Central can scan only for devices with a specific Service UUID, ignoring the rest. This not only saves energy but also simplifies the application logic: the delegate receives only relevant devices.

import CoreBluetooth

class BLECentralManager: NSObject, CBCentralManagerDelegate {

    private var centralManager: CBCentralManager!

    override init() {
        super.init()
        centralManager = CBCentralManager(
            delegate: self,
            queue: nil
        )
    }

    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        if central.state == .poweredOn {
            central.scanForPeripherals(
                withServices: nil,
                options: [
                    CBCentralManagerScanOptionAllowDuplicatesKey: false
                ]
            )
        }
    }
}

Connection management

Connection management is Central's key responsibility. After discovering a suitable Peripheral, Central initiates a connection. A BLE connection is established through a connection establishment procedure that includes parameter exchange: connection interval, slave latency, and supervision timeout.

Connection interval determines how often Central and Peripheral exchange data after connection. The interval can range from 7.5 ms to 4 seconds. The shorter the interval, the higher the throughput, but also higher power consumption. Slave latency allows Peripheral to skip several connection events to save energy. Supervision timeout is the maximum time without a response, after which the connection is considered lost.

Central is responsible for terminating the connection after data exchange is complete. BLE devices typically do not keep a connection permanently — Central connects, gets data, and disconnects. This is a standard pattern for IoT sensors: Central scans, finds a temperature sensor, connects, reads the value, and disconnects.

Central on iOS: Core Bluetooth

Core Bluetooth is Apple's framework for working with BLE on iOS and macOS. The CBCentralManager class provides the full API for implementing the Central role: scanning, connecting, connection management. Working with Central on iOS is based on a delegate model: CBCentralManagerDelegate receives events for state changes, device discovery, and connection results.

The main steps for Central on iOS: initializing CBCentralManager, checking Bluetooth state, starting scanning, handling discovered devices via delegate, connecting to the selected Peripheral, discovering services and characteristics, exchanging data.

// Connect to discovered Peripheral
func centralManager(
    _ central: CBCentralManager,
    didDiscover peripheral: CBPeripheral,
    advertisementData: [String: Any],
    rssi RSSI: NSNumber
) {
    // Keep reference to peripheral and connect
    discoveredPeripheral = peripheral
    central.connect(peripheral, options: nil)
}

// Successful connection
func centralManager(
    _ central: CBCentralManager,
    didConnect peripheral: CBPeripheral
) {
    peripheral.delegate = self
    peripheral.discoverServices(nil)
}

iOS limits background BLE work: in the background, an app can only scan with specific keys in Info.plist, and connected devices can notify Central about data changes. For critical applications (medical devices), use Background Modes with the bluetooth-central key.

Central on Android: BluetoothLeScanner

Android provides the BluetoothLeScanner API for scanning BLE devices and BluetoothGatt for connection management. Starting from Android 5.0 (API 21), BluetoothLeScanner replaced the deprecated startLeScan. The API requires BLUETOOTH, BLUETOOTH_ADMIN and ACCESS_FINE_LOCATION permissions (or ACCESS_BACKGROUND_LOCATION for Android 10+).

import android.bluetooth.le.*;
import android.bluetooth.*;

private BluetoothLeScanner scanner;
private BluetoothGatt bluetoothGatt;

// Configure scanning
ScanSettings settings = new ScanSettings.Builder()
    .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
    .build();

// Start scanning
scanner.startScan(null, settings, new ScanCallback() {
    @Override
    public void onScanResult(
            int callbackType,
            ScanResult result
    ) {
        BluetoothDevice device = result.getDevice();
        // Connect to device
        bluetoothGatt = device.connectGatt(
            context, false, gattCallback
        );
    }
});

On Android, it is important to consider scanning restrictions: starting from Android 7 (API 24), scanning cannot be started more than 5 times per 30 seconds in apps that do not use Location. Android 12+ requires BLUETOOTH_SCAN, BLUETOOTH_CONNECT and ADVERTISE permissions, as well as runtime requests for these permissions.

Central power consumption

Central power consumption is higher than that of Peripheral due to the need to constantly scan radio channels. Central receives BLE packets, processes them, manages connections, and often performs computations on the application processor. According to Bluetooth SIG, scanning consumes between 30 mA and 100 mA depending on the mode.

There are several energy saving strategies for Central. Interval scanning is the most effective method: Central scans in short windows (scan window) with long pauses (scan interval). For example, with a scan window of 30 ms and a scan interval of 1000 ms, power consumption is reduced by 97% compared to continuous scanning.

An additional optimization is UUID filtering. Central processes only relevant advertising packets faster, ignoring the rest. This reduces CPU load and increases device battery life. It is also recommended to stop scanning immediately after finding the desired device and not keep the connection longer than necessary.