Serveur d'impression

ESP32 Bluetooth Low Energy (BLE) sur Arduino IDE – Serveur d’impression

Le 15 octobre 2019 - 14 minutes de lecture

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 à BLE avec l’ESP32. Dans un premier temps, nous explorerons ce qui est BLE et comment il peut être utilisé, puis nous examinerons quelques exemples avec l’ESP32 utilisant Arduino IDE. Pour une introduction simple, nous allons créer un serveur ESP32 BLE et un scanner ESP32 BLE pour trouver ce serveur.

Présentation de Bluetooth Low Energy

Pour une introduction rapide à BLE, vous pouvez regarder la vidéo ci-dessous ou vous pouvez faire défiler l'écran pour une explication écrite.

Lecture recommandée: Apprenez à utiliser l'ESP32 Bluetooth Classic avec Arduino IDE pour échanger des données entre un smartphone ESP32 et un smartphone Android.

Qu'est-ce que Bluetooth Low Energy?

Bluetooth Low Energy, en abrégé BLE, est une variante de Bluetooth à économie d'énergie. La principale application de BLE est la transmission à courte distance de petites quantités de données (faible bande passante). Contrairement à Bluetooth toujours activé, BLE reste 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 de diffusion et le réseau maillé.

Regardez le tableau ci-dessous qui compare BLE et Bluetooth Classic de manière plus détaillée.

Voir l'image Souce

En raison de ses propriétés, BLE convient aux applications qui doivent échanger de petites quantités de données fonctionnant périodiquement sur une pile bouton. Par exemple, BLE est très utile dans les secteurs de la santé, de la forme physique, du suivi, des balises, de la sécurité et de la domotique.

BLE Server et Client

Avec Bluetooth Low Energy, il existe deux types de périphériques: le serveur et le client. L'ESP32 peut agir en tant que client ou en tant que serveur.

Le serveur annonce son existence afin qu'il puisse être trouvé par d'autres périphériques et contient les données que le client peut lire. Le client analyse les périphériques à proximité et, lorsqu'il trouve le serveur recherché, il établit une connexion et écoute les données entrantes. Cela s'appelle une communication point à point.

Comme mentionné précédemment, BLE prend également en charge le mode de diffusion et le réseau maillé:

  • Mode de diffusion: le serveur transmet les données à plusieurs 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 de maillage sont possibles à mettre en œuvre, elles ont été développées très récemment. Il n’ya donc pas beaucoup d’exemples mis en œuvre pour l’ESP32 pour le moment.

GATT

GATT est synonyme d'attributs génériques et définit une structure de données hiérarchique exposée aux périphériques BLE connectés. Cela signifie que le GATT définit la manière dont deux appareils BLE envoient et reçoivent des messages standard. Il est important de comprendre cette hiérarchie, car cela facilitera la compréhension de l’utilisation de BLE et de l’écriture de vos applications.

Service BLE

Le niveau supérieur de la hiérarchie est un profil, composé d'un ou de plusieurs services. En règle générale, un périphérique BLE contient plusieurs services.

Chaque service contient au moins une caractéristique ou peut également faire référence à d'autres services. Un service est simplement un ensemble d'informations, comme des lectures de capteurs, par exemple.

Il existe des services prédéfinis pour plusieurs types de données définis par le SIG (groupe d'intérêt spécial Bluetooth), tels que: Niveau de la batterie, Pression artérielle, Fréquence cardiaque, Pèse-personne, etc. Vous pouvez consulter ici d'autres services définis.

Voir l'image Souce

BLE Caractéristique

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 la caractéristique (qui fournit des métadonnées sur les données) et la valeur de la caractéristique.

De plus, la valeur de 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 la valeur de caractéristique peut être interagie. Fondamentalement, il contient les opérations et les procédures pouvant être utilisées avec la caractéristique:

  • Diffuser
  • Lis
  • Écrire sans réponse
  • Écrire
  • Notifier
  • Indiquer
  • Écrit Signé Authentifié
  • Propriétés étendues

UUID

Chaque service, caractéristique et descripteur possède un UUID (identificateur unique universel). Un UUID est un numéro unique de 128 bits (16 octets). Par exemple:

55072829-bc9e-4c53-938a-74a6d4c78776

Il existe des UUID raccourcis pour tous les types, services et profils spécifiés dans le SIG (groupe d'intérêt spécial Bluetooth).

Mais si votre application a besoin de son propre UUID, vous pouvez le générer à l'aide de ce site Web de 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 périphérique Bluetooth.

BLE avec ESP32

L'ESP32 peut agir en tant que serveur BLE ou en tant que 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’EDI Arduino.

Remarque: Le module complémentaire ESP32 doit être installé sur l'IDE Arduino. Suivez l’un des prochains tutoriels pour préparer votre IDE Arduino à fonctionner avec l’ESP32, si ce n’est déjà fait.

Dans votre IDE Arduino, vous pouvez aller sur Fichier > Exemples > ESP32 BLE Arduino et explorez les exemples fournis avec la bibliothèque BLE.

Remarque: pour voir les exemples ESP32, vous devez avoir sélectionné la carte ESP32 sur Outils > Planche.

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 allons utiliser et expliquer les exemples fournis avec la bibliothèque BLE.

Pour suivre cet exemple, vous avez besoin de deux cartes de développement ESP32. Nous allons utiliser la carte ESP32 DOIT DEVKIT V1.

Serveur ESP32 BLE

Pour créer un serveur ESP32 BLE, ouvrez votre IDE Arduino et accédez à Fichier > Exemples > ESP32 BLE Arduino et sélectionnez le Serveur BLE exemple. Le code suivant devrait charger:

/ *
    D'après l'exemple de Neil Kolban pour IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleServer.cpp
    Porté sur Arduino ESP32 par Evandro Copercini
    mises à jour par chegewara
* /

#comprendre 
#comprendre 
#comprendre 

// Voir ce qui suit pour générer des UUID:
// https://www.uuidgenerator.net/

#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

void setup() 
                                         BLECaractéristique :: PROPERTY_WRITE
                                       )

  pCharacteristic-> setValue ("Bonjour le monde dit Neil");
  pService-> start ();
  // BLEAdvertising * pAdvertising = pServer-> getAdvertising (); // cela fonctionne toujours pour la compatibilité ascendante
  BLEAdvertising * pAdvertising = BLEDevice :: getAdvertising ();
  pAdvertising-> addServiceUUID (SERVICE_UUID);
  pAdvertising-> setScanResponse (true);
  pAdvertising-> setMinPreferred (0x06); // fonctions qui aident avec le problème des connexions iPhone
  pAdvertising-> setMinPreferred (0x12);
  BLEDevice :: startAdvertising ();
  Serial.println ("Caractéristique définie! Vous pouvez maintenant la lire dans votre téléphone!");


boucle vide () 
  // mettez votre code principal ici, pour exécuter à plusieurs reprises:
  délai (2000);

Voir le code brut

Pour créer un serveur BLE, le code doit suivre les étapes suivantes:

  1. Créez un serveur BLE. Dans ce cas, l'ESP32 agit en tant que serveur BLE.
  2. Créer un service BLE.
  3. Créer une caractéristique BLE sur le service.
  4. Créez un descripteur BLE sur la caractéristique.
  5. Démarrer le service.
  6. Commencez la publicité pour qu'elle puisse être trouvée par d'autres appareils.

Comment fonctionne le code

Jetons un coup d’œil sur le fonctionnement de l’exemple de code de serveur BLE.

Il commence par importer les bibliothèques nécessaires aux capacités BLE.

#comprendre 
#comprendre 
#comprendre 

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 vous rendre sur uuidgenerator.net pour créer des UUID aléatoires pour vos services et caractéristiques.

dans le installer(), la communication série commence à un débit en bauds de 115200.

Serial.begin (115200);

Ensuite, vous créez un périphérique BLE appelé “MyESP32”. Vous pouvez changer ce nom en ce que vous voulez.

// Créer le périphérique BLE
BLEDevice :: init ("MyESP32");

Dans la ligne suivante, vous définissez le périphérique BLE en tant que serveur.

BLEServer * pServer = BLEDevice :: createServer ();

Ensuite, 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 la caractéristique pour ce service. Comme vous pouvez le constater, vous utilisez également l’UUID défini précédemment et vous devez transmettre en tant qu’arguments les propriétés de la caractéristique. Dans ce cas, c’est: LIRE et ÉCRIRE.

BLECharacteristic * pCharacteristic = pService-> createCharacteristic (
                                     CHARACTERISTIC_UUID,
                                     BLECaractéristique :: PROPERTY_READ |
                                     BLECaractéristique :: PROPERTY_WRITE
                                     )

Après avoir créé la caractéristique, vous pouvez définir sa valeur avec setValue () méthode.

pCharacteristic-> setValue ("Bonjour le monde dit Neil");

Dans ce cas, nous définissons la valeur sur le texte «Hello World dit Neil». Vous pouvez changer ce texte comme bon vous semble. Dans les projets futurs, ce texte peut être une lecture de capteur, ou l'état d'une lampe, par exemple.

Enfin, vous pouvez démarrer le service et la publicité afin que d'autres périphériques BLE puissent analyser et trouver ce périphérique BLE.

BLEAdvertising * pAdvertising = pServer-> getAdvertising ();
pPublicité-> 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 le boucle(), mais vous pouvez ajouter ce qui se passe lorsqu’un nouveau client se connecte (consultez l’exemple BLE_notify pour obtenir des conseils).

ESP32 BLE Scanner

Créer un scanner ESP32 BLE est simple. Saisissez un autre ESP32 (pendant que l'autre exécute l'esquisse du serveur BLE). Dans votre IDE Arduino, accédez à Fichier> Exemples > ESP32 BLE Arduino et sélectionnez le BLE_scan exemple. Le code suivant devrait charger.

/ *
   D'après l'exemple de Neil Kolban pour IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
   Porté sur Arduino ESP32 par Evandro Copercini
* /

#comprendre 
#comprendre 
#comprendre 
#comprendre 

int scanTime = 5; //En secondes
BLEScan * pBLEScan;

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks 
    void onResult (BLEAdvertisedDevice annoncisedDevice) 
      Serial.printf ("Appareil annoncé:% s  n", advertisedDevice.toString (). C_str ());
    
;

void setup() 
  Serial.begin (115200);
  Serial.println ("Numérisation ...");

  BLEDevice :: init ("");
  pBLEScan = BLEDevice :: getScan (); // créer un nouveau scan
  pBLEScan-> setAdvertisedDeviceCallbacks (new MyAdvertisedDeviceCallbacks ());
  pBLEScan-> setActiveScan (true); // l'analyse active consomme plus d'énergie, mais permet d'obtenir des résultats plus rapidement
  pBLEScan-> setInterval (100);
  pBLEScan-> setWindow (99); // valeur inférieure ou égale à setInterval


boucle vide () 
  // mettez votre code principal ici, pour exécuter à plusieurs reprises:
  BLEScanResults foundDevices = pBLEScan-> start (scanTime, false);
  Serial.print ("Périphériques trouvés:");
  Serial.println (foundDevices.getCount ());
  Serial.println ("Scan done!");
  pBLEScan-> clearResults (); // efface les résultats de la mémoire tampon BLEScan pour libérer de la mémoire
  délai (2000);

Voir le code brut

Ce code initialise l'ESP32 en tant que périphérique BLE et recherche les périphériques à proximité. Téléchargez ce code sur votre ESP32. Vous voudrez 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 chargé, vous devez allumer les deux cartes ESP32:

  • Un ESP32 avec le schéma “BLE_server”;
  • Autre avec esquisse ESP32 «BLE_scan».

Accédez au moniteur série avec l’ESP32 exécutant l’exemple «BLE_scan», appuyez sur le bouton «ESP32» (avec l’esquisse «BLE_scan») pour redémarrer et attendez quelques secondes pendant la numérisation.

Le scanner a trouvé deux périphériques: l’un est l’ESP32 (il porte le nom «MyESP32), et l'autre est notre MiBand2.

Test du serveur ESP32 BLE avec votre smartphone

La plupart des smartphones modernes devraient avoir des capacités BLE. J'utilise actuellement un OnePlus 5, mais la plupart des smartphones devraient également fonctionner.

Vous pouvez numériser votre serveur ESP32 BLE avec votre smartphone et voir ses services et ses caractéristiques. Pour cela, nous utiliserons une application gratuite appelée nRF Connect pour mobile de Nordic, cela fonctionne sur Android (Google Play Store) et iOS (App Store).

Accédez au Google Play Store ou à l'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 pouvez également vouloir le rendre visible à d'autres périphériques pour tester d'autres esquisses ultérieurement.

Une fois que tout est prêt dans votre smartphone et que l'ESP32 exécute l'esquisse du serveur BLE, dans l'application, appuyez sur le bouton Rechercher pour rechercher les appareils à proximité. Vous devriez trouver un ESP32 avec le nom “MyESP32”.

Clique le "Relier" bouton.

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, le menu s’agrandit et affiche la caractéristique avec l’UUID que vous avez également défini.

La caractéristique a 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.

Emballer

Dans ce tutoriel, nous vous avons montré les principes de base de Bluetooth Low Energy et quelques exemples avec l’ESP32. Nous avons exploré l’esquisse du serveur BLE et l’esquisse de numérisation 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 d'autres appareils. Nous publierons davantage de tutoriels et de projets sur BLE avec l’ESP32, alors restez branchés!

Voici un extrait de notre cours: Apprenez l’ESP32 avec Arduino IDE. Si vous aimez ESP32 et que vous souhaitez en savoir plus à ce sujet, nous vous recommandons de vous inscrire au cours Learn ESP32 with Arduino IDE.

Vous pourriez aussi aimer lire:

Merci d'avoir lu.

Mis à jour le 16 mai 2019

Commentaires

Laisser un commentaire

Votre commentaire sera révisé par les administrateurs si besoin.