Bluetooth e BLE: cosa sono, differenza tra Classic e Low Energy e come funzionano

Cosa sono Bluetooth e BLE?

Bluetooth è uno standard di rete personale wireless (WPAN) che opera nella banda ISM 2,4 GHz, progettato per la comunicazione tra dispositivi a distanze fino a 100 metri. La specifica IEEE 802.15.1 definisce i livelli fisico e MAC, mentre lo stack Bluetooth SIG definisce profili di alto livello per scenari specifici: cuffie audio (HSP), trasferimento file (OPP), input da tastiera (HID).

Lo standard si è diviso in due rami dalla versione 4.0 (2010): Bluetooth Classic (BR/EDR — Basic Rate / Enhanced Data Rate) e Bluetooth Low Energy (BLE, precedentemente Bluetooth Smart). Classic è progettato per flussi continui — chiamate audio, musica, file. BLE è stato creato per applicazioni in cui i dati vengono trasmessi in pacchetti brevi con pause di decine di secondi o minuti — cardiofrequenzimetri, tag, sensori di temperatura.

Secondo Bluetooth SIG (2025), il 99% dei nuovi smartphone supporta entrambe le versioni e l'ecosistema BLE conta oltre 15 tipi di profili, da Blood Pressure a Environmental Sensing.

Bluetooth Classic vs BLE: Confronto

La scelta tra Classic e BLE dipende dallo scenario: per lo streaming audio è adatto solo Classic, per interrogare un sensore una volta all'ora — solo BLE. BR/EDR utilizza 79 canali con spaziatura di 1 MHz e salto di frequenza adattivo (AFH), offrendo resistenza alle interferenze Wi-Fi.

BLE 5.x ha aggiunto LE Coded PHY per aumentare la portata fino a 1 km (in aree aperte) e LE Audio con codec LC3 — la nuova versione sta gradualmente offuscando il confine tra Classic e BLE per gli scenari audio.

Architettura BLE: Controller, Host e Application

Lo stack BLE è diviso in tre livelli: Controller (livelli fisico e di collegamento), Host (L2CAP, ATT, GATT, Security Manager) e Application (implementazione del profilo nell'app). Questa separazione consente al produttore del chip di implementare il Controller nel firmware, mentre lo sviluppatore dell'app mobile lavora solo con astrazioni GATT.

Il livello di collegamento (LL) gestisce il tempo in onda: il dispositivo passa tra gli stati Standby, Advertising, Scanning, Initiating e Connection. Nello stato Connected, Central e Peripheral concordano un intervallo di connessione — la frequenza con cui scambiano pacchetti di dati. Un intervallo tipico è 7,5–1000 ms; più frequente è lo scambio, maggiore è la velocità effettiva e maggiore è il consumo energetico.

Il Security Manager (SM) implementa la crittografia AES-128 con scambio di chiavi tramite il protocollo di accoppiamento. Esistono tre modalità: Just Works (senza inserimento PIN), Passkey Entry (codice a 6 cifre sullo schermo) e OOB (NFC o QR). Per i dispositivi indossabili si usa solitamente Just Works, per i dispositivi medici — OOB con verifica aggiuntiva.

Secondo Bluetooth Core Specification 5.4 (2023), il tempo di impostazione della connessione sicura in modalità LE Secure Connections non supera i 300 ms con un intervallo di connessione di 30 ms.

Profilo GATT: Servizi, Caratteristiche e Descrittori

Il ATT (Attribute Protocol) è il modello di trasporto di base in cui il server (dispositivo periferico) memorizza gli attributi e il client (smartphone) li legge o scrive. GATT (Generic Attribute Profile) costruisce una gerarchia su ATT: Service → Characteristic → Descriptor.

Ogni servizio è un gruppo logico di caratteristiche che descrivono una funzione del dispositivo: Heart Rate Service (UUID 0x180D) contiene la caratteristica Heart Rate Measurement (UUID 0x2A37) con un descrittore Client Characteristic Configuration (0x2902) che controlla le notifiche. Lo sviluppatore dell'app mobile ottiene l'elenco dei servizi tramite discoverServices(), quindi trova la caratteristica desiderata per UUID e si iscrive alle notifiche.

BLE utilizza UUID a 16 bit per i servizi standardizzati Bluetooth SIG e UUID a 128 bit per i servizi personalizzati del produttore. Ad esempio, una custodia tracker può definire un servizio A000-… con una caratteristica per trasmettere il livello di carica della batteria.

Esempio di lavoro con GATT in 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("Polso: $heartRate bpm")
    }
}

Nell'esempio, l'app trova il servizio Heart Rate tramite l'UUID standard Bluetooth SIG, ottiene la caratteristica di misurazione del polso e si iscrive alle sue notifiche — ogni volta che il polso cambia, il dispositivo periferico invia dati senza una richiesta esplicita dal Central.

Advertising, scansione e impostazione della connessione

Advertising è un meccanismo chiave del BLE in cui un dispositivo Peripheral invia periodicamente pacchetti broadcast (PDU di advertising) su tre canali primari (37, 38, 39). Il dispositivo centrale scansiona questi canali, riceve i dati di advertising e può avviare una connessione.

Un pacchetto di advertising contiene fino a 31 byte di payload: flag, livello di potenza TX, nome locale, UUID dei servizi, dati specifici del produttore. Questo è sufficiente per trasmettere letture dei sensori senza stabilire una connessione — modalità senza connessione (tipo Broadcaster). Per la trasmissione continua di dati (ad esempio, temperatura una volta al minuto), si utilizza una connessione con un intervallo fino a 1000 ms.

Sulle piattaforme mobili, la scansione viene avviata tramite startScan() (Android) o scanForPeripherals() (iOS). Il filtraggio per UUID del servizio consente di risparmiare energia non elaborando tutti i dispositivi visibili — l'app riceve un callback solo per tag o sensori pertinenti.

Esempio di scansione di dispositivi BLE in 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("Dispositivo trovato: \(name)")
        }
    }
}

Dopo aver scoperto un dispositivo, il Central chiama connect(), passando l'oggetto CBPeripheral. I parametri di connessione (intervallo, latenza, timeout di supervisione) vengono negoziati a livello di collegamento — lo sviluppatore non li gestisce direttamente, ma può influenzarli tramite requestConnectionPriority su Android.

Bluetooth LE nello sviluppo mobile: Core Bluetooth e android.bluetooth

Entrambe le piattaforme mobili forniscono API native per lavorare con BLE. Core Bluetooth (iOS) utilizza un approccio a delegati: il gestore centrale avvia le operazioni e l'oggetto periferico riporta i risultati tramite metodi delegati. android.bluetooth (Android) è costruito su interfacce callback e supporta operazioni GATT parallele con più dispositivi.

Differenze principali tra le piattaforme:

• iOS — supporta fino a 7 connessioni simultanee; la modalità BLE in background richiede UIBackgroundModes = bluetooth-central; dopo aver lasciato il primo piano, il sistema può ritardare i callback di diversi minuti
• Android — nessun limite di connessione fisso (limitato dalla memoria); richiede le autorizzazioni BLUETOOTH_SCAN e BLUETOOTH_CONNECT (Android 12+); un servizio in primo piano è necessario per una scansione affidabile in background
• Flutter — il pacchetto flutter_blue_plus astrae le API delle piattaforme con un'interfaccia Dart unificata: il codice per la scansione e le operazioni GATT è identico su entrambe le piattaforme

Secondo i test Bluetooth SIG (2024), il tempo di connessione BLE tra uno smartphone e un fitness tracker è in media di 150–300 ms su Android e 100–250 ms su iOS — la differenza è dovuta alle politiche di gestione del modulo a radiofrequenza.

Esempio di connessione BLE in 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;
      }
    }
  }
}

Lo sviluppatore Flutter ottiene un'interfaccia API unificata; sotto il cofano, flutter_blue_plus traduce le chiamate in android.bluetooth nativo o Core Bluetooth. Questo approccio riduce i tempi di sviluppo delle app per lavorare con periferiche BLE su entrambe le piattaforme.