ESP32 Bluetooth Joystick Beispiel - Interaktives 2D-Steuerungs-Interface Tutorial
Überblick
Das Bluetooth Joystick Beispiel bietet eine interaktive 2D-Joystick-Steuerung, die über die DIYables Bluetooth STEM App zugänglich ist. Entwickelt für ESP32-Boards mit Unterstützung für sowohl BLE (Bluetooth Low Energy) als auch Classic Bluetooth-Verbindungen. Der Joystick sendet Echtzeit-X- und Y-Koordinatenwerte von -100 bis +100, was ihn ideal für Robotersteuerung, Motorantrieb, Servo-Positionierung und jede Anwendung macht, die Richtungseingaben benötigt.
Dieses Beispiel unterstützt zwei Bluetooth-Modi:
- ESP32 BLE (Bluetooth Low Energy): Funktioniert sowohl auf Android als auch iOS
- ESP32 Classic Bluetooth: Funktioniert nur auf Android. iOS unterstützt kein Classic Bluetooth. Verwenden Sie BLE, wenn Sie iOS-Unterstützung benötigen.
Funktionen
- 2D-Steuerung: X- und Y-Achsen mit Werten von -100 bis +100
- Echtzeit-Updates: Sofortige Positionsupdates über Bluetooth-Kommunikation
- Auto-Rücksprung-Option: Konfigurierbare automatische Rückkehr zur Mittelposition (0, 0)
- Einstellbare Sensibilität: Konfigurierbare minimale Bewegungsschwelle zum Filtern kleiner Änderungen
- Roboter-kompatibel: Werte lassen sich einfach auf Motortreiber-Eingänge abbilden
- BLE & Classic Bluetooth: Wählen Sie den Bluetooth-Modus, der zu Ihrem Projekt passt
- Plattformübergreifend: BLE-Modus funktioniert sowohl auf Android als auch iOS; Classic Bluetooth funktioniert auf Android
- Stromsparoption: BLE-Modus verbraucht weniger Strom als Classic Bluetooth
Benötigte Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (30 Sensoren/Displays) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
ESP32 Code
Schnelle Schritte
Befolgen Sie diese Anweisungen Schritt für Schritt:
- Wenn Sie ESP32 zum ersten Mal verwenden, lesen Sie das Tutorial zur Einrichtung der Umgebung für ESP32 in der Arduino IDE.
- Verbinden Sie das ESP32-Board über ein USB-Kabel mit Ihrem Computer.
- Starten Sie die Arduino IDE auf Ihrem Computer.
- Wählen Sie das entsprechende ESP32-Board und den COM-Port aus.
- Navigieren Sie zum Libraries-Symbol in der linken Leiste der Arduino IDE.
- Suchen Sie nach "DIYables Bluetooth" und finden Sie die DIYables Bluetooth-Bibliothek von DIYables
- Klicken Sie auf Install, um die Bibliothek zu installieren.
- Sie werden gebeten, einige andere Bibliotheksabhängigkeiten zu installieren
- Klicken Sie auf Install All, um alle Bibliotheksabhängigkeiten zu installieren.
Wählen Sie je nach Ihren Bedürfnissen einen der beiden Bluetooth-Modi unten aus:
ESP32 Classic Bluetooth Code (funktioniert nur mit der App auf Android)
Hinweis: Classic Bluetooth wird auf iOS NICHT unterstützt. Wenn Sie iOS-Unterstützung benötigen, verwenden Sie den BLE-Code unten.
- In der Arduino IDE gehen Sie zu File Examples DIYables Bluetooth Esp32Bluetooth_Joystick Beispiel, oder kopieren Sie den obigen Code und fügen Sie ihn in den Editor der Arduino IDE ein
/*
* 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);
}
- Klicken Sie auf Upload in der Arduino IDE, um den Code auf ESP32 hochzuladen
- Öffnen Sie den Serial Monitor
- Prüfen Sie das Ergebnis im Serial Monitor. Es sieht folgendermaßen aus:
COM6
DIYables Bluetooth - ESP32 Joystick Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
ESP32 BLE Code (funktioniert mit der App sowohl auf Android als auch iOS)
- In der Arduino IDE gehen Sie zu File Examples DIYables Bluetooth Esp32BLE_Joystick Beispiel, oder kopieren Sie den obigen Code und fügen Sie ihn in den Editor der Arduino IDE ein
/*
* 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);
}
- Klicken Sie auf Upload in der Arduino IDE, um den Code auf ESP32 hochzuladen
- Öffnen Sie den Serial Monitor
- Prüfen Sie das Ergebnis im Serial Monitor. Es sieht folgendermaßen aus:
COM6
DIYables Bluetooth - ESP32 BLE Joystick Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Mobile App
- Wenn Sie den ESP32 Classic Bluetooth Code verwenden, müssen Sie das ESP32 mit Ihrem Android-Telefon koppeln, bevor Sie die App öffnen:
- Gehen Sie zu den Einstellungen > Bluetooth Ihres Telefons
- Stellen Sie sicher, dass Bluetooth aktiviert ist
- Ihr Telefon wird nach verfügbaren Geräten suchen
- Finden und tippen Sie auf "ESP32_Joystick" in der Liste der verfügbaren Geräte
- Bestätigen Sie die Kopplungsanfrage (keine PIN erforderlich)
- Warten Sie, bis "Paired" unter dem Gerätenamen angezeigt wird
- Wenn Sie den ESP32 BLE Code verwenden, ist keine Kopplung erforderlich. Fahren Sie einfach mit dem nächsten Schritt fort.
- Öffnen Sie die DIYables Bluetooth App
- Beim ersten Öffnen der App werden Berechtigungen angefragt. Gewähren Sie bitte folgende:
- Nearby Devices Berechtigung (Android 12+) / Bluetooth Berechtigung (iOS) - erforderlich zum Scannen und Verbinden von Bluetooth-Geräten
- Location Berechtigung (nur Android 11 und darunter) - erforderlich von älteren Android-Versionen zum Scannen nach BLE-Geräten
- Stellen Sie sicher, dass Bluetooth auf Ihrem Telefon aktiviert ist
- Tippen Sie auf dem Startbildschirm auf Connect. Die App wird nach sowohl BLE- als auch Classic Bluetooth-Geräten scannen.
- Finden und tippen Sie auf Ihr Gerät in den Scan-Ergebnissen, um sich zu verbinden:
- Für Classic Bluetooth: Tippen Sie auf "ESP32_Joystick"
- Für BLE: Tippen Sie auf "ESP32BLE_Joystick"
- Nach der Verbindung kehrt die App automatisch zum Startbildschirm zurück. Wählen Sie die Joystick App aus dem App-Menü.
Hinweis: Sie können auf das Einstellungen-Symbol auf dem Startbildschirm tippen, um Apps auf dem Startbildschirm ein-/auszublenden. Für weitere Details siehe das DIYables Bluetooth App Benutzerhandbuch.
- Bewegen Sie den Joystick in beliebige Richtungen, um X/Y-Koordinatenwerte zu senden
Schauen Sie nun zurück auf den Serial Monitor in der Arduino IDE. Sie werden sehen:
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
- Bewegen Sie den Joystick in der App und beobachten Sie die Echtzeit-X/Y-Werte im Serial Monitor
Kreative Anpassung - Den Code an Ihr Projekt anpassen
Auto-Rücksprung und Sensibilität konfigurieren
Setzen Sie das Joystick-Verhalten mit Konstruktor-Parametern:
// Erstelle Joystick App-Instanz
// Parameter: autoReturn (bool), sensitivity (float - minimale %-Änderung zum Auslösen von Updates)
DIYables_BluetoothJoystick bluetoothJoystick(false, 5);
// Oder zur Laufzeit ändern:
bluetoothJoystick.setAutoReturn(true); // Auto-Rücksprung zur Mitte aktivieren
bluetoothJoystick.setSensitivity(10.0); // Nur Updates senden, wenn Joystick >10% bewegt wird
// Aktuelle Konfiguration lesen:
bool autoReturn = bluetoothJoystick.getAutoReturn();
float sensitivity = bluetoothJoystick.getSensitivity();
Joystick-Positionsänderungen verarbeiten
Verwenden Sie den onJoystickValue() Callback, um X/Y-Koordinaten zu empfangen:
bluetoothJoystick.onJoystickValue([](int x, int y) {
// x reicht von -100 (links) bis +100 (rechts)
// y reicht von -100 (unten) bis +100 (oben)
Serial.print("X: ");
Serial.print(x);
Serial.print(", Y: ");
Serial.println(y);
// TODO: Fügen Sie hier Ihre Steuerungslogik hinzu
});
Konfigurationsanfrage von der App verarbeiten
Wenn sich die App verbindet und den Joystick-Bildschirm öffnet, fordert sie die Joystick-Konfiguration vom ESP32 an. Sie können den onGetConfig() Callback verwenden, um die aktuellen Joystick-Werte zu diesem Zeitpunkt an die App zu senden:
bluetoothJoystick.onGetConfig([]() {
// Dies wird aufgerufen, wenn die App die Joystick-Konfiguration anfordert
// Aktuelle Joystick-Werte senden, damit die App sie korrekt anzeigt
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
Serial.println("App requested config - sent current values");
});
Werte an die App senden
Sie können Joystick-Koordinatenwerte vom ESP32 an die App senden:
// X/Y-Koordinatenwerte an die App senden
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
// Eine Textnachricht senden
bluetoothJoystick.send("Joystick calibrated");
Verbindungsereignisse verarbeiten
Sie können erkennen, wann sich die App mit dem ESP32 verbindet oder trennt:
// Wird aufgerufen, wenn sich die App mit ESP32 verbindet
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothJoystick.send(currentJoystickX, currentJoystickY);
});
// Wird aufgerufen, wenn sich die App vom ESP32 trennt
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
// Motoren stoppen, wenn Verbindung verloren geht
stopAllMotors();
});
// Verbindungsstatus überall in Ihrem Code prüfen
if (bluetoothServer.isConnected()) {
// Nur bei Verbindung etwas tun
}
Wie man den Joystick verwendet
App-Interface-Steuerelemente
Die Joystick-Oberfläche in der DIYables Bluetooth App bietet:
- Virtueller Joystick Pad: Berühren und ziehen zur Positionssteuerung
- X-Wert-Anzeige: Zeigt aktuelle horizontale Position (-100 bis +100)
- Y-Wert-Anzeige: Zeigt aktuelle vertikale Position (-100 bis +100)
Wertebereiche
Der Joystick bietet:
- X-Achse: -100 (ganz links) bis 0 (Mitte) bis +100 (ganz rechts)
- Y-Achse: -100 (ganz unten) bis 0 (Mitte) bis +100 (ganz oben)
- Mittelposition: (0, 0) wenn Joystick in Ruhestellung ist
Programmierbeispiele
Grundlegender Joystick-Handler
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);
});
}
Zweirad-Roboter-Steuerung
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() {
// Motor-Pins konfigurieren
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) {
// Differential-Antrieb: X (Drehung) und Y (Geschwindigkeit) mischen
int leftSpeed = constrain(y + x, -100, 100);
int rightSpeed = constrain(y - x, -100, 100);
// Linker Motor Richtung und Geschwindigkeit setzen
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));
// Rechter Motor Richtung und Geschwindigkeit setzen
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("Links: ");
Serial.print(leftSpeed);
Serial.print("%, Rechts: ");
Serial.print(rightSpeed);
Serial.println("%");
});
}
Pan-Tilt Servo-Steuerung
#include <ESP32Servo.h>
Servo panServo; // Horizontal (X-Achse)
Servo tiltServo; // Vertikal (Y-Achse)
const int PAN_PIN = 13;
const int TILT_PIN = 14;
void setup() {
panServo.attach(PAN_PIN);
tiltServo.attach(TILT_PIN);
panServo.write(90); // Mittelposition
tiltServo.write(90);
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Joystick-Werte (-100 bis +100) auf Servo-Winkel (0 bis 180) abbilden
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("°");
});
}
LED Matrix Richtungsanzeiger
// 4 Richtungs-LEDs
const int LED_UP = 16;
const int LED_DOWN = 17;
const int LED_LEFT = 18;
const int LED_RIGHT = 19;
const int THRESHOLD = 30; // Minimaler Joystick-Wert zur LED-Aktivierung
void setup() {
pinMode(LED_UP, OUTPUT);
pinMode(LED_DOWN, OUTPUT);
pinMode(LED_LEFT, OUTPUT);
pinMode(LED_RIGHT, OUTPUT);
bluetoothJoystick.onJoystickValue([](int x, int y) {
// LEDs basierend auf Joystick-Richtung einschalten
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);
// Richtung im Serial anzeigen
String direction = "";
if (y > THRESHOLD) direction += "OBEN ";
if (y < -THRESHOLD) direction += "UNTEN ";
if (x > THRESHOLD) direction += "RECHTS ";
if (x < -THRESHOLD) direction += "LINKS ";
if (direction == "") direction = "MITTE";
Serial.println("Richtung: " + direction);
});
}
Erweiterte Programmiertechniken
Totzone-Filter
const int DEAD_ZONE = 15; // Joystick-Werte innerhalb ±15 ignorieren
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Totzone-Filter anwenden
int filteredX = (abs(x) > DEAD_ZONE) ? x : 0;
int filteredY = (abs(y) > DEAD_ZONE) ? y : 0;
// Gefilterte Werte für Steuerung verwenden
controlMotors(filteredX, filteredY);
});
Geschwindigkeits-Ramping
int targetX = 0, targetY = 0;
int currentX = 0, currentY = 0;
const int RAMP_RATE = 5; // Maximale Änderung pro Update
void setup() {
bluetoothJoystick.onJoystickValue([](int x, int y) {
targetX = x;
targetY = y;
});
}
void loop() {
bluetoothServer.loop();
// Graduell zu Zielwerten rampen
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);
}
Magnitude und Winkel-Berechnung
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Magnitude berechnen (Entfernung von der Mitte, 0-100)
float magnitude = sqrt(x * x + y * y);
magnitude = constrain(magnitude, 0, 100);
// Winkel in Grad berechnen (0° = rechts, 90° = oben)
float angle = atan2(y, x) * 180.0 / PI;
Serial.print("Magnitude: ");
Serial.print(magnitude, 1);
Serial.print(", Winkel: ");
Serial.print(angle, 1);
Serial.println("°");
// Magnitude für Geschwindigkeit und Winkel für Richtung verwenden
int speed = map((int)magnitude, 0, 100, 0, 255);
// Auf Ihre Hardware anwenden...
});
Hardware-Integrationsbeispiele
Mecanum-Rad-Roboter
// Mecanum-Rad-Roboter benötigt 4 Motoren
const int MOTOR_FL = 16; // Vorne-Links
const int MOTOR_FR = 17; // Vorne-Rechts
const int MOTOR_BL = 18; // Hinten-Links
const int MOTOR_BR = 19; // Hinten-Rechts
void setupMecanumRobot() {
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Mecanum-Rad-Kinematik
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) {
// -100..100 auf PWM mit Richtung abbilden
analogWrite(pin, map(abs(speed), 0, 100, 0, 255));
}
Schrittmotor-Positionssteuerung
#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) {
// Joystick auf Schrittmotor-Geschwindigkeit abbilden (-1000 bis +1000 Schritte/Sek)
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 Classic Bluetooth - Welches wählen?
| Funktion | BLE (Esp32BLE_Joystick) | Classic Bluetooth (Esp32Bluetooth_Joystick) |
|---|---|---|
| iOS-Unterstützung | ? Ja | ? Nein |
| Android-Unterstützung | ? Ja | ? Ja |
| Stromverbrauch | Niedrig | Höher |
| Reichweite | ~30-100m | ~10-100m |
| Datenrate | Niedriger | Höher |
| Kopplung erforderlich | Nein (automatische Verbindung) | Ja (manuelle Kopplung) |
| Am besten für | Batteriebetrieben, plattformübergreifend | Hoher Durchsatz, nur Android |
Fehlerbehebung
Häufige Probleme
1. Gerät in der App nicht zu finden
- Stellen Sie sicher, dass das ESP32 eingeschaltet und der Sketch hochgeladen ist
- Für BLE: Stellen Sie sicher, dass Bluetooth und Standort auf Ihrem Telefon aktiviert sind
- Für Classic Bluetooth: Koppeln Sie das Gerät zuerst in den Bluetooth-Einstellungen des Telefons
- Prüfen Sie, ob das korrekte Partitionsschema ausgewählt ist (Huge APP)
2. Joystick reagiert nicht
- Prüfen Sie den Bluetooth-Verbindungsstatus in der App
- Überprüfen Sie die Verbindung im Serial Monitor
- Versuchen Sie, die Verbindung zu trennen und wieder herzustellen
3. Joystick-Werte scheinen unregelmäßig
- Erhöhen Sie den Sensibilitätswert zum Filtern kleiner Bewegungen: bluetoothJoystick.setSensitivity(10.0)
- Wenden Sie einen Totzone-Filter in Ihrem Callback an
- Prüfen Sie auf Interferenzen von anderen Bluetooth-Geräten
4. Verbindung bricht häufig ab
- Gehen Sie näher zum ESP32 (Entfernung reduzieren)
- Für BLE: Prüfen Sie auf Interferenzen von anderen BLE-Geräten
- Für Classic Bluetooth: Stellen Sie stabile Stromversorgung zum ESP32 sicher
- Prüfen Sie den Serial Monitor auf Disconnect/Reconnect-Meldungen
5. Motoren stoppen nicht, wenn Joystick losgelassen wird
- Stellen Sie sicher, dass Auto-Rücksprung aktiviert ist: bluetoothJoystick.setAutoReturn(true)
- Fügen Sie eine Totzone-Prüfung in Ihrem Motorsteuerungscode hinzu
- Fügen Sie einen Sicherheitsstop im setOnDisconnected() Callback hinzu
6. Sketch zu groß / nicht genug Platz
- In der Arduino IDE gehen Sie zu Tools > Partition Scheme und wählen Sie "Huge APP (3MB No OTA/1MB SPIFFS)" oder "No OTA (Large APP)"
- Das Standard-Partitionsschema bietet nur ~1,2MB für App-Code, was für Bluetooth-Bibliotheken nicht ausreicht
- Diese Einstellung gibt ~3MB durch Verzicht auf die OTA (Over-the-Air Update) Partition