Esptop 10 Bluetooth - Guide ultime

ESP32 est une carte basée sur un microcontrôleur fournie avec un support Wi-Fi et Bluetooth. Il s'agit d'une carte basée sur l'IoT qui peut être intégrée à plusieurs capteurs pour exécuter des instructions. La carte ESP32 a une large application où la communication sans fil est requise.

ESP32 prend en charge le double Bluetooth contenant Bluetooth Classic et le Bluetooth Low Energy (BLE). Dans cet article, nous discuterons du fonctionnement de ces deux Bluetooth.

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.

Voici les deux modes Bluetooth disponibles dans la carte ESP32:

• Bluetooth Classic
• Bluetooth Low Energy (BLE)

1: ESP32 Bluetooth Classic avec Arduino IDE

La carte ESP32 est livrée avec un double support Bluetooth, un est Bluetooth Classic et le second est BLE (Bluetooth Low Energy). Aujourd'hui, nous discuterons de Bluetooth Classic uniquement. La seule différence qui existe entre les deux est que Bluetooth Classic peut gérer beaucoup de transfert de données, mais consomme la batterie à un taux plus élevé, mais Bluetooth Low Energy est une variante de conservation de puissance qui est utilisée pour une communication de courte distance. BLE reste en mode veille jusqu'à ce qu'il soit initialisé pour le transfert de données.

ESP32 Bluetooth Classic Serial Communication

ESP32 est livré avec des modules Bluetooth intégrés qui reçoivent d'abord des données, puis le transfèrent au processeur Xtensa. Donc, pour établir cette communication «BluetoothSerial» La bibliothèque est utilisée qui est similaire à la bibliothèque série Arduino, mais elle est juste dans ESP32. Voici quelques fonctions offertes par Bluetooth Serial Library:

• commencer()
• disponible()
• écrire()
• lire()

LED contrôlée Bluetooth à l'aide d'ESP32

Écrivons un code simple qui peut contrôler une LED à l'aide de la communication sans fil Bluetooth mobile sur Bluetooth. Voici le matériel requis pour contrôler la LED à l'aide de la communication série Bluetooth:

• ESP32
• DIRIGÉ
• Planche à pain
• Appareil Android
• Application de terminal Bluetooth en série

Circuit

Connectez LED à la broche numérique 15 de ESP32 avec un terminal négatif connecté à GND de la carte ESP32. Pour une limite de courant sûre, nous pouvons également connecter la résistance (220 ohms) entre elles:

Code

Ouvrez Arduino IDE et sélectionnez la carte ESP32 dans le gestionnaire de cartes pour voir comment installer la carte ESP32 dans Arduino IDE Cliquez ici. Après avoir sélectionné la carte, écrivez le code ci-dessous dans la fenêtre de l'éditeur:

#include / * bibliothèque de communication série Bluetooth * / /
#define led_pin 15 / * broche LED initialisée * /
BluetoothSerial Serialbt;
octet bt_inp;
#si !défini (config_bt_enable) || !défini (config_bludoid_enabled) / * Vérifiez Bluetooth dans SDK * /
#Error Bluetooth Off - Run `` Making Menuconfig 'pour l'activer
#fin si
void setup()

pinMode (LED_PIN, sortie); / * LED PIN SET comme sortie * /
En série.commencer (115200); / * Taux en bauds pour la communication série * /
Serialbt.commencer(); / * La communication Bluetooth commence * /
En série.println ("Bluetooth est prêt à être jumelé…"); / * lorsque Bluetooth s'allume * /

VOID LOOP ()

if (serialbt.Disponible ()) / * Vérifiez la disponibilité des données Bluetooth * /

Bt_inp = serialbt.lire(); / * Lire les données Bluetooth de l'appareil * /
En série.écrire (bt_inp); / * Imprimez les données de lecture * /

if (bt_inp == '1') / * si condition pour l'état LED * /

DigitalWrite (LED_PIN, HIGH); / * Allumez la LED si 1 entrée est reçue * /

if (bt_inp == '0')

DigitalWrite (LED_PIN, LOW); / * Désactivez LED si 0 entrée est reçue * /

Ici, dans le code ci-dessus, nous avons commencé par inclure la bibliothèque série Bluetooth pour ESP32. Ensuite, nous avons inclus des fonctions de bibliothèque série Bluetooth qui permettront le Bluetooth ESP32.

La broche LED suivante 15 est initialisée et en utilisant le pinMode () La broche LED de fonction est définie comme sortie.

Dans la partie de boucle du code, le programme vérifiera la disponibilité des données Bluetooth en série. Si les données d'entrée sont 1 LED s'allument et si les données reçues sont 0 LED s'éteindront.

Une fois le code téléchargé. Bluetooth de la carte ESP32 s'allume et le message suivant apparaîtra sur le moniteur série:

Installation du terminal Bluetooth en série sur le smartphone

Nous avons besoin d'un périphérique Bluetooth qui peut envoyer des instructions à ESP32 afin que nous utiliserons un smartphone Android pour l'interfacer avec ESP32 Bluetooth. Tout d'abord, nous devons installer un terminal série dans un téléphone Android. Suivez les étapes ci-dessous pour interfacer le téléphone Android avec ESP32:

Étape 1: Ouvrez Google Play Store sur votre smartphone et recherchez Terminal Bluetooth en série. Installez l'application ci-dessous:

Étape 2: Après l'installation, ouvrez les paramètres Bluetooth du téléphone mobile. Recherchez Bluetooth ESP32 et cliquez pour commencer à le jumeler avec votre smartphone en cliquant sur Paire:

Étape 3: Après avoir tapé sur un Paire, Le téléphone mobile commencera à s'associer avec ESP32 Bluetooth:

Étape 4: Ouvrez maintenant l'application de terminal Bluetooth en série et allez à Dispositifs Dans le menu latéralement:

Étape 5: Une fois l'option de périphérique ouverte, il demandera des autorisations ou appuyez sur le RAFRAÎCHIR bouton dans le coin supérieur droit:

Étape 6: La fenêtre contextuelle suivante viendra cliquer sur Paramètres et permettre l'autorisation qu'il demande:

Étape 7: Maintenant, la carte ESP32 est prête à prendre des instructions sur Bluetooth. Sous Bluetooth Classic Option Sélectionnez la carte ESP32:

Étape 8: Une fois ESP32 sélectionné, il commencera à se connecter et en cas de succès, un Connecté Le message apparaîtra:

Étape 9: Maintenant, nous pouvons envoyer des instructions en la tapant ici. Taper 1 Et cliquez sur le bouton Envoyer, la LED sur la carte ESP32 s'allumera. De même, en tapant 0 LED s'éteindra:

De même, nous pouvons voir la sortie sur le moniteur en série de l'arduino IDE ce qu'il reçoit:

Sortir

LED s'allume après avoir envoyé 1:

LED s'éteint après avoir envoyé 0:

Note: Nous pouvons également configurer des boutons pour des instructions spécifiques comme indiqué dans l'image ci-dessous. Pour ce faire, cliquez sur les boutons et définissez la valeur que vous souhaitez. Ici, nous avons établi deux boutons un pour un haut et un autre pour un état bas. Vous pouvez également configurer ces raccourcis en valeurs hexadécimales.

2: ESP32 Bluetooth Low Energy (BLE) avec Arduino IDE

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 la pression artérielle, la sécurité et la domotique. 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 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.

Serveur et client

Bluetooth Low Energy prend en charge l'appareil de deux manières différentes en raison de laquelle 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 ensemble é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 a plus d'un 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, le type, la lecture, l'écriture et les notifications.
• Valeur caractéristique: Valeur de données des caractéristiques.

Uuid: UUID (identifiant universellement unique) est donné à chaque service et 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-56048FD88B25

Un 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 une carte 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 ();
// Bleadvertizing * Padvertinging = Pserver-> getAdvertising (); // Cela fonctionne toujours pour une compatibilité en arrière
BleadVertising * Padvertising = BledEvice :: GetAdvertising ();
Padvertinging-> addServiceUuid (service_uuid);
Padvertinging-> setScanResponse (true);
Padvertinging-> setMinPreferred (0x06); // Fonctions qui aident le problème des connexions iPhone
Padvertinging-> setMinPreferred (0x12);
Bledevice :: startAdvertise ();
En série.println ("caractéristique définie! BLE Server prêt ");

VOID LOOP ()
// Mettez votre code principal ici, pour exécuter à plusieurs reprises:
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 périphérique BLE nommé ESP32 et après cela, nous avons défini le périphérique BLE comme un serveur à l'aide du 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

Le code donné sera utilisé dans la carte scanner ESP32. Ouvrez IDE et téléchargez le code, n'oubliez pas de déconnecter d'autres cartes avant de télécharger le code du 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); // Le scan actif utilise plus de puissance, mais obtenez des résultats plus rapidement
PBLESCAN-> SetInterval (100);
PBLESCAN-> SetWindow (99); // Valeur SetInterval moins ou égale

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 du tampon de canne pour libérer la mémoire
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 Le 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.cpp

Se 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 (std :: paire(annoncé ADADRESS.toString (), annoncedDevice));
omniflélele = false;

Test du serveur ESP32 BLE avec téléphone intelligent

La plupart des smartphones modernes fonctionnent avec la technologie BLE pour communiquer avec différents appareils tels que la smartwatch, les appareils portables, les capteurs et autres appareils domestiques. Ici ESP32 est un point d'accès pour les appareils. 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é comme mentionné dans l'image ci-dessous:

Étape 6: Pour écrire toute nouvelle valeur caractéristique Cliquez W:

Étape 7: Une nouvelle fenêtre contextuelle apparaîtra ici où nous pourrons écrire n'importe quelle valeur caractéristique et cliquer D'accord:

Étape 8: La nouvelle valeur écrite apparaîtra comme indiqué dans l'image:

É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 deux Bluetooth qui sont Bluetooth Classic et Bluetooth Low Energy. Ici, dans cet article, nous avons discuté à la fois Bluetooth Classic et BLE et ses diverses applications et fonctionnant. Bluetooth Classic est utilisé pour un transfert de données élevé tandis que BLE (Bluetooth Low Energy) est utilisé pour de courtes distances avec moins de fonctions d'alimentation. Cet article donne un guide ultime du travail Bluetooth de la carte ESP32 et comment les configurer.