L’ESP32 est livré non seulement avec le Wi-Fi, mais également avec Bluetooth et Bluetooth Low Energy (BLE). Cet article est une introduction rapide au BLE avec l’ESP32. Tout d’abord, nous explorerons ce qu’est le BLE et à quoi il peut être utilisé, puis nous examinerons quelques exemples avec l’ESP32 utilisant l’IDE Arduino. Pour une introduction simple, nous allons créer un serveur ESP32 BLE et un scanner ESP32 BLE pour trouver ce serveur.
Mis à jour le 11 juin 2024
Présentation du Bluetooth Low Energy
Pour une introduction rapide à BLE, vous pouvez regarder la vidéo ci-dessous ou faire défiler vers le bas pour une explication écrite.
Lecture recommandée : découvrez comment utiliser l’ESP32 Bluetooth Classic avec l’IDE Arduino pour échanger des données entre un ESP32 et un smartphone Android.
Qu’est-ce que le Bluetooth Low Energy ?
Bluetooth Low Energy, BLE en abrégé, est une variante de Bluetooth économe en énergie. La principale application du BLE est la transmission à courte distance de petites quantités de données (faible bande passante). Contrairement au Bluetooth qui est toujours activé, BLE reste constamment en mode veille, sauf lorsqu’une connexion est établie.
Cela fait qu’il consomme très peu d’énergie. BLE consomme environ 100 fois moins d’énergie que Bluetooth (selon le cas d’utilisation).
De plus, BLE prend en charge non seulement la communication point à point, mais également le mode diffusion et le réseau maillé.
Jetez un œil au tableau ci-dessous qui compare plus en détail BLE et Bluetooth Classic.
Voir la source de l’image
En raison de ses propriétés, BLE convient aux applications qui doivent échanger périodiquement de petites quantités de données sur une pile bouton. Par exemple, BLE est d’une grande utilité dans les secteurs de la santé, du fitness, du suivi, des balises, de la sécurité et de la domotique.
Serveur et client BLE
Avec Bluetooth Low Energy, il existe deux types d’appareils : le serveur et le client. L’ESP32 peut agir soit en tant que client, soit en tant que serveur.
Le serveur annonce son existence afin qu’il puisse être trouvé par d’autres appareils et contient les données que le client peut lire. Le client analyse les appareils à proximité et lorsqu’il trouve le serveur qu’il recherche, il établit une connexion et écoute les données entrantes. C’est ce qu’on appelle la communication point à point.
Comme mentionné précédemment, BLE prend également en charge le mode diffusion et le réseau maillé :
- Mode diffusion : le serveur transmet les données à de nombreux clients connectés ;
- Réseau maillé : tous les appareils sont connectés, il s’agit d’une connexion plusieurs à plusieurs.
Même si les configurations de réseau de diffusion et maillé sont possibles à mettre en œuvre, elles ont été développées très récemment, il n’y a donc pas beaucoup d’exemples implémentés pour l’ESP32 pour le moment.
GATT
GATT signifie Generic Attributes et définit une structure de données hiérarchique qui est exposée aux appareils BLE connectés. Cela signifie que le GATT définit la manière dont deux appareils BLE envoient et reçoivent des messages standard. Comprendre cette hiérarchie est important, car cela permettra de comprendre plus facilement comment utiliser le BLE et écrire vos applications.
Service BLE
Le niveau supérieur de la hiérarchie est un profil composé d’un ou plusieurs services. Habituellement, un appareil BLE contient plusieurs services.
Chaque service contient au moins une caractéristique, ou peut également référencer d’autres services. Un service est simplement une collection d’informations, comme les relevés de capteurs, par exemple.
Il existe des services prédéfinis pour plusieurs types de données définies par le SIG (Bluetooth Special Interest Group) comme : Niveau de batterie, Tension artérielle, Fréquence cardiaque, Balance de poids, etc. Vous pouvez consulter ici d’autres services définis.
Voir la source de l’image
Caractéristique BLE
La caractéristique appartient toujours à un service et c’est là que les données réelles sont contenues dans la hiérarchie (valeur). La caractéristique a toujours deux attributs : la déclaration de caractéristique (qui fournit des métadonnées sur les données) et la valeur de la caractéristique.
De plus, la valeur caractéristique peut être suivie de descripteurs, qui développent davantage les métadonnées contenues dans la déclaration de caractéristique.
Les propriétés décrivent comment interagir avec la valeur caractéristique. Fondamentalement, il contient les opérations et procédures pouvant être utilisées avec la caractéristique :
- Diffuser
- Lire
- Écrire sans réponse
- Écrire
- Notifier
- Indiquer
- Écritures signées authentifiées
- Propriétés étendues
UUID
Chaque service, caractéristique et descripteur possède un UUID (Universally Unique Identifier). Un UUID est un numéro unique de 128 bits (16 octets). Par exemple:
55072829-bc9e-4c53-938a-74a6d4c78776
Il existe des UUID abrégés pour tous les types, services et profils spécifiés dans le SIG (Bluetooth Special Interest Group).
Mais si votre application a besoin de son propre UUID, vous pouvez le générer à l’aide de ce site Web générateur d’UUID.
En résumé, l’UUID est utilisé pour identifier les informations de manière unique. Par exemple, il peut identifier un service particulier fourni par un appareil Bluetooth.
BLE avec ESP32
L’ESP32 peut agir comme serveur BLE ou comme client BLE. Il existe plusieurs exemples BLE pour l’ESP32 dans la bibliothèque ESP32 BLE pour Arduino IDE. Cette bibliothèque est installée par défaut lorsque vous installez l’ESP32 sur l’IDE Arduino.
Remarque : vous devez avoir installé le module complémentaire ESP32 sur l’IDE Arduino. Suivez le didacticiel suivant pour préparer votre IDE Arduino à fonctionner avec l’ESP32, si ce n’est pas déjà fait.
Dans votre IDE Arduino, vous pouvez accéder à Fichier > Exemples > BLE et explorer les exemples fournis avec la bibliothèque BLE.
Remarque : pour voir les exemples ESP32, vous devez avoir sélectionné la carte ESP32 dans Outils > Carte.
Pour une brève introduction à l’ESP32 avec BLE sur l’IDE Arduino, nous allons créer un serveur ESP32 BLE, puis un scanner ESP32 BLE pour trouver ce serveur. Nous utiliserons et expliquerons les exemples fournis avec la bibliothèque BLE.
Pour suivre cet exemple, vous avez besoin de deux cartes de développement ESP32. Nous utiliserons la carte ESP32 DOIT DEVKIT V1.
Serveur ESP32BLE
Pour créer un serveur ESP32 BLE, ouvrez votre IDE Arduino et accédez à Fichier > Exemples > BLE et sélectionnez l’exemple de serveur. Le code suivant devrait se charger :
/*
Complete Getting Started Guide: https://Raspberryme.com/esp32-bluetooth-low-energy-ble-arduino-ide/
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleServer.cpp
Ported to Arduino ESP32 by Evandro Copercini
*/
#include
#include
#include
// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
void setup() {
Serial.begin(115200);
Serial.println("Starting BLE work!");
BLEDevice::init("MyESP32");
BLEServer *pServer = BLEDevice::createServer();
BLEService *pService = pServer->createService(SERVICE_UUID);
BLECharacteristic *pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE
);
pCharacteristic->setValue("Hello World says Neil");
pService->start();
// BLEAdvertising *pAdvertising = pServer->getAdvertising(); // this still is working for backward compatibility
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID(SERVICE_UUID);
pAdvertising->setScanResponse(true);
pAdvertising->setMinPreferred(0x06); // functions that help with iPhone connections issue
pAdvertising->setMinPreferred(0x12);
BLEDevice::startAdvertising();
Serial.println("Characteristic defined! Now you can read it in your phone!");
}
void loop() {
// put your main code here, to run repeatedly:
delay(2000);
}
Afficher le code brut
Pour créer un serveur BLE, le code doit suivre les étapes suivantes :
- Créez un serveur BLE. Dans ce cas, l’ESP32 fait office de serveur BLE.
- Créez un service BLE.
- Créez une caractéristique BLE sur le service.
- Créez un descripteur BLE sur la caractéristique.
- Démarrez le service.
- Lancez une publicité afin qu’elle puisse être trouvée par d’autres appareils.
Comment fonctionne le code
Jetons un coup d’œil rapide au fonctionnement de l’exemple de code du serveur BLE.
Cela commence par importer les bibliothèques nécessaires pour les fonctionnalités BLE.
#include
#include
#include Ensuite, vous devez définir un UUID pour le service et la caractéristique.
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"Vous pouvez laisser les UUID par défaut ou accéder à uuidgenerator.net pour créer des UUID aléatoires pour vos services et caractéristiques.
Dans setup(), il démarre la communication série à un débit en bauds de 115 200.
Serial.begin(115200);Ensuite, vous créez un appareil BLE appelé « MyESP32 ». Vous pouvez changer ce nom comme vous le souhaitez.
// Create the BLE Device
BLEDevice::init("MyESP32");Dans la ligne suivante, vous définissez le périphérique BLE comme serveur.
BLEServer *pServer = BLEDevice::createServer();Après cela, vous créez un service pour le serveur BLE avec l’UUID défini précédemment.
BLEService *pService = pServer->createService(SERVICE_UUID);Ensuite, vous définissez les caractéristiques de ce service. Comme vous pouvez le constater, vous utilisez également l’UUID défini précédemment et vous devez passer en arguments les propriétés de la caractéristique. Dans ce cas, c’est : LIRE et ÉCRIRE.
BLECharacteristic *pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE
);Après avoir créé la caractéristique, vous pouvez définir sa valeur avec la méthode setValue().
pCharacteristic->setValue("Hello World says Neil");Dans ce cas, nous définissons la valeur sur le texte « Hello World dit Neil ». Vous pouvez modifier ce texte comme bon vous semble. Dans les projets futurs, ce texte pourra être une lecture d’un capteur, ou l’état d’une lampe, par exemple.
Enfin, vous pouvez démarrer le service et la publicité afin que d’autres appareils BLE puissent scanner et trouver cet appareil BLE.
BLEAdvertising *pAdvertising = pServer->getAdvertising();
pAdvertising->start();Ceci est juste un exemple simple sur la façon de créer un serveur BLE. Dans ce code, rien n’est fait dans la boucle(), mais vous pouvez ajouter ce qui se passe lorsqu’un nouveau client se connecte (consultez l’exemple Notify pour obtenir des conseils).
Scanner ESP32 BLE
Créer un scanner ESP32 BLE est simple. Prenez un autre ESP32 (pendant que l’autre exécute le croquis du serveur BLE). Dans votre IDE Arduino, accédez à Fichier > Exemples > BLE et sélectionnez l’exemple Scan. Le code suivant devrait se charger.
/*
Complete Getting Started Guide: https://Raspberryme.com/esp32-bluetooth-low-energy-ble-arduino-ide/
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
Ported to Arduino ESP32 by Evandro Copercini
*/
#include
#include
#include
#include
int scanTime = 5; // in seconds
BLEScan* pBLEScan;
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
void onResult(BLEAdvertisedDevice advertisedDevice) {
Serial.printf("Advertised Device: %s \n", advertisedDevice.toString().c_str());
}
};
void setup() {
Serial.begin(115200);
Serial.println("Scanning...");
BLEDevice::init("");
pBLEScan = BLEDevice::getScan(); //create new scan
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
pBLEScan->setInterval(100);
pBLEScan->setWindow(99); // less or equal setInterval value
}
void loop() {
// put your main code here, to run repeatedly:
BLEScanResults *foundDevices = pBLEScan->start(scanTime, false);
Serial.print("Devices found: ");
Serial.println(foundDevices->getCount());
Serial.println("Scan done!");
pBLEScan->clearResults(); // delete results fromBLEScan buffer to release memory
delay(2000);
}
Afficher le code brut
Ce code initialise l’ESP32 en tant que périphérique BLE et recherche les appareils à proximité. Téléchargez ce code sur votre ESP32. Vous souhaiterez peut-être déconnecter temporairement l’autre ESP32 de votre ordinateur, afin d’être sûr de télécharger le code sur la bonne carte ESP32.
Une fois le code téléchargé et les deux cartes ESP32 devraient être allumées :
- Un ESP32 avec le croquis « BLE_server » ;
- Autre avec le croquis ESP32 « BLE_scan ».
Accédez au moniteur série avec l’ESP32 exécutant l’exemple « BLE_scan », appuyez sur le bouton ENABLE de l’ESP32 (avec le croquis « BLE_scan ») pour redémarrer et attendez quelques secondes pendant l’analyse.
Le scanner a trouvé deux appareils : l’un est l’ESP32 (il porte le nom « MyESP32 ») et l’autre est une montre intelligente.
Test du serveur ESP32 BLE avec votre smartphone
La plupart des smartphones modernes devraient avoir des capacités BLE. J’utilisais un OnePlus, mais la plupart des smartphones devraient également fonctionner.
Vous pouvez scanner votre serveur ESP32 BLE avec votre smartphone et voir ses services et caractéristiques. Pour cela, nous utiliserons une application gratuite appelée nRF Connect for Mobile de Nordic, elle fonctionne sur Android (Google Play Store) et iOS (App Store).
Accédez à Google Play Store ou App Store et recherchez « nRF Connect for Mobile ». Installez l’application et ouvrez-la.
N’oubliez pas d’aller dans les paramètres Bluetooth et d’activer l’adaptateur Bluetooth sur votre smartphone. Vous souhaiterez peut-être également le rendre visible sur d’autres appareils pour tester d’autres croquis ultérieurement.
Une fois que tout est prêt sur votre smartphone et que l’ESP32 exécute le croquis du serveur BLE, dans l’application, appuyez sur le bouton de numérisation pour rechercher les appareils à proximité. Vous devriez trouver un ESP32 avec le nom « MyESP32 ».
Cliquez sur le bouton « Connecter ».
Comme vous pouvez le voir sur la figure ci-dessous, l’ESP32 dispose d’un service avec l’UUID que vous avez défini précédemment. Si vous appuyez sur le service, il développe le menu et affiche la caractéristique avec l’UUID que vous avez également défini.
La caractéristique possède les propriétés READ et WRITE et la valeur est celle que vous avez précédemment définie dans l’esquisse du serveur BLE. Donc tout fonctionne bien.
Conclusion
Dans ce tutoriel, nous vous avons montré les principes de base du Bluetooth Low Energy et vous avons montré quelques exemples avec l’ESP32. Nous avons exploré le croquis du serveur BLE et le croquis du scan BLE. Ce sont des exemples simples pour vous aider à démarrer avec BLE.
L’idée est d’utiliser BLE pour envoyer ou recevoir des lectures de capteurs provenant d’autres appareils.
Autres didacticiels liés au Bluetooth qui pourraient vous plaire :
Ceci est un extrait de notre cours : Apprenez l’ESP32 avec l’IDE Arduino. Si vous aimez l’ESP32 et que vous souhaitez en savoir plus, nous vous recommandons de vous inscrire au cours Apprendre l’ESP32 avec l’IDE Arduino.
Vous aimerez peut-être aussi lire :
Merci d’avoir lu.
Cette vidéo vous emmène dans l’histoire de Raspberry Pi :
-
ELEGOO 2PCS ESP-32 Carte de Développement Type-C, 2,4 GHz WiFi + Bluetooth -
Lot de 4 Carte Développement ESP32-C3, Module ESP32-C3 Mini, WiFi 2,4GHz et Bluetooth 5.0 Le, Processeur RISC-V 32 Bits 160MHz, pour Arduino MicroPython, IoT Maison Intelligente Réseau de Capteurs