Bluetooth Esp32 a bassa energia (ble) - collegamento alla fascia fitness per attivare una lampadina

Che bello accendere le luci automaticamente non appena si entra in casa e spegnerle di nuovo quando si esce! Sì, una semplice applicazione può farlo per te. Qui in questo progetto, useremo ESP32 come client BLE e fascia fitness come server BLE, quindi ogni volta che una persona che indossa la fascia fitness entra nel raggio di ESP32 Bluetooth, ESP32 la rileva e accende la luce. Qualsiasi dispositivo Bluetooth dotato di funzionalità server BLE può essere utilizzato come dispositivo di attivazione per controllare qualsiasi elettrodomestico utilizzando ESP32.

Abbiamo già esplorato le funzionalità BLE (Bluetooth Low Energy) del modulo ESP32 e ne sono abbastanza entusiasta. Per fare un riepilogo, questo modulo ha sia il classico Bluetooth che il Bluetooth Low Energy (BLE), il classico Bluetooth può essere utilizzato per trasferire brani o file e l'opzione BLE può essere utilizzata per applicazioni ottimizzate per la batteria come beacon Bluetooth, fasce per il fitness, dispositivi di prossimità, ecc. È anche possibile utilizzarlo come Bluetooth seriale come i moduli HC-05 o HC-06 per semplici progetti di microcontrollore.

Come sapete, ESP32 BLE può funzionare in due diverse modalità. Una è la modalità server di cui abbiamo già discusso utilizzando il servizio GATT per imitare un servizio di indicatore del livello della batteria. In quell'esercizio, l'ESP32 ha agito come un server e il nostro telefono cellulare ha agito come un client. Ora, utilizziamo ESP32 come client e proviamo a collegarlo ad altri server BLE come la mia fascia fitness.

Tutti i server BLE, inclusa la mia fascia fitness, sono in modalità pubblicitaria costante, ovvero possono sempre essere scoperti quando vengono scansionati da un cliente. Sfruttando questa funzione possiamo utilizzare questi cinturini fitness come interruttore di prossimità, il che significa che questi cinturini fitness sono sempre legati alla mano dell'utente e scansionando il cinturino possiamo rilevare se la persona è nel raggio d'azione. Questo è esattamente ciò che faremo in questo articolo. Noi programmare l'ESP32 di agire come un client BLE e costantemente tenere la scansione per i dispositivi BLE; se troviamo la fascia fitness nel raggio, proveremo a collegarci ad essa e se la connessione ha successo possiamo attivare una lampadina attivando uno dei pin GPIO sull'ESP32. Il metodo è affidabile perché ogni server BLE(fitness band) avrà un ID hardware univoco, quindi non ci saranno due dispositivi server BLE identici. Interessante vero? !!! Ora iniziamo a costruire

Prerequisiti

In questo articolo, presumo che tu abbia già familiarità su come utilizzare la scheda ESP32 con l'IDE di Arduino, se non ripiegare su come iniziare con il tutorial ESP32.

Abbiamo diviso il Bluetooth ESP32 completo in tre segmenti per facilitarne la comprensione. Quindi si consiglia di seguire i primi due tutorial prima di iniziare con questo.

Bluetooth seriale su ESP32 commutando LED dal telefono cellulare
Server BLE per inviare i dati sul livello della batteria al telefono cellulare utilizzando il servizio GATT
Client BLE per eseguire la scansione dei dispositivi BLE e fungere da beacon.

Abbiamo già coperto i primi due tutorial, qui stiamo procedendo con l'ultimo per spiegare ESP32 come client BLE.

Materiali richiesti

Scheda di sviluppo ESP32
Carico CA (lampada)
Modulo relè

Hardware

L'hardware per questo progetto ESP32 BLE Client è abbastanza semplice poiché la maggior parte della magia avviene all'interno del codice. L'ESP32 deve attivare una lampada CA (carico) quando il segnale Bluetooth viene rilevato o perso. Per attivare questo carico utilizzeremo un relè e poiché i pin GPIO di ESP32 sono compatibili solo con 3,3 V, abbiamo bisogno di un modulo relè che possa essere pilotato con 3,3 V. Basta controllare quale transistor è utilizzato nel modulo relè se è BC548, puoi andare altrimenti a costruire il tuo circuito seguendo lo schema del circuito qui sotto.

Avvertenza: il circuito gestisce la tensione di rete 220V AC diretta. Fai attenzione ai cavi sotto tensione e assicurati di non creare un cortocircuito. Sei stato avvertito.

Il motivo per cui si utilizza BC548 su BC547 o 2N2222 è che hanno una bassa tensione base-emettitore che può essere attivata con soli 3,3 V. Il relè utilizzato qui è un relè da 5 V, quindi lo alimentiamo con il pin Vin che ottiene 5 V dal cavo di alimentazione. Il pin di terra è collegato alla massa del circuito. Il resistore R1 1K viene utilizzato come resistore limitatore di corrente di base. Il filo di fase è collegato al pin NO del relè e il pin comune del relè è collegato al carico e l'altra estremità del carico è collegata al neutro. Puoi scambiare la posizione di Fase e Neutro ma fai attenzione a non metterli in cortocircuito direttamente. La corrente dovrebbe sempre passare attraverso il carico (lampadina).Ho usato un modulo relè per mantenere le cose semplici e il carico qui è una lampada LED Focus. La mia configurazione è simile a questa di seguito

Se vuoi saltare l'hardware per ora, puoi usare il pin GPIO 2 invece del pin GPIO 13 per attivare il LED integrato su ESP32. Questo metodo è consigliato ai principianti.

Ottieni il tuo indirizzo Bluetooth del server (indirizzo della fascia fitness)

Come detto in precedenza, programmeremo l'ESP32 in modo che funga da client (simile al telefono) e ci collegheremo a un server che è la mia fascia di fitness (Lenovo HW-01). Affinché un client si connetta al server, deve conoscere l'indirizzo Bluetooth del server. Ogni server Bluetooth, come la mia fascia fitness qui, ha il proprio indirizzo Bluetooth univoco che è permanente. Puoi collegarlo all'indirizzo MAC del tuo laptop o telefono cellulare.

Per ottenere questo indirizzo dal server utilizziamo un'applicazione chiamata nRF connect da semiconduttori nordici che avevamo già utilizzato per il nostro precedente tutorial. È disponibile gratuitamente sia per gli utenti iOS che Android. Basta scaricare, avviare l'applicazione e cercare i dispositivi Bluetooth nelle vicinanze. L'applicazione elencherà tutti i dispositivi BLE che trova. Il mio si chiama HW-01 semplicemente guarda sotto il suo nome e troverai l'indirizzo hardware del server come mostrato di seguito.

Quindi l' indirizzo hardware ESP32 BLE della mia fascia fitness è C7: F0: 69: F0: 68: 81, avrai un diverso insieme di numeri nello stesso formato. Basta prenderne nota poiché avremo bisogno quando programmeremo il nostro ESP32.

Ottenere il servizio e l'UUID caratteristico del server

Ok, ora abbiamo identificato il nostro server utilizzando l'indirizzo BLE ma per poter comunicare con esso dobbiamo parlare la lingua del Servizio e delle caratteristiche, che capiresti se avessi letto il tutorial precedente. In questo tutorial utilizzo la caratteristica di scrittura del mio server (fitness band) per accoppiarlo. Quindi per l'accoppiamento con il dispositivo abbiamo bisogno dell'UUID Caratteristica annuncio di servizio che possiamo ottenere nuovamente con la stessa applicazione.

Basta fare clic sul pulsante di connessione sulla tua applicazione e cercare alcune caratteristiche di scrittura, dove l'applicazione visualizzerà l'UUID del servizio e l'UUID caratteristico. Il mio è mostrato di seguito

Qui il mio UUID di servizio e UUID caratteristico sono gli stessi, ma non devono essere gli stessi. Annota l'UUID del tuo server. Il mio è stato annotato come

UUID servizio: 0000fee7-0000-1000-8000-00805f9b34fb UUID caratteristica: 0000fee7-0000-1000-8000-00805f9b34fb

Non è obbligatorio utilizzare le caratteristiche di scrittura; è possibile utilizzare qualsiasi servizio valido e UUID caratteristico del server mostrato nell'applicazione.

La programmazione di ESP32 in modo che funzioni come client per l'applicazione interruttore di prossimità

L'idea del programma è di fare in modo che ESP32 agisca come un client che continua a scansionare i dispositivi Bluetooth quando trova il nostro server (banda fitness), verifica l'ID hardware e attiverà la luce attraverso il pin GPIO 13. Bene, ok! !, ma c'è un problema con quello. Tutti i server BLE avranno una portata di 10 metri che è un po 'eccessiva. Quindi, se stiamo cercando di fare un interruttore di prossimità per accendere la luce di apertura di una porta, questo intervallo è molto alto.

Per ridurre la portata del server BLE possiamo utilizzare l'opzione di accoppiamento. Un server BLE e un client rimarranno accoppiati solo se entrambi si trovano entro una distanza di 3-4 metri. È perfetto per la nostra applicazione. Quindi, creiamo ESP32 non solo per scoprire il server BLE, ma anche per connettersi ad esso e assicurarci che rimanga accoppiato. Finché sono accoppiati, la lampada CA rimarrà accesa, quando la portata supera l'accoppiamento andrà perso e la lampada si spegnerà. Il programma di esempio completo ESP32 BLE per fare lo stesso è fornito alla fine di questa pagina. Di seguito, suddividerò il codice in piccoli frammenti e proverò a spiegarli.

Dopo aver incluso il file di intestazione, informiamo l'ESP32 sull'indirizzo BLE, sul servizio e sull'UUID caratteristico che abbiamo ottenuto tramite l'applicazione nRF connect come spiegato nei titoli precedenti. Il codice appare come di seguito

statico BLEUUID serviceUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // Servizio UUID di fitnessband ottenuto tramite nRF connect application static BLEUUID charUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // UUID caratteristico della fitnessband ottenuto tramite l'applicazione nRF connect String My_BLE_Address = "c7: f0: 69: f0: 68: 81"; // L'hardware Bluetooth MAC della mia fitnessband varia per ogni banda ottenuta tramite l'applicazione di connessione nRF

Seguito da quello nel programma abbiamo connectToserver e MyAdvertisedDeviceCallback a cui torneremo più tardi. Quindi all'interno della funzione di configurazione , inizializziamo il monitor seriale e facciamo il BLE su ESP per cercare il dispositivo. Al termine della scansione per ogni dispositivo BLE rilevato, viene chiamata la funzione MyAdvertisedDeviceCallbacks .

Abilitiamo anche la scansione attiva poiché alimentiamo l'ESP32 con l'alimentazione di rete, per l'applicazione a batteria è spento per ridurre il consumo di corrente. Il pin trigger Relay è collegato a GPIO 13 nel nostro hardware, quindi dichiariamo anche che il pin GPIO 13 come output.

void setup () { Serial.begin (115200); // Avvia il monitor seriale Serial.println ("Programma ESP32 BLE Server"); // Messaggio introduttivo BLEDevice:: init (""); pBLEScan = BLEDevice:: getScan (); // crea una nuova scansione pBLEScan-> setAdvertisedDeviceCallbacks (new MyAdvertisedDeviceCallbacks ()); // Chiama la classe definita sopra pBLEScan-> setActiveScan (true); // la scansione attiva utilizza più energia, ma ottiene risultati più velocemente pinMode (13, OUTPUT); // Dichiara il pin LED integrato come output }

All'interno della funzione MyAdvertisedDeviceCallbacks , stampiamo una riga che elencherà il nome e altre informazioni dei dispositivi BLE che sono stati scoperti. Abbiamo bisogno dell'ID hardware del dispositivo BLE che è stato scoperto in modo da poterlo confrontare con quello desiderato. Quindi usiamo la variabile Server_BLE_Address per ottenere l'indirizzo del dispositivo e quindi anche per convertirlo dal tipo BLEAddress a stringa.

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks { void onResult (BLEAdvertisedDevice advertisedDevice) { Serial.printf ("Scan Result:% s \ n", advertisedDevice.toString (). c_str ()); Server_BLE_Address = new BLEAddress (advertisedDevice.getAddress ()); Scaned_BLE_Address = Server_BLE_Address-> toString (). C_str (); } };

All'interno della funzione loop , eseguiamo la scansione per 3 secondi e inseriamo il risultato in foundDevices che è un oggetto di BLEScanResults. Se troviamo uno o più dispositivi tramite la scansione, iniziamo a verificare se l'indirizzo BLE scoperto corrisponde a quello che abbiamo inserito nel programma. Se la corrispondenza è positiva e il dispositivo non è stato accoppiato in precedenza, proviamo ad accoppiarlo utilizzando la funzione connectToserver. Abbiamo anche utilizzato alcune dichiarazioni seriali per scopi di comprensione.

while (foundDevices.getCount ()> = 1) { if (Scaned_BLE_Address == My_BLE_Address && paired == false) { Serial.println ("Found Device: -)… connessione al server come client"); if (connectToserver (* Server_BLE_Address)) {

All'interno della funzione connectToserver utilizziamo l'UUID per l'accoppiamento con il server BLE (fitness band). Per connettersi a un server, ESP32 deve agire come un client, quindi creiamo un client utilizzando la funzione createClient () e quindi ci colleghiamo all'indirizzo del server BLE. Quindi cerchiamo il servizio e la caratteristica utilizzando i valori UUID e proviamo a collegarci ad esso. Quando la connessione ha esito positivo, la funzione restituisce un vero e in caso contrario restituisce un falso. Nota che non è obbligatorio avere un servizio e un UUID caratteristico da associare a un server, è fatto solo per tua comprensione.

bool connectToserver (BLEAddress pAddress) { BLEClient * pClient = BLEDevice:: createClient (); Serial.println ("- Creato client"); // Connettiti al server BLE. pClient-> connect (pAddress); Serial.println ("- Connesso a fitnessband"); // Ottenere un riferimento al servizio che stiamo cercando nel server BLE remoto. BLERemoteService * pRemoteService = pClient-> getService (serviceUUID); if (pRemoteService! = nullptr) { Serial.println ("- Trovato il nostro servizio"); restituire vero; } altrimenti restituisce false; // Ottenere un riferimento alla caratteristica nel servizio del server BLE remoto. pRemoteCharacteristic = pRemoteService->getCharacteristic (charUUID); if (pRemoteCharacteristic! = nullptr) Serial.println ("- Trovato la nostra caratteristica"); restituire vero; }

Se la connessione ha esito positivo, il pin GPIO 13 viene reso alto e il controllo viene inviato all'esterno del ciclo utilizzando l'istruzione break. Anche la variabile booleana accoppiata è impostata su true.

if (connectToserver (* Server_BLE_Address)) { paired = true; Serial.println ("******************** LED acceso ********************** ** "); digitalWrite (13, HIGH); rompere; }

Dopo che l'accoppiamento è riuscito e il pin GPIO è acceso, dobbiamo verificare se il dispositivo è ancora nel raggio d'azione. Poiché ora il dispositivo è accoppiato, il servizio di scansione BLE non sarà più in grado di vederlo. Lo ritroveremo solo quando l'utente lascerà l'area. Quindi dobbiamo semplicemente cercare il server BLE e se scopriamo dobbiamo impostare il pin GPIO su basso come mostrato di seguito

if (Scaned_BLE_Address == My_BLE_Address && paired == true) { Serial. println ("Il nostro dispositivo è andato fuori portata"); accoppiato = falso; Seriale. println ("******************** LED OOOFFFFF ************************"); digitalWrite (13, LOW); ESP.restart (); rompere; }

Lavorare e testare

Una volta che sei pronto con il programma e la configurazione hardware, carica semplicemente il codice su ESP32 e organizza l'intera configurazione come mostrato di seguito.

Dovresti notare che la lampada si accende non appena la fascia fitness (server) si accoppia con l'ESP32. Puoi anche verificarlo notando il simbolo della connessione Bluetooth sulla fascia fitness. Una volta accoppiato, prova ad allontanarti dall'ESP32 e quando attraversi 3-4 metri noterai che il simbolo Bluetooth sull'orologio scompare e la connessione è persa. Ora, se guardi la lampada, si spegnerà. Quando torni nel dispositivo, il dispositivo viene nuovamente associato e la luce si accende. Il funzionamento completo del progetto si trova nel video sottostante.

Spero che il progetto ti sia piaciuto e hai imparato qualcosa di nuovo lungo la strada. Se hai riscontrato problemi nel farlo funzionare, sentiti libero di pubblicare il problema sui forum o anche nella sezione commenti qui sotto