Service UUID : définition, format et domaines d'application

Qu'est-ce qu'un Service UUID en BLE ?

Service UUID est un identifiant attribué à un service GATT Bluetooth Low Energy pour sa reconnaissance sans ambiguïté par d'autres appareils. Dans l'architecture BLE, chaque service représente un groupe logique de caractéristiques unies par une fonction commune. Par exemple, Battery Service contient la caractéristique Battery Level qui transmet le niveau de charge actuel de la batterie.

Le Bluetooth SIG (Special Interest Group) gère le registre des UUID 16 bits standard attribués aux services les plus courants. Cela permet aux appareils de différents fabricants de reconnaître les services les uns des autres sans configuration préalable. Un tracker fitness de n'importe quelle marque peut déclarer un Heart Rate Service avec l'UUID 0x180D, et n'importe quel smartphone comprendra qu'il s'agit d'un service de fréquence cardiaque.

Selon la Bluetooth Core Specification 5.4 (2023), la plage des UUID 16 bits (0x0000–0xFFFF) est divisée en deux parties : de 0x0001 à 0xFFFE sont les services standard Bluetooth SIG, et 0xFFFF est réservé. Si un développeur a besoin d'un service unique qui n'est pas dans le registre SIG, il utilise un UUID 128 bits.

La différence entre les UUID standard et personnalisés ne réside pas seulement dans la longueur : les UUID 16 bits économisent du temps d'antenne dans le paquet de publicité, car ils sont transmis sur 2 octets au lieu de 16. Pour les appareils ayant des restrictions strictes sur la taille du paquet de publicité (jusqu'à 31 octets), c'est crucial.

UUID standard et personnalisés

Les UUID standard 16 bits couvrent les principales catégories d'appareils BLE : capteurs médicaux, trackers fitness, électronique portable et accessoires. Si un appareil implémente une fonction standard, il est recommandé au développeur d'utiliser l'UUID correspondant du registre Bluetooth SIG pour une compatibilité maximale.

Voici quelques exemples d'UUID de service standard :

Les UUID personnalisés 128 bits sont nécessaires lorsqu'un appareil offre des fonctionnalités uniques. Par exemple, un fabricant de serrures intelligentes crée son propre service Lock Control avec un UUID au format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX. Un tel UUID ne peut pas entrer en conflit avec d'autres services, car l'espace des valeurs 128 bits est pratiquement inépuisable.

Format d'un UUID 128 bits

Un UUID 128 bits s'écrit au format standard UUID RFC 4122 : huit caractères hexadécimaux, un trait d'union, quatre, trait d'union, quatre, trait d'union, quatre, trait d'union, douze caractères. Pour BLE, on utilise une version où la partie de base de l'UUID Bluetooth SIG a des bits fixes.

Le Bluetooth SIG définit l'UUID de base : 0000XXXX-0000-1000-8000-00805F9B34FB. Pour les services standard 16 bits, la valeur de l'UUID est substituée dans ce masque : par exemple, 0x180F devient 0000180F-0000-1000-8000-00805F9B34FB. Les services personnalisés utilisent un UUID complètement indépendant généré par le développeur.

Lors de la création d'un UUID personnalisé, vous pouvez utiliser n'importe quel générateur d'UUID (UUID v4). Un UUID v4 aléatoire fournit 122 bits d'entropie, rendant les collisions pratiquement impossibles. N'utilisez pas une version modifiée de l'UUID de base Bluetooth SIG pour les services personnalisés — cela viole la spécification.

Comment déclarer un service avec UUID dans le code

La déclaration d'un service avec un UUID se fait côté Peripheral lors de la création d'un serveur GATT. Sous iOS, Core Bluetooth est utilisé ; sous Android, android.bluetooth.le. Examinons les deux approches.

iOS : Core Bluetooth

En Swift, un service est créé via CBMutableService en spécifiant l'UUID, après quoi des caractéristiques lui sont ajoutées via CBMutableCharacteristic.

import CoreBluetooth

// Standard 16-bit UUID
let batteryServiceUUID = CBUUID("180F")

// Custom 128-bit UUID
let customServiceUUID = CBUUID("E20A39F4-73F5-4BC4-A12F-17D1AD07A961")

let service = CBMutableService(
    type: customServiceUUID,
    primary: true
)

// Add characteristics
service.characteristics = [characteristic]

// Publish service via peripheralManager
peripheralManager.add(service)

Android : Serveur GATT Bluetooth

Sous Android, le service est enregistré via BluetoothGattServer et BluetoothGattService. L'UUID est passé comme chaîne via java.util.UUID.fromString.

import android.bluetooth.*;

// Custom service UUID
private static final UUID CUSTOM_SERVICE_UUID =
    UUID.fromString("E20A39F4-73F5-4BC4-A12F-17D1AD07A961");

BluetoothGattService service = new BluetoothGattService(
    CUSTOM_SERVICE_UUID,
    BluetoothGattService.SERVICE_TYPE_PRIMARY
);

// Add characteristics
service.addCharacteristic(characteristic);

// Register on GATT server
gattServer.addService(service);

Scan des services par UUID

Le scan par Service UUID permet au Central de trouver les appareils fournissant le service nécessaire sans se connecter à tous les Peripherals découverts. Un paquet de publicité BLE peut contenir une liste d'UUID de services, ce qui permet au Central de filtrer les appareils dès l'étape de scan.

Sous iOS, CBCentralManager scanne les appareils avec un filtre par UUID de service. Cela réduit la consommation d'énergie et accélère la découverte des appareils nécessaires.

import CoreBluetooth

let centralManager = CBCentralManager()

func scanForHeartRateMonitor() {
    let services: [CBUUID] = [
        CBUUID("180D") // Heart Rate Service
    ]
    centralManager.scanForPeripherals(
        withServices: services,
        options: nil
    )
}

// Delegate receives only Heart Rate Service devices
func centralManager(
    _ central: CBCentralManager,
    didDiscover peripheral: CBPeripheral,
    advertisementData: [String: Any],
    rssi RSSI: NSNumber
) {
    // peripheral has only devices with UUID 0x180D
}

Sous Android, le filtrage par UUID est également pris en charge via ScanFilter.Builder. C'est un moyen efficace de restreindre la recherche sans se connecter à chaque appareil.

import android.bluetooth.le.*;

ScanFilter filter = new ScanFilter.Builder()
    .setServiceUuid(
        new ParcelUuid(
            UUID.fromString("0000180D-0000-1000-8000-00805F9B34FB")
        )
    )
    .build();

BluetoothLeScanner scanner = bluetoothAdapter.getBluetoothLeScanner();
scanner.startScan(
    Collections.singletonList(filter),
    scanSettings,
    scanCallback
);

Plusieurs services sur un seul appareil

Un seul appareil BLE peut déclarer plusieurs services simultanément. Par exemple, un bracelet fitness peut contenir Battery Service (0x180F), Heart Rate Service (0x180D) et un service personnalisé pour synchroniser les données avec le cloud. Chaque service a son propre UUID et son propre ensemble de caractéristiques.

Avec plusieurs services, il est important de prendre en compte la limitation du paquet de publicité. Un paquet de publicité BLE peut contenir jusqu'à 31 octets de données. Si les UUID des services prennent trop de place, certains peuvent ne pas tenir dans le paquet de publicité. Dans ce cas, on utilise la scan response — un second paquet envoyé à la demande du Central.

Selon la Bluetooth Core Specification 5.4 (2023), le nombre maximal de services primaires sur un seul serveur GATT n'est pas limité par la spécification, mais en pratique il est limité par la mémoire de l'appareil et les exigences de performance. Pour les appareils embarqués avec 256 Ko de mémoire flash, pas plus de 5 à 10 services sont recommandés.