ESP32 Bluetooth Jauge Analogique - Tutoriel d'Affichage Jauge Analogique
Vue d'ensemble
L'exemple de jauge analogique Bluetooth fournit un affichage de compteur analogique classique accessible via l'application DIYables Bluetooth STEM. Conçu pour les cartes ESP32 avec prise en charge des connexions BLE (Bluetooth Low Energy) et Bluetooth Classique. Envoyez des valeurs numériques avec une plage et des étiquettes d'unité configurables — parfait pour les compteurs de vitesse, les jauges de pression, les voltmètres et toute application nécessitant un affichage à cadran analogique.
Cet exemple prend en charge deux modes Bluetooth :
- ESP32 BLE (Bluetooth Low Energy) : Fonctionne sur Android et iOS
- ESP32 Bluetooth Classique : Fonctionne uniquement sur Android. iOS ne prend pas en charge le Bluetooth Classique. Utilisez BLE si vous avez besoin du support iOS.
Fonctionnalités
- Affichage Jauge Analogique : Visualisation classique de style cadran/compteur
- Plage Configurable : Définissez les valeurs minimales et maximales pour la jauge
- Unités Personnalisées : Affichez km/h, PSI, V, %, ou toute chaîne d'unité personnalisée
- Mises à jour en Temps Réel : Envoyez des relevés en direct avec mouvement d'aiguille fluide
- Callback de Requête : L'app peut demander la valeur actuelle sur demande
- BLE et Bluetooth Classique : Choisissez le mode Bluetooth qui convient à votre projet
- Multi-plateforme : 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 (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'IDE Arduino 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'IDE Arduino.
- Recherchez "DIYables Bluetooth", puis trouvez la bibliothèque DIYables Bluetooth par DIYables
- Cliquez sur le bouton Install pour installer la bibliothèque.
- Il vous sera demandé d'installer d'autres dépendances de bibliothèque
- Cliquez sur le bouton Install All pour installer toutes les dépendances de bibliothèque.
Choisissez l'un des deux modes Bluetooth ci-dessous selon vos besoins :
Code ESP32 Bluetooth Classique (fonctionne avec l'app sur Android uniquement)
Note : Le Bluetooth Classique n'est PAS pris en charge sur iOS. Si vous avez besoin du support iOS, utilisez le code BLE ci-dessous.
- Dans l'IDE Arduino, allez à File Examples DIYables Bluetooth Esp32Bluetooth_AnalogGauge exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Analog Gauge 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 Analog Gauge feature:
* - Display values on an analog meter/gauge
* - Configurable range and unit
* - Perfect for sensor monitoring (speed, pressure, voltage, etc.)
*
* 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
*
* Optional: Analog sensor (potentiometer, pressure sensor, etc.)
*
* 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 gauge
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothAnalogGauge.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Gauge");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Analog Gauge app instance (min=0, max=100, unit="km/h")
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 100.0, "km/h");
// Variables for gauge value
float currentValue = 0.0;
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 200; // Update every 200ms
// Optional: Analog input pin for sensor
const int ANALOG_PIN = 34; // ESP32 ADC pin
// Function to read sensor value
float readSensorValue() {
// TODO: Replace with actual sensor reading
// Examples:
// - Pressure sensor: readPressure()
// - Voltage sensor: analogRead(34) * (3.3 / 4095.0)
// - Speed sensor: calculateSpeed()
// Option 1: Read from analog pin and map to gauge range
// int rawValue = analogRead(ANALOG_PIN);
// return map(rawValue, 0, 4095, 0, 100);
// Option 2: Simulated data (sine wave)
static float phase = 0;
phase += 0.05;
if (phase > 2 * PI) phase = 0;
return 50 + 50 * sin(phase); // Oscillates between 0-100
}
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Analog Gauge Example");
// Optional: Initialize analog pin
// pinMode(ANALOG_PIN, INPUT);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add gauge app to server
bluetoothServer.addApp(&bluetoothGauge);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send initial value
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Initial value sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Optional: Handle requests for current value
bluetoothGauge.onValueRequest([]() {
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Value requested - Sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
// You can change gauge configuration at runtime:
// bluetoothGauge.setRange(0.0, 200.0); // Change range to 0-200
// bluetoothGauge.setUnit("mph"); // Change unit to mph
// bluetoothGauge.setRange(0.0, 3.3); // For voltage (0-3.3V on ESP32)
// bluetoothGauge.setUnit("V");
Serial.println("Waiting for Bluetooth connection...");
Serial.print("Gauge range: ");
Serial.print(bluetoothGauge.getMin());
Serial.print(" - ");
Serial.print(bluetoothGauge.getMax());
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Send gauge updates periodically (only when connected)
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
// Read sensor value
currentValue = readSensorValue();
// Send to Bluetooth app
bluetoothGauge.send(currentValue);
// Print to Serial Monitor
Serial.print("Gauge: ");
Serial.print(currentValue, 1);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
delay(10);
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour télécharger le code sur l'ESP32
- Ouvrez le Moniteur Série
- Vérifiez le résultat sur le Moniteur Série. Il ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 Analog Gauge Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Code ESP32 BLE (fonctionne avec l'app sur Android et iOS)
- Dans l'IDE Arduino, allez à File Examples DIYables Bluetooth Esp32BLE_AnalogGauge exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 BLE Analog Gauge Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Analog Gauge feature:
* - Display values on an analog meter/gauge
* - Configurable range and unit
* - Perfect for sensor monitoring (speed, pressure, voltage, etc.)
*
* 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
*
* Optional: Analog sensor (potentiometer, pressure sensor, etc.)
*
* 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 gauge
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothAnalogGauge.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Gauge";
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 Analog Gauge app instance (min=0, max=100, unit="km/h")
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 100.0, "km/h");
// Variables for gauge value
float currentValue = 0.0;
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 200; // Update every 200ms
// Optional: Analog input pin for sensor
const int ANALOG_PIN = 34; // ESP32 ADC pin
// Function to read sensor value
float readSensorValue() {
// TODO: Replace with actual sensor reading
// Option 1: Read from analog pin and map to gauge range
// int rawValue = analogRead(ANALOG_PIN);
// return map(rawValue, 0, 4095, 0, 100); // ESP32 has 12-bit ADC
// Option 2: Simulated data (sine wave)
static float phase = 0;
phase += 0.05;
if (phase > 2 * PI) phase = 0;
return 50 + 50 * sin(phase); // Oscillates between 0-100
}
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Analog Gauge Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add gauge app to server
bluetoothServer.addApp(&bluetoothGauge);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Initial value sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
bluetoothGauge.onValueRequest([]() {
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Value requested - Sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
Serial.println("Waiting for Bluetooth connection...");
Serial.print("Gauge range: ");
Serial.print(bluetoothGauge.getMin());
Serial.print(" - ");
Serial.print(bluetoothGauge.getMax());
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Gauge: ");
Serial.print(currentValue, 1);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
delay(10);
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour télécharger le code sur l'ESP32
- Ouvrez le Moniteur Série
- Vérifiez le résultat sur le Moniteur Série. Il ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 BLE Analog Gauge 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 :
- 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_Gauge" dans la liste des appareils disponibles
- Confirmez la demande d'appairage (aucun PIN requis)
- Attendez jusqu'à ce 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 DIYables Bluetooth
- Lors de la première ouverture de l'application, elle demande des autorisations. 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 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 Classique.
- Trouvez et appuyez sur votre appareil dans les résultats de scan pour vous connecter :
- Pour Bluetooth Classique : appuyez sur "ESP32_Gauge"
- Pour BLE : appuyez sur "ESP32BLE_Gauge"
- Une fois connecté, l'application retourne automatiquement à l'écran d'accueil. Sélectionnez l'application Analog Gauge dans le menu des applications.
Note : Vous pouvez appuyer sur 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, voir le Manuel Utilisateur de l'Application DIYables Bluetooth.
- La jauge analogique affichera la valeur actuelle avec une aiguille qui bouge
Maintenant, regardez le Moniteur Série dans l'IDE Arduino. Vous verrez :
COM6
Bluetooth connected!
Gauge value: 50.0 km/h
Gauge value: 75.0 km/h
Gauge value: 93.3 km/h
Gauge value: 100.0 km/h
Autoscroll
Clear output
9600 baud
Newline
- Observez l'aiguille de la jauge se déplacer en temps réel dans l'application
Personnalisation Créative - Adaptez le Code à Votre Projet
Configurer la Plage et l'Unité de la Jauge
Définissez la plage d'affichage et l'unité :
// Constructeur : DIYables_BluetoothAnalogGauge(min, max, unité)
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 100.0, "km/h");
// Changer la plage à l'exécution
bluetoothGauge.setRange(0.0, 200.0);
// Changer l'unité
bluetoothGauge.setUnit("MPH");
// Lire la configuration actuelle
float minVal = bluetoothGauge.getMin(); // Retourne 0.0
float maxVal = bluetoothGauge.getMax(); // Retourne 100.0
String unit = bluetoothGauge.getUnit(); // Retourne "km/h"
Envoyer la Valeur de la Jauge
// Envoyer la lecture actuelle
float speed = 72.5;
bluetoothGauge.send(speed);
// Envoyer un message texte
bluetoothGauge.send("Étalonnage...");
Gérer les Demandes de Valeur de l'Application
bluetoothGauge.onValueRequest([]() {
float currentValue = readSensor();
bluetoothGauge.send(currentValue);
Serial.println("L'app a demandé la valeur : " + String(currentValue));
});
Gérer les Événements de Connexion
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connecté !");
bluetoothGauge.send(currentValue); // Envoyer la lecture actuelle
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth déconnecté !");
});
Comment Utiliser la Jauge Analogique
Interface de l'Application
L'interface de la jauge analogique dans l'application DIYables Bluetooth affiche :
- Cadran/Aiguille : Compteur analogique classique avec aiguille mobile
- Affichage Numérique : Affiche la valeur actuelle exacte
- Étiquette d'Unité : Affiche la chaîne d'unité configurée
- Graduations : Affiche l'échelle graduée du min au max
Configurations d'Unités Courantes
- Vitesse : DIYables_BluetoothAnalogGauge(0.0, 200.0, "km/h")
- Pression : DIYables_BluetoothAnalogGauge(0.0, 100.0, "PSI")
- Voltage : DIYables_BluetoothAnalogGauge(0.0, 5.0, "V")
- Pourcentage : DIYables_BluetoothAnalogGauge(0.0, 100.0, "%")
- RPM : DIYables_BluetoothAnalogGauge(0.0, 8000.0, "RPM")
Exemples de Programmation
Voltmètre
const int VOLTAGE_PIN = 34;
const float VREF = 3.3;
const float DIVIDER_RATIO = 5.0; // Ratio du diviseur de tension
// Jauge configurée pour plage 0-16V
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 16.0, "V");
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 500) {
lastUpdate = millis();
int raw = analogRead(VOLTAGE_PIN);
float voltage = (raw / 4095.0) * VREF * DIVIDER_RATIO;
bluetoothGauge.send(voltage);
Serial.println("Tension : " + String(voltage, 2) + " V");
}
delay(10);
}
Manomètre (BMP280)
#include <Adafruit_BMP280.h>
Adafruit_BMP280 bmp;
// Jauge configurée pour plage de pression atmosphérique
DIYables_BluetoothAnalogGauge bluetoothGauge(900.0, 1100.0, "hPa");
void setup() {
Serial.begin(115200);
bmp.begin(0x76);
// ... Configuration Bluetooth ...
bluetoothGauge.onValueRequest([]() {
float pressure = bmp.readPressure() / 100.0; // Pa vers hPa
bluetoothGauge.send(pressure);
});
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
float pressure = bmp.readPressure() / 100.0;
bluetoothGauge.send(pressure);
Serial.println("Pression : " + String(pressure, 1) + " hPa");
}
delay(10);
}
Capteur de Courant (ACS712)
const int CURRENT_PIN = 34;
const float SENSITIVITY = 0.185; // ACS712-05B: 185mV/A
const float ZERO_CURRENT_VOLTAGE = 2.5;
// Jauge configurée pour plage 0-5A
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 5.0, "A");
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 200) {
lastUpdate = millis();
int raw = analogRead(CURRENT_PIN);
float voltage = (raw / 4095.0) * 3.3;
float current = abs((voltage - ZERO_CURRENT_VOLTAGE) / SENSITIVITY);
bluetoothGauge.send(current);
Serial.println("Courant : " + String(current, 2) + " A");
}
delay(10);
}
Vitesse depuis Encodeur
volatile unsigned long pulseCount = 0;
const int ENCODER_PIN = 2;
const float PULSES_PER_REV = 20.0;
const float WHEEL_CIRCUMFERENCE = 0.628; // mètres (diamètre 20cm)
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 50.0, "km/h");
void IRAM_ATTR countPulse() {
pulseCount++;
}
void setup() {
Serial.begin(115200);
pinMode(ENCODER_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(ENCODER_PIN), countPulse, RISING);
// ... Configuration Bluetooth ...
}
void loop() {
bluetoothServer.loop();
static unsigned long lastCalc = 0;
if (millis() - lastCalc >= 500) {
unsigned long elapsed = millis() - lastCalc;
lastCalc = millis();
noInterrupts();
unsigned long count = pulseCount;
pulseCount = 0;
interrupts();
float revPerSec = (count / PULSES_PER_REV) / (elapsed / 1000.0);
float speedKmh = revPerSec * WHEEL_CIRCUMFERENCE * 3.6;
bluetoothGauge.send(speedKmh);
Serial.println("Vitesse : " + String(speedKmh, 1) + " km/h");
}
delay(10);
}
Techniques de Programmation Avancées
Mouvement d'Aiguille Fluide
float displayValue = 0;
float targetValue = 0;
const float SMOOTHING = 0.1; // 0.0-1.0, plus bas = plus fluide
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 50) { // 20 FPS
lastUpdate = millis();
targetValue = readSensor();
displayValue += (targetValue - displayValue) * SMOOTHING;
bluetoothGauge.send(displayValue);
}
delay(5);
}
Maintien de Pic
float peakValue = 0;
unsigned long peakTime = 0;
const unsigned long PEAK_HOLD_MS = 3000; // Maintenir le pic pendant 3 secondes
void updateWithPeakHold(float value) {
if (value > peakValue) {
peakValue = value;
peakTime = millis();
}
if (millis() - peakTime > PEAK_HOLD_MS) {
peakValue = value; // Réinitialiser le pic
}
// Envoyer le plus élevé entre actuel ou pic
bluetoothGauge.send(max(value, peakValue));
}
Mise à l'Échelle Automatique de la Plage
float autoMin = 0;
float autoMax = 100;
void autoScale(float value) {
bool changed = false;
if (value < autoMin) {
autoMin = value - 10;
changed = true;
}
if (value > autoMax) {
autoMax = value + 10;
changed = true;
}
if (changed) {
bluetoothGauge.setRange(autoMin, autoMax);
}
bluetoothGauge.send(value);
}
Idées d'Intégration Matériel
Capteurs Analogiques
Tout capteur avec sortie analogique peut piloter la jauge : potentiomètres, capteurs de force, capteurs de flexion, et plus encore.
Capteurs I2C/SPI
Utilisez des capteurs I2C comme BMP280 (pression), INA219 (courant/puissance), ou capteurs SPI pour mesure haute vitesse.
Capteurs Impulsion/Fréquence
Encodeurs de vitesse, débitmètres et capteurs RPM utilisant le comptage basé sur interruption.
Cellules de Charge (HX711)
Mesure de poids avec l'amplificateur HX711 pour balances de cuisine ou pesage industriel.
BLE vs Bluetooth Classique - Lequel Choisir ?
| Fonctionnalité | BLE (Esp32BLE_AnalogGauge) | Bluetooth Classique (Esp32Bluetooth_AnalogGauge) |
|---|---|---|
| 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 (auto-connexion) | Oui (appairage manuel) |
| Idéal 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 le sketch téléchargé
- Pour BLE : Assurez-vous que le Bluetooth et la 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 bon schéma de partition est sélectionné (Huge APP)
2. La jauge affiche 0 ou une valeur incorrecte
- Vérifiez le câblage et les connexions du capteur
- Vérifiez d'abord la lecture du capteur avec le Moniteur Série
- Assurez-vous que la valeur est dans la plage configurée
- Vérifiez la configuration de l'unité et de la plage dans le constructeur
3. L'aiguille de la jauge ne bouge pas en douceur
- Augmentez la fréquence de mise à jour (intervalle plus petit dans la vérification millis())
- Appliquez un lissage/filtrage aux lectures du capteur
- Vérifiez le bruit du capteur ou les lectures instables
4. Valeurs hors plage de la jauge
- Ajustez la plage avec setRange(min, max) pour correspondre à la sortie de votre capteur
- Les valeurs hors plage s'afficheront mais peuvent être coupées au min/max
- Considérez la mise à l'échelle automatique pour les plages inconnues
5. Connexion qui tombe 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 pour l'ESP32
6. Sketch trop volumineux / pas assez d'espace
- Dans l'IDE Arduino, 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 de l'app, ce qui n'est pas suffisant pour les bibliothèques Bluetooth
- Ce paramètre donne ~3MB en sacrifiant la partition OTA (mise à jour sans fil)
Conseils de Débogage
Ajoutez un débogage complet :
void debugGauge(float value) {
Serial.println("=== Debug Jauge ===");
Serial.println("Valeur : " + String(value, 2) + " " + bluetoothGauge.getUnit());
Serial.println("Plage : " + String(bluetoothGauge.getMin(), 1) + " - " + String(bluetoothGauge.getMax(), 1));
Serial.println("Dans la Plage : " + String(value >= bluetoothGauge.getMin() && value <= bluetoothGauge.getMax() ? "Oui" : "Non"));
float percentage = (value - bluetoothGauge.getMin()) / (bluetoothGauge.getMax() - bluetoothGauge.getMin()) * 100.0;
Serial.println("Pourcentage : " + String(percentage, 1) + "%");
Serial.println("===================");
}
Idées de Projets
Véhicule et Mouvement
- Compteur de vitesse pour voiture RC ou vélo
- Compte-tours RPM pour moteurs
- Compteur de force G pour accélération
- Indicateur d'angle d'inclinaison
Électrique et Puissance
- Voltmètre (moniteur de tension batterie)
- Ampèremètre (consommation de courant)
- Wattmètre (usage de puissance)
- Jauge de niveau de batterie
Environnemental
- Manomètre barométrique
- Vitesse du vent (anémomètre)
- Compteur d'index UV
- Sonomètre (dB)
Industriel
- Affichage balance
- Compteur de débit
- Indicateur de niveau de réservoir
- Compteur de couple
Intégration avec Autres Applications Bluetooth
Combiner avec Bluetooth Temperature
Jauge pour une métrique, température pour une autre :
// La jauge affiche la pression
bluetoothGauge.send(pressure);
// La température affiche la température
bluetoothTemperature.send(temperature);
Combiner avec Bluetooth Table
Jauge pour le visuel, tableau pour les détails :
float speed = readSpeed();
bluetoothGauge.send(speed);
bluetoothTable.sendValueUpdate("Vitesse", String(speed, 1) + " km/h");
bluetoothTable.sendValueUpdate("Distance", String(totalDistance, 2) + " km");
bluetoothTable.sendValueUpdate("Vitesse Max", String(maxSpeed, 1) + " km/h");
bluetoothTable.sendValueUpdate("Vitesse Moy", String(avgSpeed, 1) + " km/h");
Prochaines Étapes
Après avoir maîtrisé l'exemple de jauge analogique Bluetooth, essayez :
- Bluetooth Temperature - Pour affichage de température dédié
- Bluetooth Plotter - Pour visualisation de tendances dans le temps
- Bluetooth Table - Pour affichage structuré multi-valeurs
- Applications Bluetooth Multiples - Combinaison de jauge avec autres affichages
Support
Pour une aide supplémentaire :
- Consultez la documentation de référence API
- Visitez les tutoriels DIYables
- Forums de la communauté Arduino