Characteristic: wat is het, gegevenstypen en waarden lezen

Wat is Characteristic in BLE?

Characteristic is een attribuut van het GATT-protocol dat een waarde (value) en metadata bevat. In de BLE-architectuur worden gegevens niet direct tussen apparaten verzonden, maar door het lezen en schrijven van waarden van servicekarakteristieken. Als de service een map is, dan is Characteristic een bestand in die map.

Elke Characteristic bestaat uit drie componenten: declaratie (declaration), waarde (value) en descriptors (descriptors). De declaratie bevat de UUID van de karakteristiek en zijn eigenschappen. De waarde zijn de eigenlijke gegevens die worden verzonden tussen Central en Peripheral. Descriptors bieden aanvullende configuratie.

Volgens Bluetooth Core Specification 5.4 (2023) vindt alle gegevensuitwisseling in BLE plaats via bewerkingen op karakteristieken. Zelfs standaardprofielen zoals Heart Rate Profile of Battery Service zijn gebouwd op een set karakteristieken met vooraf gedefinieerde UUID's. Dit zorgt voor compatibiliteit tussen apparaten van verschillende fabrikanten zonder voorafgaande configuratie.

Het is belangrijk voor de ontwikkelaar om te begrijpen: elke Characteristic kan verschillende combinaties van eigenschappen ondersteunen. De ene karakteristiek kan alleen-lezen zijn, de andere alleen-schrijven, de derde voor meldingen. De juiste keuze van eigenschappen bepaalt het gebruiksscenario en het energieverbruik van het apparaat.

Eigenschappen en rechten van Characteristic

Eigenschappen (properties) van de karakteristiek bepalen welke bewerkingen erop zijn toegestaan. Het is een bytemasker waarbij elke bit een specifieke bewerking in- of uitschakelt. Hieronder staan de belangrijkste eigenschappen.

Rechten (permissions) zijn het toegangsniveau op GATT-serverniveau. In tegenstelling tot eigenschappen, die in de declaratie van de karakteristiek worden vermeld, worden rechten bij elke bewerking gecontroleerd. Ze kunnen versleutelings- en authenticatievereisten omvatten.

Standaard Bluetooth SIG-karakteristieken

Bluetooth SIG heeft meer dan 500 standaardkarakteristieken gespecificeerd die de meeste gangbare BLE-gebruiksscenario's dekken. Het gebruik van standaard UUID's garandeert dat elk ontvangend apparaat de gegevens correct interpreteert zonder voorafgaande configuratie.

Hier zijn de meest gebruikte standaardkarakteristieken:

Als een bestaande standaardkarakteristiek uw taak dekt — gebruik deze dan. Dit vereenvoudigt Bluetooth-certificering en verhoogt de compatibiliteit met het ecosysteem. Maak alleen aangepaste karakteristieken voor unieke gegevens die niet in het SIG-register staan.

Characteristic maken in iOS en Android

Het maken van een karakteristiek gebeurt aan de kant van Peripheral — het apparaat dat gegevens levert. Laten we de implementatie op iOS (Swift) en Android (Java) bekijken.

iOS: CBMutableCharacteristic

Core Bluetooth biedt de klasse CBMutableCharacteristic voor het maken van een karakteristiek met specificatie van UUID, eigenschappen en beginwaarde.

import CoreBluetooth

let characteristicUUID = CBUUID("2A19") // Batterijniveau-karakteristiek

let characteristic = CBMutableCharacteristic(
    type: characteristicUUID,
    properties: [.read, .notify],
    value: nil,
    permissions: [.readable]
)

// Waarde bijwerken bij wijziging
let batteryData = Data([batteryLevel]) // uint8
peripheralManager.updateValue(
    batteryData,
    for: characteristic,
    onSubscribedCentrals: nil
)

Android: BluetoothGattCharacteristic

Op Android wordt de karakteristiek gemaakt via BluetoothGattCharacteristic met specificatie van UUID, eigenschappen en rechten.

import android.bluetooth.*;

UUID charUuid = UUID.fromString("00002A19-0000-1000-8000-00805F9B34FB");

BluetoothGattCharacteristic characteristic =
    new BluetoothGattCharacteristic(
        charUuid,
        BluetoothGattCharacteristic.PROPERTY_READ
            | BluetoothGattCharacteristic.PROPERTY_NOTIFY,
        BluetoothGattCharacteristic.PERMISSION_READ
    );

// Stel de waarde in
characteristic.setValue(batteryLevel, BluetoothGattCharacteristic.FORMAT_UINT8, 0);
gattServer.notifyCharacteristicChanged(device, characteristic, false);

Lezen, schrijven en meldingen

Bewerkingen op Characteristic zijn onderverdeeld in drie typen: lezen (read), schrijven (write) en meldingen (notify/indicate). De keuze van bewerking hangt af van het scenario: gegevens op aanvraag worden gelezen, opdrachten worden geschreven, streamgegevens worden geabonneerd op meldingen.

Read — Central stuurt een leesverzoek voor de karakteristiekwaarde. Peripheral antwoordt met de huidige waarde. De bewerking is synchroon en vereist een expliciet verzoek van beide kanten. Wordt gebruikt voor gegevens die zelden veranderen: firmwareversie, serienummer, instellingen.

Write — Central stuurt gegevens naar Peripheral. Er zijn twee modi: Write with Response (bevestiging van Peripheral) en Write Without Response (zonder bevestiging). Write with Response garandeert levering — Peripheral stuurt een bevestiging na het schrijven. Write Without Response is sneller, maar garandeert geen levering.

Notify en Indicate — Peripheral initieert het verzenden van gegevens naar Central. Bij Notify worden gegevens zonder bevestiging verzonden — als Central het pakket niet heeft kunnen ontvangen, gaat het verloren. Bij Indicate stuurt Central een bevestiging (op PDU-niveau), wat levering garandeert. Indicate is langzamer, maar betrouwbaarder. Om zich te abonneren op meldingen schrijft Central de waarde 0x0001 in de CCCD (Client Characteristic Configuration Descriptor).

MTU en grootte van verzonden gegevens

MTU (Maximum Transmission Unit) bepaalt de maximale grootte van één BLE-gegevenspakket. Standaard is de MTU 23 bytes, waarvan 3 bytes header — de nuttige lading (ATT payload) is 20 bytes. Dit is voldoende voor de meeste sensorgegevens, maar onvoldoende voor het verzenden van bestanden of grote configuraties.

Bluetooth Core Specification 5.4 ondersteunt MTU-onderhandeling (MTU negotiation) — Central en Peripheral kunnen een grotere pakketgrootte tot 517 bytes overeenkomen. Het proces ziet er als volgt uit: Central stuurt een MTU Exchange-verzoek met zijn MTU-voorstel; Peripheral antwoordt met zijn MTU; de kleinste van de twee waarden wordt gebruikt.

// iOS vraagt MTU bij verbinding
// Maximale MTU in iOS is 185 bytes
func peripheral(
    _ peripheral: CBPeripheral,
    didDiscoverServices error: Error?
) {
    // Vraag MTU aan voor specifiek perifeer apparaat
    peripheral.maximumWriteValueLength(for: .withResponse)
}

Volgens Bluetooth SIG (2023) vermindert het verhogen van de MTU van 23 naar 185 bytes de overhead van gegevensoverdracht met tot 80% door het verminderen van het aantal pakketten. Voor toepassingen die metingen met hoge frequentie verzenden (bijv. ECG of accelerometer), is MTU-verhoging cruciaal voor de stabiliteit van de stroom.