Tutoriel ESPTOP 10 BLE utilisant Arduino IDE
ESP32 prend en charge la basse énergie Bluetooth Classic et Bluetooth. Ici, nous nous concentrerons sur Bluetooth à faible énergie. Voyons-le en détail.
Qu'est-ce que Bluetooth à faible énergie
Ble ou Bluetooth Low Energy est un mode d'économie d'énergie de Bluetooth. Son application principale comprend le transfert de données sur de courtes distances telles que l'entrée de porte, les montres intelligentes, les appareils portables, le moniteur de pression artérielle, la sécurité et les autorités domestiques. BLE peut transférer des données limitées.
Contrairement à Bluetooth Classic qui reste activé pendant tout le temps que BLE reste en mode veille, sauf lorsqu'il est appelé ou que la connexion est initiée. Cela rend le BLE très économe en puissance et consomme 100 fois moins de puissance que la puissance classique.
Voici une brève comparaison de Bluetooth Classic avec Bluetooth Low Energy:
| spécification | Bluetooth Classic | Bluetooth basse énergie / ble |
| Taux de transfert des données | 2-3Mbps | 1Mbps |
| Gamme | ~ 10-100m | ~ 50m |
| Fréquence de fonctionnement | 79 RF | 40 RF |
| Consommation de courant maximal | ~ 30mA | <15mA |
| Consommation d'énergie | 1W | 0.01-0.5W |
| Temps total pour envoyer des données | 100 ms | 3 ms |
| Applications | Audio, diffusion de musique | Capteur, portables |
Pour une comparaison plus détaillée, cliquez ici pour visiter le site officiel de Bluetooth.
Serveur et client
Bluetooth Low Energy prend en charge l'appareil de deux manières différentes: serveur et client. ESP32 peut agir en tant que serveur ainsi que client pour Bluetooth à faible énergie.
Support BLE suivant les modes de communication:
- Point à point: Communication entre deux points ou nœuds qui est serveur et client.
- Mode de diffusion: Le serveur transmet des données à de nombreux appareils.
- Réseau de maillage: Plusieurs appareils connectés également connues comme beaucoup à de nombreuses connexions.
Lorsque vous agissez en tant que serveur, ESP32 annonce son existence aux appareils clients à proximité. Une fois que les périphériques clients ont scrutant les périphériques Bluetooth disponibles, le serveur établit une connexion entre eux et transfère les données du serveur au périphérique client. Cette communication est appelée point à point.
Dans ce tutoriel, nous prendrons un exemple de communication point à point entre deux planches ESP32.
Termes importants dans BLE
Voici quelques termes importants que l'on devrait connaître tout en travaillant avec des applications ESP32 BLE:
GATT: GATT ou Attributs génériques qui définissent une structure hiérarchique pour les transferts de données entre les appareils BLE en utilisant le service et les caractéristiques. Il définit la façon dont deux appareils communiquent les données entre eux.
Service BLE: Le niveau supérieur à l'intérieur de la hiérarchie GATT est un profil qui contient un ou plusieurs services. Ble contient plus d'un seul service. Chacun de ces services a ses propres caractéristiques qui peuvent également agir comme référence pour d'autres services.
Caractéristique ble: La caractéristique est un groupe d'informations toujours détenues par le service; C'est là que les données réelles sont stockées dans la hiérarchie (valeur). Il contient toujours deux attributs:
- Déclaration: Propriétés caractéristiques telles que l'emplacement, type, lire, écrire et notifier.
- Valeur caractéristique: Valeur de données des caractéristiques.
Uuid: L'UUID (identifiant universellement unique) est une pièce d'identité unique donnée à un service et à une caractéristique. Il s'agit d'un identifiant 128 bits unique qui peut être généré à l'aide de n'importe quel générateur UUID en ligne. Vérifiez ce générateur UUID gratuit. Un échantillon UUID ressemble à ceci:
583F8B30-74B4-4757-8143-56048FD88B25Un groupe d'intérêt spécial Bluetooth universel (SIG) a prédéfini certains des UUID raccourcis pour différents types de services et de profil pour les lire Cliquez ici.
Configurez BLE dans ESP32 avec Arduino IDE
Pour comprendre le fonctionnement de BLE, nous utiliserons deux cartes ESP32 différentes, l'un d'eux agira comme serveur et annoncer un signal Bluetooth tandis que l'autre ESP32 qui agit comme un client essaiera de connecter le serveur Bluetooth.
Arduino IDE a des exemples distincts pour le scanner et le serveur.
Pour voir comment installer un ESP32 avec Arduino IDE dans Windows, cliquez ici.
ESP32 BLE Server
Tout d'abord, nous téléchargerons un exemple d'exemple de serveur dans notre première carte ESP32 qui agit comme un serveur.
Pour ouvrir l'exemple du serveur BLE, allez à: Fichier> Exemples> ESP32 BLE ARDUINO> BLE_SERVER:
Le code donné ci-dessous sera ouvert dans Arduino IDE.
Code de serveur
Téléchargez le code ci-dessous dans la carte ESP32 à l'aide d'Arduino IDE. Mais assurez-vous de déconnecter la deuxième carte pendant un certain temps pour éviter de télécharger le même code sur une seule carte.
#inclure#inclure
#inclure
#Define Service_UUID "4FAFC201-1FB5-459E-8FCC-C5C9C331914B"
#define caractéristique_uuid "beb5483e-36e1-4688-b7f5-ea07361b26a8"
void setup()
En série.commencer (115200);
En série.println ("Démarrer le travail BLE!");
Bledevice :: init ("ESP32");
Bleserver * pServer = BledEvice :: CreateServer ();
BleService * PSERVICE = PSERver-> CreateService (Service_UUID);
Blecharacteristic * pcharactérisme = pseservice-> createCharacteristic (
Caractéristique_uuid,
Blecharacteristic :: Property_read |
Blecharacteristic :: Property_write
));
PcharacTristic-> setValue ("Bonjour dire Linuxhint.com ");
PSERVICE-> start ();
// BleadVertising * Padvertinging = pServer-> getAdvertising (); / * Compatibilité arrière * /
BleadVertising * Padvertising = BledEvice :: GetAdvertising ();
Padvertinging-> addServiceUuid (service_uuid);
Padvertinging-> setScanResponse (true);
Padvertinging-> setMinPreferred (0x06); // Fonctions pour la connexion iPhone
Padvertinging-> setMinPreferred (0x12);
Bledevice :: startAdvertise ();
En série.println ("caractéristique définie! BLE Server prêt ");
VOID LOOP ()
Retard (2000);
Le code commence par inclure les fichiers de bibliothèque Bluetooth nécessaires. Ensuite, l'UUID est défini pour le service et la caractéristique. Vous pouvez aller avec l'UUID par défaut ou générer en utilisant le générateur UUID gratuit. La prochaine communication série est initialisée en définissant le taux de bauds.
Ensuite, nous avons créé un appareil BLE nommé ESP32. Après cela, nous avons défini le périphérique BLE comme un serveur en utilisant le createServer () fonction et plus tard nous définissons la valeur caractéristique. À la dernière étape, nous avons commencé le service en le publiant pour que d'autres appareils puissent le rechercher.
Scanner ESP32 BLE
Nous allons maintenant télécharger un exemple de numérisation ESP32 dans la deuxième carte ESP32. Pour ce faire, allez à: Fichier> Exemples> ESP32 BLE ARDUINO> BLE_SCAN
Le code ci-dessous sera ouvert dans Arduino IDE Editor.
Code de scanner
#inclure#inclure
#inclure
#inclure
int santime = 5; //En secondes
Blescan * Pblescan;
classe MyAdvertisedDeviceCallbacks: public BleadvertisedDeviceCallbacks
void onResult (BleadvertisedDevice annoncédevice)
En série.printf ("Dispositif annoncé:% S \ n", annoncé device.toString ().c_str ());
;
void setup()
En série.commencer (115200);
En série.println ("scanning…");
Bledevice :: init ("");
PBLESCAN = BLEDEVICE :: GetSCAN (); // Créer un nouveau scan
PBLESCAN-> SETADVERTISEDDEVICECALLBACKS (New MyAdvertisedDeviceCallbacks ());
PBLESCAN-> SetActivesCan (true); // scan rapide mais plus de puissance utilisée
PBLESCAN-> SetInterval (100);
PBLESCAN-> SetWindow (99);
VOID LOOP ()
// Mettez votre code principal ici, pour exécuter à plusieurs reprises:
BlescanResults FoundDevices = PBLESCAN-> START (SCANTIME, FAUX);
En série.print ("Appareils trouvés:");
En série.println (FoundDevices.getCount ());
En série.println ("scan terminé!");
PBLESCAN-> ClearResults (); // Supprimer les résultats à la mémoire libre
Retard (2000);
Le code ci-dessus recherchera le nombre d'appareils disponibles totaux pour BLE et affichera leur nombre total avec des adresses. Après le téléchargement du code dans la carte de scanner ESP32, appuyez sur le Activer Bouton, la carte ESP32 recherchera automatiquement les appareils disponibles.
Sortir
Une fois que l'ESP32 a analysé les appareils disponibles, le résultat suivant apparaîtra. Ici ESP32 a scanné 9 appareils parmi lesquels un est une carte ESP32 avec du code BLE_SERVER et un autre appareil est MI Band 6. Le reste de tous les appareils sont disponibles près de mon ESP32.
Comment corriger la bibliothèque de numérisation ESP32 BLE sans compter les appareils
L'exemple de bibliothèque ESP32 Scan a un bug de ne pas compter le nombre total d'appareils. Pour rectifier ce problème, accédez à l'emplacement mentionné et remplacez le code ci-dessous.
C: \ Users \ username \ appdata \ local \ arduino15 \ packages \ esp32 \ matériel \ esp32 \ 1.0.6 \ bibliothèques \ ble \ src \ blescan.cppSe souvenir de inutile Tous les dossiers car le dossier AppData à l'intérieur du répertoire C reste caché par défaut. Après avoir ouvert le fichier source BLE_SCAN .cpp Remplacez l'état donné ci-dessous à l'intérieur du code.
if (m_padvertiseddeviceCallbacks)m_padvertisedDeviceCallbacks-> onResult (* annoncédEvice);
si (!m_wantduplicate && !trouvé)
m_scanresults.m_vectoradvertiseddevices.insérer (paire std :: (annoncéddress.toString (), annoncedDevice));
omniflélele = false;
Test du serveur ESP32 BLE avec téléphone intelligent
La plupart des smartphones modernes fonctionnent avec BLE Technology pour communiquer avec différents appareils tels que Smartwatch, les appareils portables, les capteurs et autres appareils domestiques. Ici, la carte ESP32 agira comme un point d'accès. Nous allons donc connecter un téléphone Android avec une carte ESP32.
Code de serveur BLE pour l'accès au smartphone ESP32
Téléchargez le code donné ci-dessous dans la carte ESP32.
#include / * bibliothèque Bluetooth incluse * /#inclure
#inclure
#define Service_UUID "A484A399-7272-4282-91CF-9018E075FC35"
#define caractéristique_UUID "C7E084BD-5279-484D-8319-FFF7D917537D"
Class MyCallbacks: public BlecharacteristicCallbacks
void onwrite (Blecharacteristic * pcharactériste)
std :: string value = pCharacteristic-> getValue ();
si (valeur.length ()> 0)
En série.print ("Valeur caractéristique mise à jour:");
for (int i = 0; i créateService (service_uuid);
Blecharacteristic * pcharactérisme = pseservice-> createCharacteristic (
Caractéristique_uuid,
Blecharacteristic :: Property_read |
Blecharacteristic :: Property_write
));
pCharAtteristic-> setCallbacks (new MyCallbacks ());
pcharactrique-> setValue ("Linuxhint.Com ");
PSERVICE-> start ();
BleadVertising * Padvertinging = Pserver-> getAdvertising ();
Padvertinging-> start ();
VOID LOOP ()
Retard (2000);
Installation de l'application BLE dans un smartphone Android
Les étapes suivantes vous guideront vers l'installation d'applications BLE dans les smartphones et aideront à interface des appareils mobiles avec des cartes ESP32.
Étape 1: Installation d'ouvrir Google Play Store Scanner BLE application.
Étape 2: Après l'installation, ouvrez l'application et autorisez toute l'autorisation requise et n'oubliez pas d'activer le Bluetooth mobile.
Étape 3: Méalienne maintenant pour les appareils Bluetooth disponibles. Connectez la carte ESP32.
Étape 4: Une fois que la carte ESP32 est connectée au smartphone après que la spécification de la carte ESP32 apparaîtra. Ici, nous pouvons voir les adresses UUID et lire et écrire de nouvelles valeurs caractéristiques.
Étape 5: Pour lire la valeur caractéristique enregistrée, cliquez R. Le résultat sera affiché.
Étape 6: Pour écrire toute nouvelle valeur caractéristique Cliquez W.
Étape 7: Une nouvelle fenêtre contextuelle apparaîtra ici, nous pouvons écrire n'importe quelle valeur caractéristique et cliquer D'accord.
Étape 8: Une nouvelle valeur écrite apparaîtra.
Étape 9: De plus, nous pouvons voir la même nouvelle valeur caractéristique imprimée sur le moniteur en série d'Arduino IDE.
Nous avons réussi à connecter un appareil avec ESP32 BLE.
Conclusion
ESP32 est livré avec du double Bluetooth qui est classique et à faible énergie. Ici, dans cet article, nous avons discuté de BLE et de ses diverses applications et de travail. Plus tard, nous avons configuré BLE avec deux cartes ESP32 différentes avec l'un agissant comme serveur et autre comme scanner. Enfin, nous avons connecté notre smartphone avec le serveur ESP32 et avons écrit une nouvelle valeur caractéristique.