Exemple de tableau Bluetooth ESP32 - Tutoriel sur l'interface d'affichage de données structurées
Vue d'ensemble
L'exemple Table Bluetooth offre une présentation structurée de données clé-valeur accessible via l'application STEM Bluetooth de DIYables. Conçu pour les cartes ESP32 avec prise en charge à la fois du BLE (Bluetooth Low Energy) et du Bluetooth Classic. Définissez des lignes nommées et mettez à jour leurs valeurs en temps réel — parfait pour les tableaux de bord, les panneaux d'état des capteurs, les moniteurs système et toute application nécessitant une présentation organisée des données.
Cet exemple prend en charge deux modes Bluetooth :
- ESP32 BLE (Bluetooth Low Energy): Fonctionne sur Android et iOS
- ESP32 Classic Bluetooth: Fonctionne sur Android uniquement. iOS ne prend pas en charge le Bluetooth Classic. Utilisez BLE si vous avez besoin d'une compatibilité avec iOS.
Fonctionnalités
- Lignes structurées: jusqu'à 20 lignes d'attributs nommés
- Mises à jour en temps réel: Mettre à jour les valeurs des lignes individuelles sans actualiser l'ensemble de la table
- Attributs nommés: Chaque ligne possède une étiquette descriptive (par exemple « Température », « Statut »)
- Valeurs dynamiques: Envoyez n'importe quelle valeur sous forme de chaîne pour chaque ligne
- Synchronisation de la structure du tableau: L'application demande la configuration du tableau lors de la connexion
- 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 à faible consommation d'énergie: Le mode BLE consomme moins d'énergie que le Bluetooth classique
Préparation du matériel
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 utilisation de l'ESP32, consultez le tutoriel sur Installation du logiciel ESP32..
- Connectez la carte ESP32 à votre ordinateur à l'aide d'un câble USB.
- Lancez l'IDE Arduino sur votre ordinateur.
- Sélectionnez la carte ESP32 appropriée et le port COM.
- Accédez à l'icône Libraries dans la barre de gauche de l'IDE Arduino.
- Recherchez "DIYables Bluetooth", puis trouvez la bibliothèque DIYables Bluetooth par DIYables
- Cliquez sur le bouton Install pour installer la bibliothèque.
- Vous serez invité à installer d'autres dépendances de bibliothèque
- Cliquez sur le bouton Tout installer pour installer toutes les dépendances de bibliothèque.
Choisissez l’un des deux modes Bluetooth ci-dessous en fonction de vos besoins :
Code Bluetooth Classique ESP32 (fonctionne uniquement avec l'application sur Android)
Note : Le Bluetooth classique n'est pas pris en charge sur iOS. Si vous avez besoin d'une prise en charge iOS, utilisez le code BLE ci-dessous.
- Dans l'IDE Arduino, allez dans Fichier Exemples DIYables Bluetooth Esp32Bluetooth_Table exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Table 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 Table feature:
* - Display structured data in a two-column table
* - Real-time value updates for each row
* - Perfect for sensor dashboards and status displays
*
* 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 the table
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothTable.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Table");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Table app instance
DIYables_BluetoothTable bluetoothTable;
// Variables for demo data
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 1000; // Update every second
int counter = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Table Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add table app to server
bluetoothServer.addApp(&bluetoothTable);
// Define table structure (add rows with attribute names)
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Counter");
bluetoothTable.addRow("Uptime");
bluetoothTable.addRow("Free Heap");
bluetoothTable.addRow("CPU Freq");
bluetoothTable.addRow("Status");
Serial.print("Table rows defined: ");
Serial.println(bluetoothTable.getRowCount());
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send table structure
bluetoothTable.sendTableStructure();
// Send initial values
updateTableValues();
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Optional: Handle requests for table data
bluetoothTable.onDataRequest([]() {
Serial.println("App requested table data");
bluetoothTable.sendTableStructure();
updateTableValues();
});
Serial.println("Waiting for Bluetooth connection...");
}
void updateTableValues() {
// TODO: Replace with actual sensor readings
// Simulated temperature (20-30°C)
float temperature = 20.0 + random(0, 100) / 10.0;
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
// Simulated humidity (40-60%)
int humidity = 40 + random(0, 21);
bluetoothTable.sendValueUpdate("Humidity", String(humidity) + " %");
// Simulated pressure (1000-1020 hPa)
int pressure = 1000 + random(0, 21);
bluetoothTable.sendValueUpdate("Pressure", String(pressure) + " hPa");
// Counter value
bluetoothTable.sendValueUpdate("Counter", String(counter));
counter++;
// Uptime (in seconds)
unsigned long uptime = millis() / 1000;
String uptimeStr = String(uptime / 3600) + "h " +
String((uptime % 3600) / 60) + "m " +
String(uptime % 60) + "s";
bluetoothTable.sendValueUpdate("Uptime", uptimeStr);
// ESP32-specific: Free heap memory
bluetoothTable.sendValueUpdate("Free Heap", String(ESP.getFreeHeap()) + " bytes");
// ESP32-specific: CPU frequency
bluetoothTable.sendValueUpdate("CPU Freq", String(ESP.getCpuFreqMHz()) + " MHz");
// Status
bluetoothTable.sendValueUpdate("Status", counter % 2 == 0 ? "Running" : "Active");
Serial.println("Table values updated");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Update table values periodically (only when connected)
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
updateTableValues();
}
delay(10);
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code sur l'ESP32
- Ouvrez le moniteur série
- Vérifiez le résultat sur le moniteur série. Il ressemble à ce qui suit :
COM6
DIYables Bluetooth - ESP32 Table Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Code BLE ESP32 (fonctionne avec l'application sur Android et iOS)
- Dans l'IDE Arduino, allez dans Fichier Exemples DIYables Bluetooth Esp32BLE_Table exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 BLE Table Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Table feature:
* - Display structured data in a two-column table
* - Real-time value updates for each row
* - Perfect for sensor dashboards and status displays
*
* 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 the table
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothTable.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Table";
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 Table app instance
DIYables_BluetoothTable bluetoothTable;
// Variables for demo data
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 1000;
int counter = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Table Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add table app to server
bluetoothServer.addApp(&bluetoothTable);
// Define table structure
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Counter");
bluetoothTable.addRow("Uptime");
bluetoothTable.addRow("Free Heap");
bluetoothTable.addRow("Status");
Serial.print("Table rows defined: ");
Serial.println(bluetoothTable.getRowCount());
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothTable.sendTableStructure();
updateTableValues();
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
bluetoothTable.onDataRequest([]() {
Serial.println("App requested table data");
bluetoothTable.sendTableStructure();
updateTableValues();
});
Serial.println("Waiting for Bluetooth connection...");
}
void updateTableValues() {
float temperature = 20.0 + random(0, 100) / 10.0;
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
int humidity = 40 + random(0, 21);
bluetoothTable.sendValueUpdate("Humidity", String(humidity) + " %");
int pressure = 1000 + random(0, 21);
bluetoothTable.sendValueUpdate("Pressure", String(pressure) + " hPa");
bluetoothTable.sendValueUpdate("Counter", String(counter));
counter++;
unsigned long uptime = millis() / 1000;
String uptimeStr = String(uptime / 3600) + "h " +
String((uptime % 3600) / 60) + "m " +
String(uptime % 60) + "s";
bluetoothTable.sendValueUpdate("Uptime", uptimeStr);
bluetoothTable.sendValueUpdate("Free Heap", String(ESP.getFreeHeap()) + " bytes");
bluetoothTable.sendValueUpdate("Status", counter % 2 == 0 ? "Running" : "Active");
Serial.println("Table values updated");
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
updateTableValues();
}
delay(10);
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code vers l'ESP32
- Ouvrez le moniteur série
- Vérifiez le résultat dans le moniteur série. Il ressemble à ce qui suit :
COM6
DIYables Bluetooth - ESP32 BLE Table Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
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 :
- Accédez à Paramètres > Bluetooth de votre téléphone
- Assurez-vous que le Bluetooth est activé
- Votre téléphone va rechercher les appareils disponibles
- Trouvez et touchez "ESP32_Table" dans la liste des appareils disponibles
- Confirmez la demande d'appairage (aucun code PIN requis)
- Attendez qu'il affiche "Paired" 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 Bluetooth DIYables
- Lors de la première ouverture de l'application, elle vous demandera des autorisations. Veuillez accorder les suivantes :
- Périphériques à proximité autorisation (Android 12+) / Bluetooth autorisation (iOS) - requise pour scanner et se connecter à des périphériques Bluetooth
- Autorisation de localisation (Android 11 et versions antérieures uniquement) - requise par les anciennes versions d'Android pour rechercher des périphériques BLE
- Assurez-vous que le Bluetooth est activé sur votre téléphone
- Sur l'écran d'accueil, touchez le bouton Connect. L'application va rechercher à la fois les périphériques BLE et Bluetooth classiques.
- Trouvez et touchez votre appareil dans les résultats du balayage pour vous connecter:
- Pour Bluetooth classique : touchez "ESP32_Table"
- Pour BLE : touchez "ESP32BLE_Table"
- Une fois connecté, l'application retourne automatiquement à l'écran d'accueil. Sélectionnez l'application Table dans le menu des applications.
Remarque : Vous pouvez toucher l'icône des paramètres sur l'écran d'accueil pour masquer/afficher les applications sur l'écran d'accueil. Pour plus de détails, consultez le Manuel d'utilisation de l'application DIYables Bluetooth.
- Le tableau se remplira avec les noms des attributs et leurs valeurs actuelles
Maintenant, revenez au Moniteur Série de l'IDE Arduino. Vous verrez :
COM6
Bluetooth connected!
App requested table data
Sent table structure
Temperature: 25.3
Humidity: 62%
Pressure: 1013 hPa
Counter: 1
Uptime: 0h 0m 5s
Free Heap: 245780
Status: Running
Autoscroll
Clear output
9600 baud
Newline
- Observez les valeurs du tableau qui se mettent à jour en temps réel dans l'application
Personnalisation créative - Adaptez le code à votre projet
Définir les lignes du tableau
Ajouter des lignes d'attributs au tableau (jusqu'à 20 lignes au maximum) :
// Add rows during setup
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Status");
bluetoothTable.addRow("Uptime");
// Check row count
int rows = bluetoothTable.getRowCount();
Serial.println("Total rows: " + String(rows));
// Get attribute name by index
String attr = bluetoothTable.getAttribute(0); // Returns "Temperature"
Mise à jour des valeurs de la ligne
Mettre à jour les valeurs de chaque ligne par nom d'attribut ou par indice :
// Update by attribute name
bluetoothTable.sendValueUpdate("Temperature", "25.3 °C");
bluetoothTable.sendValueUpdate("Humidity", "62%");
bluetoothTable.sendValueUpdate("Status", "Running");
// Update by row index (0-based)
bluetoothTable.sendValueUpdate(0, "25.3 °C"); // First row
bluetoothTable.sendValueUpdate(1, "62%"); // Second row
Gérer les demandes de données de l'application
Lorsque l'application se connecte ou demande un rafraîchissement :
bluetoothTable.onDataRequest([]() {
Serial.println("App requested table data");
bluetoothTable.sendTableStructure(); // Send row names
// Send current values for all rows
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
bluetoothTable.sendValueUpdate("Humidity", String(humidity) + "%");
bluetoothTable.sendValueUpdate("Status", "Online");
});
Vider et reconstruire la table
// Clear all rows
bluetoothTable.clearTable();
// Add new rows
bluetoothTable.addRow("Sensor A");
bluetoothTable.addRow("Sensor B");
// Send updated structure to app
bluetoothTable.sendTableStructure();
Gérer les événements de connexion
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
Comment utiliser le tableau
Interface de l'application
L’interface tabulaire de l’application Bluetooth DIYables affiche :
- Colonne d'attributs: étiquettes de ligne définies par addRow()
- Colonne de valeurs: valeurs actuelles mises à jour par sendValueUpdate()
- Rafraîchissement automatique: les valeurs se mettent à jour en temps réel dès leur arrivée
Limites des tables
- Maximum de 20 lignes par table (MAX_TABLE_ROWS = 20)
- Les noms d'attributs doivent être concis mais descriptifs
- Les valeurs sont affichées sous forme de chaînes de caractères
Exemples de programmation
Tableau de bord des capteurs
// Define sensor dashboard rows
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Light Level");
bluetoothTable.addRow("Air Quality");
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 2000) {
lastUpdate = millis();
float temp = readTemperature();
float hum = readHumidity();
float press = readPressure();
int light = analogRead(34);
int airQuality = analogRead(35);
bluetoothTable.sendValueUpdate("Temperature", String(temp, 1) + " °C");
bluetoothTable.sendValueUpdate("Humidity", String(hum, 0) + "%");
bluetoothTable.sendValueUpdate("Pressure", String(press, 0) + " hPa");
bluetoothTable.sendValueUpdate("Light Level", String(map(light, 0, 4095, 0, 100)) + "%");
bluetoothTable.sendValueUpdate("Air Quality", airQuality < 1000 ? "Good" : "Poor");
}
delay(10);
}
Moniteur d'état du système
bluetoothTable.addRow("Uptime");
bluetoothTable.addRow("Free Heap");
bluetoothTable.addRow("CPU Temp");
bluetoothTable.addRow("WiFi Signal");
bluetoothTable.addRow("Clients");
bluetoothTable.addRow("Status");
void updateSystemStatus() {
unsigned long uptime = millis() / 1000;
int hours = uptime / 3600;
int minutes = (uptime % 3600) / 60;
int seconds = uptime % 60;
bluetoothTable.sendValueUpdate("Uptime",
String(hours) + "h " + String(minutes) + "m " + String(seconds) + "s");
bluetoothTable.sendValueUpdate("Free Heap", String(ESP.getFreeHeap()) + " bytes");
bluetoothTable.sendValueUpdate("CPU Temp", String(temperatureRead(), 1) + " °C");
bluetoothTable.sendValueUpdate("Status", "Online");
}
Tableau des états des broches GPIO
const int PINS[] = {2, 4, 5, 12, 13, 14, 15, 16};
const int NUM_PINS = sizeof(PINS) / sizeof(PINS[0]);
void setup() {
// ... Bluetooth setup ...
for (int i = 0; i < NUM_PINS; i++) {
pinMode(PINS[i], INPUT);
bluetoothTable.addRow("GPIO " + String(PINS[i]));
}
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
for (int i = 0; i < NUM_PINS; i++) {
int state = digitalRead(PINS[i]);
bluetoothTable.sendValueUpdate("GPIO " + String(PINS[i]),
state == HIGH ? "HIGH ?" : "LOW ?");
}
}
delay(10);
}
Réseau de capteurs analogiques
struct SensorConfig {
String name;
int pin;
String unit;
float scale;
};
SensorConfig sensors[] = {
{"Temperature", 34, "°C", 0.0488},
{"Humidity", 35, "%", 0.0244},
{"Light", 36, "lux", 0.244},
{"Pressure", 39, "hPa", 0.488}
};
const int NUM_SENSORS = sizeof(sensors) / sizeof(sensors[0]);
void setup() {
// ... Bluetooth setup ...
for (int i = 0; i < NUM_SENSORS; i++) {
bluetoothTable.addRow(sensors[i].name);
}
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 2000) {
lastUpdate = millis();
for (int i = 0; i < NUM_SENSORS; i++) {
int raw = analogRead(sensors[i].pin);
float value = raw * sensors[i].scale;
bluetoothTable.sendValueUpdate(sensors[i].name,
String(value, 1) + " " + sensors[i].unit);
}
}
delay(10);
}
Techniques de programmation avancées
Mise en forme conditionnelle avec des émojis
void updateTemperatureRow(float temp) {
String status;
if (temp < 10) {
status = "❄️ " + String(temp, 1) + " °C (Cold)";
} else if (temp < 30) {
status = "✅ " + String(temp, 1) + " °C (Normal)";
} else {
status = "🔥 " + String(temp, 1) + " °C (Hot!)";
}
bluetoothTable.sendValueUpdate("Temperature", status);
}
Mises à jour basées sur les événements
float lastTemp = 0;
float threshold = 0.5; // Only update on significant change
void loop() {
bluetoothServer.loop();
float temp = readTemperature();
if (abs(temp - lastTemp) >= threshold) {
lastTemp = temp;
bluetoothTable.sendValueUpdate("Temperature", String(temp, 1) + " °C");
bluetoothTable.sendValueUpdate("Last Change", getTimestamp());
}
delay(100);
}
Idées d'intégration du matériel
Tableau de station météorologique BME280
Connectez un capteur BME280 pour afficher la température, l'humidité et la pression dans le tableau.
Tableau de bord multi-capteurs
Connectez plusieurs capteurs (DHT22, BMP280, LDR, MQ-135) et affichez toutes les lectures sous forme de lignes.
Panneau d'informations sur l'appareil
Afficher les informations système de l'ESP32 : modèle de puce, taille de la mémoire flash, mémoire libre (heap), temps de fonctionnement et adresse MAC.
BLE vs Bluetooth Classique - Lequel faut-il choisir ?
| Feature | BLE (Esp32BLE_Table) | Classic Bluetooth (Esp32Bluetooth_Table) |
|---|---|---|
| iOS Support | ? Yes | ? No |
| Android Support | ? Yes | ? Yes |
| Power Consumption | Low | Higher |
| Range | ~30-100m | ~10-100m |
| Data Rate | Lower | Higher |
| Pairing Required | No (auto-connect) | Yes (manual pairing) |
| Best For | Battery-powered, cross-platform | High throughput, Android-only |
Dépannage
Problèmes courants
- Impossible de trouver l'appareil dans l'application.
- Assurez-vous que l'ESP32 est sous tension et que le sketch est téléversé
- Pour le BLE : Assurez-vous que le Bluetooth et la localisation de votre téléphone sont activés
- Pour le Bluetooth classique : appairez d'abord l'appareil dans les paramètres Bluetooth de votre téléphone
- Vérifiez que le bon schéma de partition est sélectionné (Huge APP)
2. Le tableau ne montre aucune donnée
- Assurez-vous que sendTableStructure() est appelée dans le rappel onDataRequest
- Vérifiez que les lignes sont ajoutées avec addRow() avant l'envoi des mises à jour
- Vérifiez le Moniteur Série pour le message "App requested table data"
3. Les valeurs ne se mettent pas à jour
- Vérifiez que le nom de l'attribut dans sendValueUpdate() correspond exactement à celui qui a été ajouté avec addRow()
- Vérifiez que votre minuterie d'intervalle de mise à jour fonctionne
- Assurez-vous que le Bluetooth est toujours connecté
4. Lignes manquantes dans le tableau
- Un maximum de 20 lignes est pris en charge
- Vérifiez getRowCount() pour vous assurer que toutes les lignes ont été ajoutées
- Les lignes doivent être ajoutées avant l'envoi de la structure du tableau
- La connexion se coupe fréquemment
- Approchez-vous de l'ESP32 (réduire la distance)
- Pour le BLE : Vérifiez les interférences provenant d'autres appareils BLE
- Pour le Bluetooth classique : Assurez une alimentation stable pour l'ESP32
- Esquisse trop grande / pas assez d'espace
- Dans l'IDE Arduino, 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 qu'environ ~1,2 Mo pour le code d'application, ce qui n'est pas suffisant pour les bibliothèques Bluetooth
- Ce réglage offre environ ~3 Mo en sacrifiant la partition OTA (mise à jour sans fil)
Astuces de débogage
Ajouter un débogage exhaustif :
void debugTable() {
Serial.println("=== Table Debug ===");
Serial.println("Row Count: " + String(bluetoothTable.getRowCount()));
for (int i = 0; i < bluetoothTable.getRowCount(); i++) {
Serial.println("Row " + String(i) + ": " + bluetoothTable.getAttribute(i));
}
Serial.println("===================");
}
Idées de projets
Tableaux de bord de surveillance
- Affichage de la station météo (température, humidité, pression, vent)
- Moniteur d’état du serveur et du réseau
- Tableau de bord des soins des plantes (humidité du sol, lumière, température)
- Moniteur d’aquarium (température, pH, TDS)
Informations système
- Tableau de diagnostics du système ESP32
- Détails de la connexion Wi-Fi
- Moniteur de l’utilisation de la mémoire
- Affichage de l'état de la batterie
Enregistrement des données
- Suivi des valeurs min/max/moyenne du capteur
- Affichage du compteur d'événements
- Statistiques de timing (temps de réponse, temps de fonctionnement)
- Résumé de l'état des broches d'entrée/sortie
Domotique
- Affichage de la température par pièce
- Aperçu de l'état des appareils
- Résumé de la consommation d'énergie
- État des capteurs de sécurité
Intégration avec d'autres applications Bluetooth
Utiliser avec un traceur Bluetooth
Afficher les valeurs sous forme de tableau et visualiser les tendances dans le traceur :
float temperature = 0;
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 2000) {
lastUpdate = millis();
temperature = readTemperature();
// Update table
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
bluetoothTable.sendValueUpdate("Status", temperature > 30 ? "Warning" : "Normal");
// Plot trend
bluetoothPlotter.send(temperature);
}
delay(10);
}
Combiner avec le moniteur Bluetooth
Utilisez un tableau pour les données structurées et surveillez les messages de journalisation :
bluetoothTable.sendValueUpdate("Temperature", String(temp, 1) + " °C");
bluetoothMonitor.send("[INFO] Temperature: " + String(temp, 1) + " °C");
if (temp > 40) {
bluetoothTable.sendValueUpdate("Status", "? ALERT");
bluetoothMonitor.send("[ALERT] High temperature detected!");
}
Étapes suivantes
Après avoir maîtrisé l'exemple de la Table Bluetooth, essayez :
- Bluetooth Monitor - Pour l'enregistrement de texte libre
- Bluetooth Plotter - Pour visualiser les tendances des données
- Bluetooth Temperature - Pour un affichage dédié de la température
- Multiple Bluetooth Apps - Combiner un tableau avec d'autres affichages
Assistance
Pour obtenir de l'aide supplémentaire :
- Consultez la documentation de l’API
- Visitez tutoriels de DIYables
- Forums de la communauté Arduino