Bluetooth och BLE: vad är det, skillnad mellan Classic och Low Energy och hur det fungerar

Vad är Bluetooth och BLE?

Bluetooth — är en standard för trådlöst personligt nätverk (WPAN) som arbetar i ISM-bandet 2,4 GHz och är avsett för kommunikation mellan enheter på upp till 100 meters avstånd. Specifikationen IEEE 802.15.1 definierar den fysiska och MAC-lagret, och Bluetooth SIG-stacken definierar profiler på högre nivå för specifika scenarier: ljudheadset (HSP), filöverföring (OPP), tangentbordsinmatning (HID).

Standarden delades i två grenar från och med version 4.0 (2010): Bluetooth Classic (BR/EDR) och Bluetooth Low Energy (BLE, tidigare Bluetooth Smart). Classic är avsett för kontinuerliga strömmar — ljudsamtal, musik, filer. BLE skapades för applikationer där data överförs i korta paket med pauser på tiotals sekunder eller minuter — pulsmätare, taggar, temperatursensorer.

Enligt Bluetooth SIG (2025) stödjer 99% av nya smartphones båda versionerna och BLE-ekosystemet omfattar över 15 proiltyper från Blood Pressure till Environmental Sensing.

Bluetooth Classic vs BLE: jämförande egenskaper

Valet mellan Classic och BLE beror på scenariot: för ljudströmning är endast Classic lämpligt, för avläsning av sensor en gång i timmen — endast BLE. BR/EDR använder 79 kanaler med 1 MHz steg och adaptiv frekvensmodulering (AFH), vilket ger motståndskraft mot Wi-Fi-störningar.

BLE 5.x lade till LE Coded PHY för att öka räckvidden till 1 km (utomhus) och LE Audio med LC3-codec — den nya versionen suddar gradvis ut gränsen mellan Classic och BLE i ljudscenarier.

BLE-arkitektur: Controller, Host och Application

BLE-stacken är uppdelad i tre lager: Controller (fysiskt och länklager), Host (L2CAP, ATT, GATT, Security Manager) och Application (profilimplementering i appen). Denna uppdelning gör det möjligt för chiptillverkaren att implementera Controller i firmware och för mobilapputvecklaren att endast arbeta med GATT-abstraktioner.

Link Layer (LL) hanterar sändningstiden: enheten växlar mellan tillstånden Standby, Advertising, Scanning, Initiating och Connection. I Connected-tillstånd kommer Central och Peripheral överens om connection interval — frekvensen för datautbyte. Typiskt intervall är 7,5–1000 ms; ju oftare utbyte, desto högre bandbredd och energiförbrukning.

Security Manager (SM) implementerar AES-128-kryptering med nyckelutbyte via pairing-protokollet. Tre lägen särskiljs: Just Works (utan PIN), Passkey Entry (6-siffrig kod på skärmen) och OOB (NFC eller QR). För bärbara enheter används vanligtvis Just Works, för medicinska — OOB med extra verifiering.

Enligt Bluetooth Core Specification 5.4 (2023) överstiger inte tiden för att upprätta en säker anslutning i LE Secure Connections-läge 300 ms vid connection interval 30 ms.

GATT-profil: tjänster, egenskaper och deskriptorer

Protokollet ATT (Attribute Protocol) — grundläggande transportmodell där servern (kringutrustningen) lagrar attribut och klienten (smarttelefonen) läser eller skriver dem. GATT (Generic Attribute Profile) bygger en hierarki över ATT: Service → Characteristic → Descriptor.

Varje tjänst är en logisk grupp av egenskaper som beskriver en funktion hos enheten: Heart Rate Service (UUID 0x180D) innehåller egenskapen Heart Rate Measurement (UUID 0x2A37) med Descriptor Client Characteristic Configuration (0x2902) som hanterar notifikationer. Mobilapputvecklaren får listan över tjänster via discoverServices(), hittar sedan önskad egenskap via UUID och prenumererar på notifikationer.

BLE använder 16-bitars UUID för standardiserade Bluetooth SIG-tjänster och 128-bitars UUID för tillverkaranpassade tjänster. Till exempel kan ett trackerkäll definiera tjänsten A000-… med en egenskap för att överföra laddningsnivån för sitt eget batteri.

Exempel på arbete med GATT i Kotlin (Android)

private val gattCallback = object BluetoothGattCallback() {
    override fun onServicesDiscovered(
        gatt: BluetoothGatt, status: Int
    ) {
        val service = gatt.getService(UUID.fromString("0000180d-0000-1000-8000-00805f9b34fb"))
        val char = service?.getCharacteristic(
            UUID.fromString("00002a37-0000-1000-8000-00805f9b34fb")
        )
        gatt.setCharacteristicNotification(char, true)
    }

    override fun onCharacteristicChanged(
        gatt: BluetoothGatt, char: BluetoothGattCharacteristic
    ) {
        val heartRate = char.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 1)
        updateUi("Puls: $heartRate slag/min")
    }
}

I exemplet hittar appen Heart Rate-tjänsten via standard-UUID från Bluetooth SIG, hämtar pulsmätningsegenskapen och prenumererar på dess notifikationer — vid varje pulsändring skickar kringutrustningen data utan explicit begäran från Central.

Advertising, skanning och upprättande av anslutning

Advertising — nyckelmekanismen i BLE där Peripheral-enheten periodiskt skickar sändningspaket (advertising PDUs) på tre primära kanaler (37, 38, 39). Den centrala enheten skannar dessa kanaler, tar emot advertising-data och kan initiera en anslutning.

Advertising-paketet innehåller upp till 31 byte nyttolast: flaggor, TX power level, lokalt namn, tjänste-UUID, tillverkarspecifik data. Detta räcker för att överföra sensoravläsningar utan anslutning — Connectionless-läge (Broadcaster-typ). För kontinuerlig dataöverföring (t.ex. temperatur varje minut) används en anslutning med connection interval upp till 1000 ms.

På mobil plattform startas skanning via startScan() (Android) eller scanForPeripherals() (iOS). Filtrering efter tjänste-UUID sparar energi — appen får callback endast för intressanta taggar eller sensorer.

Exempel på skanning av BLE-enheter i Swift (iOS)

import CoreBluetooth

class ScannerViewController: UIViewController {
    private var centralManager: CBCentralManager!

    override func viewDidLoad() {
        centralManager = CBCentralManager(
            delegate: self, queue: nil
        )
    }

    func centralManagerDidUpdateState(central: CBCentralManager) {
        if central.state == .poweredOn {
            centralManager.scanForPeripherals(
                withServices: nil, options: nil
            )
        }
    }

    func centralManager(
        central: CBCentralManager,
        didDiscover peripheral: CBPeripheral,
        advertisementData: [String : Any],
        rssi RSSI: NSNumber
    ) {
        if let name = advertisementData[CBAdvertisementDataLocalNameKey] {
            print("Enhet hittad: \(name)")
        }
    }
}

Efter upptäckt av enheten anropar Central connect() med CBPeripheral-objektet. Anslutningsparametrarna (interval, latency, supervision timeout) förhandlas på Link Layer-nivå — utvecklaren hanterar dem inte direkt men kan påverka via requestConnectionPriority på Android.

Bluetooth LE inom mobilutveckling: Core Bluetooth och android.bluetooth

Båda mobila plattformarna tillhandahåller inbyggda API:er för arbete med BLE. Core Bluetooth (iOS) använder delegeringsmetod: den centrala hanteraren initierar operationer och kringutrustningen rapporterar resultat via delegatmetoder. android.bluetooth (Android) är byggt på callback-gränssnitt och stödjer parallella GATT-operationer med flera enheter.

Viktigaste skillnaderna mellan plattformarna:

• iOS — stödjer upp till 7 samtidiga anslutningar; BLE-bakgrundsläge kräver UIBackgroundModes = bluetooth-central; efter att ha lämnat bakgrunden kan systemet försena callbacks med flera minuter
• Android — ingen fast anslutningsgräns (minnesbegränsning); kräver behörigheterna BLUETOOTH_SCAN och BLUETOOTH_CONNECT (Android 12+); foreground service behövs för tillförlitlig bakgrundsskanning
• Flutter — paketet flutter_blue_plus abstraherar plattforms-API:erna med ett enhetligt Dart-gränssnitt: kod för skanning och GATT-operationer är identisk på båda plattformarna

Enligt Bluetooth SIG-tester (2024) är BLE-anslutningstiden för en smartphone med ett fitnessarmband i genomsnitt 150–300 ms på Android och 100–250 ms på iOS — skillnaden beror på policyer för radiomodulhantering.

Exempel på BLE-anslutning i Dart (Flutter)

import 'package:flutter_blue_plus/flutter_blue_plus.dart';

class BleService {
  final FlutterBluePlus fbp = FlutterBluePlus();

  Future<void> scanAndConnect(String deviceName) async {
    await fbp.startScan(timeout: Duration(seconds: 15));

    await for (final result in fbp.scanResults) {
      if (result.device.advName == deviceName) {
        await fbp.stopScan();
        await result.device.connect();
        break;
      }
    }
  }
}

Flutter-utvecklaren får ett enhetligt API-gränssnitt, under vilket flutter_blue_plus översätter anrop till inbyggd android.bluetooth eller Core Bluetooth. Detta tillvägagångssätt minskar utvecklingstiden för appar som arbetar med BLE-kringutrustning på båda plattformarna.