ESP32 Manette Bluetooth - Tutoriel Interface de Contrôle 2D Interactive
Aperçu
L'exemple de manette Bluetooth fournit un contrôle joystick 2D interactif 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. La manette envoie des valeurs de coordonnées X et Y en temps réel allant de -100 à +100, idéale pour le contrôle de robots, la commande de moteurs, le positionnement de servos et toute application nécessitant une entrée directionnelle.
Cet exemple supporte deux modes Bluetooth :
- ESP32 BLE (Bluetooth Low Energy) : Fonctionne sur Android et iOS
- ESP32 Bluetooth Classique : Fonctionne uniquement sur Android. iOS ne supporte pas le Bluetooth Classique. Utilisez BLE si vous avez besoin du support iOS.
Fonctionnalités
- Contrôle 2D : Axes X et Y avec des valeurs de -100 à +100
- Mises à jour temps réel : Mises à jour instantanées de position via communication Bluetooth
- Option de retour automatique : Retour configurable automatique vers la position centrale (0, 0)
- Sensibilité ajustable : Configurez le seuil minimal de mouvement pour filtrer les petits changements
- Compatible robot : Valeurs facilement adaptées aux entrées de pilotes de moteur
- 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 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, 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 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 bibliothèque.
Choisissez l'un des deux modes Bluetooth ci-dessous selon vos besoins :
Code ESP32 Bluetooth Classique (fonctionne avec l'app uniquement sur Android)
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_Joystick, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Joystick 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 Joystick feature:
* - Interactive joystick control via Bluetooth
* - Real-time X/Y coordinate values (-100 to +100)
* - Control pins based on joystick position
*
* 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 the joystick
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothJoystick.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Joystick");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Joystick app instance
// Configure with autoReturn=false and sensitivity=5 (minimum 5% change to trigger updates)
DIYables_BluetoothJoystick bluetoothJoystick(false, 5);
// Variables to store current joystick values
int currentJoystickX = 0;
int currentJoystickY = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Joystick Example");
// TODO: initialize your hardware pins here
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add joystick app to server
bluetoothServer.addApp(&bluetoothJoystick);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up joystick callback for position changes
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Store the received values
currentJoystickX = x;
currentJoystickY = y;
// Print joystick position values (-100 to +100)
Serial.print("Joystick - X: ");
Serial.print(x);
Serial.print(", Y: ");
Serial.println(y);
// TODO: Add your control logic here based on joystick position
// Examples:
// - Control motors: if (x > 50) { /* move right */ }
// - Control servos: servo.write(map(y, -100, 100, 0, 180));
// - Control LEDs: ledcWrite(channel, map(abs(x), 0, 100, 0, 255));
// - Send commands to other devices via Serial, I2C, SPI, etc.
});
// Optional: Handle requests for current joystick values (when app loads)
bluetoothJoystick.onGetConfig([]() {
// Send the stored joystick values back to the app
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
Serial.print("App requested values - Sent: X=");
Serial.print(currentJoystickX);
Serial.print(", Y=");
Serial.println(currentJoystickY);
});
// You can change configuration at runtime:
// bluetoothJoystick.setAutoReturn(false); // Disable auto-return
// bluetoothJoystick.setSensitivity(10.0); // Only send updates when joystick moves >10% (less sensitive)
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// TODO: Add your main application code here
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. Cela ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 Joystick 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_Joystick, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - ESP32 BLE Joystick Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Joystick feature:
* - Interactive joystick control via Bluetooth
* - Real-time X/Y coordinate values (-100 to +100)
* - Control pins based on joystick position
*
* 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 the joystick
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothJoystick.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Joystick";
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 Joystick app instance
DIYables_BluetoothJoystick bluetoothJoystick(false, 5);
// Variables to store current joystick values
int currentJoystickX = 0;
int currentJoystickY = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Joystick Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add joystick app to server
bluetoothServer.addApp(&bluetoothJoystick);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up joystick callback for position changes
bluetoothJoystick.onJoystickValue([](int x, int y) {
currentJoystickX = x;
currentJoystickY = y;
Serial.print("Joystick - X: ");
Serial.print(x);
Serial.print(", Y: ");
Serial.println(y);
// TODO: Add your control logic here based on joystick position
});
bluetoothJoystick.onGetConfig([]() {
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
Serial.print("App requested values - Sent: X=");
Serial.print(currentJoystickX);
Serial.print(", Y=");
Serial.println(currentJoystickY);
});
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 moniteur série
- Vérifiez le résultat dans le moniteur série. Cela ressemble à ceci :
COM6
DIYables Bluetooth - ESP32 BLE Joystick 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'app :
- 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_Joystick" 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'app, 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é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'app va scanner les appareils BLE et Bluetooth Classique.
- Trouvez et appuyez sur votre appareil dans les résultats de scan pour vous connecter :
- Pour le Bluetooth Classique : appuyez sur "ESP32_Joystick"
- Pour BLE : appuyez sur "ESP32BLE_Joystick"
- Une fois connecté, l'app retourne automatiquement à l'écran d'accueil. Sélectionnez l'app Joystick depuis le menu d'applications.
Note : Vous pouvez appuyer sur l'icône paramètres de l'écran d'accueil pour masquer/afficher les apps sur l'écran d'accueil. Pour plus de détails, consultez le Manuel utilisateur de l'application DIYables Bluetooth.
- Bougez le joystick dans n'importe quelle direction pour envoyer les valeurs de coordonnées X/Y
Maintenant regardez à nouveau le moniteur série dans l'IDE Arduino. Vous verrez :
COM6
Bluetooth connected!
Joystick - X: 50, Y: 0
Joystick - X: 75, Y: -30
Joystick - X: 0, Y: 100
Joystick - X: -60, Y: 45
Joystick - X: 0, Y: 0
Autoscroll
Clear output
9600 baud
Newline
- Bougez le joystick dans l'app et observez les valeurs X/Y en temps réel dans le moniteur série
Personnalisation créative - Adaptez le code à votre projet
Configurer le retour automatique et la sensibilité
Définissez le comportement du joystick avec les paramètres du constructeur :
// Créer une instance de l'app Joystick
// Paramètres : autoReturn (bool), sensitivity (float - % de changement minimum pour déclencher une mise à jour)
DIYables_BluetoothJoystick bluetoothJoystick(false, 5);
// Ou changer à l'exécution :
bluetoothJoystick.setAutoReturn(true); // Activer le retour automatique au centre
bluetoothJoystick.setSensitivity(10.0); // Envoyer les mises à jour seulement quand le joystick bouge >10%
// Lire la configuration actuelle :
bool autoReturn = bluetoothJoystick.getAutoReturn();
float sensitivity = bluetoothJoystick.getSensitivity();
Gérer les changements de position du joystick
Utilisez le callback onJoystickValue() pour recevoir les coordonnées X/Y :
bluetoothJoystick.onJoystickValue([](int x, int y) {
// x varie de -100 (gauche) à +100 (droite)
// y varie de -100 (bas) à +100 (haut)
Serial.print("X: ");
Serial.print(x);
Serial.print(", Y: ");
Serial.println(y);
// TODO: Ajoutez votre logique de contrôle ici
});
Gérer la demande de configuration depuis l'app
Quand l'app se connecte et ouvre l'écran Joystick, elle demande la configuration du joystick depuis l'ESP32. Vous pouvez utiliser le callback onGetConfig() pour envoyer les valeurs actuelles du joystick à l'app à ce moment :
bluetoothJoystick.onGetConfig([]() {
// Ceci est appelé quand l'app demande la configuration du joystick
// Envoyer les valeurs actuelles du joystick pour que l'app les affiche correctement
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
Serial.println("L'app a demandé la config - valeurs actuelles envoyées");
});
Envoyer des valeurs à l'app
Vous pouvez envoyer des valeurs de coordonnées de joystick depuis l'ESP32 vers l'app :
// Envoyer les valeurs de coordonnées X/Y à l'app
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
// Envoyer un message texte
bluetoothJoystick.send("Joystick calibré");
Gérer les événements de connexion
Vous pouvez détecter quand l'app se connecte ou se déconnecte de l'ESP32 :
// Appelé quand l'app se connecte à l'ESP32
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connecté !");
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
});
// Appelé quand l'app se déconnecte de l'ESP32
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth déconnecté !");
// Arrêter les moteurs quand la connexion est perdue
stopAllMotors();
});
// Vérifier l'état de connexion n'importe où dans votre code
if (bluetoothServer.isConnected()) {
// Faire quelque chose seulement quand connecté
}
Comment utiliser le joystick
Contrôles de l'interface app
L'interface joystick dans l'application DIYables Bluetooth fournit :
- Pad de joystick virtuel : Touchez et glissez pour contrôler la position
- Affichage valeur X : Montre la position horizontale actuelle (-100 à +100)
- Affichage valeur Y : Montre la position verticale actuelle (-100 à +100)
Plages de valeurs
Le joystick fournit :
- Axe X : -100 (tout à gauche) à 0 (centre) à +100 (tout à droite)
- Axe Y : -100 (tout en bas) à 0 (centre) à +100 (tout en haut)
- Position centrale : (0, 0) quand le joystick est au repos
Exemples de programmation
Gestionnaire de joystick basique
void setup() {
bluetoothJoystick.onJoystickValue([](int x, int y) {
currentJoystickX = x;
currentJoystickY = y;
Serial.print("Joystick - X: ");
Serial.print(x);
Serial.print(", Y: ");
Serial.println(y);
});
}
Contrôle de robot à deux roues
const int MOTOR_LEFT_PWM = 16;
const int MOTOR_LEFT_DIR1 = 18;
const int MOTOR_LEFT_DIR2 = 19;
const int MOTOR_RIGHT_PWM = 17;
const int MOTOR_RIGHT_DIR1 = 21;
const int MOTOR_RIGHT_DIR2 = 22;
void setup() {
// Configurer les broches moteur
pinMode(MOTOR_LEFT_PWM, OUTPUT);
pinMode(MOTOR_LEFT_DIR1, OUTPUT);
pinMode(MOTOR_LEFT_DIR2, OUTPUT);
pinMode(MOTOR_RIGHT_PWM, OUTPUT);
pinMode(MOTOR_RIGHT_DIR1, OUTPUT);
pinMode(MOTOR_RIGHT_DIR2, OUTPUT);
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Entraînement différentiel : mélanger X (virage) et Y (vitesse)
int leftSpeed = constrain(y + x, -100, 100);
int rightSpeed = constrain(y - x, -100, 100);
// Définir direction et vitesse moteur gauche
if (leftSpeed >= 0) {
digitalWrite(MOTOR_LEFT_DIR1, HIGH);
digitalWrite(MOTOR_LEFT_DIR2, LOW);
} else {
digitalWrite(MOTOR_LEFT_DIR1, LOW);
digitalWrite(MOTOR_LEFT_DIR2, HIGH);
}
analogWrite(MOTOR_LEFT_PWM, map(abs(leftSpeed), 0, 100, 0, 255));
// Définir direction et vitesse moteur droit
if (rightSpeed >= 0) {
digitalWrite(MOTOR_RIGHT_DIR1, HIGH);
digitalWrite(MOTOR_RIGHT_DIR2, LOW);
} else {
digitalWrite(MOTOR_RIGHT_DIR1, LOW);
digitalWrite(MOTOR_RIGHT_DIR2, HIGH);
}
analogWrite(MOTOR_RIGHT_PWM, map(abs(rightSpeed), 0, 100, 0, 255));
Serial.print("Gauche: ");
Serial.print(leftSpeed);
Serial.print("%, Droite: ");
Serial.print(rightSpeed);
Serial.println("%");
});
}
Contrôle servo pan-tilt
#include <ESP32Servo.h>
Servo panServo; // Horizontal (axe X)
Servo tiltServo; // Vertical (axe Y)
const int PAN_PIN = 13;
const int TILT_PIN = 14;
void setup() {
panServo.attach(PAN_PIN);
tiltServo.attach(TILT_PIN);
panServo.write(90); // Position centre
tiltServo.write(90);
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Convertir les valeurs joystick (-100 à +100) en angles servo (0 à 180)
int panAngle = map(x, -100, 100, 0, 180);
int tiltAngle = map(y, -100, 100, 0, 180);
panServo.write(panAngle);
tiltServo.write(tiltAngle);
Serial.print("Pan: ");
Serial.print(panAngle);
Serial.print("°, Tilt: ");
Serial.print(tiltAngle);
Serial.println("°");
});
}
Indicateur de direction matrice LED
// 4 LEDs directionnelles
const int LED_UP = 16;
const int LED_DOWN = 17;
const int LED_LEFT = 18;
const int LED_RIGHT = 19;
const int THRESHOLD = 30; // Valeur joystick minimum pour activer la LED
void setup() {
pinMode(LED_UP, OUTPUT);
pinMode(LED_DOWN, OUTPUT);
pinMode(LED_LEFT, OUTPUT);
pinMode(LED_RIGHT, OUTPUT);
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Allumer les LEDs selon la direction du joystick
digitalWrite(LED_UP, y > THRESHOLD ? HIGH : LOW);
digitalWrite(LED_DOWN, y < -THRESHOLD ? HIGH : LOW);
digitalWrite(LED_RIGHT, x > THRESHOLD ? HIGH : LOW);
digitalWrite(LED_LEFT, x < -THRESHOLD ? HIGH : LOW);
// Afficher la direction dans le série
String direction = "";
if (y > THRESHOLD) direction += "HAUT ";
if (y < -THRESHOLD) direction += "BAS ";
if (x > THRESHOLD) direction += "DROITE ";
if (x < -THRESHOLD) direction += "GAUCHE ";
if (direction == "") direction = "CENTRE";
Serial.println("Direction: " + direction);
});
}
Techniques de programmation avancées
Filtre de zone morte
const int DEAD_ZONE = 15; // Ignorer les valeurs joystick dans ±15
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Appliquer le filtre de zone morte
int filteredX = (abs(x) > DEAD_ZONE) ? x : 0;
int filteredY = (abs(y) > DEAD_ZONE) ? y : 0;
// Utiliser les valeurs filtrées pour le contrôle
controlMotors(filteredX, filteredY);
});
Rampe de vitesse
int targetX = 0, targetY = 0;
int currentX = 0, currentY = 0;
const int RAMP_RATE = 5; // Changement max par mise à jour
void setup() {
bluetoothJoystick.onJoystickValue([](int x, int y) {
targetX = x;
targetY = y;
});
}
void loop() {
bluetoothServer.loop();
// Progresser graduellement vers les valeurs cibles
if (currentX < targetX) currentX = min(currentX + RAMP_RATE, targetX);
else if (currentX > targetX) currentX = max(currentX - RAMP_RATE, targetX);
if (currentY < targetY) currentY = min(currentY + RAMP_RATE, targetY);
else if (currentY > targetY) currentY = max(currentY - RAMP_RATE, targetY);
controlMotors(currentX, currentY);
delay(20);
}
Calcul de magnitude et d'angle
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Calculer la magnitude (distance depuis le centre, 0-100)
float magnitude = sqrt(x * x + y * y);
magnitude = constrain(magnitude, 0, 100);
// Calculer l'angle en degrés (0° = droite, 90° = haut)
float angle = atan2(y, x) * 180.0 / PI;
Serial.print("Magnitude: ");
Serial.print(magnitude, 1);
Serial.print(", Angle: ");
Serial.print(angle, 1);
Serial.println("°");
// Utiliser magnitude pour vitesse et angle pour direction
int speed = map((int)magnitude, 0, 100, 0, 255);
// Appliquer à votre matériel...
});
Exemples d'intégration matérielle
Robot à roues mecanum
// Le robot à roues mecanum nécessite 4 moteurs
const int MOTOR_FL = 16; // Avant-Gauche
const int MOTOR_FR = 17; // Avant-Droite
const int MOTOR_BL = 18; // Arrière-Gauche
const int MOTOR_BR = 19; // Arrière-Droite
void setupMecanumRobot() {
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Cinématique des roues mecanum
int fl = constrain(y + x, -100, 100);
int fr = constrain(y - x, -100, 100);
int bl = constrain(y - x, -100, 100);
int br = constrain(y + x, -100, 100);
setMotor(MOTOR_FL, fl);
setMotor(MOTOR_FR, fr);
setMotor(MOTOR_BL, bl);
setMotor(MOTOR_BR, br);
});
}
void setMotor(int pin, int speed) {
// Convertir -100..100 en PWM avec direction
analogWrite(pin, map(abs(speed), 0, 100, 0, 255));
}
Contrôle de position moteur pas à pas
#include <AccelStepper.h>
AccelStepper stepperX(AccelStepper::DRIVER, 16, 17);
AccelStepper stepperY(AccelStepper::DRIVER, 18, 19);
void setup() {
stepperX.setMaxSpeed(1000);
stepperX.setAcceleration(500);
stepperY.setMaxSpeed(1000);
stepperY.setAcceleration(500);
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Convertir joystick en vitesse stepper (-1000 à +1000 pas/sec)
int speedX = map(x, -100, 100, -1000, 1000);
int speedY = map(y, -100, 100, -1000, 1000);
stepperX.setSpeed(speedX);
stepperY.setSpeed(speedY);
});
}
void loop() {
bluetoothServer.loop();
stepperX.runSpeed();
stepperY.runSpeed();
}
BLE vs Bluetooth Classique - Lequel choisir ?
| Fonctionnalité | BLE (Esp32BLE_Joystick) | Bluetooth Classique (Esp32Bluetooth_Joystick) |
|---|---|---|
| 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 (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'app
- Assurez-vous que l'ESP32 est alimenté et le sketch téléversé
- Pour 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 du téléphone
- Vérifiez que le bon schéma de partition est sélectionné (Huge APP)
2. Le joystick ne répond pas
- Vérifiez l'état de la connexion Bluetooth dans l'app
- Vérifiez la connexion dans le moniteur série
- Essayez de vous déconnecter et reconnecter
3. Les valeurs du joystick semblent erratiques
- Augmentez la valeur de sensibilité pour filtrer les petits mouvements : bluetoothJoystick.setSensitivity(10.0)
- Appliquez un filtre de zone morte dans votre callback
- Vérifiez les interférences d'autres appareils Bluetooth
4. La connexion se coupe fréquemment
- Rapprochez-vous de l'ESP32 (réduire la distance)
- Pour BLE : Vérifiez les interférences d'autres appareils BLE
- Pour le Bluetooth Classique : Assurez une alimentation stable pour l'ESP32
- Vérifiez le moniteur série pour les messages de déconnexion/reconnexion
5. Les moteurs ne s'arrêtent pas quand le joystick est relâché
- Assurez-vous que le retour automatique est activé : bluetoothJoystick.setAutoReturn(true)
- Ajoutez une vérification de zone morte dans votre code de contrôle moteur
- Ajoutez un arrêt de sécurité dans le callback setOnDisconnected()
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 app, ce qui n'est pas suffisant pour les bibliothèques Bluetooth
- Ce paramètre donne ~3MB en sacrifiant la partition OTA (mise à jour over-the-air)
Conseils de débogage
Ajoutez un débogage complet :
void debugJoystickValues(int x, int y) {
float magnitude = sqrt(x * x + y * y);
float angle = atan2(y, x) * 180.0 / PI;
Serial.println("=== Debug Joystick ===");
Serial.println("X: " + String(x) + ", Y: " + String(y));
Serial.println("Magnitude: " + String(magnitude, 1));
Serial.println("Angle: " + String(angle, 1) + "°");
Serial.println("======================");
}
Idées de projets
Projets robotiques
- Robot à entraînement différentiel contrôlé par Bluetooth
- Robot à roues mecanum ou omnidirectionnelles
- Contrôle d'articulations de bras robotique
- Contrôleur de station sol pour drone
Projets caméra
- Contrôle de support caméra pan-tilt
- Positionnement de slider caméra motorisé
- Contrôle à distance de caméra de surveillance
Projets de jeu
- Contrôleur de jeu Bluetooth pour jeux ESP32
- Jeu de navigation dans un labyrinthe
- Jeux joystick sur matrice LED (Snake, Pong)
Projets industriels
- Contrôleur de déplacement CNC
- Positionnement de platine ou plateforme motorisée
- Contrôle directionnel de grue ou de treuil
Intégration avec d'autres applications Bluetooth
Combiner avec le curseur Bluetooth
Utilisez le joystick pour la direction et les curseurs pour les limites de vitesse :
int maxSpeed = 100;
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
maxSpeed = slider1; // Le curseur contrôle la vitesse maximale
});
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Mettre à l'échelle le 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 le moniteur Bluetooth
Utilisez le joystick pour le contrôle et le moniteur pour la télémétrie :
bluetoothJoystick.onJoystickValue([](int x, int y) {
controlMotors(x, y);
// Envoyer la télémétrie au moniteur
bluetoothMonitor.send("X=" + String(x) + " Y=" + String(y) +
" Speed=" + String(sqrt(x*x + y*y), 0));
});
Prochaines étapes
Après avoir maîtrisé l'exemple de joystick Bluetooth, essayez :
- Curseur Bluetooth - Pour un contrôle précis de valeurs analogiques
- Broches numériques Bluetooth - Pour un contrôle discret marche/arrêt
- Moniteur Bluetooth - Pour déboguer les valeurs du joystick
- Applications Bluetooth multiples - Combiner le joystick avec des curseurs et 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