View source for Domotica Arduino Integrazione Bluetooth

=Introduzione=
Fondamentale è la guida di Arduino sul '''BLE''' (Bluetooth Low Energy): [https://docs.arduino.cc/learn/communication/bluetooth/ docs.arduino.cc]
==BLE==
E' una tecnologia di comunicazione wireless progettata per lo scambio di dati a corto raggio tra dispositivi elettronici.<br />A differenza del suo predecessore, '''Bluetooth Classic''', ottimizzato per comunicazioni continue e a velocità di trasmissione dati relativamente elevate, BLE punta alla riduzione al minimo del consumo energetico mantenendo la connettività. BLE è particolarmente adatto per applicazioni che richiedono una lunga durata della batteria.<br />BLE opera alla frequenza di banda 2.4GHz ISM ((Industrial, Scientific, and Medical), questa banda è poi suddivisa in canali multipli.<br />
Il '''range''' è circa di 50 metri che è influenzato da diversi fattori:
* ostacoli, come muri;
* interferenze, ad es. per la presenza di altri dispositivi a 2.4 GHz;
* design dell'antenna;
* orientamento.

===Central e Peripheral===
Nella comunicazione tra due dispositivi esistono due ruoli: il dispositivo "'''Central'''" e il dispositivo "'''Peripheral'''".<br />
Sebbene la maggior parte dei dispositivi possa svolgere entrambi i ruoli, se si sta sviluppando un'applicazione Android per connettersi a un dispositivo fisico tramite BLE, il dispositivo Android svolgerà il ruolo ''Central''. Allo stesso modo, se si sta progettando un dispositivo basato su microcontrollore si sta costruendo un dispositivo ''Peripheral''.<br />
I dispositivi central sono clients, essi leggono e scrivono dati da dispositivi periferici (peripheral).<br />
I dispositivi Peripheral sono server, forniscono dati dai sensori come caratteristiche in lettura e forniscono caratteristiche in lettura\scrittura per controllare attuatori come motori, luci e così via.

Quando si crea un'applicazione ''Central'', ci sono tre passaggi di alto livello da implementare:
* Trovare i dispositivi Periphral e filtrare fino al dispositivo e al servizio di interesse.
* Definire caratteristiche di lettura e scrittura.
* Disconnettersi quando desiderato.

Il dispositivo Peripheral definisce un insieme di ''services'' (servizi), ''characteristics'' (caratteristiche) e ''descriptors'' (descrittori):

* I '''services''' sono indispensabili: un dispositivo senza almeno un servizio non è utile. Un service potrebbe apparire come un cardiofrequenzimetro, un termometro, un sensore generico. I services hanno delle caratteristiche.

* Le '''characteristics''' sono simili alle "variabili membro" in un linguaggio orientato agli oggetti in quanto contengono dati e rappresentano valori.  Le characteristics includono valori come la frequenza cardiaca (battiti al minuto) o il volume. Le characteristics possono essere di sola ''lettura'', di sola ''scrittura'', di ''lettura''/''scrittura'' e così via. Scrivere un nuovo valore in una characteristic è in qualche modo analogo all'invocazione di un "setter" in un linguaggio orientato agli oggetti, poiché il metodo non solo aggiornerà il valore, ma avrà anche la possibilità di intervenire in seguito all'aggiornamento di tale valore.

* I '''descriptors''' forniscono informazioni aggiuntive su una caratteristica.

===UUID===
Ogni dispositivo fornisce dei ''servizi'' che a loro volta forniscono ''caratteristiche''. Si posson definire i propri servizi o utilizzarne degli standard (vedi [https://www.bluetooth.com/specifications/assigned-numbers/ bluetooth.com]). BLE identifica i servizi  e le caratteristiche con a un identificatore univoco universale, o '''UUID'''. <br />
Un UUID è un numero a 128 bit. I 96 bit più bassi sono tutti uguali e ci interessano solo i 32 bit più alti. E, per la maggior parte, i 16 bit più alti sono zero. Quindi, in generale, ci rimangono 16 bit di interesse.

Ecco un esempio di UUID BLE:

<code>0000'''fa01'''-0000-1000-8000-00805f9b34fb</code>

L'unica parte di questo UUID che ci interessa davvero è <code>fa01</code>, questa è la parte che identifica questo dispositivo.

BLE consente ai produttori di dispositivi di definire un numero qualsiasi di servizi, caratteristiche e descrittori, ma esistono alcuni valori pre-assegnati per dispositivi e caratteristiche che vengono utilizzati per contenere informazioni che tutti i dispositivi devono fornire, come il nome o l'aspetto.



Materiale e link utili:
* [https://developer.ibm.com/tutorials/build-connected-devices-using-ble-apis/ developer.ibm.com]

=Arduino Nano ESP32=
Grazie al chip ''ESP32-S3'' che supporta sia sia Bluetooth Classic che il '''BLE''' (Bluetooth Low Energy).<br />Il BLE è ideale per dispositivi a batteria e app mobile.
* Le librerie più diffuse sono:
** La libreria standard inclusa nel pacchetto ESP32 che è '''<code>BLEDevice.h</code>''' (Usando VS Code con PlatformIO non c'è bisogno di installare nulla, si può già includere). 
** Altra libreria disponibile senza installazioni è la '''<code>ArduinoBLE.h</code>''' (anche con PlatformIO).
** Valida alternativa alle precedenti ma meno efficiente è la libreria ''Bluetooth Classic'' '''<code>BluetoothSerial.h</code>''' che consente una connessione seriale semplice (tipo RS232).
* L'app per smartphone potrebbe essere:  "''nRF Connect for Mobile''" (Nordic Semiconductor) o "''Serial Bluetooth Terminal''" (per emulare la seriale via BLE). 

==Libreria: BLEDevice.h==
NOTA Per usare la libreria si generano dei codici univoci alfanumerici ad identificare la connessione, [https://it.wikipedia.org/wiki/Universally_unique_identifier UUID], per generarli si può usare un servizio on-line su [https://uuidgenerator.net uuidgenerator.net]<br />
===Esempio Base===
Esempio minimale per impostare il dispositivo microcontrollore come server:
<syntaxhighlight lang="csharp">
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

// UUID generati casualmente (puoi cambiarli)
#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

void setup() {
  Serial.begin(115200);
  Serial.println("Avvio BLE...");

  // Inizializza il dispositivo BLE
  BLEDevice::init("NanoESP32-LED");

  // Crea il server BLE
  BLEServer *pServer = BLEDevice::createServer();

  // Crea il servizio BLE
  BLEService *pService = pServer->createService(SERVICE_UUID);

  // Crea la caratteristica BLE
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                         CHARACTERISTIC_UUID, BLECharacteristic::PROPERTY_READ |
                                         BLECharacteristic::PROPERTY_WRITE
                                       );
  // Imposta un valore iniziale
  pCharacteristic->setValue("Benvenuto ospite");
  pService->start();

  // Inizia l'advertising (rendere il dispositivo visibile)
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  BLEDevice::startAdvertising();

  Serial.println("Il dispositivo ora è visibile e pronto alla connessione!");
}

void loop() {
  // Esempio base
  delay(2000);
}
</syntaxhighlight>
Lato smartphone:

# Aprire l'app ''nRF Connect'' quindi avviare la scansione dei dispositivi disponibili alla comunicazione.
# Cercare il dispositivo usando il nome che si è scelto di dare nello sketch, quindi cliccare su "Connect".
# Una volta connesso, vedrai un servizio con il UUID definito. Puoi leggere il valore ("Ciao Cellulare") o scriverne uno nuovo.

==Libreria: ArduinoBLE.h==
E' una libreria ufficiale anche se in VS Code con PlatformIO è necessario installarla (in automatico si risolveranno delle dipendenze); come nella libreia BLE*.h si fa uso di [https://it.wikipedia.org/wiki/Universally_unique_identifier UUID].<br />Doc ufficiale:

* [https://docs.arduino.cc/libraries/arduinoble/ arduino.cc]
* GitHub esempi ufficiali etc [https://github.com/arduino-libraries/ArduinoBLE/tree/master/examples]

<br />
La libreria instanzia direttamente diverse classi e come accennato precedentemente, si definiscono ''Service'', ''Characteristic'' e ''Descriptor'':

* '''<code>BLE</code>''' viene utilizzato per ''abilitare'' il modulo Bluetooth® Low Energy.
* '''<code>BLEDevice</code>''' viene utilizzato per ''ottenere informazioni'' sui dispositivi connessi o rilevati durante la scansione.
* '''<code>BLEService</code>''' viene utilizzato per ''abilitare i servizi'' forniti dalla scheda o per interagire con i servizi forniti da una scheda remota.
* '''<code>BLECharacteristic</code>''' viene utilizzato per ''abilitare le caratteristiche offerte dalla scheda'' in un servizio o per interagire con le caratteristiche fornite da una scheda remota. Come descritto prima, le caratteristiche possono agire con una combinazione di read\write; per una stessa caratteristica si posson definite concatenandoli col pipe | , ad es. <code>BLEUnsignedCharCharacteristic buttonCharacteristic("2102", '''BLERead''' | '''BLEWrite''' | '''BLENotify''');</code>
* '''<code>BLEDescriptor</code>''' viene utilizzato per ''descrivere una caratteristica'' offerta dalla scheda. Es. <code>BLEDescriptor mydescriptor1("2103","''Mia descrizione''");</code>

In merito alle ''characteristic'' un dispositivo central può averle di tipo:

* '''read''', per chiedere alla periferica di restituire il valore corrente della caratteristica. Spesso utilizzato per characteristic che non cambiano molto spesso, ad esempio caratteristiche utilizzate per la configurazione, i numeri di versione, ecc.
* '''write''', per modificare il valore della characteristic . Spesso utilizzato per operazioni simili a comandi, ad esempio per dire alla periferica di accendere o spegnere un motore.
* indicate e '''notify''', per chiedere alla periferica di inviare continuamente valori aggiornati della caratteristica, senza che la centrale debba richiederlo costantemente.

===Oggetto BLE: metodi di interesse===
{| class="wikitable"
|-
!|Istruzione
!|Descrizione
!|Esempio
|-
||<code>BLE.begin()</code>
||Usata per inizializzare il Bluetooth Low Energy del dispositivo.
||<syntaxhighlight lang="csharp">
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");

    while (1);
  }
</syntaxhighlight>
|-
||<code>BLE.end()</code>
||Interrompe l'uso del BLE.
||<syntaxhighlight lang="csharp">// Supponendo si sia già correttamente inizializzato:
  BLE.end();
</syntaxhighlight>
|-
||<code>BLE.disconnect()</code>
||Disconnette qualsiasi dispositivo BLE connesso.
||<syntaxhighlight lang="csharp">
if (BLE.connected()) {
    BLE.disconnect();
  }
</syntaxhighlight>
|-
||<code>BLE.address()</code>
||Ottiene l'indirizzo MAC dei dispositivi connessi.
||<syntaxhighlight lang="csharp">
String address = BLE.address();
Serial.print("Local address is: ");
Serial.println(address); //Esempio:  65:d1:4e:41:9c:ac
</syntaxhighlight>
|-
||<code>BLE.rssi()</code>
||Restituisce la potenza del segnale RSSI (Received signal strength indication) del dispositivo connesso.
||<syntaxhighlight lang="csharp">if (BLE.connected()) {
    Serial.print("RSSI = ");
    Serial.println(BLE.rssi());
  }
</syntaxhighlight>
|-
||<code>BLE.setLocalName(name)</code>
||Imposta il nome del dispositivo in fase iniziale di annuncio
||<syntaxhighlight lang="csharp">// begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");
    while (1);
  }
  BLE.setLocalName("LED");
  // ...
  // start advertising
  BLE.advertise();
</syntaxhighlight>
|-
||<code>BLE.setDeviceName(name)</code>
||Imposta il nome del dispositivo comecaratteristica predefinita. Se non impostato, il default è "Arduino".
||<syntaxhighlight lang="csharp">// begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");
    while (1);
  }
  BLE.setDeviceName("Arduino_LED");
  // ...
  // start advertising
  BLE.advertise();
</syntaxhighlight>
|-
||<code>BLE.advertise()</code>
||Inizializza l'annuncio alla prima connessione. Restituisce 1 in caso di successo e 0 altrimenti.
||<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
||<code>BLE.central()</code>
||Restituisce il nome del dispositivo connesso.
||<syntaxhighlight lang="csharp">// listen for Bluetooth® Low Energy peripherals to connect:
  BLEDevice central = BLE.central();
  // if a central is connected to peripheral:
  if (central) {
    Serial.print("Connected to central: ");
    // print the central's MAC address:
    Serial.println(central.address());
  }
</syntaxhighlight>
|-
||<code>BLE.scan()</code>
||Inizia la scansione per individuare dispositivi BLE che si annunciano
||<syntaxhighlight lang="csharp">// begin initialization
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");
    while (1);
  }
  Serial.println("BLE Central scan");
  // start scanning for peripheral
  BLE.scan();
  BLEDevice peripheral = BLE.available();
  if (peripheral) {
     // ...
  }
</syntaxhighlight>
|-
||<code>BLE.scanForName(name)</code>
||Avvia la scansione dei dispositivi BLE pubblicizzati con un nome (locale) specifico. 1=OK, 0=KO
||<syntaxhighlight lang="csharp">  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");
    while (1);
  }
  Serial.println("BLE Central scan");
  // start scanning for peripheral
  BLE.scanForName("LED");
  BLEDevice peripheral = BLE.available();
  if (peripheral) {
     // ...
  }
</syntaxhighlight>
|}
===Oggetto BLEDevice: metodi di interesse===
ToDo...
<syntaxhighlight lang="csharp">
</syntaxhighlight>
===Oggetto BLEService: metodi di interesse===
ToDo...
<syntaxhighlight lang="csharp">
</syntaxhighlight>
===Oggetto BLECharacteristic: metodi di interesse===
ToDo...

{| class="wikitable"
|-
!|Istruzione
!|Descrizione
!|Esempio
|-
| <code>BLECharacteristic()</code>
| Crea una caratteristica al servizio. <br />
uuid: 16-bit or 128-bit UUID in String format<br />
properties: mask of the properties (BLEBroadcast, BLERead, BLEWriteWithoutResponse, BLEWrite, BLENotify, BLEIndicate)<br />
valueSize: (maximum) size of characteristic value<br />
fixedLength: if true, size of characteristic value is fixed<br />
stringValue: value as a string<br />
{| class="wikitable"
|-
! Istruzione
! Tipo
! Esempio
|-
| BLECharacteristic(uuid, properties, valueSize)
| 
| <syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| BLECharacteristic(uuid, properties, valueSize, fixedLength)
| 
| <syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| BLECharacteristic(uuid, properties, valueSize)
| 
| <syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| BLEBoolCharacteristic(uuid, properties)
BLEBooleanCharacteristic(uuid, properties)
| Caratteristica di tipo booleano 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLECharCharacteristic(uuid, properties)
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEUnsignedCharCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEByteCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEShortCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEUnsignedShortCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEWordCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEIntCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEUnsignedIntCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLELongCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEUnsignedLongCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEFloatCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>BLEDoubleCharacteristic(uuid, properties)</code>
| 
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|}
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|-
| <code>x</code>
| row 2, cell 2
|<syntaxhighlight lang="csharp">
</syntaxhighlight>
|}

===Oggetto BLEDescriptor: metodi di interesse===
ToDo...
<syntaxhighlight lang="csharp">
</syntaxhighlight>

===Esempio 1===
L'esempio seguente configura l'ESP32 come una periferica BLE con servizio "Serial" personalizzato.<br />Si è anche accodato l'invio di una stringa contatore ogni 2 secondi, questo ad esemplificare l'invio di dati dal microcontrollore verso il cellulare e non dal serial monitor del microcontrollore al cellulare.<br />
NOTE:

* l'uso del Monitor seriale è fondamentale in questo esempio, lo sketch non va avanti se non trova il monitor seriale --> <code>while (!Serial);</code>
* All'apertura del Monitor seriale, scrivere comunque qualcosa anche se non si visualizza quanto si sta scrivendo ed infine prendete invio, il messaggio arriverà sullo smartphone.

<syntaxhighlight lang="csharp">
#include <Arduino.h>
#include <ArduinoBLE.h>

long m_lastUpdateSmartPhone = 0;
int m_intCounter = 0;
String m_strCount = "";

// UUID generici per il servizio UART (Nordic style)
BLEService         m_uartService("6E400001-B5A3-F393-E0A9-E50E24DCCA9E"); 
BLEStringCharacteristic m_rxChar("6E400002-B5A3-F393-E0A9-E50E24DCCA9E", BLEWrite, 20);
BLEStringCharacteristic m_txChar("6E400003-B5A3-F393-E0A9-E50E24DCCA9E", BLENotify, 20);
BLEDescriptor m_DescripRX("2901", "Caratteristica: ricezione da smartphone (RX)");
BLEDescriptor m_DescripTX("2901", "Caratteristica: trasmissione vs smartphone (TX)");

void setup() {
  Serial.begin(9600);  
  
  // Configura il pin del LED blu come output
  pinMode(LED_BLUE, OUTPUT);

  //Si attende che la seriale sia pronta, con un timeout di 2 secondi
  //altrimenti se se ci fosse l'istruzione  while (!Serial) e non si avviasse 
  //il Monitor Seriale l'applicazione andrebbe in loop infinito
  unsigned long previousMillis = millis();
  unsigned long currentMillis = millis();
  while (!Serial 
    && (currentMillis - previousMillis <= 2000)) {	//timeout 2s per evitare di restare bloccati
      currentMillis = millis();
  }

  if (!BLE.begin()) {
    Serial.println("Errore nell'inizializzazione BLE!");
    while (1);
  }

  String address = BLE.address();
  Serial.println("Il MAC address di questo dispositivo è: [" + address + "]");

  // Nome del dispositivo BLE. Può essere visualizzato dagli smartphone durante la scansione dei dispositivi BLE.
  // E' sufficiente questo, non serve anche definire setDeviceName
  BLE.setLocalName("NanoESP32_Aino"); 
  BLE.setDeviceName("NanoESP32_Aino"); // Non è strettamente necessario se si è già definito setLocalName
  BLE.setAdvertisedService(m_uartService);

  // Le descrizioni sono opzionali, ma aiuta a identificare le caratteristiche quando si esplorano i servizi BLE con app come nRF Connect.
  m_rxChar.addDescriptor(m_DescripRX);
  m_txChar.addDescriptor(m_DescripTX);

  m_uartService.addCharacteristic(m_rxChar);
  m_uartService.addCharacteristic(m_txChar);

  BLE.addService(m_uartService);

  BLE.advertise(); // Inizia a pubblicizzare il servizio BLE
  Serial.println("Dispositivo BLE pronto. In attesa di connessione...");

  //Eventuali handler aggiuntivi per eventi BLE possono essere configurati qui, ad esempio:
  //  BLE.setEventHandler(BLEConnected, onBLEConnected);
  //  BLE.setEventHandler(BLEDisconnected, onBLEDisconnected);
}

void loop() {
  BLEDevice central = BLE.central();

  if (central) { // Questo perché il cellulare funge da central mentre il cellulare o altro dispositivo funge da peripheral
    digitalWrite(LED_BLUE, LOW); // Accende il LED blu con LOW perché è in logica inversa

    Serial.print("Connesso al dispositivo con MAC: "); Serial.print(central.address());    
    Serial.print("Potenza RSSI: "); Serial.println(central.rssi());
    if (central.hasLocalName()) {
      Serial.print("Nome Locale: "); Serial.println(central.localName());
    }

    while (central.connected()) {
      // 1. Dallo Smartphone al Monitor Seriale
      if (m_rxChar.written()) {
        Serial.print("Da smartphone: ");
        Serial.println(m_rxChar.value());
      }

      // 2.1 Dal Monitor Seriale allo Smartphone
      if (Serial.available()) {
        String msg = Serial.readStringUntil('\n') + "\n";
        m_txChar.writeValue(msg);
        Serial.print("Da Arduino: ");
        Serial.println(msg);
        delay(100); // Piccola pausa per evitare di sovraccaricare la comunicazione BLE
      }

      // 2.2 Sullo Smartphone ad intervalli regolari (ad esempio ogni 2 secondi) 
      if (millis() - m_lastUpdateSmartPhone > 2000) {
        m_lastUpdateSmartPhone = millis();
        m_intCounter++;
        m_strCount = "Contatore: " + String(m_intCounter) + "\n";
        m_txChar.writeValue(m_strCount);
        Serial.print("Contatore inviato: ");
        Serial.println(m_strCount);
      }
    }

    Serial.println("Disconnesso.");
    digitalWrite(LED_BLUE, HIGH); // Spegne il LED blu con HIGH perché è in logica inversa
  }
}
</syntaxhighlight>

==Libreria: Bluetooth Classic==
Anche questa libreria è immediatamente disponibile sia su Arduino IDE che su VS Code con plugin PlatformIO.<br />
Gli esempi si riferiscono all'uso della libreria "<code>BluetoothSerial.h</code>"
===Esempio 1===
Il seguente consente sia la lettura, dal Serial Monitor di Arduino al cellulare, che viceversa:
<syntaxhighlight lang="csharp">
#include "BluetoothSerial.h"

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  SerialBT.begin("NanoESP32-Classic"); // Nome Bluetooth
  Serial.println("Dispositivo pronto per il pairing");
}

void loop() {
  if (Serial.available()) {
    SerialBT.write(Serial.read());
  }
  if (SerialBT.available()) {
    Serial.write(SerialBT.read());
  }
}
</syntaxhighlight>
Per questa modalità, utilizza l'app "Serial Bluetooth Terminal", associa il dispositivo dalle impostazioni Bluetooth del telefono, poi connettilo nell'app.<br />
<br />
Altro esempio per pilotare azioni sul dispositivo (NOTA, controlla se il bluetooth è abilitato! )<br />
Il seguente sketch imposta il Nano ESP32 come server BLE che accende e spegne il LED integrato ed invia dati allo smartphone:
<syntaxhighlight lang="csharp">
#include "BluetoothSerial.h"

// Controlla se il Bluetooth è abilitato
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  // Nome del dispositivo Bluetooth
  SerialBT.begin("NanoESP32_BT");
  Serial.println("Il dispositivo è pronto per l'accoppiamento");
  pinMode(LED_BUILTIN, OUTPUT); // LED integrato
}

void loop() {
  if (SerialBT.available()) {
    char incomingChar = SerialBT.read();
    Serial.write(incomingChar); // Echo sul monitor seriale del PC

    // Controllo LED con comandi
    if (incomingChar == '1') {
      digitalWrite(LED_BUILTIN, HIGH);
      SerialBT.println("LED Acceso");
    } else if (incomingChar == '0') {
      digitalWrite(LED_BUILTIN, LOW);
      SerialBT.println("LED Spento");
    }
  }
  delay(20);
}
</syntaxhighlight>

=(Mappa e Link)=

----
[[Domotica Device Arduino Integrazioni tipiche| Integrazioni tipiche]] | [[Domotica Device Arduino Indx | Arduino indice]] | [[Domotica Device Arduino Progetti | Arduino Progetti]]

----
[[Cpp Info fondamentali | C++ Info fondamentali]] | [[Domotica Device ESP32 Indx| ESP32 indice]] |[[Domotica Device ESP8266 | ESP8266]] | [[Domotica]] | [[Dizionario:Termini elettronica | Dizionario Elettronica]] | [[Elettronica]] | [[Elettronica Appunti]]

----
'''Parole chiave''':