Characteristic : définition, types de données et lecture des valeurs

Qu’est-ce qu’une Characteristic dans BLE ?

Une Characteristic est un attribut du protocole GATT qui contient une valeur et des métadonnées. Dans l’architecture BLE, les données ne sont pas transférées directement entre les appareils, mais par la lecture et l’écriture des valeurs des caractéristiques du service. Si un service est un dossier, alors une Characteristic est un fichier dans ce dossier.

Chaque Characteristic se compose de trois éléments : déclaration (declaration), valeur (value) et descripteurs (descriptors). La déclaration contient l’UUID de la caractéristique et ses propriétés. La valeur correspond aux données réelles transférées entre Central et Peripheral. Les descripteurs fournissent une configuration supplémentaire.

Selon la Bluetooth Core Specification 5.4 (2023), tous les échanges de données en BLE se font par des opérations sur les caractéristiques. Même les profils standard comme Heart Rate Profile ou Battery Service sont construits sur un ensemble de caractéristiques avec des UUID prédéfinis. Cela garantit la compatibilité des appareils de différents fabricants sans configuration préalable.

Il est important que le développeur comprenne : chaque Characteristic peut prendre en charge différentes combinaisons de propriétés. Une caractéristique peut être en lecture seule, une autre en écriture, une troisième pour les notifications. Le choix correct des propriétés détermine le scénario d’utilisation et la consommation énergétique de l’appareil.

Propriétés et autorisations de la Characteristic

Les propriétés (properties) d’une caractéristique définissent les opérations autorisées sur celle-ci. Il s’agit d’un masque d’octets où chaque bit active ou désactive une opération spécifique. Voici les principales propriétés.

Les autorisations (permissions) sont le niveau d’accès au niveau du serveur GATT. Contrairement aux propriétés, qui sont déclarées dans la déclaration de la caractéristique, les autorisations sont vérifiées à chaque opération. Elles peuvent inclure des exigences de chiffrement et d’authentification.

Caractéristiques standard Bluetooth SIG

Bluetooth SIG a spécifié plus de 500 caractéristiques standard qui couvrent la plupart des cas d’utilisation courants du BLE. L’utilisation d’UUID standard garantit que tout appareil récepteur interprète correctement les données sans configuration préalable.

Voici les caractéristiques standard les plus fréquemment utilisées :

Si une caractéristique standard existante couvre votre tâche, utilisez-la. Cela simplifie la certification Bluetooth et améliore la compatibilité avec l’écosystème. Créez des caractéristiques personnalisées uniquement pour les données uniques qui ne figurent pas dans le registre SIG.

Comment créer une Characteristic sur iOS et Android

La création d’une caractéristique se fait du côté Peripheral — l’appareil qui fournit les données. Examinons les implémentations sur iOS (Swift) et Android (Java).

iOS : CBMutableCharacteristic

Core Bluetooth fournit la classe CBMutableCharacteristic pour créer une caractéristique avec un UUID, des propriétés et une valeur initiale.

import CoreBluetooth

let characteristicUUID = CBUUID("2A19") // Caractéristique de niveau de batterie

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

// Mettre à jour la valeur lors du changement
let batteryData = Data([batteryLevel]) // uint8
peripheralManager.updateValue(
    batteryData,
    for: characteristic,
    onSubscribedCentrals: nil
)

Android : BluetoothGattCharacteristic

Sur Android, une caractéristique est créée avec BluetoothGattCharacteristic avec un UUID, des propriétés et des autorisations.

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
    );

// Définir la valeur
characteristic.setValue(batteryLevel, BluetoothGattCharacteristic.FORMAT_UINT8, 0);
gattServer.notifyCharacteristicChanged(device, characteristic, false);

Lecture, écriture et notifications

Les opérations sur une Characteristic se divisent en trois types : lecture (read), écriture (write) et notifications (notify/indicate). Le choix dépend du scénario : les données à la demande sont lues, les commandes sont écrites, les données en flux s’abonnent aux notifications.

Read : Central envoie une demande pour lire la valeur de la caractéristique. Peripheral répond avec la valeur actuelle. L’opération est synchrone et nécessite une demande explicite de chaque côté. Utilisée pour les données qui changent rarement : version du firmware, numéro de série, paramètres.

Write : Central envoie des données à Peripheral. Deux modes existent : Write with Response (confirmation de Peripheral) et Write Without Response (sans confirmation). Write with Response garantit la livraison — Peripheral envoie une confirmation après l’écriture. Write Without Response est plus rapide mais ne garantit pas la livraison.

Notify et Indicate : Peripheral initie la transmission de données vers Central. Avec Notify, les données sont envoyées sans confirmation — si Central ne reçoit pas le paquet, il est perdu. Avec Indicate, Central envoie une confirmation (niveau PDU), garantissant la livraison. Indicate est plus lent mais plus fiable. Pour s’abonner aux notifications, Central écrit la valeur 0x0001 dans le CCCD (Client Characteristic Configuration Descriptor).

MTU et taille des données transférées

MTU (Maximum Transmission Unit) définit la taille maximale d’un seul paquet de données BLE. Par défaut, le MTU est de 23 octets, dont 3 octets d’en-tête — la charge utile (ATT payload) est de 20 octets. Cela suffit pour la plupart des données de capteurs, mais pas pour les transferts de fichiers ou les grandes configurations.

Bluetooth Core Specification 5.4 prend en charge la négociation du MTU — Central et Peripheral peuvent convenir d’une taille de paquet plus grande allant jusqu’à 517 octets. Le processus fonctionne ainsi : Central envoie une demande MTU Exchange avec son MTU proposé ; Peripheral répond avec son MTU ; la plus petite des deux valeurs est utilisée.

// iOS demande MTU à la connexion
// Le MTU maximal dans iOS est de 185 octets
func peripheral(
    _ peripheral: CBPeripheral,
    didDiscoverServices error: Error?
) {
    // Demander MTU pour un périphérique spécifique
    peripheral.maximumWriteValueLength(for: .withResponse)
}

Selon Bluetooth SIG (2023), l’augmentation du MTU de 23 à 185 octets réduit la surcharge de transmission des données jusqu’à 80% grâce à la réduction du nombre de paquets. Pour les applications transmettant des lectures à haute fréquence (par exemple, ECG ou accéléromètre), l’augmentation du MTU est critique pour la stabilité du flux.