Esptop 10 Bluetooth - Ultimate Guide
ESP32 supporta il doppio bluetooth contenente Bluetooth Classic e il Bluetooth a bassa energia (BLE). In questo articolo discuteremo del funzionamento di entrambi questi Bluetooth.
Ecco un breve confronto di Bluetooth Classic con Bluetooth a bassa energia:
| Specifiche | Bluetooth Classic | Bluetooth a bassa energia/ble |
| Velocità di trasferimento dati | 2-3 Mbps | 1 Mbps |
| Allineare | ~ 10-100m | ~ 50m |
| Frequenza operativa | 79 rf | 40 rf |
| Consumo di massima corrente | ~ 30Ma | <15mA |
| Consumo di energia | 1W | 0.01-0.5W |
| Tempo totale per inviare dati | 100 ms | 3ms |
| Applicazioni | Audio, streaming musicale | Sensore, dispositivi indossabili |
Per un confronto più dettagliato fai clic qui per visitare il sito ufficiale di Bluetooth.
Di seguito sono riportate le due modalità Bluetooth disponibili nella scheda ESP32:
- Bluetooth Classic
- Bluetooth a bassa energia (BLE)
1: ESP32 Bluetooth Classic con Arduino IDE
La scheda ESP32 viene fornita con il supporto Bluetooth Dual Bluetooth è Bluetooth Classic e il secondo è ble (Bluetooth Low Energy). Oggi discuteremo solo di Bluetooth Classic. L'unica differenza che esiste tra entrambi è che Bluetooth Classic può gestire un sacco di trasferimento di dati ma consuma la batteria a velocità più elevata, tuttavia Bluetooth a bassa energia è la variante di conservazione dell'alimentazione che viene utilizzata per la comunicazione a breve distanza. Ble rimane in modalità sospensione fino a quando non viene inizializzato per il trasferimento dei dati.
ESP32 Bluetooth Classic Serial Communication
ESP32 viene fornito con moduli Bluetooth integrati che prima ricevono dati e poi li inoltrano al processore XTENSA. Quindi, per stabilire questa comunicazione "Bluetoothserial" La libreria viene utilizzata che è simile alla libreria seriale Arduino, ma è solo all'interno di ESP32. Di seguito sono riportate alcune funzioni offerte dalla libreria seriale Bluetooth:
- inizio()
- disponibile()
- scrivere()
- Leggere()
LED controllato Bluetooth con ESP32
Scriviamo un codice semplice in grado di controllare un LED utilizzando la comunicazione wireless Bluetooth mobile su Bluetooth. Di seguito è riportato l'hardware richiesto per controllare il LED utilizzando la comunicazione seriale Bluetooth:
- ESP32
- GUIDATO
- Breadboard
- Dispositivo Android
- Applicazione del terminale Bluetooth seriale
Circuito
Connetti LED al pin digitale 15 di ESP32 con terminale negativo collegato a GND della scheda ESP32. Per un limite di corrente sicura possiamo anche collegare il resistore (220 ohm) tra di loro:
Codice
Apri Arduino IDE e seleziona la scheda ESP32 nel gestore della scheda per vedere come installare la scheda ESP32 in Arduino IDE Clicca qui. Dopo aver selezionato la scheda Scrivi il codice qui sotto nella finestra dell'editor:
#include /*libreria di comunicazione seriale bluetooth* /#define LED_PIN 15 /*PIN LED inizializzato* /
Serialbt bluetoothserial;
byte bt_inp;
#Se !definito (config_bt_enabled) || !definito (config_bluedroid_enabled)/*Controlla bluetooth in sdk*/
#error bluetooth off-run 'make menuconfig' per abilitarlo
#finisci se
void setup ()
pinMode (led_pin, output); /*Pin LED impostata come output*/
Seriale.Inizia (115200); /*Tasso di baud per comunicazione seriale*/
Serialbt.inizio(); /*La comunicazione Bluetooth inizia*/
Seriale.println ("Bluetooth è pronto per l'abbinamento ..."); /*Quando Bluetooth si accende*/
void loop ()
if (serialbt.Disponibile ()) /*Controlla la disponibilità dei dati Bluetooth* /
Bt_inp = serialbt.Leggere(); /*Leggi i dati Bluetooth dal dispositivo*/
Seriale.scrivere (bt_inp); /*Stampa i dati di lettura*/
if (bt_inp == '1') /*se condizione per stato a LED* /
DigitalWrite (LED_PIN, HIGH); /*attiva il LED se viene ricevuto 1 input*/
if (bt_inp == '0')
DigitalWrite (LED_PIN, basso);/*Disattiva LED se viene ricevuto l'input 0*/
Qui nel codice sopra, abbiamo iniziato includendo la libreria seriale Bluetooth per ESP32. Successivamente abbiamo incluso le funzioni della libreria seriale Bluetooth che consentiranno Bluetooth ESP32.
Il Pin 15 successivo 15 è inizializzato e utilizzando il pinMode () Il pin LED di funzione è impostato come output.
Nella parte del codice del codice il programma verificherà la disponibilità di dati Bluetooth seriale. Se i dati di input sono 1 LED si accende e se i dati ricevuti sono 0 LED disattiva.
Una volta caricato il codice. Bluetooth della scheda ESP32 si accenderà e il seguente messaggio verrà visualizzato sul monitor seriale:
Installazione del terminale bluetooth seriale su smartphone
Abbiamo bisogno di un dispositivo Bluetooth in grado di inviare istruzioni a ESP32, quindi utilizzeremo uno smartphone Android per interfacciarlo con ESP32 Bluetooth. Innanzitutto, dobbiamo installare un terminale seriale in un telefono Android. Seguire i passaggi indicati di seguito per interfaccia il telefono Android con ESP32:
Passo 1: Apri Google Play Store sul tuo smartphone e cerca Terminale bluetooth seriale. Installa l'applicazione mostrata seguente:
Passo 2: Dopo l'installazione, apri le impostazioni Bluetooth del telefono cellulare. Cerca ESP32 Bluetooth e fai clic per iniziare ad abbinarlo allo smartphone facendo clic su Paio:
Passaggio 3: Dopo aver toccato un file Paio, Il telefono cellulare inizierà l'abbinamento con ESP32 Bluetooth:
Passaggio 4: Ora apri l'applicazione del terminale Bluetooth seriale e vai a Dispositivi Dal menu laterale:
Passaggio 5: Una volta aperta l'opzione del dispositivo, chiederà alcune autorizzazioni o premi il RICARICARE Pulsante in alto a destra:
Passaggio 6: Dopo il pop-up arriverà clic su Impostazioni e consentire il permesso che chiede:
Passaggio 7: Ora la scheda ESP32 è pronta a prendere istruzioni su Bluetooth. Sotto Bluetooth Classic Opzione Seleziona scheda ESP32:
Passaggio 8: Una volta selezionato ESP32, inizierà a connettersi e in caso di successo, a Collegato Apparirà il messaggio:
Passaggio 9: Ora possiamo inviare qualsiasi istruzione digitandola qui. Tipo 1 e fare clic sul pulsante Invia, si accenderà il LED sulla scheda ESP32. Allo stesso modo, digitando 0 LED si spegne:
Allo stesso modo, possiamo vedere l'output sul monitor seriale dell'IDE Arduino quello che sta ricevendo:
Produzione
LED si accende dopo aver inviato 1:
LED si spegne dopo l'invio 0:
Nota: Possiamo anche configurare pulsanti per istruzioni specifiche come mostrato nell'immagine di seguito. Per fare questo clic sui pulsanti e impostare il valore desiderato. Qui abbiamo impostato due pulsanti uno per alto e altro per lo stato basso. Puoi anche configurare queste scorciatoie in valori esadecimali.
2: ESP32 Bluetooth a bassa energia (BLE) con Arduino IDE
Ble o Bluetooth a bassa energia è una modalità di risparmio energetico di Bluetooth. La sua applicazione principale include il trasferimento di dati su brevi distanze come l'ingresso della porta, gli orologi intelligenti, i dispositivi indossabili, il monitor della pressione sanguigna, la sicurezza e le automazione domestiche. Ble può trasferire dati limitati.
A differenza del classico Bluetooth che rimane acceso per tutto il tempo, BLE rimane in modalità di sospensione tranne quando viene chiamato o viene avviata la connessione. Questo rende il BLE molto efficiente dal punto di vista energetico e consuma 100 volte meno potenza di quella classica.
Server ble e client
Bluetooth Low Energy supporta il dispositivo in due modi diversi a causa dei quali ESP32 può fungere da server e client per Bluetooth a bassa energia.
Supporto ble seguendo le modalità di comunicazione:
- Punto a punto: Comunicazione tra due punti o nodi che è server e client.
- Modalità di trasmissione: Il server trasmette i dati su molti dispositivi.
- Network Mesh: Dispositivi multipli collegati tra loro noti anche come molti a molte connessioni.
Quando agisce come server, ESP32 pubblicizza la propria esistenza ai dispositivi client vicini. Una volta che i dispositivi client scansionano per i dispositivi Bluetooth disponibili, il server stabilisce una connessione tra loro e trasferisce i dati dal server a dispositivo client. Questa comunicazione è chiamata punto a punto.
In questo tutorial, faremo un esempio di comunicazione punto a punto tra due schede ESP32.
Termini importanti in ble
Ecco alcuni termini importanti che si dovrebbero sapere mentre si lavora con le applicazioni ESP32 BLE:
GATT: GATT o attributi generici che definiscono una struttura gerarchica per i trasferimenti di dati tra dispositivi BLE utilizzando il servizio e le caratteristiche. Definisce il modo in cui due dispositivi comunicano i dati tra di loro.
Servizio ble: Il livello superiore all'interno della gerarchia GATT è un profilo che contiene uno o più servizi. Ble ha più di un servizio. Ognuno di questi servizi ha le proprie caratteristiche che possono anche fungere da riferimento per altri servizi.
Caratteristica ble: La caratteristica è un gruppo di informazioni sempre di proprietà del servizio; È dove i dati effettivi sono archiviati in gerarchia (valore). Contiene sempre due attributi:
- Dichiarazione: Proprietà caratteristiche come posizione, tipo, lettura, scrittura e notifica.
- Valore caratteristico: Valore dei dati delle caratteristiche.
Uuid: Uuid (identificatore universalmente univoco) viene dato a ciascun servizio e caratteristico. È un ID univoco a 128 bit che può essere generato utilizzando qualsiasi generatore UUID online. Controlla questo generatore UUID gratuito. Un campione Uuid sembra questo:
583F8B30-74B4-4757-8143-56048FD88B25Un gruppo di interesse speciale Bluetooth universale (SIG) ha predefinito alcuni degli Uuidi abbreviati per diversi tipi di servizi e profilo, per leggerli clicca qui.
Imposta BLE in ESP32 con Arduino IDE
Per comprendere il funzionamento di BLE utilizzeremo due diverse schede ESP32 una di esse agirà come server e pubblicizzare un segnale Bluetooth mentre l'altro ESP32 che agisce come a cliente Proverà a collegare il server Bluetooth.
Arduino IDE ha esempi separati sia per lo scanner che per il server.
Per vedere come installare una scheda ESP32 con Arduino IDE in Windows Clicca qui.
ESP32 BLE Server
Innanzitutto, caricheremo il codice di esempio del server all'interno della nostra prima scheda ESP32 che funge da server.
Per aprire l'esempio del server ble vai a: File> Esempi> ESP32 BLE Arduino> ble_server:
Il codice indicato di seguito verrà aperto in Arduino IDE.
Codice del server
Carica il codice seguente nella scheda ESP32 usando Arduino IDE ma assicurati di scollegare la seconda scheda per un po 'per evitare di caricare lo stesso codice su una singola scheda:
#includere#includere
#includere
#Define Service_Uuid "4FAFC201-1FB5-459E-8FCC-C5C9C331914B"
#define caratteristica_uuid "beb5483e-36e1-4688-b7f5-ea07361b26a8"
void setup ()
Seriale.Inizia (115200);
Seriale.println ("Inizio ble work!");
Bledevice :: init ("ESP32");
BLeserver *pserver = bledevice :: createserver ();
BLeservice *pservice = pserver-> createService (Service_uuid);
BleCharacteristic *pCharacteristic = pservice-> createCharacteristic (
Caratteristico_uuid,
BleCharacteristic :: Property_Read |
BleCharacteristic :: Property_Write
);
pcharacteristic-> setValue ("Hello Say LinuxHint.com ");
pService-> start ();
// bleADVERTISING *padvertising = pserver-> getAdvertising (); // Questo funziona ancora per la compatibilità all'indietro
BLEADERTINE *padvertising = bledevice :: getAdvertising ();
padvertising-> AddServiceUuid (Service_Uuid);
padvertising-> setScanResponse (true);
padvertising-> setMinPreferred (0x06); // Funzioni che aiutano con il problema delle connessioni per iPhone
padvertising-> setMinPreferred (0x12);
Bledevice :: startAdvertising ();
Seriale.println ("caratteristico definito! Server ble pronto ");
void loop ()
// Metti qui il tuo codice principale, per eseguire ripetutamente:
ritardo (2000);
Il codice inizia con l'inclusione dei file di libreria Bluetooth necessari. Quindi uuid è definito sia per il servizio che per le caratteristiche. Puoi andare con l'UUID predefinito o generare utilizzando il generatore UUID gratuito. La prossima comunicazione seriale viene inizializzata definendo il tasso di baud.
Successivamente, abbiamo creato un dispositivo BLE chiamato ESP32 e successivamente abbiamo definito il dispositivo BLE come server utilizzando il createserver () funzione e successivamente impostiamo il valore caratteristico. Nel passaggio finale abbiamo avviato il servizio pubblicizzandolo in modo che altri dispositivi possano cercarlo.
ESP32 Ble Scanner
Ora caricheremo un esempio di scansione ESP32 nella seconda scheda ESP32. Per farlo vai a: File> Esempi> ESP32 ble Arduino> ble_scan:
Il codice seguente sarà aperto in Arduino IDE Editor.
Codice scanner
Il codice indicato verrà utilizzato nella scheda scanner ESP32. Apri IDE e carica il codice, ricorda di scollegare altre schede prima di caricare il codice scanner.
#includere#includere
#includere
#includere
int scantime = 5; //In secondi
Blescan* pblescan;
Classe myAdvertedDeviceCallbacks: pubblico bleadverteddevicecallbacks
void onResult (bleADvertedDevice pubblicizzato DEVICE)
Seriale.printf ("dispositivo pubblicizzato: %s \ n", pubblicizzato.accordare().c_str ());
;
void setup ()
Seriale.Inizia (115200);
Seriale.println ("scansione ...");
Bledevice :: init ("");
pblescan = bledevice :: getScan (); // Crea una nuova scansione
pblescan-> setaDvertedDeviceCallbacks (New MyAdvertedDeviceCallbacks ());
pblescan-> setactiveScan (true); // Active Scan utilizza più potenza, ma ottieni risultati più velocemente
pblescan-> setInterval (100);
pblescan-> setWindow (99); // Valore setInterval inferiore o uguale
void loop ()
// Metti qui il tuo codice principale, per eseguire ripetutamente:
BlescanResults FoundDevices = pblescan-> start (scantime, false);
Seriale.print ("Dispositivi trovati:");
Seriale.println (FoundDevices.getCount ());
Seriale.println ("scansione fatta!");
pblescan-> clearresults (); // Elimina i risultati dal buffer BLescan per rilasciare la memoria
ritardo (2000);
Il codice sopra cercherà il numero di dispositivi disponibili totali per BLE e visualizzerà il loro conteggio totale con gli indirizzi. Dopo aver caricato il codice nella scheda scanner ESP32 Premere il Abilitare pulsante, la scheda ESP32 cercherà automaticamente i dispositivi disponibili:
Produzione
Una volta scansionati ESP32, verrà visualizzato i dispositivi disponibili, il seguente risultato verrà visualizzato. Qui ESP32 ha scansionato 9 dispositivi tra cui uno è una scheda ESP32 con codice ble_server e un altro dispositivo è MI BAND 6. Il resto di tutti i dispositivi sono disponibili vicino al mio ESP32.
Come correggere la libreria di scansione ESP32 ble non contando i dispositivi
L'esempio della libreria di scansione ESP32 ha un bug di non contare il numero totale di dispositivi. Per correggere questo problema, vai nella posizione menzionata e sostituisci il codice indicato di seguito:
C: \ Users \ Username \ AppData \ Local \ Arduino15 \ Packages \ ESP32 \ Hardware \ ESP32 \ 1.0.6 \ librerie \ ble \ src \ blescan.CPPRicordati di Unhide Tutte le cartelle perché la cartella AppData all'interno della directory C rimane nascosta per impostazione predefinita. Dopo aver aperto il file di origine ble_scan .CPP Sostituire la condizione indicata sotto all'interno del codice:
if (m_padverteddevicecallbacks)m_padvertedDeviceCallbacks-> onResult (*pubblicizzato DEVICE);
Se (!m_wantduplicates && !trovato)
m_scanresults.M_VectorAdvertedDevices.Insert (std :: coppia
dovrebbe dolete = false;
Test del server ESP32 BLE con smartphone
La maggior parte dei moderni smartphone lavora con la tecnologia BLE per comunicare con diversi dispositivi come smartwatch, dispositivi indossabili, sensori e altri dispositivi di automazione domestica. Qui ESP32 è un punto di accesso per i dispositivi. Quindi, collegheremo un telefono Android con una scheda ESP32.
Codice server BLE per l'accesso allo smartphone ESP32
Carica il codice indicato di seguito nella scheda ESP32:
#include /*libreria bluetooth inclusa* /#includere
#includere
#Define Service_Uuid "A484A399-7272-4282-91CF-9018E075FC35"
#define caratteristica_uuid "C7E084BD-5279-484D-8319-FFF7D917537D"
Classe MyCallbacks: BleCharacteristicCallbacks pubblico
void onwrite (blecharacteristic *pcharacteristic)
std :: string value = pCharacteristic-> getValue ();
if (valore.lunghezza ()> 0)
Seriale.print ("Valore caratteristico aggiornato:");
per (int i = 0; i createservice (service_uuid);
BleCharacteristic *pCharacteristic = pservice-> createCharacteristic (
Caratteristico_uuid,
BleCharacteristic :: Property_Read |
BleCharacteristic :: Property_Write
);
pcharacteristic-> setCallbacks (new MyCallbacks ());
pcharacteristic-> setValue ("LinuxHint.Com ");
pService-> start ();
BLEADERTINE *padvertising = pserver-> getAdvertising ();
padvertising-> start ();
void loop ()
ritardo (2000);
Installazione dell'applicazione BLE in smartphone Android
I seguenti passaggi ti guideranno all'installazione di applicazioni BLE negli smartphone e ti aiuteranno a interfacciarsi i dispositivi mobili con le schede ESP32.
Passo 1: Apri l'installazione di Google Play Store Scanner ble applicazione:
Passo 2: Dopo l'installazione, aprire l'applicazione e consentire tutta l'autorizzazione richiesta e ricordare di attivare il Bluetooth mobile:
Passaggio 3: Ora scansiona i dispositivi Bluetooth disponibili. Connect ESP32 Board:
Passaggio 4: Una volta che la scheda ESP32 è collegata allo smartphone a seguito della specifica della scheda ESP32. Qui possiamo vedere gli indirizzi UUID e possiamo leggere e scrivere nuovi valori caratteristici:
Passaggio 5: Per leggere il valore caratteristico salvato clic R. Il risultato verrà visualizzato come menzionato nell'immagine di seguito:
Passaggio 6: Per scrivere qualsiasi nuovo valore caratteristico fai clic W:
Passaggio 7: Un nuovo pop-up apparirà qui in cui possiamo scrivere qualsiasi valore caratteristico e fare clic OK:
Passaggio 8: Il nuovo valore scritto apparirà come mostrato nell'immagine:
Passaggio 9: Inoltre, possiamo vedere lo stesso nuovo valore caratteristico stampato sul monitor seriale di Arduino IDE:
Abbiamo collegato correttamente un dispositivo con ESP32 BLE.
Conclusione
ESP32 viene fornito con Dual Bluetooth che sono Bluetooth Classic e Bluetooth Low Energy. Qui in questo articolo, abbiamo discusso sia Bluetooth Classic che BLE e le sue varie applicazioni e lavoro. Il classico Bluetooth viene utilizzato per il trasferimento di dati elevato mentre BLE (Bluetooth Low Energy) viene utilizzato per brevi distanze con meno requisiti di alimentazione. Questo articolo fornisce una guida definitiva al lavoro Bluetooth della scheda ESP32 e come configurarli.