Central — vad är det, roll i BLE och hur det skannar enheter

Vad är Central i BLE?

Central — är en GATT-klient i Bluetooth Low Energy-arkitekturen som initierar all kommunikation. Till skillnad från Peripheral, som passivt väntar på anslutning och annonserar sina tjänster, skannar Central aktivt etern, upptäcker reklampaket och initierar anslutning.

Den asymmetriska Central-Peripheral-modellen är en grundläggande egenskap hos BLE. Central hanterar interaktionslogiken: den bestämmer vilken enhet den ska ansluta till, vilka tjänster den ska undersöka, vilka egenskaper den ska läsa och skriva. Peripheral fungerar som dataservern — lagrar tjänster och egenskaper, men initierar inte anslutningar.

Enligt Bluetooth Core Specification 5.4 (2023) kan en enhet samtidigt vara Central och Peripheral (dual role). Till exempel kan en smartphone vara Central för ett fitnessarmband och Peripheral för en annan smartphone som överför filer. Att arbeta samtidigt i båda rollerna ökar dock energiförbrukningen och komplexiteten i anslutningshanteringen.

I ekosystemet för mobilutveckling är Central-rollen det vanligaste scenariot. Appen på smartphonen söker efter BLE-enheter (sensorer, hörlurar, armband), ansluter till dem och tar emot data. Utvecklaren använder operativsystemets API för att arbeta med Central: CBCentralManager i iOS, BluetoothLeScanner och BluetoothGatt i Android.

Processen för att skanna enheter

Skanning — är det första steget i Central arbete. Enheten lyssnar på BLE-radiokanaler (37, 38, 39) för att upptäcka reklampaket som skickas periodiskt av Peripheral. Varje reklampaket innehåller enhetens namn, en lista med tjänste-UUID och användardata.

Central kan arbeta i två skanningslägen: passive scanning (endast mottagning av reklampaket) och active scanning (sändning av skanningsbegäran för att få ytterligare data via scan response). Passive scanning sparar energi men ger mindre information. Active scanning gör det möjligt att få fullständiga data från reklampaketet, inklusive enhetens namn och den fullständiga listan över tjänster.

Filtrering efter UUID — en viktig optimering. Central kan endast skanna enheter med ett specifikt Service UUID och ignorera de andra. Detta sparar inte bara energi utan förenklar också applikationslogiken: delegaten får endast relevanta enheter.

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
                ]
            )
        }
    }
}

Anslutningshantering

Anslutningshantering — Central främsta ansvar. Efter att ha upptäckt en lämplig Peripheral initierar Central anslutningen. BLE-anslutningen upprättas genom en anslutningsprocedur som inkluderar parameterutbyte: connection interval, slave latency och supervision timeout.

Connection interval bestämmer hur ofta Central och Peripheral utbyter data efter anslutning. Intervallet kan vara från 7.5 ms till 4 sekunder. Ju kortare intervall, desto högre bandbredd, men också högre energiförbrukning. Slave latency tillåter Peripheral att hoppa över flera anslutningshändelser för att spara energi. Supervision timeout — den maximala tiden utan svar, efter vilken anslutningen anses förlorad.

Central ansvarar för att avbryta anslutningen efter att datautbytet är slutfört. BLE-enheter håller vanligtvis inte anslutningen permanent — Central ansluter, tar emot data och kopplar från. Detta är ett standardmönster för IoT-sensorer: Central skannar, hittar en temperatursensor, ansluter, läser värdet och kopplar från.

Central i iOS: Core Bluetooth

Core Bluetooth — Apples ramverk för att arbeta med BLE på iOS och macOS. Klassen CBCentralManager tillhandahåller fullt API för att implementera Central-rollen: skanning, anslutning, anslutningshantering. Arbete med Central i iOS baseras på delegatmodellen: CBCentralManagerDelegate tar emot händelser om statusändringar, enhetsupptäckt och anslutningsresultat.

Huvudstegen för Central i iOS: initiera CBCentralManager, kontrollera Bluetooth-status, starta skanning, bearbeta upptäckta enheter via delegat, ansluta till vald Peripheral, upptäcka tjänster och egenskaper, datautbyte.

// Anslut till upptäckt Peripheral
func centralManager(
    _ central: CBCentralManager,
    didDiscover peripheral: CBPeripheral,
    advertisementData: [String: Any],
    rssi RSSI: NSNumber
) {
    // Behåll referens till peripheral och anslut
    discoveredPeripheral = peripheral
    central.connect(peripheral, options: nil)
}

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

iOS begränsar BLE-arbete i bakgrunden: i bakgrundsläge kan appen endast skanna med specifika nycklar i Info.plist, och anslutna enheter kan meddela Central om dataändringar. För kritiska applikationer (medicintekniska produkter) använd Background Modes med nyckeln bluetooth-central.

Central i Android: BluetoothLeScanner

Android tillhandahåller BluetoothLeScanner API för skanning av BLE-enheter och BluetoothGatt för anslutningshantering. Från och med Android 5.0 (API 21) ersatte BluetoothLeScanner den föråldrade startLeScan. API kräver behörigheterna BLUETOOTH, BLUETOOTH_ADMIN och ACCESS_FINE_LOCATION (eller ACCESS_BACKGROUND_LOCATION för Android 10+).

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

private BluetoothLeScanner scanner;
private BluetoothGatt bluetoothGatt;

// Konfigurera skanning
ScanSettings settings = new ScanSettings.Builder()
    .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
    .build();

// Starta skanning
scanner.startScan(null, settings, new ScanCallback() {
    @Override
    public void onScanResult(
            int callbackType,
            ScanResult result
    ) {
        BluetoothDevice device = result.getDevice();
        // Anslut till enhet
        bluetoothGatt = device.connectGatt(
            context, false, gattCallback
        );
    }
});

På Android är det viktigt att ta hänsyn till skanningsbegränsningar: från och med Android 7 (API 24) kan skanning inte startas mer än 5 gånger på 30 sekunder i appar som inte använder Location. Android 12+ kräver behörigheterna BLUETOOTH_SCAN, BLUETOOTH_CONNECT och ADVERTISE, samt runtime-begäran av dessa behörigheter.

Central energiförbrukning

Central energiförbrukning är högre än Peripheral på grund av behovet av att kontinuerligt skanna radiokanaler. Central tar emot data via BLE-paket, bearbetar dem, hanterar anslutningar och utför ofta beräkningar på applikationsprocessorn. Enligt Bluetooth SIG förbrukar skanning mellan 30 mA och 100 mA beroende på läge.

Det finns flera energibesparingsstrategier för Central. Intervallskanning — den mest effektiva metoden: Central skannar i korta fönster (scan window) med långa pauser (scan interval). Till exempel med scan window 30 ms och scan interval 1000 ms minskar energiförbrukningen med 97% jämfört med kontinuerlig skanning.

Ytterligare optimering — filtrering efter UUID. Central bearbetar snabbare endast relevanta reklampaket och ignorerar de andra. Detta minskar processorbelastningen och förlänger enhetens batteritid. Det rekommenderas också att stoppa skanningen omedelbart efter upptäckt av önskad enhet och inte hålla anslutningen längre än nödvändigt.