ESP32 Moniteur Bluetooth - Tutoriel Interface Moniteur Série Temps Réel
Aperçu
L'exemple Moniteur Bluetooth fournit une interface de moniteur série sans fil accessible via l'application DIYables Bluetooth STEM. Conçu pour les cartes ESP32 avec prise en charge du BLE (Bluetooth Low Energy) et du Bluetooth Classic. Transmettez des messages de statut en temps réel vers l'application, recevez et traitez des commandes texte, affichez les informations système et déboguez vos projets sans fil — parfait pour la surveillance déconnectée, le débogage à distance et l'affichage de statut système.
Cet exemple prend en charge deux modes Bluetooth :
- ESP32 BLE (Bluetooth Low Energy) : Fonctionne sur Android et iOS
- ESP32 Bluetooth Classic : Fonctionne sur Android uniquement. iOS ne prend pas en charge le Bluetooth Classic. Utilisez BLE si vous avez besoin du support iOS.
Fonctionnalités
- Transmission Temps Réel : Envoyez des messages de statut continus vers l'affichage de l'application
- Traitement de Commandes : Recevez et gérez les commandes texte depuis l'application
- Surveillance Système : Affichez l'uptime, la mémoire libre, les infos CPU et plus
- Contrôle LED : Commandes ON/OFF de LED intégrée pour des tests rapides
- Mises à Jour Périodiques : Messages de heartbeat automatiques et de statut à intervalles configurables
- BLE & Bluetooth Classic : Choisissez le mode Bluetooth qui convient à votre projet
- Multi-Plateforme : Le mode BLE fonctionne sur Android et iOS ; le Bluetooth Classic fonctionne sur Android
- Option Faible Consommation : Le mode BLE consomme moins d'énergie que le Bluetooth Classic
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 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..
- Connectez la carte ESP32 à votre ordinateur avec un câble USB.
- Lancez l'Arduino IDE sur votre ordinateur.
- Sélectionnez la carte ESP32 appropriée et le port COM.
- Naviguez vers l'icône Libraries dans la barre gauche de l'Arduino IDE.
- Recherchez "DIYables Bluetooth", puis trouvez la bibliothèque DIYables Bluetooth par DIYables
- Cliquez sur le bouton Install pour installer la bibliothèque.
- On vous demandera d'installer d'autres dépendances de bibliothèques
- Cliquez sur le bouton Install All pour installer toutes les dépendances.
Choisissez l'un des deux modes Bluetooth ci-dessous selon vos besoins :
Code ESP32 Bluetooth Classic (fonctionne avec l'application sur Android uniquement)
Note : Le Bluetooth Classic n'est PAS pris en charge sur iOS. Si vous avez besoin du support iOS, utilisez le code BLE ci-dessous.
- Dans l'Arduino IDE, allez à File Examples DIYables Bluetooth Esp32Bluetooth_Monitor, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Monitor 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 Monitor feature:
* - Send real-time status messages to the mobile app
* - Display system information and sensor readings
* - Receive and process commands from the app
* - Perfect for debugging and system monitoring
*
* 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
* 3. Use DIYables Bluetooth App to connect and view monitor output
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothMonitor.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Monitor");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Monitor app instance
DIYables_BluetoothMonitor bluetoothMonitor;
// Variables for demo
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 3000; // Send update every 3 seconds
int messageCount = 0;
bool ledState = false;
// ESP32 built-in LED (may vary by board)
const int LED_PIN = 2;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Monitor Example");
// Initialize LED
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add monitor app to server
bluetoothServer.addApp(&bluetoothMonitor);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothMonitor.send("=== ESP32 Monitor Connected ===");
bluetoothMonitor.send("System Ready");
bluetoothMonitor.send("Type HELP for available commands");
bluetoothMonitor.send("");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up message handler for incoming commands
bluetoothMonitor.onMonitorMessage([](const String& message) {
Serial.print("Received command: ");
Serial.println(message);
handleCommand(message);
});
Serial.println("Waiting for Bluetooth connection...");
}
void handleCommand(const String& cmd) {
if (cmd == "HELP") {
bluetoothMonitor.send("Available Commands:");
bluetoothMonitor.send(" LED_ON - Turn LED on");
bluetoothMonitor.send(" LED_OFF - Turn LED off");
bluetoothMonitor.send(" STATUS - Show system status");
bluetoothMonitor.send(" HEAP - Show memory info");
bluetoothMonitor.send(" CLEAR - Clear monitor (if supported)");
bluetoothMonitor.send(" HELP - Show this help");
}
else if (cmd == "LED_ON") {
digitalWrite(LED_PIN, HIGH);
ledState = true;
bluetoothMonitor.send("✓ LED turned ON");
}
else if (cmd == "LED_OFF") {
digitalWrite(LED_PIN, LOW);
ledState = false;
bluetoothMonitor.send("✓ LED turned OFF");
}
else if (cmd == "STATUS") {
showStatus();
}
else if (cmd == "HEAP") {
bluetoothMonitor.send("=== Memory Info ===");
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("Min Free Heap: " + String(ESP.getMinFreeHeap()) + " bytes");
bluetoothMonitor.send("Heap Size: " + String(ESP.getHeapSize()) + " bytes");
bluetoothMonitor.send("===================");
}
else if (cmd == "CLEAR") {
bluetoothMonitor.send("");
}
else {
bluetoothMonitor.send("✗ Unknown command: " + cmd);
bluetoothMonitor.send("Type HELP for available commands");
}
}
void showStatus() {
bluetoothMonitor.send("=== System Status ===");
// LED Status
bluetoothMonitor.send("LED State: " + String(ledState ? "ON" : "OFF"));
// Uptime
unsigned long uptime = millis() / 1000;
bluetoothMonitor.send("Uptime: " + String(uptime / 3600) + "h " + String((uptime % 3600) / 60) + "m " + String(uptime % 60) + "s");
// ESP32-specific info
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("CPU Freq: " + String(ESP.getCpuFreqMHz()) + " MHz");
bluetoothMonitor.send("Chip Model: " + String(ESP.getChipModel()));
// Messages sent
bluetoothMonitor.send("Messages Sent: " + String(messageCount));
bluetoothMonitor.send("====================");
}
void sendPeriodicUpdate() {
messageCount++;
// Example of different message types
if (messageCount % 3 == 0) {
bluetoothMonitor.send("[INFO] Heartbeat #" + String(messageCount));
}
else if (messageCount % 5 == 0) {
bluetoothMonitor.send("[HEAP] Free: " + String(ESP.getFreeHeap()) + " bytes");
}
else {
bluetoothMonitor.send("[TIME] Uptime: " + String(millis() / 1000) + "s");
}
Serial.print("Sent update #");
Serial.println(messageCount);
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Send periodic updates (only when connected)
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
sendPeriodicUpdate();
}
delay(10);
}
- Cliquez sur le bouton Upload dans l'Arduino IDE pour téléverser le code vers l'ESP32
- Ouvrez le Serial Monitor
- Vérifiez le résultat dans le Serial Monitor. Cela ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 Monitor Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Code ESP32 BLE (fonctionne avec l'application sur Android et iOS)
- Dans l'Arduino IDE, allez à File Examples DIYables Bluetooth Esp32BLE_Monitor, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 BLE Monitor Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Monitor feature:
* - Send real-time status messages to the mobile app
* - Display system information and sensor readings
* - Receive and process commands from the app
* - Perfect for debugging and system monitoring
*
* 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
* 3. Use DIYables Bluetooth App to connect and view monitor output
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothMonitor.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Monitor";
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 Monitor app instance
DIYables_BluetoothMonitor bluetoothMonitor;
// Variables for demo
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 3000;
int messageCount = 0;
bool ledState = false;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Monitor Example");
// Initialize built-in LED
pinMode(2, OUTPUT); // ESP32 built-in LED is usually on GPIO 2
digitalWrite(2, LOW);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add monitor app to server
bluetoothServer.addApp(&bluetoothMonitor);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothMonitor.send("=== ESP32 BLE Monitor Connected ===");
bluetoothMonitor.send("System Ready");
bluetoothMonitor.send("Type HELP for available commands");
bluetoothMonitor.send("");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up message handler for incoming commands
bluetoothMonitor.onMonitorMessage([](const String& message) {
Serial.print("Received command: ");
Serial.println(message);
handleCommand(message);
});
Serial.println("Waiting for Bluetooth connection...");
}
void handleCommand(const String& cmd) {
if (cmd == "HELP") {
bluetoothMonitor.send("Available Commands:");
bluetoothMonitor.send(" LED_ON - Turn LED on");
bluetoothMonitor.send(" LED_OFF - Turn LED off");
bluetoothMonitor.send(" STATUS - Show system status");
bluetoothMonitor.send(" HEAP - Show free heap memory");
bluetoothMonitor.send(" HELP - Show this help");
}
else if (cmd == "LED_ON") {
digitalWrite(2, HIGH);
ledState = true;
bluetoothMonitor.send("LED turned ON");
}
else if (cmd == "LED_OFF") {
digitalWrite(2, LOW);
ledState = false;
bluetoothMonitor.send("LED turned OFF");
}
else if (cmd == "STATUS") {
showStatus();
}
else if (cmd == "HEAP") {
bluetoothMonitor.send("Free heap: " + String(ESP.getFreeHeap()) + " bytes");
}
else {
bluetoothMonitor.send("Unknown command: " + cmd);
bluetoothMonitor.send("Type HELP for available commands");
}
}
void showStatus() {
bluetoothMonitor.send("=== System Status ===");
bluetoothMonitor.send("LED State: " + String(ledState ? "ON" : "OFF"));
unsigned long uptime = millis() / 1000;
bluetoothMonitor.send("Uptime: " + String(uptime / 3600) + "h " + String((uptime % 3600) / 60) + "m " + String(uptime % 60) + "s");
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("Messages Sent: " + String(messageCount));
bluetoothMonitor.send("====================");
}
void sendPeriodicUpdate() {
messageCount++;
if (messageCount % 3 == 0) {
bluetoothMonitor.send("[INFO] Heartbeat #" + String(messageCount));
}
else if (messageCount % 5 == 0) {
bluetoothMonitor.send("[HEAP] Free: " + String(ESP.getFreeHeap()) + " bytes");
}
else {
bluetoothMonitor.send("[TIME] Uptime: " + String(millis() / 1000) + "s");
}
Serial.print("Sent update #");
Serial.println(messageCount);
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
sendPeriodicUpdate();
}
delay(10);
}
- Cliquez sur le bouton Upload dans l'Arduino IDE pour téléverser le code vers l'ESP32
- Ouvrez le Serial Monitor
- Vérifiez le résultat dans le Serial Monitor. Cela ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 BLE Monitor Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Application Mobile
- Si vous utilisez le code ESP32 Bluetooth Classic, 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 le Bluetooth est activé
- Votre téléphone va scanner les appareils disponibles
- Trouvez et appuyez sur "ESP32_Monitor" 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 simplement à 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érieurs uniquement) - requise par les anciennes versions Android pour scanner les appareils BLE
- Assurez-vous que le Bluetooth est activé sur votre téléphone
- Sur l'écran d'accueil, appuyez sur le bouton Connect. L'application va scanner les appareils BLE et Bluetooth Classic.
- Trouvez et appuyez sur votre appareil dans les résultats de scan pour vous connecter :
- Pour Bluetooth Classic : appuyez sur "ESP32_Monitor"
- Pour BLE : appuyez sur "ESP32BLE_Monitor"
- Une fois connecté, l'application revient automatiquement à l'écran d'accueil. Sélectionnez l'application Monitor dans le menu des applications.
Note : Vous pouvez appuyer sur l'icône paramètres de l'écran d'accueil pour masquer/afficher les applications. Pour plus de détails, consultez le Manuel d'utilisation de l'application DIYables Bluetooth.
- Vous verrez les messages de statut défiler dans l'affichage du moniteur
- Tapez LED_ON dans le champ de saisie et appuyez sur Send — la LED intégrée de l'ESP32 s'allumera, et le moniteur affichera un message de confirmation
Regardez maintenant le Serial Monitor dans l'Arduino IDE. Vous verrez :
COM6
Bluetooth connected!
Sent update #1
Sent update #2
Received command: HELP
Received command: STATUS
Autoscroll
Clear output
9600 baud
Newline
- Tapez des commandes dans l'application (HELP, STATUS, LED_ON, LED_OFF, HEAP) et observez les réponses
Personnalisation Créative - Adaptez le Code à Votre Projet
Envoyer des Messages à l'Application
Utilisez la méthode send() pour transmettre des messages texte vers l'affichage du moniteur :
// Envoyer des messages simples
bluetoothMonitor.send("System initialized");
bluetoothMonitor.send("Sensor reading: 25.3°C");
// Envoyer des données formatées
bluetoothMonitor.send("[INFO] Heartbeat #" + String(count));
bluetoothMonitor.send("[WARN] Temperature high: " + String(temp) + "°C");
bluetoothMonitor.send("[ERROR] Sensor disconnected");
// Envoyer des informations système
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("Uptime: " + String(millis() / 1000) + " seconds");
Recevoir des Commandes depuis l'Application
Utilisez le callback onMonitorMessage() pour recevoir les commandes tapées dans l'application Monitor et y réagir :
bluetoothMonitor.onMonitorMessage([](const String& message) {
Serial.print("Received command: ");
Serial.println(message);
if (message == "HELP") {
bluetoothMonitor.send("Available Commands:");
bluetoothMonitor.send(" LED_ON - Turn LED on");
bluetoothMonitor.send(" LED_OFF - Turn LED off");
bluetoothMonitor.send(" STATUS - Show system status");
bluetoothMonitor.send(" HEAP - Show memory info");
} else if (message == "LED_ON") {
digitalWrite(LED_BUILTIN, HIGH);
bluetoothMonitor.send("LED turned ON");
} else if (message == "LED_OFF") {
digitalWrite(LED_BUILTIN, LOW);
bluetoothMonitor.send("LED turned OFF");
} else if (message == "STATUS") {
bluetoothMonitor.send("System is running normally");
bluetoothMonitor.send("Uptime: " + String(millis() / 1000) + "s");
} else if (message == "HEAP") {
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
} else {
bluetoothMonitor.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.
Gérer les Événements de Connexion
Vous pouvez détecter quand l'application se connecte ou se déconnecte de l'ESP32 :
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothMonitor.send("=== ESP32 Monitor Connected ===");
bluetoothMonitor.send("System Ready");
bluetoothMonitor.send("Type HELP for available commands");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
if (bluetoothServer.isConnected()) {
bluetoothMonitor.send("Status update");
}
Comment Utiliser le Moniteur
Contrôles de l'Interface Application
L'interface du moniteur dans l'application DIYables Bluetooth fournit :
- Affichage des Messages : Liste déroulante des messages reçus avec défilement automatique
- Saisie Texte : Tapez des commandes en bas
- Bouton Envoyer : Appuyez pour envoyer la commande tapée vers l'ESP32
Commandes Intégrées
Le code d'exemple inclut ces commandes intégrées :
- HELP – Affiche toutes les commandes disponibles
- LED_ON – Allume la LED intégrée
- LED_OFF – Éteint la LED intégrée
- STATUS – Affiche le statut système (état LED, uptime, heap, messages envoyés)
- HEAP – Affiche les informations mémoire détaillées
Exemples de Programmation
Transmission de Statut Basique
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 3000;
int messageCount = 0;
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
messageCount++;
// Alterner entre différents messages de statut
if (messageCount % 3 == 0) {
bluetoothMonitor.send("[INFO] Heartbeat #" + String(messageCount));
} else if (messageCount % 5 == 0) {
bluetoothMonitor.send("[HEAP] Free: " + String(ESP.getFreeHeap()) + " bytes");
} else {
bluetoothMonitor.send("[TIME] Uptime: " + String(millis() / 1000) + "s");
}
}
delay(10);
}
Enregistreur de Données de Capteur
#include <DHT.h>
DHT dht(4, DHT22);
unsigned long lastSensorRead = 0;
const unsigned long SENSOR_INTERVAL = 5000;
void setup() {
dht.begin();
bluetoothMonitor.onMonitorMessage([](const String& message) {
if (message == "READ") {
readAndSendSensorData();
} else if (message == "INTERVAL") {
bluetoothMonitor.send("Sensor interval: " + String(SENSOR_INTERVAL / 1000) + "s");
}
});
}
void readAndSendSensorData() {
float temp = dht.readTemperature();
float hum = dht.readHumidity();
if (!isnan(temp) && !isnan(hum)) {
bluetoothMonitor.send("Temp: " + String(temp, 1) + "°C | Humidity: " + String(hum, 1) + "%");
} else {
bluetoothMonitor.send("[ERROR] Failed to read sensor");
}
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastSensorRead >= SENSOR_INTERVAL) {
lastSensorRead = millis();
readAndSendSensorData();
}
delay(10);
}
Tableau de Bord Multi-Capteurs
void sendDashboard() {
bluetoothMonitor.send("========== DASHBOARD ==========");
bluetoothMonitor.send("Temp: " + String(readTemperature(), 1) + "°C");
bluetoothMonitor.send("Humidity: " + String(readHumidity(), 0) + "%");
bluetoothMonitor.send("Light: " + String(analogRead(34)));
bluetoothMonitor.send("Battery: " + String(readBatteryVoltage(), 2) + "V");
bluetoothMonitor.send("Heap: " + String(ESP.getFreeHeap()) + " bytes");
unsigned long uptime = millis() / 1000;
bluetoothMonitor.send("Uptime: " + String(uptime / 3600) + "h " +
String((uptime % 3600) / 60) + "m " +
String(uptime % 60) + "s");
bluetoothMonitor.send("===============================");
}
Moniteur de Broches GPIO
const int MONITOR_PINS[] = {16, 17, 18, 19, 21, 22};
const int NUM_PINS = 6;
int lastPinStates[6] = {0};
void setup() {
for (int i = 0; i < NUM_PINS; i++) {
pinMode(MONITOR_PINS[i], INPUT_PULLUP);
lastPinStates[i] = digitalRead(MONITOR_PINS[i]);
}
bluetoothMonitor.onMonitorMessage([](const String& message) {
if (message == "PINS") {
for (int i = 0; i < NUM_PINS; i++) {
int state = digitalRead(MONITOR_PINS[i]);
bluetoothMonitor.send("Pin " + String(MONITOR_PINS[i]) + ": " +
String(state ? "HIGH" : "LOW"));
}
}
});
}
void loop() {
bluetoothServer.loop();
// Détecter les changements de broches et rapporter
for (int i = 0; i < NUM_PINS; i++) {
int state = digitalRead(MONITOR_PINS[i]);
if (state != lastPinStates[i]) {
lastPinStates[i] = state;
if (bluetooth.isConnected()) {
bluetoothMonitor.send("[PIN] GPIO " + String(MONITOR_PINS[i]) +
" changed to " + String(state ? "HIGH" : "LOW"));
}
}
}
delay(10);
}
Techniques de Programmation Avancées
Journalisation Catégorisée
enum LogLevel { LOG_INFO, LOG_WARN, LOG_ERROR, LOG_DEBUG };
void sendLog(LogLevel level, const String& message) {
String prefix;
switch (level) {
case LOG_INFO: prefix = "[INFO] "; break;
case LOG_WARN: prefix = "[WARN] "; break;
case LOG_ERROR: prefix = "[ERROR] "; break;
case LOG_DEBUG: prefix = "[DEBUG] "; break;
}
bluetoothMonitor.send(prefix + message);
}
// Utilisation :
sendLog(LOG_INFO, "System started");
sendLog(LOG_WARN, "Battery low: " + String(voltage, 2) + "V");
sendLog(LOG_ERROR, "Sensor read failed");
sendLog(LOG_DEBUG, "Loop time: " + String(loopTime) + "ms");
Configuration Basée sur les Commandes
int sensorInterval = 3000;
bool verboseMode = false;
bluetoothMonitor.onMonitorMessage([](const String& message) {
String cmd = message;
cmd.toUpperCase();
if (cmd.startsWith("SET INTERVAL ")) {
sensorInterval = cmd.substring(13).toInt() * 1000;
bluetoothMonitor.send("Interval set to " + String(sensorInterval / 1000) + "s");
} else if (cmd == "VERBOSE ON") {
verboseMode = true;
bluetoothMonitor.send("Verbose mode enabled");
} else if (cmd == "VERBOSE OFF") {
verboseMode = false;
bluetoothMonitor.send("Verbose mode disabled");
} else if (cmd == "CONFIG") {
bluetoothMonitor.send("Interval: " + String(sensorInterval / 1000) + "s");
bluetoothMonitor.send("Verbose: " + String(verboseMode ? "ON" : "OFF"));
}
});
Exemples d'Intégration Matérielle
Moniteur Watchdog
unsigned long lastLoopTime = 0;
unsigned long maxLoopTime = 0;
int warningCount = 0;
void loop() {
unsigned long loopStart = millis();
bluetoothServer.loop();
// Votre code d'application ici
performTasks();
unsigned long loopTime = millis() - loopStart;
if (loopTime > maxLoopTime) {
maxLoopTime = loopTime;
}
if (loopTime > 100) { // Avertir si la boucle prend >100ms
warningCount++;
if (bluetooth.isConnected()) {
bluetoothMonitor.send("[WARN] Slow loop: " + String(loopTime) + "ms");
}
}
delay(10);
}
BLE vs Bluetooth Classic - Lequel Choisir ?
| Fonctionnalité | BLE (Esp32BLE_Monitor) | Bluetooth Classic (Esp32Bluetooth_Monitor) |
|---|---|---|
| Support iOS | ✓ Oui | ✗ Non |
| Support Android | ✓ Oui | ✓ Oui |
| Consommation d'Énergie | 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) |
| Meilleur Pour | Alimenté par batterie, multi-plateforme | 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 : Vérifiez que le Bluetooth et la localisation de votre téléphone sont activés
- Pour Bluetooth Classic : 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 le moniteur
- Vérifiez le statut de connexion Bluetooth dans l'application
- Vérifiez la connexion dans le Serial Monitor
- Assurez-vous que les messages sont envoyés avec bluetoothMonitor.send()
- Essayez de vous déconnecter et reconnecter
3. Les commandes ne sont pas reçues
- Vérifiez que le callback onMonitorMessage() est configuré correctement
- Consultez le Serial Monitor pour les commandes reçues
- Assurez-vous que l'écran de l'application moniteur 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 Classic : Assurez-vous d'une alimentation stable de l'ESP32
- Réduisez la fréquence des messages si l'envoi est trop rapide
5. Les messages apparaissent corrompus ou tronqués
- Gardez les messages individuels courts (moins de 200 caractères)
- Ajoutez de petits délais entre les envois rapides
- Vérifiez la mémoire libre heap pour des problèmes de buffer
6. Sketch trop volumineux / pas assez d'espace
- Dans l'Arduino IDE, allez à Tools > Partition Scheme 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 app, ce qui n'est pas suffisant pour les bibliothèques Bluetooth
- Ce paramètre donne ~3MB en sacrifiant la partition OTA (mise à jour over-the-air)
Conseils de Débogage
Ajoutez un débogage complet :
void debugMonitorStatus() {
Serial.println("=== Monitor Debug ===");
Serial.println("Connected: " + String(bluetooth.isConnected()));
Serial.println("Messages sent: " + String(messageCount));
Serial.println("Free Heap: " + String(ESP.getFreeHeap()));
Serial.println("=====================");
}
Idées de Projets
Projets de Débogage
- Remplacement de moniteur série sans fil
- Visualiseur de données de capteur à distance
- Inspection de variables en temps réel
- Surveillance des performances système
Projets de Surveillance
- Affichage de données de station météo
- Statut de système domotique
- Surveillance de capteur industriel
- Tableau de bord de santé d'appareils IoT
Projets de Journalisation
- Enregistreur d'événements avec horodatage
- Enregistrement de données de capteur
- Suivi d'erreurs et alertes
- Profilage des performances
Projets Éducatifs
- Apprendre la communication Bluetooth
- Pratiquer la messagerie type série
- Comprendre la surveillance de système embarqué
- Construire des outils de débogage personnalisés
Intégration avec d'Autres Applications Bluetooth
Combiner avec Bluetooth Chat
Utilisez Monitor pour une sortie continue et Chat pour des commandes interactives :
// Monitor transmet automatiquement les données de capteur
void loop() {
if (bluetooth.isConnected() && millis() - lastUpdate >= 3000) {
bluetoothMonitor.send("[SENSOR] " + String(readSensor()));
}
}
// Chat gère les commandes interactives
bluetoothChat.onChatMessage([](const String& message) {
if (message == "read") {
bluetoothChat.send("Value: " + String(readSensor()));
}
});
Combiner avec Bluetooth Slider
Utilisez Monitor pour afficher les valeurs de slider en temps réel :
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
bluetoothMonitor.send("Slider1=" + String(slider1) + "% Slider2=" + String(slider2) + "%");
bluetoothMonitor.send("PWM1=" + String(map(slider1, 0, 100, 0, 255)) +
" PWM2=" + String(map(slider2, 0, 100, 0, 255)));
});
Étapes Suivantes
Après avoir maîtrisé l'exemple Moniteur Bluetooth, essayez :
- Bluetooth Chat - Pour la messagerie interactive bidirectionnelle
- Bluetooth Table - Pour l'affichage de données structurées
- Bluetooth Plotter - Pour la visualisation graphique de données
- Applications Bluetooth Multiples - Combiner le moniteur 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