ESP32 Bluetooth Slider Exemple - Tutoriel d'interface à double contrôle curseur
Aperçu
L'exemple Bluetooth Slider fournit deux contrôles de curseur indépendants accessibles via l'application DIYables Bluetooth STEM. Conçu pour les cartes ESP32 avec support pour les connexions BLE (Bluetooth Low Energy) et Bluetooth Classique. Chaque curseur offre des valeurs de 0-100, les rendant parfaits pour le contrôle PWM, l'ajustement de luminosité, le contrôle de vitesse moteur, et toute application nécessitant des valeurs de contrôle analogique.
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
- Double curseurs : Deux contrôles de curseur indépendants (plage 0-100 chacun)
- Valeurs en temps réel : Mises à jour instantanées des valeurs via communication Bluetooth
- Compatible PWM : Valeurs (0-100) facilement mappées aux fonctions analogWrite()
- Retour visuel : Affichage des valeurs en temps réel pour chaque curseur dans l'application
- 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
- Plage et pas configurables : Personnalisez la plage et la taille du pas du curseur à l'exécution
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 à l'aide d'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.
- 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'application 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 Arduino IDE, allez à File Examples DIYables Bluetooth Esp32Bluetooth_Slider exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Slider 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 Slider feature:
* - Control values using sliders (0-100)
* - Support for dual sliders
* - Configurable range and step
*
* 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 control sliders
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothSlider.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Slider");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Slider app instance (min=0, max=100, step=1)
DIYables_BluetoothSlider bluetoothSlider(0, 100, 1);
// Variables to store current slider values
int currentSlider1 = 0;
int currentSlider2 = 0;
// PWM output pins (for LED brightness control example)
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
// ESP32 LEDC PWM channels
const int PWM_CHANNEL_1 = 0;
const int PWM_CHANNEL_2 = 1;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Slider Example");
// Initialize PWM using ESP32 LEDC
ledcSetup(PWM_CHANNEL_1, 5000, 8); // 5kHz, 8-bit resolution
ledcSetup(PWM_CHANNEL_2, 5000, 8);
ledcAttachPin(PWM_PIN_1, PWM_CHANNEL_1);
ledcAttachPin(PWM_PIN_2, PWM_CHANNEL_2);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add slider app to server
bluetoothServer.addApp(&bluetoothSlider);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send initial slider positions
bluetoothSlider.send(currentSlider1, currentSlider2);
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up slider callback for value changes
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Store the received values
currentSlider1 = slider1;
currentSlider2 = slider2;
// Print slider values (0-100)
Serial.print("Slider 1: ");
Serial.print(slider1);
Serial.print(", Slider 2: ");
Serial.println(slider2);
// Map slider values (0-100) to PWM range (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Control LED brightness using ESP32 LEDC
ledcWrite(PWM_CHANNEL_1, pwm1);
ledcWrite(PWM_CHANNEL_2, pwm2);
// TODO: Add your control logic here based on slider values
// Examples:
// - Servo control: myServo.write(map(slider1, 0, 100, 0, 180));
// - Motor speed: ledcWrite(MOTOR_CHANNEL, pwm1);
// - Volume control: setVolume(slider1);
// - Brightness control: setBrightness(slider2);
});
// Optional: Handle requests for current slider values (when app loads)
bluetoothSlider.onGetConfig([]() {
// Send the stored slider values back to the app
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.print("App requested values - Sent: Slider1=");
Serial.print(currentSlider1);
Serial.print(", Slider2=");
Serial.println(currentSlider2);
});
// You can change slider configuration at runtime:
// bluetoothSlider.setRange(0, 255); // Change range to 0-255
// bluetoothSlider.setStep(5); // Change step to 5 (coarser control)
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
delay(10);
}
- Cliquez sur le bouton Upload dans Arduino IDE pour téléverser le code sur l'ESP32
- Ouvrez le Serial Monitor
- Consultez le résultat dans le Serial Monitor. Il ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 Slider Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Code ESP32 BLE (fonctionne avec l'application sur Android et iOS)
- Dans Arduino IDE, allez à File Examples DIYables Bluetooth Esp32BLE_Slider exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 BLE Slider Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Slider feature:
* - Control values using sliders (0-100)
* - Support for dual sliders
* - Configurable range and step
*
* 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 control sliders
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothSlider.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Slider";
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 Slider app instance (min=0, max=100, step=1)
DIYables_BluetoothSlider bluetoothSlider(0, 100, 1);
// Variables to store current slider values
int currentSlider1 = 0;
int currentSlider2 = 0;
// PWM output pins
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Slider Example");
// Initialize PWM pins
pinMode(PWM_PIN_1, OUTPUT);
pinMode(PWM_PIN_2, OUTPUT);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add slider app to server
bluetoothServer.addApp(&bluetoothSlider);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothSlider.send(currentSlider1, currentSlider2);
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up slider callback for value changes
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
Serial.print("Slider 1: ");
Serial.print(slider1);
Serial.print(", Slider 2: ");
Serial.println(slider2);
// Map slider values (0-100) to PWM range (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
analogWrite(PWM_PIN_1, pwm1);
analogWrite(PWM_PIN_2, pwm2);
// TODO: Add your control logic here
});
bluetoothSlider.onGetConfig([]() {
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.print("App requested values - Sent: Slider1=");
Serial.print(currentSlider1);
Serial.print(", Slider2=");
Serial.println(currentSlider2);
});
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
bluetoothServer.loop();
delay(10);
}
- Cliquez sur le bouton Upload dans Arduino IDE pour téléverser le code sur l'ESP32
- Ouvrez le Serial Monitor
- Consultez le résultat dans le Serial Monitor. Il ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 BLE Slider Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Application mobile
- Si vous utilisez le code ESP32 Bluetooth Classique, vous devez jumeler 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 recherchera les appareils disponibles
- Trouvez et touchez "ESP32_Slider" dans la liste des appareils disponibles
- Confirmez la demande d'appairage (aucun 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. Procédez simplement à l'étape suivante.
- Ouvrez l'application DIYables Bluetooth
- Lors de la première ouverture de l'application, elle demandera des autorisations. Veuillez accorder les suivantes :
- Autorisation Nearby Devices (Android 12+) / Bluetooth (iOS) - requis pour scanner et se connecter aux appareils Bluetooth
- Autorisation Location (Android 11 et versions antérieures uniquement) - requis par les anciennes versions d'Android pour scanner les appareils BLE
- Assurez-vous que le Bluetooth est activé sur votre téléphone
- Sur l'écran d'accueil, touchez le bouton Connect. L'application recherchera les appareils BLE et Bluetooth Classique.
- Trouvez et touchez votre appareil dans les résultats de recherche pour vous connecter :
- Pour Bluetooth Classique : touchez "ESP32_Slider"
- Pour BLE : touchez "ESP32BLE_Slider"
- Une fois connecté, l'application revient automatiquement à l'écran d'accueil. Sélectionnez l'application Slider dans le menu des applications.
Note : 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 utilisateur de l'application DIYables Bluetooth.
- Déplacez les deux curseurs pour contrôler les valeurs PWM (0-100)
Maintenant regardez le Serial Monitor dans Arduino IDE. Vous verrez :
COM6
Bluetooth connected!
Slider 1: 50, Slider 2: 30
Slider 1: 75, Slider 2: 30
Slider 1: 75, Slider 2: 60
Slider 1: 100, Slider 2: 85
Autoscroll
Clear output
9600 baud
Newline
- Déplacez les curseurs dans l'application et observez le retour en temps réel dans le Serial Monitor
Personnalisation créative - Adaptez le code à votre projet
Définir les valeurs par défaut des curseurs
Configurez les positions initiales des curseurs :
// Valeurs actuelles des curseurs (0-100)
int currentSlider1 = 25; // Par défaut 25%
int currentSlider2 = 50; // Par défaut 50%
Personnaliser la plage et le pas des curseurs
// Créer une instance d'application Slider avec plage personnalisée (min=0, max=255, pas=5)
DIYables_BluetoothSlider bluetoothSlider(0, 255, 5);
// Ou changer à l'exécution :
bluetoothSlider.setRange(0, 255); // Changer la plage à 0-255
bluetoothSlider.setStep(5); // Changer le pas à 5 (contrôle plus grossier)
// Lire la configuration actuelle :
int currentMin = bluetoothSlider.getMin(); // Obtenir la valeur minimale actuelle
int currentMax = bluetoothSlider.getMax(); // Obtenir la valeur maximale actuelle
int currentStep = bluetoothSlider.getStep(); // Obtenir la valeur de pas actuelle
Gérer la demande de configuration depuis l'application
Quand l'application se connecte et ouvre l'écran Slider, elle demande la configuration des curseurs à l'ESP32. Vous pouvez utiliser le callback onGetConfig() pour envoyer les valeurs actuelles des curseurs à l'application à ce moment :
bluetoothSlider.onGetConfig([]() {
// Ceci est appelé quand l'application demande la configuration des curseurs
// Envoyer les valeurs actuelles des curseurs pour que l'application les affiche correctement
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.println("App requested config - sent current values");
});
Envoyer des valeurs à l'application
Vous pouvez envoyer des valeurs de curseurs de l'ESP32 vers l'application (par exemple, pour mettre à jour les positions des curseurs de l'application) :
// Envoyer les deux valeurs de curseurs à l'application
bluetoothSlider.send(currentSlider1, currentSlider2);
// Envoyer une seule valeur (appliquée aux deux curseurs)
bluetoothSlider.send(50);
Gérer les événements de connexion
Vous pouvez détecter quand l'application se connecte ou se déconnecte de l'ESP32 :
// Appelé quand l'application se connecte à l'ESP32
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Envoyer les valeurs actuelles des curseurs à l'application
bluetoothSlider.send(currentSlider1, currentSlider2);
});
// Appelé quand l'application se déconnecte de l'ESP32
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
// Optionnel : arrêter les moteurs, réinitialiser les sorties, etc.
});
// Vérifier le statut de connexion n'importe où dans votre code
if (bluetoothServer.isConnected()) {
// Faire quelque chose seulement quand connecté
}
Comment utiliser les curseurs
Contrôles de l'interface de l'application
L'interface des curseurs dans l'application DIYables Bluetooth fournit :
- Curseur 1 : Premier curseur de contrôle avec affichage de valeur
- Curseur 2 : Deuxième curseur de contrôle avec affichage de valeur
- Affichage des valeurs : Valeurs numériques en temps réel pour les deux curseurs
Plages de valeurs
Chaque curseur fournit :
- Plage par défaut : 0 à 100
- Configurable : La plage et le pas peuvent être personnalisés dans le code
- Mappage PWM : Mappage facile vers 0-255 pour analogWrite()
Exemples de programmation
Gestionnaire de curseur de base
void setup() {
// Configurer le callback du curseur pour les changements de valeur
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Stocker les valeurs reçues
currentSlider1 = slider1;
currentSlider2 = slider2;
// Imprimer les valeurs des curseurs
Serial.println("Slider 1: " + String(slider1) + ", Slider 2: " + String(slider2));
// Ajouter votre logique de contrôle ici
});
}
Contrôle de luminosité LED (Exemple BLE)
// Broches de sortie PWM
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
void setup() {
// Configurer les broches PWM comme sorties
pinMode(PWM_PIN_1, OUTPUT);
pinMode(PWM_PIN_2, OUTPUT);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Mapper les valeurs des curseurs (0-100) vers la plage PWM (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Contrôler la luminosité des LED
analogWrite(PWM_PIN_1, pwm1);
analogWrite(PWM_PIN_2, pwm2);
Serial.println("LED1 Brightness: " + String(pwm1) +
", LED2 Brightness: " + String(pwm2));
});
}
Contrôle de luminosité LED (Bluetooth Classique avec ESP32 LEDC)
// Broches de sortie PWM
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
// Canaux PWM ESP32 LEDC
const int PWM_CHANNEL_1 = 0;
const int PWM_CHANNEL_2 = 1;
void setup() {
// Initialiser PWM en utilisant ESP32 LEDC
ledcSetup(PWM_CHANNEL_1, 5000, 8); // 5kHz, résolution 8-bit
ledcSetup(PWM_CHANNEL_2, 5000, 8);
ledcAttachPin(PWM_PIN_1, PWM_CHANNEL_1);
ledcAttachPin(PWM_PIN_2, PWM_CHANNEL_2);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Mapper les valeurs des curseurs (0-100) vers la plage PWM (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Contrôler la luminosité des LED en utilisant ESP32 LEDC
ledcWrite(PWM_CHANNEL_1, pwm1);
ledcWrite(PWM_CHANNEL_2, pwm2);
Serial.println("LED1 Brightness: " + String(pwm1) +
", LED2 Brightness: " + String(pwm2));
});
}
Contrôle de position servo
#include <ESP32Servo.h>
Servo servo1, servo2;
void setup() {
// Attacher les servos aux broches
servo1.attach(16);
servo2.attach(17);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Mapper les valeurs des curseurs (0-100) vers les angles servo (0-180°)
int angle1 = map(slider1, 0, 100, 0, 180);
int angle2 = map(slider2, 0, 100, 0, 180);
// Déplacer les servos aux positions calculées
servo1.write(angle1);
servo2.write(angle2);
Serial.println("Servo1: " + String(angle1) + "°, Servo2: " + String(angle2) + "°");
});
}
Contrôle de vitesse moteur
// Broches du pilote de moteur
const int MOTOR1_PWM = 16; // Contrôle de vitesse moteur 1
const int MOTOR1_DIR1 = 18; // Broche de direction moteur 1 pin 1
const int MOTOR1_DIR2 = 19; // Broche de direction moteur 1 pin 2
const int MOTOR2_PWM = 17; // Contrôle de vitesse moteur 2
const int MOTOR2_DIR1 = 21; // Broche de direction moteur 2 pin 1
const int MOTOR2_DIR2 = 22; // Broche de direction moteur 2 pin 2
void setup() {
// Configurer les broches moteur
pinMode(MOTOR1_PWM, OUTPUT);
pinMode(MOTOR1_DIR1, OUTPUT);
pinMode(MOTOR1_DIR2, OUTPUT);
pinMode(MOTOR2_PWM, OUTPUT);
pinMode(MOTOR2_DIR1, OUTPUT);
pinMode(MOTOR2_DIR2, OUTPUT);
// Définir les directions initiales des moteurs (avant)
digitalWrite(MOTOR1_DIR1, HIGH);
digitalWrite(MOTOR1_DIR2, LOW);
digitalWrite(MOTOR2_DIR1, HIGH);
digitalWrite(MOTOR2_DIR2, LOW);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Mapper les valeurs des curseurs (0-100) vers la plage PWM (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Contrôler les vitesses des moteurs
analogWrite(MOTOR1_PWM, pwm1);
analogWrite(MOTOR2_PWM, pwm2);
Serial.println("Motor1: " + String(slider1) + "%, " +
"Motor2: " + String(slider2) + "%");
});
}
Contrôle de couleur LED RGB
// Broches LED RGB
const int RED_PIN = 16;
const int GREEN_PIN = 17;
const int BLUE_PIN = 18;
void setup() {
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Utiliser les curseurs pour contrôler les composants RGB
// Curseur 1 contrôle l'intensité du rouge
// Curseur 2 contrôle l'intensité du bleu
// Le vert est calculé basé sur les deux curseurs
int redValue = map(slider1, 0, 100, 0, 255);
int blueValue = map(slider2, 0, 100, 0, 255);
int greenValue = (redValue + blueValue) / 2;
analogWrite(RED_PIN, redValue);
analogWrite(GREEN_PIN, greenValue);
analogWrite(BLUE_PIN, blueValue);
Serial.println("RGB - R:" + String(redValue) +
" G:" + String(greenValue) +
" B:" + String(blueValue));
});
}
Techniques de programmation avancées
Lissage de valeur
class SliderSmoother {
private:
int currentValue = 0;
int targetValue = 0;
unsigned long lastUpdate = 0;
const int SMOOTH_RATE = 2; // Changement par cycle de mise à jour
public:
void setTarget(int target) {
targetValue = target;
}
int getCurrentValue() {
return currentValue;
}
bool update() {
if (millis() - lastUpdate > 10) { // Mise à jour toutes les 10ms
bool changed = false;
if (currentValue < targetValue) {
currentValue = min(currentValue + SMOOTH_RATE, targetValue);
changed = true;
} else if (currentValue > targetValue) {
currentValue = max(currentValue - SMOOTH_RATE, targetValue);
changed = true;
}
lastUpdate = millis();
return changed;
}
return false;
}
};
SliderSmoother smoother1, smoother2;
void setup() {
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Définir les valeurs cibles pour une transition douce
smoother1.setTarget(slider1);
smoother2.setTarget(slider2);
});
}
void loop() {
bluetoothServer.loop();
// Mettre à jour les valeurs lissées
bool changed1 = smoother1.update();
bool changed2 = smoother2.update();
if (changed1 || changed2) {
// Mapper les valeurs lissées (0-100) vers PWM (0-255) et appliquer
analogWrite(16, map(smoother1.getCurrentValue(), 0, 100, 0, 255));
analogWrite(17, map(smoother2.getCurrentValue(), 0, 100, 0, 255));
}
}
Contrôle basé sur des seuils
void setupThresholdControl() {
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Contrôle basé sur des seuils pour des sorties discrètes
const int LOW_THRESHOLD = 33;
const int MEDIUM_THRESHOLD = 66;
// Contrôler les sorties digitales basées sur les seuils du curseur 1
if (slider1 < LOW_THRESHOLD) {
// Niveau bas : Éteindre toutes les sorties
digitalWrite(18, LOW);
digitalWrite(19, LOW);
digitalWrite(21, LOW);
} else if (slider1 < MEDIUM_THRESHOLD) {
// Niveau moyen : Allumer la première sortie
digitalWrite(18, HIGH);
digitalWrite(19, LOW);
digitalWrite(21, LOW);
} else {
// Niveau haut : Allumer toutes les sorties
digitalWrite(18, HIGH);
digitalWrite(19, HIGH);
digitalWrite(21, HIGH);
}
// Utiliser le curseur 2 pour le contrôle PWM analogique
analogWrite(16, map(slider2, 0, 100, 0, 255));
});
}
Système de valeurs prédéfinies
// Valeurs prédéfinies (plage 0-100)
const int PRESETS[][2] = {
{0, 0}, // Preset 0: Les deux éteints
{25, 50}, // Preset 1: Bas/Moyen
{50, 50}, // Preset 2: Les deux moyens
{100, 50}, // Preset 3: Haut/Moyen
{100, 100} // Preset 4: Les deux au maximum
};
void applyPreset(int presetNumber) {
if (presetNumber >= 0 && presetNumber < 5) {
currentSlider1 = PRESETS[presetNumber][0];
currentSlider2 = PRESETS[presetNumber][1];
// Mettre à jour le matériel
analogWrite(16, map(currentSlider1, 0, 100, 0, 255));
analogWrite(17, map(currentSlider2, 0, 100, 0, 255));
// Envoyer les valeurs mises à jour à l'application
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.println("Applied preset " + String(presetNumber) +
": " + String(currentSlider1) + ", " + String(currentSlider2));
}
}
Exemples d'intégration matérielle
Contrôle de bande LED
// Pour WS2812B ou des bandes LED adressables similaires
// (nécessite des bibliothèques supplémentaires comme FastLED ou Adafruit NeoPixel)
const int LED_STRIP_PIN = 16;
const int NUM_LEDS = 30;
void setupLEDStrip() {
// Initialiser la bande LED (dépend de la bibliothèque utilisée)
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Curseur 1 contrôle la luminosité (0-100 mappé vers 0-255)
// Curseur 2 contrôle la température de couleur ou la teinte (0-100 mappé vers 0-255)
uint8_t brightness = map(slider1, 0, 100, 0, 255);
uint8_t hue = map(slider2, 0, 100, 0, 255);
// Mettre à jour la bande LED (exemple avec fonctions conceptuelles)
// strip.setBrightness(brightness);
// strip.fill(CHSV(hue, 255, 255));
// strip.show();
Serial.println("LED Strip - Brightness: " + String(brightness) +
", Hue: " + String(hue));
});
}
Contrôle de vitesse de ventilateur
const int FAN1_PIN = 16;
const int FAN2_PIN = 17;
void setupFanControl() {
pinMode(FAN1_PIN, OUTPUT);
pinMode(FAN2_PIN, OUTPUT);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Mapper les valeurs des curseurs (0-100) vers PWM (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Contrôler les vitesses des ventilateurs avec seuil minimum pour le démarrage
int fan1Speed = (pwm1 > 50) ? map(pwm1, 50, 255, 100, 255) : 0;
int fan2Speed = (pwm2 > 50) ? map(pwm2, 50, 255, 100, 255) : 0;
analogWrite(FAN1_PIN, fan1Speed);
analogWrite(FAN2_PIN, fan2Speed);
Serial.println("Fan1: " + String(slider1) + "%, " +
"Fan2: " + String(slider2) + "%");
});
}
BLE vs Bluetooth classique - Lequel choisir ?
| Fonctionnalité | BLE (Esp32BLE_Slider) | Bluetooth classique (Esp32Bluetooth_Slider) |
|---|---|---|
| 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 automatique) | Oui (appairage manuel) |
| Idéal pour | Alimenté par batterie, multiplateforme | Haut débit, Android uniquement |
Dépannage
Problèmes courants
1. Impossible de trouver l'appareil dans l'application
- Assurez-vous que l'ESP32 est alimenté et que le sketch est téléversé
- Pour BLE : Assurez-vous que 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 schéma de partition correct est sélectionné (Huge APP)
2. Les curseurs ne répondent pas
- Vérifiez l'état de connexion Bluetooth dans l'application
- Vérifiez la connexion dans le Moniteur Série
- Essayez de déconnecter et reconnecter
3. Les valeurs n'atteignent pas la plage complète
- Vérifiez la configuration de plage du curseur : DIYables_BluetoothSlider(min, max, step)
- Vérifiez la correspondance des valeurs dans la fonction de rappel
- Consultez le Moniteur Série pour les valeurs réelles reçues
4. 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 une alimentation stable pour l'ESP32
- Consultez le Moniteur Série pour les messages de déconnexion/reconnexion
5. La sortie PWM ne fonctionne pas
- Vérifiez que les broches supportent le PWM sur votre variante ESP32
- Pour ESP32 : Utilisez ledcSetup/ledcAttachPin/ledcWrite pour le PWM matériel
- Vérifiez les connexions matérielles et les exigences de charge
6. Sketch trop volumineux / pas assez d'espace
- Dans Arduino IDE, allez dans Outils > Schéma de partition et sélectionnez "Huge APP (3MB No OTA/1MB SPIFFS)" ou "No OTA (Large APP)"
- Le schéma de partition par défaut ne fournit que ~1,2MB pour le code d'application, ce qui n'est pas suffisant pour les bibliothèques Bluetooth
- Ce paramètre donne ~3MB en sacrifiant la partition OTA (mise à jour par voie hertzienne)
Conseils de débogage
Ajoutez un débogage complet :
void debugSliderValues(int slider1, int slider2) {
Serial.println("=== Slider Debug ===");
Serial.println("Slider 1: " + String(slider1) + "%");
Serial.println("Slider 2: " + String(slider2) + "%");
Serial.println("PWM 1: " + String(map(slider1, 0, 100, 0, 255)));
Serial.println("PWM 2: " + String(map(slider2, 0, 100, 0, 255)));
Serial.println("===================");
}
Idées de projets
Projets de contrôle d'éclairage
- Contrôle de luminosité de l'éclairage intérieur via Bluetooth
- Interface de mélange de couleurs RGB
- Contrôle de vitesse d'animation de bande LED
- Contrôle d'éclairage de scène sans fil
Projets de contrôle de moteurs
- Vitesse de robot contrôlé par Bluetooth
- Régulation de vitesse de ventilateur sans fil
- Contrôle de débit de pompe
- Vitesse de tapis roulant
Projets audio
- Contrôle du volume sans fil
- Contrôle de tonalité/égaliseur
- Intensité des effets sonores
Domotique
- Contrôle climatique sans fil (intensité chauffage/refroidissement)
- Contrôle de position de store Bluetooth
- Contrôle du débit du système d'irrigation
Intégration avec d'autres applications Bluetooth
Combiner avec le joystick Bluetooth
Utilisez les curseurs pour les limites de vitesse et le joystick pour la direction :
// Limite de vitesse globale depuis les curseurs
int maxSpeed = 100;
// Dans le rappel du curseur Bluetooth
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
maxSpeed = slider1; // Utiliser le curseur 1 comme limite de vitesse globale
});
// Dans le rappel du joystick Bluetooth
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Mettre à l'échelle les valeurs du joystick par la limite de vitesse contrôlée par curseur
int scaledX = map(x, -100, 100, -maxSpeed, maxSpeed);
int scaledY = map(y, -100, 100, -maxSpeed, maxSpeed);
controlRobot(scaledX, scaledY);
});
Combiner avec les broches numériques Bluetooth
Utilisez les curseurs pour contrôler le PWM et les broches numériques pour marche/arrêt :
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Appliquer le PWM seulement si les broches numériques correspondantes sont ON
if (digitalRead(18) == HIGH) {
analogWrite(16, map(slider1, 0, 100, 0, 255));
} else {
analogWrite(16, 0);
}
if (digitalRead(19) == HIGH) {
analogWrite(17, map(slider2, 0, 100, 0, 255));
} else {
analogWrite(17, 0);
}
});
Prochaines étapes
Après avoir maîtrisé l'exemple de curseur Bluetooth, essayez :
- Joystick Bluetooth - Pour le contrôle directionnel 2D
- Broches numériques Bluetooth - Pour un contrôle discret marche/arrêt
- Moniteur Bluetooth - Pour déboguer les valeurs de curseur
- Applications Bluetooth multiples - Combiner les curseurs 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