Characteristic: definizione, tipi di dati e lettura dei valori

Cos’è una Characteristic in BLE?

Una Characteristic è un attributo del protocollo GATT che contiene un valore e metadati. Nell’architettura BLE, i dati non vengono trasferiti direttamente tra dispositivi, ma attraverso la lettura e scrittura dei valori delle caratteristiche del servizio. Se un servizio è una cartella, allora una Characteristic è un file all’interno di quella cartella.

Ogni Characteristic è composta da tre componenti: dichiarazione (declaration), valore (value) e descrittori (descriptors). La dichiarazione contiene l’UUID della caratteristica e le sue proprietà. Il valore sono i dati effettivi trasferiti tra Central e Peripheral. I descrittori forniscono configurazione aggiuntiva.

Secondo la Bluetooth Core Specification 5.4 (2023), tutti gli scambi di dati in BLE avvengono attraverso operazioni sulle caratteristiche. Anche i profili standard come Heart Rate Profile o Battery Service sono costruiti su un insieme di caratteristiche con UUID predefiniti. Questo garantisce la compatibilità dei dispositivi di diversi produttori senza configurazione preliminare.

È importante che lo sviluppatore capisca: ogni Characteristic può supportare diverse combinazioni di proprietà. Una caratteristica può essere solo lettura, un’altra per scrittura, una terza per notifiche. La scelta corretta delle proprietà determina lo scenario d’uso e il consumo energetico del dispositivo.

Proprietà e permessi della Characteristic

Le proprietà (properties) di una caratteristica definiscono quali operazioni sono consentite su di essa. È una maschera di byte dove ogni bit abilita o disabilita un’operazione specifica. Di seguito sono elencate le proprietà principali.

I permessi (permissions) sono il livello di accesso a livello del server GATT. A differenza delle proprietà, che sono dichiarate nella dichiarazione della caratteristica, i permessi vengono verificati in ogni operazione. Possono includere requisiti di crittografia e autenticazione.

Caratteristiche standard Bluetooth SIG

Bluetooth SIG ha specificato oltre 500 caratteristiche standard che coprono la maggior parte dei casi d’uso comuni del BLE. L’uso di UUID standard garantisce che qualsiasi dispositivo ricevente interpreti correttamente i dati senza configurazione preliminare.

Ecco le caratteristiche standard più utilizzate:

Se una caratteristica standard esistente copre il tuo compito, usala. Questo semplifica la certificazione Bluetooth e migliora la compatibilità con l’ecosistema. Crea caratteristiche personalizzate solo per dati unici non presenti nel registro SIG.

Come creare una Characteristic in iOS e Android

La creazione di una caratteristica viene eseguita sul lato Peripheral — il dispositivo che fornisce i dati. Vediamo le implementazioni su iOS (Swift) e Android (Java).

iOS: CBMutableCharacteristic

Core Bluetooth fornisce la classe CBMutableCharacteristic per creare una caratteristica con UUID, proprietà e valore iniziale.

import CoreBluetooth

let characteristicUUID = CBUUID("2A19") // Caratteristica del livello della batteria

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

// Aggiorna valore al cambiamento
let batteryData = Data([batteryLevel]) // uint8
peripheralManager.updateValue(
    batteryData,
    for: characteristic,
    onSubscribedCentrals: nil
)

Android: BluetoothGattCharacteristic

Su Android, una caratteristica viene creata usando BluetoothGattCharacteristic con UUID, proprietà e permessi.

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

// Imposta il valore
characteristic.setValue(batteryLevel, BluetoothGattCharacteristic.FORMAT_UINT8, 0);
gattServer.notifyCharacteristicChanged(device, characteristic, false);

Lettura, scrittura e notifiche

Le operazioni su una Characteristic si dividono in tre tipi: lettura (read), scrittura (write) e notifiche (notify/indicate). La scelta dipende dallo scenario: i dati su richiesta vengono letti, i comandi vengono scritti, i dati in flusso si iscrivono alle notifiche.

Read: Central invia una richiesta per leggere il valore della caratteristica. Peripheral risponde con il valore corrente. L’operazione è sincrona e richiede una richiesta esplicita da ciascun lato. Utilizzata per dati che cambiano raramente: versione del firmware, numero di serie, impostazioni.

Write: Central invia dati a Peripheral. Esistono due modalità: Write with Response (conferma da Peripheral) e Write Without Response (senza conferma). Write with Response garantisce la consegna — Peripheral invia una conferma dopo la scrittura. Write Without Response è più veloce ma non garantisce la consegna.

Notify e Indicate: Peripheral avvia la trasmissione dei dati a Central. Con Notify, i dati vengono inviati senza conferma — se Central non riceve il pacchetto, viene perso. Con Indicate, Central invia una conferma (livello PDU), garantendo la consegna. Indicate è più lento ma più affidabile. Per iscriversi alle notifiche, Central scrive il valore 0x0001 nel CCCD (Client Characteristic Configuration Descriptor).

MTU e dimensione dei dati trasferiti

MTU (Maximum Transmission Unit) definisce la dimensione massima di un singolo pacchetto di dati BLE. Per impostazione predefinita, l’MTU è di 23 byte, di cui 3 byte sono l’intestazione — il carico utile (ATT payload) è di 20 byte. Questo è sufficiente per la maggior parte dei dati dei sensori, ma non per il trasferimento di file o grandi configurazioni.

Bluetooth Core Specification 5.4 supporta la negoziazione dell’MTU — Central e Peripheral possono concordare una dimensione del pacchetto maggiore fino a 517 byte. Il processo funziona così: Central invia una richiesta MTU Exchange con il suo MTU proposto; Peripheral risponde con il suo MTU; viene utilizzato il minore dei due valori.

// iOS richiede MTU alla connessione
// Il MTU massimo in iOS è 185 byte
func peripheral(
    _ peripheral: CBPeripheral,
    didDiscoverServices error: Error?
) {
    // Richiedi MTU per un periferico specifico
    peripheral.maximumWriteValueLength(for: .withResponse)
}

Secondo Bluetooth SIG (2023), l’aumento dell’MTU da 23 a 185 byte riduce l’overhead di trasmissione dei dati fino all’80% grazie alla riduzione del numero di pacchetti. Per le applicazioni che trasmettono letture ad alta frequenza (ad esempio, ECG o accelerometro), l’aumento dell’MTU è critico per la stabilità del flusso.