Esp32 ble server

Draadloze koptelefoons, fitnessbanden, bluetooth-luidsprekers, in-ear koptelefoons, mobiele telefoons, laptops… er zijn zoveel bluetooth-apparaten om ons heen en de meeste van deze apparaten werken op batterijen. Heeft u zich ooit afgevraagd dat, wanneer u een Bluetooth-apparaat op uw mobiele telefoon aansluit, het automatisch begrijpt dat het aangesloten apparaat een computer of audioapparaat of een mobiele telefoon is? Voor sommige apparaten toont onze telefoon zelfs automatisch het batterijpercentage van het aangesloten apparaat op de meldingsbalk. Hoe gaat dit allemaal vanzelf? Er zou een gemeenschappelijk protocol moeten zijn dat tussen de telefoon en het Bluetooth-apparaat wordt gedeeld, toch!

Blijf nieuwsgierig, u krijgt antwoorden op deze vragen terwijl we Bluetooth Low Energy (afgekort BLE) proberen te begrijpen met de populaire ESP32-module. In tegenstelling tot klassieke Bluetooth in ESP32 werkt de BLE alleen wanneer een communicatie is geactiveerd en blijft hij anders in de slaapstand, waardoor het de juiste keuze is voor toepassingen op batterijen. BLE kan ook mesh-netwerken vormen en als bakens fungeren. Normaal gesproken werken een BLE-module als een server of als een client, hier zullen we ESP32 BLE als server gebruiken.

Hier hebben we de volledige ESP32 Bluetooth in drie segmenten verdeeld voor een beter begrip.

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 op BLE-apparaten en als baken te fungeren.

We hebben het eerste artikel al behandeld; in dit artikel zullen we leren hoe we de ESP32 BLE kunnen laten werken als een server en hoe we de GATT-service kunnen gebruiken om informatie over het batterijniveau te verzenden. Voor testdoeleinden sturen we hardgecodeerde waarden van ESP32 als batterijpercentage naar onze mobiele telefoon via de BLE GATT-service, op deze manier zal onze mobiele telefoon aannemen dat ESP32 een op batterijen werkend Bluetooth-apparaat is dat probeert te verzenden naar zijn batterijpercentage. Voordat we in detail treden, zullen we enkele terminologieën met betrekking tot Bluetooth Low Energy onderkennen.

Terminologieën met betrekking tot BLE (Bluetooth Low Energy)

BLE-server: zoals eerder verteld, kan de BLE worden geprogrammeerd om als server of als client te werken. Bij het werken als server kan de BLE alleen gegevens verstrekken en kan hij geen verbinding tot stand brengen. Voorbeeld zou een fitnessband zijn. Een server kan alleen informatie verzenden als de klant erom vraagt.

Meestal wordt de BLE van de ESP32 gebruikt als een server. Elke server heeft een of meer services en op dezelfde manier heeft elke service een of meer bijbehorende kenmerken. Een kenmerk kan nul, een of meer beschrijvingen bevatten. Elke service, kenmerk of descriptor heeft zijn eigen vooraf gedefinieerde unieke ID genaamd UUID.

BLE-client: de client kan scannen, verbinden en luisteren naar andere Bluetooth-apparaten. Een voorbeeld hiervan is uw mobiele telefoon. Merk op dat de meeste BLE-hardwareapparaten kunnen werken als server en als client, het is de software die de rol van het apparaat bepaalt.

Randapparaat / Centraal apparaat: in een BLE-netwerk kan er maar één centraal apparaat zijn, maar er kunnen zoveel randapparaten zijn als nodig is. Het centrale apparaat kan verbinding maken met alle randapparatuur tegelijkertijd, maar het randapparaat kan alleen verbinding maken met het centrale apparaat, op deze manier kunnen geen twee randapparatuur gegevens met elkaar delen. Een beste voorbeeld voor een centraal apparaat zijn onze slimme telefoons en voor randapparatuur zijn onze Bluetooth-oortelefoons of fitnessbanden.

BLE-reclame: een BLE-reclame is de geeky term om het Bluetooth-apparaat te instrueren om voor iedereen zichtbaar te zijn, zodat het kan koppelen en een verbinding tot stand kan brengen. Het kan worden beschouwd als een eenrichtingscommunicatie. Hier houdt de server advertentiegegevens bij in de verwachting dat een server deze ontvangt. BLE Beacon is een type BLE.

UUID (Universal Unique Identifier): elk BLE Bluetooth-apparaat krijgt een universeel uniek identificatienummer wanneer het door de programmeur wordt geprogrammeerd. U kunt deze identificatie zien als een reeks getallen die de functionaliteit / rol van het BLE-apparaat vertegenwoordigt. Ook hier zijn er twee soorten UUID. De ene is de service-UUID en de andere is de karakteristieke UUID.

GATT-service: GATT staat voor Generic Attribute Profile; dit definieert enkele standaard manieren waarop twee BLE-apparaten altijd moeten communiceren. Dit kenmerkprotocol (ATT) is vooraf gedefinieerd en is gemeenschappelijk voor alle BLE-apparaten, zodat op deze manier twee BLE-apparaten elkaar kunnen identificeren. Dus GATT was het antwoord op onze vorige vraag.

De techniek waarmee twee BLE-apparaten gegevens heen en weer moeten sturen, wordt bepaald door het concept dat services en kenmerken wordt genoemd.

BLE-service / BLE-kenmerk: de service-UUID vertelt ons welk type service het BLE-apparaat gaat uitvoeren en de karakteristieke UUID vertelt wat de parameters of functies zijn die door die service zullen worden uitgevoerd. Elke service heeft dus een of meer kenmerken. Oke! Waar haalt de programmeur deze UUID vandaan? Elke UUID is al gedefinieerd door de GATT (Generic Attribute Profile). U kunt hun website bezoeken en de UUID selecteren zoals vereist voor het project. Ik weet dat het een beetje boven ons hoofd is gestuiterd; laten we het proberen te begrijpen met een voorbeeld.

Laten we aannemen dat het BLE-apparaat van een audiospeler is. Wanneer u hem aan uw telefoon koppelt, herkent uw telefoon deze aanvankelijk als een audioapparaat en wordt het batterijniveau ook weergegeven op de statusbalk. Om dit te laten gebeuren, moet de audiospeler uw telefoon dus op de een of andere manier vertellen dat hij bereid is om het batterijniveau en het percentage van de lading in de batterij te delen. Dit wordt gedaan door het gebruik van de UUID, is er een specifieke UUID waarin wordt verteld dat de BLE dobbelstenen gaat om details over het batterijniveau deze UUID die de aard van de dienst heet vertelt bieden dienst UUID, weer kunnen er zoveel parameters die aan heeft worden ingewisseld voor het voltooien van een service zoals de waarde van de batterij op een dergelijke parameter, elke parameter heeft zijn eigen UUID en deze worden de karakteristieke UUID genoemd.De algemene functie die door een kenmerk wordt uitgevoerd, is lezen, schrijven, melden en aangeven.

BLE-descriptor: de descriptor is een optioneel attribuut dat aanwezig is in het kenmerk. Een descriptor specificeert normaal gesproken hoe u toegang krijgt tot een kenmerk.

BLE Beacon: een Bluetooth Beacon is meer een naderingsschakelaar die een vooraf gedefinieerde actie uitvoert wanneer de gebruiker binnen bereik komt (dichtbij). Het maakt de hele tijd reclame voor zijn identiteit en is daarom altijd klaar om te koppelen.

BLE2902: Ik ben nog steeds sceptisch over dit ding, maar u kunt het zien als een stukje software aan de clientzijde dat de server informeert om de melding in of uit te schakelen, dit zal ons helpen energie te besparen

Ik hoop dat je een globaal idee hebt, het goede is dat we niet veel hoeven te weten, aangezien al het handwerk al voor ons is gedaan via de bibliotheken.

De hardware voorbereiden

Het project vereist geen hardware-installatie, maar zorg ervoor dat je ESP32-kaartdetails hebt toegevoegd aan je Arduino IDE en een minimaal voorbeeld van een knipperingsprogramma hebt geprobeerd om te controleren of alles werkt zoals verwacht. Als je sceptisch bent over hoe je het moet doen, kun je de tutorial Aan de slag met ESP32 met Arduino volgen om hetzelfde te doen.

Ook om de BLE-services te testen, zullen we de nRF Android-applicatie op onze mobiel gebruiken die direct kan worden gedownload vanuit de PlayStore. Het is ook beschikbaar in de iTunes Store voor iPhone-gebruikers. Als u van plan bent om voor een lange tijd met BLE te werken, is deze applicatie erg handig voor het opsporen van fouten.

ESP32 programmeren voor indicatie van batterijniveau met behulp van GATT-service

Ik neem aan dat je tegen die tijd een goed idee hebt van welke GATT-service en hoe deze wordt geïmplementeerd met behulp van service- en karakteristieke modellen. Laten we nu in het programma duiken om te leren hoe het wordt geïmplementeerd in ESP32 met behulp van de Arduino IDE. Voordat we verder gaan, wil ik deze ruimte gebruiken om Andreas Spiess te bedanken voor zijn video BLE die de zaken aan mijn kant veel duidelijk maakte.

We beginnen het programma door de vereiste bibliotheken in onze schets te importeren. Er zijn veel dingen te configureren om de BLE-functionaliteit van de ESP32 te gebruiken, hopelijk dankzij Neil Kolban die al het harde werk voor ons heeft gedaan en de bibliotheken heeft geleverd. Als je de functionaliteit van de bibliotheken wilt begrijpen, kun je zijn documentatie op de github-pagina raadplegen.

# omvatten # omvatten # omvatten // Bibliotheek om BLE als server te gebruiken # omvatten

Vervolgens moeten we de Server Call-back-functie voor ons Bluetooth-apparaat definiëren. Laten we eerst begrijpen wat de callback-functie is in BLE.

Wat is de callback-functie in BLE?

Wanneer BLE als server werkt, is het belangrijk om een ​​server-callback-functie te definiëren. Er zijn veel soorten callbacks die aan BLE zijn gekoppeld, maar om het simpel te houden, beschouwt u deze als een bevestiging die wordt uitgevoerd om er zeker van te zijn dat de actie is voltooid. Een server callback wordt gebruikt om ervoor te zorgen dat de verbinding tussen client en server succesvol tot stand wordt gebracht.

We gebruiken de volgende regels code om een ​​server callback uit te voeren.

bool _BLEClientConnected = false; klasse MyServerCallbacks : openbare BLEServerCallbacks { void onConnect (BLEServer * pServer) { _BLEClientConnected = true; }; ongeldig onDisconnect (BLEServer * pServer) { _BLEClientConnected = false; } };

Binnen de leegte-instelfunctie starten we seriële communicatie op 115200 voor foutopsporing en initialiseren we vervolgens het Bluetooth-apparaat via de InitBLE- functie.

ongeldige setup () { Serial.begin (115200); Serial.println ("Indicator batterijniveau - BLE"); InitBLE (); }

De initBLE is de plek waar alle magie gebeurt. We moeten een Bluetooth-server maken en de Battery Level-service hier gebruiken. Maar daarvoor moeten we de UUID definiëren voor Service, Characteristic en Descriptor voor het lezen van het batterijniveau. Alle UUID's kunnen worden verkregen via de Bluetooth GATT-servicewebsite. Voor ons geval proberen we de batterijservice te gebruiken en UUID hiervoor wordt gedefinieerd als 0X180F zoals hieronder weergegeven.

Vervolgens moeten we het kenmerk weten dat aan deze service is gekoppeld. Om dat te weten, klikt u gewoon op Batterijservice en u wordt naar de pagina met servicekenmerken gebracht, waar wordt vermeld dat batterijniveau de naam is van de kenmerken en de waarde tussen 0 en 100 inneemt. Merk ook op dat we er maar twee kunnen uitvoeren acties met deze eigenschap, de ene is Lezen, wat verplicht is om te doen en de andere is Melden, wat optioneel is. We moeten dus de batterijwaarde naar de klant (telefoon) sturen, wat verplicht is en indien nodig kunnen we de telefoon informeren over wat optioneel is.

Maar wacht, we hebben de UUID-waarde voor het karakteristieke batterijniveau nog steeds niet gevonden. Om dat te doen, gaat u naar de pagina Accukarakteristiek en zoekt u naar de naam van het batterijniveau. U vindt de UUID als 0X2A19, de momentopname hiervan wordt hieronder weergegeven.

Nu we alle waarden hebben, laten we het in het programma plaatsen zoals hieronder getoond. De naam BatterySerivce , BatteryLevelCharacteristic en BatteryLevelDescriptor zijn door de gebruiker gedefinieerde variabelen die verwijzen naar de Service, Characteristic en Descriptor die we in het programma gebruiken. De waarde voor descriptor 0X2901 wordt gebruikt als de grootte van de waarde 8-bit is, meer informatie is te vinden op de beschrijvingspagina.

#define BatteryService BLEUUID ((uint16_t) 0x180F)

BLECharacteristic BatteryLevelCharacteristic (BLEUUID ((uint16_t) 0x2A19), BLECharacteristic :: PROPERTY_READ - BLECharacteristic :: PROPERTY_NOTIFY); BLEDescriptor BatteryLevelDescriptor (BLEUUID ((uint16_t) 0x2901));

Terugkomend op de initBLE- functie. We moeten eerst de BLE-server starten en deze laten adverteren met een naam. De volgende regels worden gebruikt om de BLE als server te starten. De naam die ik aan mijn BLe-server heb gegeven is "BLE Battery", maar u kunt uw eigen naam kiezen.

BLEDevice:: init ("BLE-batterij"); // Maak de BLE-server BLEServer * pServer = BLEDevice:: createServer (); pServer-> setCallbacks (nieuwe MyServerCallbacks ());

Vervolgens moeten we de GATT-service starten, aangezien we de UUID al hebben gedefinieerd, kunnen we de service eenvoudig starten met behulp van de onderstaande regel.

// Maak de BLE-service BLEService * pBattery = pServer-> createService (BatteryService);

Zodra de service is gestart, kunnen we de descriptor koppelen aan kenmerken en de waarden instellen. De BLE2902-service wordt hier ook toegevoegd, zoals hieronder weergegeven.

pBattery-> addCharacteristic (& BatteryLevelCharacteristic); BatteryLevelDescriptor.setValue ("Percentage 0 - 100"); BatteryLevelCharacteristic.addDescriptor (& BatteryLevelDescriptor); BatteryLevelCharacteristic.addDescriptor (nieuwe BLE2902 ());

Eindelijk is alles ingesteld, nu hoeft u alleen nog maar de ESP32 te vragen om reclame te maken, zodat andere apparaten zoals onze telefoon het kunnen ontdekken en er verbinding mee kunnen maken, en wanneer verbonden met een client, zou het de batterijservice moeten starten die kan worden gedaan via de volgende regels.

pServer-> getAdvertising () -> addServiceUUID (BatteryService); pBattery-> start (); // Begin met adverteren pServer-> getAdvertising () -> start ();

Dat is het tot nu toe zo goed, de laatste stap is om de descriptor te vertellen wat de waarde is van de batterij in percentage die naar de klant (telefoon) moet worden gestuurd. Deze waarde kan van 0 tot 100 zijn, zoals we eerder hebben gelezen, om het simpel te houden, heb ik de waarde van de batterij eenvoudig hard gecodeerd op 57 en vervolgens elke 5 seconden verhoogd en bij 0 beginnen zodra deze 100 bereikt. dat wordt hieronder getoond. Merk op dat de waarde die wordt verzonden de indeling unit8_t heeft.

uint8_t level = 57; void loop () { BatteryLevelCharacteristic.setValue (& niveau, 1); BatteryLevelCharacteristic.notify (); vertraging (5000); niveau ++; Serial.println (int (niveau)); if (int (level) == 100) level = 0; }

Uw GATT-service testen op ESP32 BLE

De volledige code die hierboven is uitgelegd, staat aan het einde van de pagina. Upload de code naar uw ESP32-bord. Na het uploaden zou uw telefoon een Bluetooth-apparaat moeten ontdekken met de naam "BLE Battery". Koppel ermee.

Installeer vervolgens de nRF Android-applicatie en open deze en maak verbinding met het BLE Battery BLE-apparaat. Vouw het gedeelte Batterijservice uit en u zou het volgende scherm moeten vinden.

Zoals u kunt zien, heeft de applicatie automatisch vastgesteld dat de BLE batterijservice biedt en de kenmerken van batterijniveau heeft vanwege de UUID die we in het programma hebben gebruikt. U kunt ook zien dat de huidige batterijwaarde die 67% is 5 seconden wacht en u kunt ook merken dat deze wordt verhoogd.

Het leuke van het gebruik van BLE is dat nu elke toepassing die met BLE werkt, denkt dat uw ESP32 een BLE-apparaat is dat het batterijniveau aangeeft. Om het uit te proberen, gebruikte ik een applicatie genaamd BatON en de applicatie identificeerde de ESP32 als een Bluetooth-apparaat op batterijen en gaf de procentuele melding op mijn telefoon als volgt

Stoer!! Rechtsaf? Ik heb ook het volledige werk laten zien in de onderstaande video. Nu je hebt geleerd hoe je BLE Battery-services met ESP32 kunt gebruiken, kun je ook andere GATT-services proberen die erg interessant zijn, zoals Pulse rate, HID, Heart Rate enz. Veel plezier….