ESP32 Chat Bluetooth - Interface de messagerie bidirectionnelle
Aperçu
L'exemple Chat Bluetooth permet la messagerie bidirectionnelle entre votre ESP32 et un smartphone via l'application DIYables Bluetooth STEM. Conçu pour les cartes ESP32 avec support pour les connexions BLE (Bluetooth Low Energy) et Bluetooth Classique. Envoyez et recevez des messages texte en temps réel, implémentez la gestion de commandes personnalisées, et créez un pont entre le Moniteur Série et Bluetooth — parfait pour le débogage, le contrôle à distance, et les projets interactifs.
Cet exemple supporte deux modes Bluetooth :
- ESP32 BLE (Bluetooth Low Energy) : Fonctionne sur Android et iOS
- ESP32 Bluetooth Classique : Fonctionne sur Android uniquement. iOS ne supporte pas le Bluetooth Classique. Utilisez BLE si vous avez besoin du support iOS.
Fonctionnalités
- Messagerie bidirectionnelle : Envoyez et recevez des messages texte en temps réel
- Mode écho : Renvoie automatiquement les messages reçus vers l'application
- Gestion des commandes : Traite des commandes texte personnalisées (ping, status, time, heap)
- Messages périodiques : Envoie des mises à jour de statut automatiques à intervalles configurables
- Pont Serial-to-Bluetooth : Tapez des messages dans le Moniteur Série et envoyez-les vers l'application
- BLE et Bluetooth Classique : Choisissez le mode Bluetooth qui convient à votre projet
- Multiplateforme : Le mode BLE fonctionne sur Android et iOS ; le Bluetooth Classique fonctionne sur Android
- Option basse consommation : Le mode BLE consomme moins d'énergie que le Bluetooth Classique
Matériel requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
Code ESP32
Étapes rapides
Suivez ces instructions étape par étape :
- Si c'est votre première fois avec l'ESP32, consultez le tutoriel sur Installation du logiciel ESP32..
- Nouveau sur ESP32 ? Commencez par notre guide ESP32 Getting Started pour apprendre les bases.
- Connectez la carte ESP32 à votre ordinateur avec un câble USB.
- Lancez Arduino IDE sur votre ordinateur.
- Sélectionnez la carte ESP32 appropriée et le port COM.
- Naviguez vers l'icône Bibliothèques dans la barre de gauche d'Arduino IDE.
- Recherchez "DIYables Bluetooth", puis trouvez la bibliothèque DIYables Bluetooth par DIYables
- Cliquez sur le bouton Installer pour installer la bibliothèque.
- Il vous sera demandé d'installer d'autres dépendances de bibliothèques
- Cliquez sur le bouton Tout installer pour installer toutes les dépendances.
Choisissez l'un des deux modes Bluetooth ci-dessous selon vos besoins :
Code ESP32 Bluetooth Classique (fonctionne avec l'application sur Android uniquement)
Note : Le Bluetooth Classique n'est PAS supporté sur iOS. Si vous avez besoin du support iOS, utilisez le code BLE ci-dessous.
- Dans Arduino IDE, allez dans Fichier Exemples DIYables Bluetooth Esp32Bluetooth_Chat, ou copiez le code ci-dessus et collez-le dans l'éditeur d'Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Chat Example
* Works with DIYables Bluetooth STEM app on Android
* Note: Classic Bluetooth is NOT supported on iOS. Use BLE examples for iOS support.
*
* This example demonstrates the Bluetooth Chat feature:
* - Two-way text messaging via Bluetooth
* - Receive messages from mobile app
* - Send messages to mobile app
*
* Compatible Boards:
* - ESP32 (all variants with Classic Bluetooth)
* - ESP32-WROOM-32
* - ESP32-DevKitC
* - ESP32-WROVER
*
* Note: Select "Huge APP (3MB No OTA/1MB SPIFFS)" partition scheme
* in Arduino IDE: Tools > Partition Scheme
*
* Setup:
* 1. Upload the sketch to your ESP32
* 2. Open Serial Monitor (115200 baud) to see connection status and messages
* 3. Use DIYables Bluetooth App to connect and chat
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothChat.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Chat");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Chat app instance
DIYables_BluetoothChat bluetoothChat;
// Variables for periodic messages
unsigned long lastMessageTime = 0;
const unsigned long MESSAGE_INTERVAL = 10000; // Send message every 10 seconds
int messageCount = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Chat Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add chat app to server
bluetoothServer.addApp(&bluetoothChat);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothChat.send("Hello! ESP32 is ready to chat.");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
messageCount = 0;
});
// Set up callback for received chat messages
bluetoothChat.onChatMessage([](const String& message) {
Serial.print("Received: ");
Serial.println(message);
// Echo the message back
String response = "Echo: ";
response += message;
bluetoothChat.send(response);
// You can add custom command handling here
if (message.equalsIgnoreCase("ping")) {
bluetoothChat.send("pong!");
} else if (message.equalsIgnoreCase("status")) {
bluetoothChat.send("ESP32 is running normally");
} else if (message.equalsIgnoreCase("time")) {
String timeMsg = "Uptime: ";
timeMsg += String(millis() / 1000);
timeMsg += " seconds";
bluetoothChat.send(timeMsg);
} else if (message.equalsIgnoreCase("heap")) {
String heapMsg = "Free heap: ";
heapMsg += String(ESP.getFreeHeap());
heapMsg += " bytes";
bluetoothChat.send(heapMsg);
}
});
Serial.println("Waiting for Bluetooth connection...");
Serial.println("Type 'ping', 'status', 'time', or 'heap' in the app to test commands");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Send periodic status message (only when connected)
if (bluetooth.isConnected() && millis() - lastMessageTime >= MESSAGE_INTERVAL) {
lastMessageTime = millis();
messageCount++;
String statusMsg = "Status update #";
statusMsg += String(messageCount);
statusMsg += " - All systems operational";
bluetoothChat.send(statusMsg);
Serial.print("Sent: ");
Serial.println(statusMsg);
}
// Optional: Read from Serial and send to Bluetooth
if (Serial.available()) {
String serialMsg = Serial.readStringUntil('\n');
serialMsg.trim();
if (serialMsg.length() > 0 && bluetooth.isConnected()) {
bluetoothChat.send(serialMsg);
Serial.print("Sent from Serial: ");
Serial.println(serialMsg);
}
}
delay(10);
}
- Cliquez sur le bouton Téléverser dans Arduino IDE pour téléverser le code vers l'ESP32
- Ouvrez le Moniteur Série
- Vérifiez le résultat dans le Moniteur Série. Cela ressemble à ceci :
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
DIYables Bluetooth - ESP32 Chat Example
Waiting for Bluetooth connection...
Type 'ping', 'status', 'time', or 'heap' in the app to test commands
Code ESP32 BLE (fonctionne avec l'application sur Android et iOS)
- Dans Arduino IDE, allez dans Fichier Exemples DIYables Bluetooth Esp32BLE_Chat, ou copiez le code ci-dessus et collez-le dans l'éditeur d'Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 BLE Chat Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Chat feature:
* - Two-way text messaging via Bluetooth
* - Receive messages from mobile app
* - Send messages to mobile app
*
* Compatible Boards:
* - ESP32-WROOM-32
* - ESP32-DevKitC
* - ESP32-WROVER
* - ESP32-S3
* - ESP32-C3
* - Any ESP32 board supporting BLE
*
* Note: Select "Huge APP (3MB No OTA/1MB SPIFFS)" partition scheme
* in Arduino IDE: Tools > Partition Scheme
*
* Setup:
* 1. Upload the sketch to your ESP32
* 2. Open Serial Monitor (115200 baud) to see connection status and messages
* 3. Use DIYables Bluetooth App to connect and chat
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothChat.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Chat";
const char* SERVICE_UUID = "19B10000-E8F2-537E-4F6C-D104768A1214";
const char* TX_UUID = "19B10001-E8F2-537E-4F6C-D104768A1214";
const char* RX_UUID = "19B10002-E8F2-537E-4F6C-D104768A1214";
// Create Bluetooth instances
DIYables_Esp32BLE bluetooth(DEVICE_NAME, SERVICE_UUID, TX_UUID, RX_UUID);
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Chat app instance
DIYables_BluetoothChat bluetoothChat;
// Variables for periodic messages
unsigned long lastMessageTime = 0;
const unsigned long MESSAGE_INTERVAL = 10000; // Send message every 10 seconds
int messageCount = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Chat Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add chat app to server
bluetoothServer.addApp(&bluetoothChat);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothChat.send("Hello! ESP32 BLE is ready to chat.");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
messageCount = 0;
});
// Set up callback for received chat messages
bluetoothChat.onChatMessage([](const String& message) {
Serial.print("Received: ");
Serial.println(message);
// Echo the message back
String response = "Echo: ";
response += message;
bluetoothChat.send(response);
// Custom command handling
if (message.equalsIgnoreCase("ping")) {
bluetoothChat.send("pong!");
} else if (message.equalsIgnoreCase("status")) {
bluetoothChat.send("ESP32 BLE is running normally");
} else if (message.equalsIgnoreCase("time")) {
String timeMsg = "Uptime: ";
timeMsg += String(millis() / 1000);
timeMsg += " seconds";
bluetoothChat.send(timeMsg);
} else if (message.equalsIgnoreCase("heap")) {
String heapMsg = "Free heap: ";
heapMsg += String(ESP.getFreeHeap());
heapMsg += " bytes";
bluetoothChat.send(heapMsg);
}
});
Serial.println("Waiting for Bluetooth connection...");
Serial.println("Type 'ping', 'status', 'time', or 'heap' in the app to test commands");
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastMessageTime >= MESSAGE_INTERVAL) {
lastMessageTime = millis();
messageCount++;
String statusMsg = "Status update #";
statusMsg += String(messageCount);
statusMsg += " - All systems operational";
bluetoothChat.send(statusMsg);
Serial.print("Sent: ");
Serial.println(statusMsg);
}
if (Serial.available()) {
String serialMsg = Serial.readStringUntil('\n');
serialMsg.trim();
if (serialMsg.length() > 0 && bluetooth.isConnected()) {
bluetoothChat.send(serialMsg);
Serial.print("Sent from Serial: ");
Serial.println(serialMsg);
}
}
delay(10);
}
- Cliquez sur le bouton Téléverser dans Arduino IDE pour téléverser le code vers l'ESP32
- Ouvrez le Moniteur Série
- Vérifiez le résultat dans le Moniteur Série. Cela ressemble à ceci :
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
DIYables Bluetooth - ESP32 BLE Chat Example
Waiting for Bluetooth connection...
Type 'ping', 'status', 'time', or 'heap' in the app to test commands
Application mobile
- Si vous utilisez le code ESP32 Bluetooth Classique, vous devez appairer l'ESP32 avec votre téléphone Android avant d'ouvrir l'application :
- Allez dans les Paramètres > Bluetooth de votre téléphone
- Assurez-vous que Bluetooth est activé
- Votre téléphone va scanner les appareils disponibles
- Trouvez et tapez "ESP32_Chat" dans la liste des appareils disponibles
- Confirmez la demande d'appairage (aucun PIN requis)
- Attendez jusqu'à ce qu'il affiche "Appairé" sous le nom de l'appareil
- Si vous utilisez le code ESP32 BLE, aucun appairage n'est nécessaire. Passez directement à l'étape suivante.
- Ouvrez l'application DIYables Bluetooth
- Lors de la première ouverture de l'application, elle demandera des permissions. Veuillez accorder les suivantes :
- Permission Appareils à proximité (Android 12+) / Permission Bluetooth (iOS) - requise pour scanner et se connecter aux appareils Bluetooth
- Permission Localisation (Android 11 et antérieur uniquement) - requise par les anciennes versions Android pour scanner les appareils BLE
- Assurez-vous que Bluetooth est activé sur votre téléphone
- Sur l'écran d'accueil, tapez le bouton Se connecter. L'application va scanner les appareils BLE et Bluetooth Classique.
- Trouvez et tapez votre appareil dans les résultats de scan pour vous connecter :
- Pour Bluetooth Classique : tapez "ESP32_Chat"
- Pour BLE : tapez "ESP32BLE_Chat"
- Une fois connecté, l'application retourne automatiquement à l'écran d'accueil. Sélectionnez l'application Chat dans le menu des applications.
Note : Vous pouvez taper l'icône paramètres sur l'écran d'accueil pour masquer/afficher les applications sur l'écran d'accueil. Pour plus de détails, voir le Manuel utilisateur de l'application DIYables Bluetooth.
- Tapez un message dans le champ de saisie et tapez Envoyer
Maintenant regardez le Moniteur Série dans Arduino IDE. Vous verrez :
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
Bluetooth connected!
Received: Hello
Received: ping
Received: status
Sent: Status update #1 - All systems operational
- Tapez des messages dans l'application et observez le retour en temps réel dans le Moniteur Série
- Essayez les commandes intégrées : ping, status, time, heap
- Vous pouvez aussi taper des messages dans le Moniteur Série et ils seront envoyés vers l'application
Personnalisation créative - Adaptez le code à votre projet
Recevoir des messages depuis l'application
Utilisez le callback onChatMessage() pour traiter les messages reçus depuis l'application. Vous pouvez définir n'importe quels mots de commande personnalisés qui ont du sens pour votre projet — l'ESP32 réagira en conséquence :
bluetoothChat.onChatMessage([](const String& message) {
Serial.print("Received: ");
Serial.println(message);
// Traiter le message
if (message == "LED_ON") {
digitalWrite(2, HIGH);
bluetoothChat.send("LED turned ON");
} else if (message == "LED_OFF") {
digitalWrite(2, LOW);
bluetoothChat.send("LED turned OFF");
} else {
bluetoothChat.send("Unknown command: " + message);
}
});
Vous pouvez ajouter autant de commandes personnalisées que nécessaire en ajoutant plus de blocs else if. Par exemple, ajoutez RELAY_ON / RELAY_OFF pour contrôler un relais, ou READ pour déclencher une lecture de capteur — tout mot que vous tapez dans l'application devient une commande.
Envoyer des messages vers l'application
Vous pouvez envoyer des messages texte depuis l'ESP32 vers l'application à tout moment :
// Envoyer un message texte simple
bluetoothChat.send("Hello from ESP32!");
// Envoyer des données de capteur sous forme de texte
float temperature = 25.3;
bluetoothChat.send("Temperature: " + String(temperature) + "°C");
// Envoyer des mises à jour de statut
bluetoothChat.send("System ready");
Gérer les événements de connexion
Vous pouvez détecter quand l'application se connecte ou se déconnecte de l'ESP32 :
// Appelé quand l'application se connecte à l'ESP32
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothChat.send("Welcome! ESP32 is ready to chat.");
});
// Appelé quand l'application se déconnecte de l'ESP32
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Vérifier le statut de connexion n'importe où dans votre code
if (bluetoothServer.isConnected()) {
bluetoothChat.send("Still connected!");
}
Pont Serial-to-Bluetooth
Transférez les messages tapés dans le Moniteur Série d'Arduino IDE vers l'application Bluetooth :
void loop() {
bluetoothServer.loop();
// Lire depuis Serial et envoyer vers Bluetooth
if (Serial.available()) {
String serialMsg = Serial.readStringUntil('\n');
serialMsg.trim();
if (serialMsg.length() > 0 && bluetooth.isConnected()) {
bluetoothChat.send(serialMsg);
Serial.print("Sent from Serial: ");
Serial.println(serialMsg);
}
}
delay(10);
}
Comment utiliser le chat
Contrôles de l'interface de l'application
L'interface de chat dans l'application DIYables Bluetooth fournit :
- Liste des messages : Liste déroulante montrant les messages envoyés et reçus
- Saisie de texte : Tapez votre message en bas
- Bouton Envoyer : Tapez pour envoyer le message tapé
- Défilement automatique : Défile automatiquement vers le dernier message
Commandes intégrées
Le code d'exemple inclut ces commandes intégrées :
- ping → Répond avec "pong!"
- status → Rapporte le statut de fonctionnement de l'ESP32
- time → Affiche le temps de fonctionnement en secondes
- heap → Affiche la mémoire heap libre en octets
Exemples de programmation
Chat d'écho basique
void setup() {
// Configurer le callback du chat
bluetoothChat.onChatMessage([](const String& message) {
Serial.print("Received: ");
Serial.println(message);
// Renvoyer le message en écho
bluetoothChat.send("Echo: " + message);
});
}
Contrôle de LED basé sur les commandes
const int LED_PIN = 2; // LED intégrée
const int RED_PIN = 16;
const int GREEN_PIN = 17;
const int BLUE_PIN = 18;
void setup() {
pinMode(LED_PIN, OUTPUT);
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
bluetoothChat.onChatMessage([](const String& message) {
String cmd = message;
cmd.toUpperCase();
if (cmd == "LED ON") {
digitalWrite(LED_PIN, HIGH);
bluetoothChat.send("LED is now ON");
} else if (cmd == "LED OFF") {
digitalWrite(LED_PIN, LOW);
bluetoothChat.send("LED is now OFF");
} else if (cmd == "RED") {
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
bluetoothChat.send("Red LED activated");
} else if (cmd == "GREEN") {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
bluetoothChat.send("Green LED activated");
} else if (cmd == "BLUE") {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
bluetoothChat.send("Blue LED activated");
} else if (cmd == "OFF") {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
bluetoothChat.send("All LEDs off");
} else if (cmd == "HELP") {
bluetoothChat.send("Commands: LED ON, LED OFF, RED, GREEN, BLUE, OFF, HELP");
} else {
bluetoothChat.send("Unknown command. Type HELP for list.");
}
});
}
Système d'interrogation de capteurs
#include <DHT.h>
DHT dht(4, DHT22);
void setup() {
dht.begin();
bluetoothChat.onChatMessage([](const String& message) {
String cmd = message;
cmd.toUpperCase();
if (cmd == "TEMP") {
float temp = dht.readTemperature();
if (!isnan(temp)) {
bluetoothChat.send("Temperature: " + String(temp, 1) + " °C");
} else {
bluetoothChat.send("Error reading temperature sensor");
}
} else if (cmd == "HUMIDITY") {
float hum = dht.readHumidity();
if (!isnan(hum)) {
bluetoothChat.send("Humidity: " + String(hum, 1) + " %");
} else {
bluetoothChat.send("Error reading humidity sensor");
}
} else if (cmd == "ALL") {
float temp = dht.readTemperature();
float hum = dht.readHumidity();
bluetoothChat.send("Temp: " + String(temp, 1) + "°C | Humidity: " + String(hum, 1) + "%");
} else if (cmd == "HELP") {
bluetoothChat.send("Commands: TEMP, HUMIDITY, ALL, HELP");
}
});
}
Contrôle de relais avec confirmation
const int RELAY_1 = 16;
const int RELAY_2 = 17;
bool relay1State = false;
bool relay2State = false;
void setup() {
pinMode(RELAY_1, OUTPUT);
pinMode(RELAY_2, OUTPUT);
digitalWrite(RELAY_1, LOW);
digitalWrite(RELAY_2, LOW);
bluetoothChat.onChatMessage([](const String& message) {
String cmd = message;
cmd.toUpperCase();
if (cmd == "R1 ON") {
digitalWrite(RELAY_1, HIGH);
relay1State = true;
bluetoothChat.send("Relay 1: ON");
} else if (cmd == "R1 OFF") {
digitalWrite(RELAY_1, LOW);
relay1State = false;
bluetoothChat.send("Relay 1: OFF");
} else if (cmd == "R2 ON") {
digitalWrite(RELAY_2, HIGH);
relay2State = true;
bluetoothChat.send("Relay 2: ON");
} else if (cmd == "R2 OFF") {
digitalWrite(RELAY_2, LOW);
relay2State = false;
bluetoothChat.send("Relay 2: OFF");
} else if (cmd == "STATUS") {
bluetoothChat.send("Relay 1: " + String(relay1State ? "ON" : "OFF"));
bluetoothChat.send("Relay 2: " + String(relay2State ? "ON" : "OFF"));
} else if (cmd == "HELP") {
bluetoothChat.send("Commands: R1 ON, R1 OFF, R2 ON, R2 OFF, STATUS, HELP");
}
});
}
Techniques de programmation avancées
Mises à jour de statut périodiques
unsigned long lastMessageTime = 0;
const unsigned long MESSAGE_INTERVAL = 10000; // 10 secondes
void loop() {
bluetoothServer.loop();
// Envoyer des mises à jour de statut périodiques (seulement quand connecté)
if (bluetooth.isConnected() && millis() - lastMessageTime >= MESSAGE_INTERVAL) {
lastMessageTime = millis();
messageCount++;
String statusMsg = "Status update #" + String(messageCount);
statusMsg += " - Uptime: " + String(millis() / 1000) + "s";
statusMsg += " - Heap: " + String(ESP.getFreeHeap()) + " bytes";
bluetoothChat.send(statusMsg);
}
delay(10);
}
Journalisation des messages
// Enregistrer tous les messages vers Serial avec horodatage
bluetoothChat.onChatMessage([](const String& message) {
unsigned long timestamp = millis() / 1000;
Serial.print("[");
Serial.print(timestamp);
Serial.print("s] Received: ");
Serial.println(message);
// Traiter et répondre
String response = processCommand(message);
bluetoothChat.send(response);
Serial.print("[");
Serial.print(millis() / 1000);
Serial.print("s] Sent: ");
Serial.println(response);
});
String processCommand(const String& cmd) {
if (cmd.equalsIgnoreCase("ping")) return "pong!";
if (cmd.equalsIgnoreCase("status")) return "All systems operational";
if (cmd.equalsIgnoreCase("time")) return "Uptime: " + String(millis() / 1000) + "s";
return "Echo: " + cmd;
}
Analyseur de commandes avec arguments
bluetoothChat.onChatMessage([](const String& message) {
// Analyser commande et argument (format: "COMMANDE ARG")
int spaceIndex = message.indexOf(' ');
String command, argument;
if (spaceIndex > 0) {
command = message.substring(0, spaceIndex);
argument = message.substring(spaceIndex + 1);
} else {
command = message;
argument = "";
}
command.toUpperCase();
if (command == "PWM") {
int value = argument.toInt();
value = constrain(value, 0, 255);
analogWrite(16, value);
bluetoothChat.send("PWM set to " + String(value));
} else if (command == "DELAY") {
int ms = argument.toInt();
bluetoothChat.send("Waiting " + String(ms) + "ms...");
delay(ms);
bluetoothChat.send("Done!");
} else if (command == "PIN") {
// Format: "PIN 13 HIGH" ou "PIN 13 LOW"
int secondSpace = argument.indexOf(' ');
if (secondSpace > 0) {
int pin = argument.substring(0, secondSpace).toInt();
String state = argument.substring(secondSpace + 1);
state.toUpperCase();
digitalWrite(pin, state == "HIGH" ? HIGH : LOW);
bluetoothChat.send("Pin " + String(pin) + " set " + state);
}
}
});
Exemples d'intégration matérielle
Contrôle de servo via chat
#include <ESP32Servo.h>
Servo myServo;
const int SERVO_PIN = 13;
void setup() {
myServo.attach(SERVO_PIN);
bluetoothChat.onChatMessage([](const String& message) {
// Accepter les commandes d'angle comme "90" ou "SERVO 90"
String cmd = message;
cmd.toUpperCase();
int angle = -1;
if (cmd.startsWith("SERVO ")) {
angle = cmd.substring(6).toInt();
} else {
angle = cmd.toInt();
if (angle == 0 && cmd != "0") angle = -1; // Pas un nombre
}
if (angle >= 0 && angle <= 180) {
myServo.write(angle);
bluetoothChat.send("Servo moved to " + String(angle) + "°");
} else if (cmd == "SWEEP") {
bluetoothChat.send("Sweeping servo...");
for (int a = 0; a <= 180; a += 5) {
myServo.write(a);
delay(30);
}
for (int a = 180; a >= 0; a -= 5) {
myServo.write(a);
delay(30);
}
bluetoothChat.send("Sweep complete");
}
});
}
Contrôle de moteur via chat
const int MOTOR_PWM = 16;
const int MOTOR_DIR1 = 18;
const int MOTOR_DIR2 = 19;
void setup() {
pinMode(MOTOR_PWM, OUTPUT);
pinMode(MOTOR_DIR1, OUTPUT);
pinMode(MOTOR_DIR2, OUTPUT);
bluetoothChat.onChatMessage([](const String& message) {
String cmd = message;
cmd.toUpperCase();
if (cmd == "FORWARD") {
digitalWrite(MOTOR_DIR1, HIGH);
digitalWrite(MOTOR_DIR2, LOW);
analogWrite(MOTOR_PWM, 200);
bluetoothChat.send("Motor running forward");
} else if (cmd == "REVERSE") {
digitalWrite(MOTOR_DIR1, LOW);
digitalWrite(MOTOR_DIR2, HIGH);
analogWrite(MOTOR_PWM, 200);
bluetoothChat.send("Motor running reverse");
} else if (cmd == "STOP") {
analogWrite(MOTOR_PWM, 0);
bluetoothChat.send("Motor stopped");
} else if (cmd.startsWith("SPEED ")) {
int speed = cmd.substring(6).toInt();
speed = constrain(speed, 0, 255);
analogWrite(MOTOR_PWM, speed);
bluetoothChat.send("Motor speed: " + String(speed));
}
});
}
BLE vs Bluetooth Classique - Lequel choisir ?
| Fonctionnalité | BLE (Esp32BLE_Chat) | Bluetooth Classique (Esp32Bluetooth_Chat) |
|---|---|---|
| Support iOS | ✓ Oui | ✗ Non |
| Support Android | ✓ Oui | ✓ Oui |
| Consommation | Faible | Plus élevée |
| Portée | ~30-100m | ~10-100m |
| Débit de données | Plus faible | Plus élevé |
| Appairage requis | Non (connexion auto) | Oui (appairage manuel) |
| Idéal pour | Alimenté par batterie, multiplateforme | Haut débit, Android uniquement |
Dépannage
Problèmes courants
1. Impossible de trouver l'appareil dans l'application
- Assurez-vous que l'ESP32 est alimenté et que le sketch est téléversé
- Pour BLE : Assurez-vous que Bluetooth et Localisation de votre téléphone sont activés
- Pour Bluetooth Classique : Appairez d'abord l'appareil dans les paramètres Bluetooth du téléphone
- Vérifiez que le schéma de partition correct est sélectionné (Huge APP)
2. Les messages n'apparaissent pas dans l'application
- Vérifiez le statut de connexion Bluetooth dans l'application
- Vérifiez la connexion dans le Moniteur Série
- Assurez-vous que les messages sont envoyés avec bluetoothChat.send()
- Essayez de vous déconnecter et vous reconnecter
3. Les messages d'écho ne fonctionnent pas
- Vérifiez que le callback onChatMessage() est configuré correctement
- Vérifiez le Moniteur Série pour les messages reçus
- Assurez-vous que l'écran de l'application de chat est sélectionné dans l'application mobile
4. La connexion se coupe fréquemment
- Rapprochez-vous de l'ESP32 (réduire la distance)
- Pour BLE : Vérifiez les interférences d'autres appareils BLE
- Pour Bluetooth Classique : Assurez-vous d'une alimentation stable de l'ESP32
- Vérifiez le Moniteur Série pour les messages de déconnexion/reconnexion
5. Le pont Serial-to-Bluetooth ne fonctionne pas
- Assurez-vous que le débit du Moniteur Série est 115200
- Réglez la fin de ligne sur "Newline" dans le Moniteur Série
- Vérifiez que bluetooth.isConnected() retourne true
- Vérifiez que le code Serial.available() est dans loop()
6. Sketch trop volumineux / pas assez d'espace
- Dans Arduino IDE, allez dans Outils > Schéma de partition et sélectionnez "Huge APP (3MB No OTA/1MB SPIFFS)" ou "No OTA (Large APP)"
- Le schéma de partition par défaut ne fournit que ~1,2MB pour le code d'application, ce qui n'est pas suffisant pour les bibliothèques Bluetooth
- Ce paramètre donne ~3MB en sacrifiant la partition OTA (mise à jour par voie hertzienne)
Conseils de débogage
Ajoutez un débogage complet :
void debugChatMessage(const String& message) {
Serial.println("=== Chat Debug ===");
Serial.println("Message: " + message);
Serial.println("Length: " + String(message.length()));
Serial.println("Free Heap: " + String(ESP.getFreeHeap()));
Serial.println("==================");
}
Idées de projets
Projets de contrôle à distance
- Contrôle textuel de style commande vocale pour robots
- Centre de commande domotique
- Contrôle de relais sans fil avec retour textuel
- Positionnement de servo à distance via chat
Projets de surveillance
- Interrogation de données de capteurs à distance
- Vérification de l'état du système via commandes chat
- Journalisation de données avec retour Bluetooth
- Débogage et diagnostics à distance
Projets interactifs
- Jeu de quiz ou de culture générale via chat Bluetooth
- Tutoriels interactifs avec instructions étape par étape
- Chatbot pour informations sur les projets ESP32
- Outil de configuration à distance
Projets éducatifs
- Apprendre les bases de la communication Bluetooth
- Pratiquer l'analyse de chaînes et la gestion des commandes
- Comprendre les schémas de messagerie client-serveur
- Construire des protocoles de communication personnalisés
Intégration avec d'autres applications Bluetooth
Combiner avec le moniteur Bluetooth
Utilisez Chat pour les commandes et Monitor pour la sortie continue :
bluetoothChat.onChatMessage([](const String& message) {
if (message.equalsIgnoreCase("start")) {
monitoring = true;
bluetoothChat.send("Monitoring started");
} else if (message.equalsIgnoreCase("stop")) {
monitoring = false;
bluetoothChat.send("Monitoring stopped");
}
});
// In loop: send data to monitor when active
if (monitoring) {
bluetoothMonitor.send("Sensor: " + String(analogRead(34)));
}
Combiner avec le curseur Bluetooth
Utilisez Chat pour définir des préréglages de curseur et Slider pour le contrôle fin :
bluetoothChat.onChatMessage([](const String& message) {
if (message.equalsIgnoreCase("preset1")) {
currentSlider1 = 25;
currentSlider2 = 75;
bluetoothSlider.send(currentSlider1, currentSlider2);
bluetoothChat.send("Applied Preset 1: 25%, 75%");
} else if (message.equalsIgnoreCase("preset2")) {
currentSlider1 = 50;
currentSlider2 = 50;
bluetoothSlider.send(currentSlider1, currentSlider2);
bluetoothChat.send("Applied Preset 2: 50%, 50%");
}
});
Prochaines étapes
Après avoir maîtrisé l'exemple de chat Bluetooth, essayez :
- Moniteur Bluetooth - Pour la diffusion de données unidirectionnelle vers l'application
- Curseur Bluetooth - Pour le contrôle de valeurs de type analogique
- Broches numériques Bluetooth - Pour un contrôle discret marche/arrêt
- Applications Bluetooth multiples - Combiner le chat avec d'autres contrôles
Support
Pour une aide supplémentaire :
- Consultez la documentation de référence API
- Visitez les tutoriels DIYables
- Forums de la communauté Arduino