ESP32 bluetooth low energy (ble) - verbinden met fitnessband om een ​​lamp te activeren

Hoe gaaf is het om de lichten automatisch aan te doen zodra je je huis binnenkomt en het weer uit te schakelen als je weggaat! Ja, een eenvoudige applicatie kan dit voor u doen. Hier in dit project zullen we ESP32 gebruiken als BLE-client en fitnessband als BLE-server, dus wanneer een persoon die de fitnessband draagt ​​binnen het bereik van ESP32 Bluetooth komt, detecteert de ESP32 het en schakelt het licht in. Alle Bluetooth-apparaten met BLE-servermogelijkheden kunnen worden gebruikt als een triggerapparaat om elk huishoudelijk apparaat met ESP32 te bedienen.

We hebben de BLE (Bluetooth Low Energy) -functionaliteiten van de ESP32-module al verkend en ik ben er best enthousiast over. Om een ​​samenvatting te geven, deze module heeft zowel klassieke Bluetooth als Bluetooth Low Energy (BLE), de klassieke Bluetooth kan worden gebruikt om liedjes of bestanden over te zetten en de BLE-optie kan worden gebruikt voor batterij-geoptimaliseerde toepassingen zoals Bluetooth-bakens, fitnessbanden, proximitys, etc. Het is ook mogelijk om het te gebruiken als seriële Bluetooth zoals de HC-05 of HC-06 modules voor eenvoudige microcontroller projecten.

Zoals u weet, kan de ESP32 BLE in twee verschillende modi werken. Een daarvan is de servermodus die we al hebben besproken door de GATT-service te gebruiken om een ​​batterijniveau-indicator na te bootsen. In die oefening fungeerde de ESP32 als server en onze mobiele telefoon als client. Laten we nu de ESP32 als een client gebruiken en proberen deze te verbinden met andere BLE-servers zoals mijn fitnessband.

Alle BLE-servers, inclusief mijn fitnessband, bevinden zich in constante advertentiemodus, dat wil zeggen dat ze altijd kunnen worden ontdekt wanneer ze door een klant worden gescand. Door gebruik te maken van deze functie kunnen we deze fitnessbanden als naderingsschakelaar gebruiken, wat betekent dat deze fitnessbanden altijd aan de hand van de gebruiker zijn vastgemaakt en door te scannen naar de band kunnen we detecteren of de persoon binnen bereik is. Dit is precies wat we in dit artikel gaan doen. We zullen de ESP32 programmeren om als een BLE-client te fungeren en constant blijven zoeken naar BLE-apparaten; als we de fitnessband binnen bereik vinden, zullen we proberen er verbinding mee te maken en als de verbinding succesvol is, kunnen we een gloeilamp activeren door een van de GPIO-pinnen op de ESP32 om te schakelen. De methode is betrouwbaar omdat elke BLE-server(fitnessband) heeft een unieke hardware-ID, zodat geen twee BLE-serverapparaten identiek zijn. Interessant toch? !!! Laten we nu beginnen met bouwen

Eerste vereisten

In dit artikel ga ik ervan uit dat je al bekend bent met het gebruik van het ESP32-bord met Arduino IDE, zo niet val je terug op het aan de slag gaan met de ESP32-tutorial.

We hebben de volledige ESP32 Bluetooth onderverdeeld in drie segmenten voor een beter begrip. Het wordt dus aanbevolen om de eerste twee tutorials door te nemen voordat u met deze begint.

1. Seriële Bluetooth op ESP32 schakelende LED van mobiele telefoon
2. BLE-server om batterijniveau-gegevens naar mobiele telefoon te verzenden met behulp van GATT-service
3. BLE-client om te scannen naar BLE-apparaten en als baken te fungeren.

We hebben de eerste twee tutorials al behandeld, hier gaan we verder met de laatste om ESP32 uit te leggen als BLE-client.

Vereiste materialen

• ESP32-ontwikkelbord
• AC-belasting (lamp)
• Relaismodule

Hardware

De hardware voor dit ESP32 BLE Client-project is vrij duidelijk, aangezien de meeste magie in de code gebeurt. De ESP32 moet een AC-lamp (Load) schakelen wanneer het Bluetooth-signaal wordt ontdekt of verloren gaat. Om deze belasting om te schakelen, gebruiken we een relais en aangezien de GPIO-pinnen van ESP32 slechts 3,3 V compatibel zijn, hebben we een relaismodule nodig die kan worden aangestuurd met 3,3 V. Controleer gewoon welke transistor in de relaismodule wordt gebruikt als het BC548 is, je bent klaar om anders je eigen circuit te bouwen door het onderstaande schakelschema te volgen.

Waarschuwing: De schakeling werkt met directe netspanning van 220V AC. Pas op met spanningvoerende draden en zorg ervoor dat u geen kortsluiting veroorzaakt. Je bent gewaarschuwd.

De reden achter het gebruik van BC548 via BC547 of 2N2222 is dat ze een lage basis-emitterspanning hebben die kan worden geactiveerd met slechts 3.3V. Het relais dat hier wordt gebruikt is een 5V-relais, dus we voeden het met Vin-pin die 5V krijgt van de voedingskabel. De aardingspin is verbonden met de aarde van het circuit. De weerstand R1 1K wordt gebruikt als een basisstroombegrenzerweerstand. De fasedraad is verbonden met de NO-pin van het relais en de gemeenschappelijke pin van het relais is verbonden met de belasting en het andere uiteinde van de belasting is verbonden met neutraal. U kunt de positie van Phase en Neutral omwisselen, maar pas op dat u ze niet direct kortsluit. De stroom moet altijd door de belasting (lamp) gaan.Ik heb een relaismodule gebruikt om het simpel te houden en de belasting hier is een Focus LED-lamp. Mijn opstelling ziet er hieronder ongeveer zo uit

Als u de hardware voorlopig wilt overslaan, kunt u de GPIO 2-pin gebruiken in plaats van de GPIO 13-pin om de ingebouwde LED op ESP32 om te schakelen. Deze methode wordt aanbevolen voor beginners.

Krijg uw Bluetooth-adres van de server (adres van fitnessband)

Zoals eerder verteld, gaan we de ESP32 programmeren om als een client te fungeren (vergelijkbaar met een telefoon) en verbinding maken met een server die mijn fitnessband is (Lenovo HW-01). Om verbinding te maken met de server, moet een client het Bluetooth-adres van de server kennen. Elke Bluetooth-server zoals mijn fitnessband hier, heeft zijn eigen unieke Bluetooth-adres dat permanent is. U kunt dit relateren aan het MAC-adres van uw laptop of mobiele telefoon.

Om dit adres van de server te krijgen, gebruiken we de applicatie genaamd nRF connect van Noordse halfgeleiders die we al hadden gebruikt voor onze vorige tutorial. Het is gratis beschikbaar voor zowel IOS- als Android-gebruikers. Gewoon downloaden, de applicatie starten en zoeken naar Bluetooth-apparaten in de buurt. De applicatie geeft een lijst van alle BLE-apparaten die het vindt. De mijne heet HW-01, kijk gewoon onder de naam en je zult het hardware-adres van de server vinden, zoals hieronder weergegeven.

Dus het ESP32 BLE- hardwareadres van mijn fitnessband is C7: F0: 69: F0: 68: 81, je hebt een andere reeks getallen in hetzelfde formaat. Noteer het gewoon, want we hebben het nodig wanneer we onze ESP32 programmeren.

Het verkrijgen van de service en karakteristieke UUID van de server

Oké, nu hebben we onze server geïdentificeerd met behulp van het BLE-adres, maar om ermee te kunnen communiceren, moeten we de taal van de Service en de kenmerken spreken, die je zou begrijpen als je de vorige tutorial had gelezen. In deze tutorial gebruik ik de schrijfkarakteristiek van mijn server (fitnessband) om ermee te koppelen. Dus voor het koppelen met het apparaat hebben we de Service-advertentie Karakteristieke UUID nodig die we opnieuw kunnen verkrijgen met dezelfde applicatie.

Klik gewoon op de verbindingsknop op uw applicatie en zoek naar enkele schrijfkenmerken, waar de applicatie de service UUID en karakteristieke UUID zal weergeven. De mijne wordt hieronder getoond

Hier is mijn Service UUID en Characteristic UUID hetzelfde, maar het hoeft niet hetzelfde te zijn. Noteer de UUID van uw server. De mijne werd genoteerd als

Service UUID: 0000fee7-0000-1000-8000-00805f9b34fb Kenmerkende UUID: 0000fee7-0000-1000-8000-00805f9b34fb

Het is niet verplicht om de schrijfkenmerken te gebruiken; u kunt elke geldige service en karakteristieke UUID van de server gebruiken die in de applicatie wordt weergegeven.

Programmeren van de ESP32 om te fungeren als een client voor de toepassing van naderingsschakelaars

Het idee van het programma is om de ESP32 te laten fungeren als een client die blijft scannen naar Bluetooth-apparaten wanneer deze onze server (fitnessband) vindt, de hardware-ID verifieert en het licht door de GPIO-pin 13 schakelt. Oké! !, maar daar is één probleem mee. Alle BLE-servers hebben een bereik van 10 meter, wat iets te veel is. Dus als we een naderingsschakelaar proberen te maken om het licht aan te doen of een deur te openen, is dit bereik erg hoog.

Om het bereik van de BLE-server te verkleinen, kunnen we de koppelingsoptie gebruiken. Een BLE-server en -client blijven alleen gekoppeld als beide zich binnen een afstand van 3-4 meter bevinden. Dat is perfect voor onze applicatie. Dus maken we de ESP32 niet alleen om de BLE server te vinden, maar ook om verbinding te maken en ervoor te zorgen dat als het blijft gekoppeld. Zolang ze zijn gekoppeld, blijft de AC-lamp branden, wanneer het bereik wordt overschreden, gaat de koppeling verloren en wordt de lamp uitgeschakeld. Het volledige ESP32 BLE-voorbeeldprogramma om hetzelfde te doen staat aan het einde van deze pagina. Hieronder zal ik de code in kleine stukjes breken en proberen ze uit te leggen.

Na het opnemen van het header-bestand, informeren we de ESP32 over het BLE-adres, de service en de karakteristieke UUID die we hebben verkregen via de nRF connect-applicatie, zoals uitgelegd in de bovenstaande kopjes. De code ziet er als volgt uit

statische BLEUUID serviceUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // Service-UUID van fitnessband verkregen via nRF connect applicatie statische BLEUUID charUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // Kenmerkende UUID van fitnessband verkregen via nRF connect-applicatie String My_BLE_Address = "c7: f0: 69: f0: 68: 81"; // Hardware Bluetooth MAC van mijn fitnessband , varieert voor elke band die is verkregen via de nRF connect-applicatie

Gevolgd door dat in het programma hebben we de connectToserver en MyAdvertisedDeviceCallback, waar we later op terugkomen. Vervolgens initialiseren we in de setup- functie de seriële monitor en laten we de BLE op ESP scannen naar een apparaat. Nadat de scan voor elk ontdekt BLE-apparaat is voltooid, wordt de functie MyAdvertisedDeviceCallbacks aangeroepen.

We schakelen ook actieve scan in omdat we de ESP32 voeden met netstroom, voor batterijtoepassing is deze uitgeschakeld om het stroomverbruik te verminderen. De Relay-triggerpin is verbonden met GPIO 13 in onze hardware, dus we verklaren ook dat de GPIO-pin 13 als output is.

ongeldige setup () { Serial.begin (115200); // Start seriële monitor Serial.println ("ESP32 BLE Server-programma"); // Introbericht BLEDevice:: init (""); pBLEScan = BLEDevice:: getScan (); // maak nieuwe scan pBLEScan-> setAdvertisedDeviceCallbacks (nieuwe MyAdvertisedDeviceCallbacks ()); // Roep de klasse aan die hierboven is gedefinieerd pBLEScan-> setActiveScan (true); // actieve scan verbruikt meer stroom, maar verkrijg snellere resultaten pinMode (13, OUTPUT); // Declareer de ingebouwde LED-pin als output }

Binnen de functie MyAdvertisedDeviceCallbacks , drukken we een regel af met de naam en andere informatie van de BLE-apparaten die zijn ontdekt. We hebben de hardware-ID nodig van het BLE-apparaat dat is ontdekt, zodat we het kunnen vergelijken met het gewenste apparaat. Dus gebruiken we de variabele Server_BLE_Address aan het adres van het apparaat te krijgen en dan ook nog om te zetten van het type BLEAddress tot string.

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

Binnen de loop- functie scannen we gedurende 3 seconden en plaatsen het resultaat in foundDevices, een object van BLEScanResults. Als we een of meer dan één apparaat vinden door te scannen, beginnen we te controleren of het gevonden BLE-adres overeenkomt met het adres dat we in het programma hebben ingevoerd. Als de overeenkomst positief is en het apparaat niet eerder is gekoppeld, proberen we het te koppelen met behulp van de connectToserver-functie. We hebben ook enkele seriële verklaringen gebruikt om het doel te begrijpen.

while (foundDevices.getCount ()> = 1) { if (Scaned_BLE_Address == My_BLE_Address && paired == false) { Serial.println ("Gevonden apparaat: -)… verbinding maken met server als client"); if (connectToserver (* Server_BLE_Address)) {

Binnen de connectToserver- functie maken we gebruik van de UUID om te koppelen met de BLE-server (fitnessband). Om verbinding te maken met een server, moet de ESP32 optreden als een client, dus we maken een client aan met behulp van de createClient () -functie en maken vervolgens verbinding met het adres van de BLE-server. Vervolgens zoeken we de service en het kenmerk met behulp van de UUID-waarden en proberen we er verbinding mee te maken. Als de verbinding succesvol is, retourneert de functie een true en zo niet, dan geeft het een false terug. Merk op dat het niet verplicht is om service en karakteristieke UUID te hebben om te koppelen met een server, dit wordt alleen gedaan voor uw begrip.

bool connectToserver (BLEAddress pAddress) { BLEClient * pClient = BLEDevice:: createClient (); Serial.println ("- Klant aangemaakt"); // Maak verbinding met de BLE-server. pClient-> connect (pAddress); Serial.println ("- Verbonden met fitnessband"); // Verkrijg een verwijzing naar de service die we zoeken op de externe BLE-server. BLERemoteService * pRemoteService = pClient-> getService (serviceUUID); if (pRemoteService! = nullptr) { Serial.println ("- Onze service gevonden"); terugkeer waar; } else retourneert false; // Verkrijg een verwijzing naar het kenmerk in de service van de externe BLE-server. pRemoteCharacteristic = pRemoteService->getCharacteristic (charUUID); if (pRemoteCharacteristic! = nullptr) Serial.println ("- Vond ons kenmerk"); terugkeer waar; }

Als de verbinding succesvol is, wordt de GPIO-pin 13 hoog gemaakt en wordt de besturing buiten de lus gestuurd met behulp van de break-instructie. De gekoppelde Booleaanse variabele is ook ingesteld op true.

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

Nadat het koppelen is gelukt en de GPIO-pin is ingeschakeld, moeten we controleren of het apparaat nog binnen bereik is. Omdat het apparaat nu is gekoppeld, kan de BLE-scanservice het niet langer zien. We vinden het pas terug als de gebruiker het gebied verlaat. We moeten dus gewoon naar onze BLE-server zoeken en als we ontdekken, moeten we de GPIO-pin op laag zetten, zoals hieronder wordt weergegeven

if (Scaned_BLE_Address == My_BLE_Address && paired == true) { Serial. println ("Ons apparaat viel buiten bereik"); paired = false; Serieel. println ("******************** LED OOOFFFFF *************************"); digitalWrite (13, LOW); ESP.restart (); breken; }

Werken en testen

Zodra u klaar bent met het programma en de hardware-installatie, uploadt u eenvoudig de code naar de ESP32 en regelt u de hele installatie zoals hieronder weergegeven.

U zou moeten opmerken dat de lamp wordt ingeschakeld zodra de fitnessband (server) is gekoppeld met de ESP32. U kunt dit ook controleren door het Bluetooth-verbindingssymbool op de fitnessband te zien. Eenmaal gekoppeld, probeer gewoon weg te lopen van de ESP32 en wanneer u 3-4 meter oversteekt, zult u merken dat het Bluetooth-symbool op het horloge verdwijnt en de verbinding wordt verbroken. Als u nu naar de lamp kijkt, wordt deze uitgeschakeld. Wanneer u weer binnenloopt, wordt het apparaat opnieuw gekoppeld en gaat het lampje branden. De volledige werking van het project is te vinden in de onderstaande video.

Ik hoop dat je van het project genoten hebt en onderweg iets nieuws hebt geleerd. Als u problemen had ondervonden om het aan het werk te krijgen, kunt u het probleem op forums of zelfs in de commentaarsectie hieronder posten