ESP 32 WROOM - Bluetooth

La funzione viene utilizzata per impostare i callback (chiamate di ritorno) per gestire gli eventi del server BLE. I callback consentono di gestire determinati eventi o azioni che si verificano nel server BLE. Di seguito un elenco degli eventi che possono essere personalizzati :

1. onConnect: Chiamato quando un dispositivo si connette al server BLE.
2. onDisconnect: Chiamato quando un dispositivo si disconnette dal server BLE.
3. onWrite: Chiamato quando una caratteristica viene scritta da un dispositivo connesso al server BLE.
4. onRead: Chiamato quando una caratteristica viene letta da un dispositivo connesso al server BLE.
5. onSubscribe: Chiamato quando un dispositivo si abbona alle notifiche o indicazioni di una caratteristica.
6. onUnsubscribe: Chiamato quando un dispositivo si disiscrive dalle notifiche o indicazioni di una caratteristica.
7. onNotify: Chiamato quando viene inviata una notifica o indicazione a un dispositivo connesso.

Di seguito un esempio funzionante

 #include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>

BLEServer *pServer;
BLECharacteristic *pCharacteristic;

class MyServerCallbacks : public BLEServerCallbacks {
  void onConnect(BLEServer* pServer) {
    Serial.println("Device connected");
  }

  void onDisconnect(BLEServer* pServer) {
    Serial.println("Device disconnected");
  }

  void onWrite(BLECharacteristic *pCharacteristic) {
    std::string value = pCharacteristic->getValue();
    Serial.print("Received data: ");
    Serial.println(value.c_str());
  }
};

void setup() {
  Serial.begin(115200);

  BLEDevice::init("ESP32");
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  BLEService *pService = pServer->createService(BLEUUID((uint16_t)0x180D));

  pCharacteristic = pService->createCharacteristic(
      BLEUUID((uint16_t)0x2A37),
      BLECharacteristic::PROPERTY_READ |
          BLECharacteristic::PROPERTY_WRITE);

  pService->start();

  BLEAdvertising *pAdvertising = pServer->getAdvertising();
  pAdvertising->start();
}

void loop() {
  // Do nothing in the loop
}

La classe MyServerCallbacks eredita dalla classe BLEServerCallbacks e definisce i callback personalizzati per gli eventi del server BLE. Nel nostro esempio, abbiamo implementato onConnect, onDisconnect e onWrite.

Nella funzione setup(), inizializziamo la comunicazione seriale, inizializziamo il dispositivo BLE, creiamo il server BLE e impostiamo i callback utilizzando pServer->setCallbacks(new MyServerCallbacks()).

Creiamo un servizio BLE e una caratteristica BLE all'interno del server. La caratteristica è impostata come leggibile e scrivibile. Infine, avviamo il servizio e l'annuncio BLE.

Nel callback onConnect, stampiamo un messaggio sulla console seriale quando un dispositivo si connette al server BLE.

Nel callback onDisconnect, stampiamo un messaggio sulla console seriale quando un dispositivo si disconnette dal server BLE.

Nel callback onWrite, recuperiamo il valore scritto nella caratteristica BLE e lo stampiamo sulla console seriale.

All'interno della funzione loop(), non è presente alcun codice poiché non è necessario fare nulla di specifico nel loop principale per gestire gli eventi BLE.

Una caratteristica (characteristic) nel contesto del Bluetooth Low Energy (BLE) è un'entità di dati che rappresenta una proprietà o una funzionalità specifica di un dispositivo BLE. Le caratteristiche sono organizzate all'interno di servizi (services) e consentono la trasmissione di dati tra dispositivi BLE.

Ogni caratteristica ha una UUID (Universally Unique Identifier) che ne identifica in modo univoco il tipo e le proprietà. Le proprietà di una caratteristica definiscono il suo comportamento e includono:

1. Proprietà di lettura (Read): Consente a un dispositivo centrale di leggere il valore corrente della caratteristica dal dispositivo periferico.
2. Proprietà di scrittura (Write): Consente a un dispositivo centrale di scrivere un valore nella caratteristica del dispositivo periferico.
3. Proprietà di notifica (Notify): Consente a un dispositivo periferico di inviare notifiche ai dispositivi centrali quando il valore della caratteristica cambia.

Proprietà di indicazione (Indicate): Simile alle notifiche, consente a un dispositivo periferico di inviare indicazioni periodiche ai dispositivi centrali con il valore aggiornato della caratteristica.

Oltre alle proprietà, una caratteristica può anche avere dei descrittori (descriptors) associati. I descrittori forniscono ulteriori informazioni o configurazioni sulla caratteristica stessa, come metadati, unità di misura o limiti di valori consentiti.

Le caratteristiche vengono organizzate all'interno dei servizi BLE, che possono rappresentare una raccolta logica di caratteristiche correlate. Ad esempio, un servizio potrebbe rappresentare il servizio di misurazione di un sensore, con caratteristiche per la temperatura, l'umidità, la pressione, ecc.

La comunicazione e lo scambio di dati tra dispositivi BLE avviene attraverso la lettura o scrittura delle caratteristiche dei servizi. I dispositivi centrali possono leggere il valore delle caratteristiche dei dispositivi periferici, scrivere nuovi valori nelle caratteristiche o sottoscriversi per ricevere notifiche o indicazioni quando il valore di una caratteristica cambia.

Le caratteristiche e i servizi BLE sono definiti utilizzando un'appropriato profilo BLE o personalizzati per soddisfare le specifiche esigenze del tuo progetto. La definizione delle caratteristiche, dei servizi e dei descrittori avviene mediante l'assegnazione delle relative UUID e la configurazione delle proprietà e delle funzionalità desiderate.

Di seguito un esempio di uso delle caratteristiche in cui una volta creato un oggetto BLECharacteristic chiamato pCharacteristic con un UUID specifico. La caratteristica viene configurata come notificabile (BLENotify) e scrivibile (BLEWrite).

Successivamente, utilizziamo il metodo addDescriptor() per aggiungere un nuovo descrittore alla caratteristica. In questo caso, stiamo aggiungendo un descrittore BLE2902, che è comunemente usato per abilitare o disabilitare le notifiche o gli indirizzi di raccolta dati.

#include <BLE2902.h>

// Creazione della caratteristica
BLECharacteristic pCharacteristic("characteristicUUID", BLENotify | BLEWrite);

// Aggiunta del descrittore BLE2902
pCharacteristic.addDescriptor(new BLE2902());

Nella classe BluetoothSerial, i metodi println() e write() hanno due scopi diversi per l'invio dei dati tramite Bluetooth:

• SerialBT.println(): Questo metodo invia una stringa ( oggetto String di Arduino/ESP32 ) o un valore seguito da un carattere di nuova riga ("\r\n"). Ad esempio, se utilizzi SerialBT.println("Hello"), invierà la stringa "Hello" seguita da un carattere di nuova riga. Questo è utile quando desideri inviare dati con una nuova riga alla fine, il che può essere utile per distinguere i messaggi o per interpretare correttamente i dati ricevuti.
• SerialBT.write(): Questo metodo invia un singolo byte di dati. Puoi utilizzarlo per inviare un carattere, un valore numerico o qualsiasi dato rappresentato da un singolo byte. Ad esempio, se utilizzi SerialBT.write('A'), invierà il carattere "A" come byte. Questo metodo è utile quando desideri inviare dati byte per byte senza aggiungere caratteri di formattazione o di controllo.

L'elenco completo dei metodi disponibili nella classe BluetoothSerial:

• begin(deviceName): Avvia la comunicazione Bluetooth e imposta il nome del dispositivo Bluetooth come specificato da deviceName.
• end(): Termina la comunicazione Bluetooth e libera le risorse associate al modulo Bluetooth.
• available(): Restituisce il numero di byte disponibili per la lettura dal modulo Bluetooth.
• read(): Legge il prossimo byte disponibile dal modulo Bluetooth e lo restituisce come un valore di tipo int.
• peek(): Restituisce il prossimo byte disponibile dal modulo Bluetooth senza rimuoverlo dalla coda di lettura.
• flush(): Svuota il buffer di trasmissione del modulo Bluetooth e assicura che tutti i dati siano stati inviati.
• write(data): Invia un singolo byte (data) al dispositivo remoto connesso attraverso il modulo Bluetooth.
• print(data): Stampa i dati specificati (di tipo int, float, char, ecc.) sulla porta seriale di debug.
• println(data): Stampa i dati specificati seguiti da un carattere di nuova riga sulla porta seriale di debug.
• printf(format, args…): Stampa i dati specificati formattati secondo il formato specificato.
• setTransmitPower(powerLevel): Imposta il livello di potenza di trasmissione per il modulo Bluetooth (disponibile solo su alcune schede).
• setPin(pin): Imposta il pin di connessione per il modulo Bluetooth (disponibile solo su alcune schede).
• connected(): Restituisce true se c'è una connessione Bluetooth attiva, altrimenti restituisce false.
• operator bool(): Restituisce true se il modulo Bluetooth è stato inizializzato correttamente, altrimenti restituisce false.