Regarder sur YouTube

Tutoriel ESP32 37/55 - Utiliser l'application Bluetooth avec ESP32 BLE | Kit d'apprentissage IoT ESP32 de SunFounder

Dans ce tutoriel, nous explorerons comment utiliser l'ESP32 en tant que serveur Bluetooth pour envoyer et recevoir des messages d'une application mobile. Cela permet une communication interactive entre votre carte ESP32 et votre appareil mobile, ce qui en fait un ajout polyvalent à vos projets IoT. À la fin de cette leçon, vous serez en mesure d'envoyer du texte de votre appareil mobile à l'ESP32 et de le voir affiché sur le moniteur série.

Nous utiliserons l'application LightBlue Explorer, disponible à la fois sur iOS et Android, pour communiquer avec l'ESP32. Ce tutoriel est fondamental pour comprendre la communication Bluetooth Low Energy (BLE) et prépare le terrain pour des projets plus avancés. Pour un guide visuel, veuillez vous référer à la vidéo à (dans la vidéo à 02:00).

Matériel expliqué

Le composant principal de ce projet est le microcontrôleur ESP32, qui intègre à la fois des capacités Wi-Fi et Bluetooth. Cela permet à l'ESP32 d'agir en tant que serveur, recevant et envoyant des données sans fil. La fonctionnalité Bluetooth intégrée de l'ESP32 prend en charge le BLE, ce qui le rend efficace pour les applications à faible consommation d'énergie.

En plus de l'ESP32, nous utiliserons un appareil mobile avec l'application LightBlue installée. Cette application permet aux utilisateurs de se connecter à l'ESP32 et d'envoyer des données via Bluetooth. L'intégration de ces composants permet une communication fluides entre l'ESP32 et les appareils mobiles, améliorant l'interaction utilisateur.

Détails de la fiche technique

• Assurez une alimentation électrique stable (3,3 V) pour éviter les baisses de tension.
• Utilisez des condensateurs pour le découplage près des broches d'alimentation.
• Maintenez une dissipation thermique adéquate si vous utilisez un courant élevé.
• Soyez prudent avec les niveaux de tension des broches GPIO ; elles tolèrent 3,3 V.
• Utilisez des résistances pull-up ou pull-down selon les besoins pour les configurations GPIO.
• Surveillez les connexions BLE ; assurez-vous que l'application est correctement appariée.
• Vérifiez que les UUID des services et des caractéristiques sont uniques.
• Vérifiez régulièrement le moniteur série pour les messages de débogage.
• Envisagez d'utiliser un analyseur logique pour le dépannage de signaux complexes.

Instructions de câblage

Le câblage pour ce projet est simple puisque l'ESP32 se connecte principalement via USB pour l'alimentation et la programmation. Connectez l'ESP32 à votre ordinateur à l'aide d'un câble micro USB. Assurez-vous que le port USB fournit une puissance suffisante (typiquement 5 V). Le moniteur série sera utilisé pour le débogage, donc aucune connexion matérielle supplémentaire n'est nécessaire pour cette application.

Lors de l'utilisation de l'ESP32 avec des composants externes dans de futurs projets, n'oubliez pas de connecter les broches de masse à une masse commune. Cela garantit que l'ESP32 et tous les capteurs ou modules connectés partagent le même point de référence. De plus, si vous utilisez une batterie, connectez la borne positive à la broche 3.3 V et la borne négative à une broche de masse sur l'ESP32.

Exemples de code et guide étape par étape

Le code fourni initialise le serveur Bluetooth, configure les services et caractéristiques nécessaires, et gère les messages entrants. Les identifiants clés incluentbleName, qui définit le nom de l'appareil Bluetooth, etreceivedText, qui stocke le message entrant de l'application mobile.

const char *bleName = "ESP32_Bluetooth";
String receivedText = "";

Lesetup()La fonction initialise la communication série et la configuration BLE. Ceci est crucial pour établir une connexion avec l'application LightBlue.

void setup() {
  Serial.begin(115200);  // Initialize the serial port
  setupBLE();            // Initialize the Bluetooth BLE
}

Dans leloop()fonction, le code vérifie les messages entrants. Si un nouveau message est reçu, il est imprimé sur le moniteur série et une notification est envoyée à l'appareil BLE connecté.

if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
}

Pour une compréhension complète, reportez-vous au code complet qui se charge ci-dessous l'article. Cela vous fournira tous les détails nécessaires pour réaliser le projet avec succès.

Démonstration / À quoi s'attendre

Après une mise en œuvre réussie, vous devriez être en mesure d'envoyer des messages depuis l'application LightBlue vers l'ESP32. Au fur et à mesure que vous tapez un message, comme "Bonjour", il apparaîtra sur le moniteur série. De plus, vous pouvez envoyer des messages de retour vers l'application, confirmant la communication bidirectionnelle. Si vous rencontrez des problèmes tels que des messages qui n'apparaissent pas, assurez-vous que l'ESP32 est correctement appairé avec l'application et que les UUID correspondent.

Horodatages vidéo

• 00:00 Début
• 2:10 Introduction au projet
• 2:45 Page de documentation
• 4:04 code Arduino
• 6:31 Installation de l'application Bluetooth
• 7:12 Sélection du tableau ESP32 et du port COM
• 8:54 Démonstration du projet

Images

bluetooth_lightblue

bluetooth_lightblue

#include "BLEDevice.h"
#include "BLEServer.h"
#include "BLEUtils.h"
#include "BLE2902.h"

 // Définir le nom de l'appareil Bluetooth
const char *bleName = "ESP32_Bluetooth";

 // Définir le texte reçu et l'heure du dernier message.
String receivedText = "";
unsigned long lastMessageTime = 0;

 // Définir les UUID des services et des caractéristiques
#define SERVICE_UUID           "your_service_uuid_here"
#define CHARACTERISTIC_UUID_RX "your_rx_characteristic_uuid_here"
#define CHARACTERISTIC_UUID_TX "your_tx_characteristic_uuid_here"

 // Définir la caractéristique Bluetooth
BLECharacteristic *pCharacteristic;

void setup() {
  Serial.begin(115200); // Initialisez le port série
  setupBLE(); // Initialiser le Bluetooth BLE
}

void loop() {
 // Lorsque le texte reçu n'est pas vide et que le temps écoulé depuis le dernier message est supérieur à 1 seconde.
 // Envoyer une notification et imprimer le texte reçu
  if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
  }

 // Lire les données du port série et les envoyer à la caractéristique BLE.
  if (Serial.available() > 0) {
    String str = Serial.readStringUntil('\n');
    const char *newValue = str.c_str();
    pCharacteristic->setValue(newValue);
    pCharacteristic->notify();
  }
}

 // Définir les rappels du serveur BLE
class MyServerCallbacks : public BLEServerCallbacks {
 // Imprimez le message de connexion lorsqu'un client est connecté.
  void onConnect(BLEServer *pServer) {
    Serial.println("Connected");
  }
 // Imprimez le message de déconnexion lorsqu'un client est déconnecté.
  void onDisconnect(BLEServer *pServer) {
    Serial.println("Disconnected");
  }
};

 // Définir les rappels de caractéristiques BLE
class MyCharacteristicCallbacks : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) {
 // Lorsque des données sont reçues, récupérez les données et enregistrez-les dans receivedText, et notez l'heure.
    std::string value = std::string(pCharacteristic->getValue().c_str());
    receivedText = String(value.c_str());
    lastMessageTime = millis();
    Serial.print("Received: ");
    Serial.println(receivedText);
  }
};

 // Initialiser le Bluetooth BLE
void setupBLE() {
  BLEDevice::init(bleName); // Initialiser le dispositif BLE
  BLEServer *pServer = BLEDevice::createServer(); // Créez le serveur BLE
 // Imprimez le message d'erreur si la création du serveur BLE échoue.
  if (pServer == nullptr) {
    Serial.println("Error creating BLE server");
    return;
  }
  pServer->setCallbacks(new MyServerCallbacks()); // Définissez les rappels du serveur BLE.

 // Créer le service BLE
  BLEService *pService = pServer->createService(SERVICE_UUID);
 // Imprimer le message d'erreur si la création du service BLE échoue.
  if (pService == nullptr) {
    Serial.println("Error creating BLE service");
    return;
  }
 // Créez la caractéristique BLE pour l'envoi de notifications.
  pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
  pCharacteristic->addDescriptor(new BLE2902()); // Ajoutez le descripteur
 // Créer la caractéristique BLE pour recevoir des données
  BLECharacteristic *pCharacteristicRX = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
  pCharacteristicRX->setCallbacks(new MyCharacteristicCallbacks()); // Définir les rappels de caractéristiques BLE
  pService->start(); // Démarrer le service BLE
  pServer->getAdvertising()->start(); // Commencer la publicité
  Serial.println("Waiting for a client connection..."); // Attendre une connexion client
}