ESP32 Exemple Rotateur Bluetooth - Tutoriel Interface de Contrôle Disque/Bouton Rotatif
Aperçu
L'exemple Rotateur Bluetooth fournit un contrôle de disque/bouton rotatif accessible via l'application DIYables Bluetooth STEM. Conçu pour les cartes ESP32 avec support pour les connexions BLE (Bluetooth Low Energy) et Bluetooth Classique. Le rotateur envoie des valeurs d'angle et prend en charge les modes d'angle continu (0-360°) ou limité — parfait pour le contrôle de servo, affichage de boussole, boutons de volume, et toute application nécessitant une entrée rotative.
Cet exemple prend en charge deux modes Bluetooth :
- ESP32 BLE (Bluetooth Low Energy) : Fonctionne sur Android et iOS
- ESP32 Bluetooth Classique : Fonctionne sur Android uniquement. iOS ne prend pas en charge le Bluetooth Classique. Utilisez BLE si vous avez besoin du support iOS.
Fonctionnalités
- Bouton Rotatif : Touchez et faites glisser pour faire tourner le disque à l'écran
- Mode Continu : Rotation complète de 360° sans limites
- Mode Limité : Plage d'angle contrainte (ex. 0-180° pour servos)
- Sortie d'Angle : Valeur d'angle float envoyée en temps réel
- Compatible Servo : Mappage direct vers les angles de servo (0-180°)
- BLE & 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 Faible 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, référez-vous au tutoriel sur Installation du logiciel ESP32..
- Connectez la carte ESP32 à votre ordinateur en utilisant 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 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.
- 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 la 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 supporté 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_Rotator, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Rotator 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 Rotator feature:
* - Rotatable disc/knob control (0-360 degrees)
* - Continuous or limited angle range
* - Perfect for servo control, compass display, volume knobs
*
* 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: Servo motor for visual feedback
*
* 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 rotate the knob
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothRotator.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Rotator");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Rotator app instance
// Option 1: Continuous mode (0-360, wraps around)
// DIYables_BluetoothRotator bluetoothRotator(ROTATOR_MODE_CONTINUOUS);
// Option 2: Limited mode (constrained angle range)
DIYables_BluetoothRotator bluetoothRotator(ROTATOR_MODE_LIMITED, 0, 180);
// Variables to store current angle
float currentAngle = 0.0;
// Optional: Servo control (uncomment if using ESP32Servo library)
// #include <ESP32Servo.h>
// Servo myServo;
// const int SERVO_PIN = 13;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Rotator Example");
// Optional: Initialize servo
// myServo.attach(SERVO_PIN);
// myServo.write(0);
bluetoothServer.begin();
bluetoothServer.addApp(&bluetoothRotator);
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothRotator.send(currentAngle);
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
Serial.print("Rotator angle: ");
Serial.print(angle);
Serial.println("°");
// TODO: Add your control logic here based on angle
// Examples:
// - Servo control: myServo.write((int)angle);
// - Stepper motor: stepper.moveTo(angleToSteps(angle));
// - LED ring: setLEDPosition(angle);
// - Volume control: setVolume(map(angle, 0, 360, 0, 100));
});
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
bluetoothServer.loop();
delay(10);
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code vers l'ESP32
- Ouvrez le Serial Monitor
- Vérifiez le résultat sur le Serial Monitor. Cela ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 Rotator 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_Rotator, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 BLE Rotator Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Rotator feature:
* - Rotatable disc/knob control (0-360 degrees)
* - Continuous or limited angle range
* - Perfect for servo control, compass display, volume knobs
*
* 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: Servo motor for visual feedback
*
* 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 rotate the knob
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothRotator.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Rotator";
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 Rotator app instance
DIYables_BluetoothRotator bluetoothRotator(ROTATOR_MODE_LIMITED, 0, 180);
// Variables to store current angle
float currentAngle = 0.0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Rotator Example");
bluetoothServer.begin();
bluetoothServer.addApp(&bluetoothRotator);
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothRotator.send(currentAngle);
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
Serial.print("Rotator angle: ");
Serial.print(angle);
Serial.println("°");
// TODO: Add your control logic here based on angle
});
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
bluetoothServer.loop();
delay(10);
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code vers l'ESP32
- Ouvrez le Serial Monitor
- Vérifiez le résultat sur le Serial Monitor. Cela ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 BLE Rotator 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_Rotator" 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 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 Classique.
- Trouvez et appuyez sur votre appareil dans les résultats de scan pour vous connecter :
- Pour Bluetooth Classique : appuyez sur "ESP32_Rotator"
- Pour BLE : appuyez sur "ESP32BLE_Rotator"
- Une fois connecté, l'application retourne automatiquement à l'écran d'accueil. Sélectionnez l'application Rotator 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 d'Utilisation de l'Application DIYables Bluetooth.
- Faites glisser le bouton du rotateur pour changer l'angle
Maintenant regardez à nouveau le Serial Monitor dans l'IDE Arduino. Vous verrez :
COM6
Bluetooth connected!
Rotator angle: 45.0°
Rotator angle: 90.0°
Rotator angle: 135.0°
Rotator angle: 180.0°
Autoscroll
Clear output
9600 baud
Newline
- Tournez le bouton dans l'application et observez les valeurs d'angle en temps réel dans le Serial Monitor
Personnalisation Créative - Adaptez le Code à Votre Projet
Configurer le Mode Rotateur
Définissez le mode continu ou limité :
// Option 1: Mode continu (0-360°, retour automatique)
DIYables_BluetoothRotator bluetoothRotator(ROTATOR_MODE_CONTINUOUS);
// Option 2: Mode limité (plage d'angle contrainte)
DIYables_BluetoothRotator bluetoothRotator(ROTATOR_MODE_LIMITED, 0, 180);
// Changer le mode à l'exécution :
bluetoothRotator.setRotatorMode(ROTATOR_MODE_LIMITED, 0, 270);
// Lire la configuration actuelle :
int mode = bluetoothRotator.getRotatorMode();
float minAngle = bluetoothRotator.getMinAngle();
float maxAngle = bluetoothRotator.getMaxAngle();
Gérer les Changements d'Angle
Utilisez le callback onRotatorAngle() pour recevoir les valeurs d'angle :
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
Serial.print("Rotator angle: ");
Serial.print(angle);
Serial.println("°");
// TODO: Ajoutez votre logique de contrôle ici
});
Gérer la Demande de Configuration depuis l'App
bluetoothRotator.onGetConfig([]() {
// Envoyer l'angle actuel à l'application
bluetoothRotator.send(currentAngle);
Serial.println("App requested config - sent current angle");
});
Envoyer l'Angle à l'App
Vous pouvez mettre à jour la position du rotateur depuis l'ESP32 :
// Envoyer une valeur d'angle pour mettre à jour l'affichage de l'app
bluetoothRotator.send(90.0); // Définir le rotateur à 90°
// Envoyer un message texte
bluetoothRotator.send("Calibrated");
Gérer les Événements de Connexion
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothRotator.send(currentAngle); // Envoyer la position actuelle
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
Comment Utiliser le Rotateur
Contrôles de l'Interface de l'App
L'interface du rotateur dans l'application DIYables Bluetooth fournit :
- Disque Rotatif : Touchez et faites glisser pour tourner
- Affichage d'Angle : Montre la valeur d'angle actuelle
- Indicateur Visuel : Marque la position de rotation actuelle
Modes Rotateur
- ROTATOR_MODE_CONTINUOUS (0) : Rotation complète de 360°, retour automatique
- ROTATOR_MODE_LIMITED (1) : Contraint à la plage d'angle min/max
Exemples de Programmation
Contrôle de Servo
#include <ESP32Servo.h>
Servo myServo;
const int SERVO_PIN = 13;
void setup() {
myServo.attach(SERVO_PIN);
myServo.write(0);
// Mode limité : 0-180° correspond à la plage du servo
// bluetoothRotator déjà configuré comme (ROTATOR_MODE_LIMITED, 0, 180)
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
myServo.write((int)angle);
Serial.print("Servo: ");
Serial.print((int)angle);
Serial.println("°");
});
}
Bouton Volume/Luminosité
const int PWM_PIN = 16;
void setup() {
pinMode(PWM_PIN, OUTPUT);
// Mode continu : 0-360° mappé à 0-255
bluetoothRotator.setRotatorMode(ROTATOR_MODE_CONTINUOUS);
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
int pwmValue = map((int)angle, 0, 360, 0, 255);
analogWrite(PWM_PIN, pwmValue);
int percentage = map((int)angle, 0, 360, 0, 100);
Serial.print("Volume: ");
Serial.print(percentage);
Serial.println("%");
});
}
Affichage Boussole
// Lire le cap de la boussole depuis le capteur et l'afficher sur le rotateur
float getCompassHeading() {
// TODO: Lire depuis HMC5883L, QMC5883L, ou BMM150
// Retourner le cap en degrés 0-360
return 0.0;
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 500) {
lastUpdate = millis();
float heading = getCompassHeading();
bluetoothRotator.send(heading); // Mettre à jour l'affichage du rotateur
}
delay(10);
}
Contrôle de Moteur Pas à Pas
#include <AccelStepper.h>
AccelStepper stepper(AccelStepper::DRIVER, 16, 17);
const int STEPS_PER_REV = 200;
void setup() {
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
// Convertir l'angle en position du stepper
long targetSteps = (long)(angle / 360.0 * STEPS_PER_REV);
stepper.moveTo(targetSteps);
Serial.print("Stepper target: ");
Serial.print(targetSteps);
Serial.println(" steps");
});
}
void loop() {
bluetoothServer.loop();
stepper.run();
delay(1);
}
Techniques de Programmation Avancées
Accrochage d'Angle par Incréments
bluetoothRotator.onRotatorAngle([](float angle) {
// Accrocher au plus proche incrément de 15°
float snapped = round(angle / 15.0) * 15.0;
currentAngle = snapped;
Serial.print("Snapped angle: ");
Serial.print(snapped, 0);
Serial.println("°");
// Mettre à jour l'app pour montrer la valeur accrochée
bluetoothRotator.send(snapped);
});
Contrôle Basé sur des Zones
bluetoothRotator.onRotatorAngle([](float angle) {
currentAngle = angle;
// Diviser 360° en zones
if (angle < 90) {
Serial.println("Zone: NORD");
setColor(0, 0, 255); // Bleu
} else if (angle < 180) {
Serial.println("Zone: EST");
setColor(0, 255, 0); // Vert
} else if (angle < 270) {
Serial.println("Zone: SUD");
setColor(255, 0, 0); // Rouge
} else {
Serial.println("Zone: OUEST");
setColor(255, 255, 0); // Jaune
}
});
BLE vs Bluetooth Classique - Lequel Choisir ?
| Fonctionnalité | BLE (Esp32BLE_Rotator) | Bluetooth Classique (Esp32Bluetooth_Rotator) |
|---|---|---|
| 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 | Alimentation par batterie, multi-plateforme | Haut débit, Android uniquement |
Dépannage
Problèmes Courants
1. Impossible de trouver l'appareil dans l'app
- Assurez-vous que l'ESP32 est alimenté et que le sketch est téléversé
- 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. Le rotateur ne répond pas
- Vérifiez le statut de connexion Bluetooth dans l'app
- Vérifiez la connexion dans le Serial Monitor
- Essayez de vous déconnecter et de vous reconnecter
3. Les valeurs d'angle semblent incorrectes
- Vérifiez la configuration du mode rotateur (continu vs limité)
- Vérifiez les paramètres d'angle min/max avec getMinAngle() et getMaxAngle()
- Vérifiez le Serial Monitor pour les valeurs d'angle réellement reçues
4. Le servo tremble à certains angles
- Ajoutez un petit filtre de zone morte pour les changements d'angle
- Utilisez une alimentation séparée pour le servo
- Ajoutez un condensateur aux broches d'alimentation du servo
5. La connexion se coupe fréquemment
- Rapprochez-vous de l'ESP32 (réduisez 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
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 d'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 debugRotatorValue(float angle) {
Serial.println("=== Rotator Debug ===");
Serial.println("Angle: " + String(angle, 1) + "°");
Serial.println("Mode: " + String(bluetoothRotator.getRotatorMode() == ROTATOR_MODE_CONTINUOUS ? "Continu" : "Limité"));
Serial.println("Plage: " + String(bluetoothRotator.getMinAngle(), 0) + "° - " + String(bluetoothRotator.getMaxAngle(), 0) + "°");
Serial.println("=====================");
}
Idées de Projets
Contrôle de Moteur
- Bouton de position servo
- Sélecteur d'angle moteur pas à pas
- Cadran de vitesse moteur
- Contrôle d'articulation de bras robotique
Projets d'Affichage
- Affichage de cap de boussole
- Aiguilles d'horloge analogique
- Indicateur de direction du vent
- Simulateur de jauge cadran
Projets Audio
- Bouton de contrôle de volume
- Sélecteur de fréquence de ton
- Contrôle de bande d'égaliseur
- Cadran de tuner radio
Projets d'Éclairage
- Contrôle de position d'anneau LED
- Roue de couleur (sélecteur de teinte)
- Contrôle de direction de projecteur
- Angle d'éclairage de scène
Intégration avec Autres Applications Bluetooth
Combiner avec Slider Bluetooth
Utilisez le rotateur pour l'angle et le slider pour la vitesse/intensité :
float speed = 50;
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
speed = slider1;
});
bluetoothRotator.onRotatorAngle([](float angle) {
// Combiner l'angle (direction) avec la vitesse (intensité)
float radians = angle * PI / 180.0;
float x = speed * cos(radians);
float y = speed * sin(radians);
controlMotors(x, y);
});
Combiner avec Table Bluetooth
Afficher les données du rotateur dans un tableau structuré :
bluetoothRotator.onRotatorAngle([](float angle) {
bluetoothTable.sendValueUpdate("Angle", String(angle, 1) + "°");
bluetoothTable.sendValueUpdate("Quadrant", String((int)(angle / 90) + 1));
bluetoothTable.sendValueUpdate("Radians", String(angle * PI / 180.0, 3));
});
Prochaines Étapes
Après avoir maîtrisé l'exemple Rotateur Bluetooth, essayez :
- Joystick Bluetooth - Pour un contrôle directionnel 2D
- Slider Bluetooth - Pour un contrôle de valeur linéaire
- Jauge Analogique Bluetooth - Pour un affichage de retour style jauge
- Applications Bluetooth Multiples - Combiner le rotateur 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