Joystick-Modul verwenden: X-Y-Achsen und Taster mit dem Arduino auslesen

Ein Joystick-Modul ist die Arduino-taugliche Version der Daumensticks, die du von Gamecontrollern kennst. Bewegst du den Stick nach links-rechts und vor-zurück, liefert er die Position auf zwei Achsen; drückst du von oben auf den Stick, löst ein eingebauter Taster aus. Für Fernsteuerungen von Roboterautos, Pan-Tilt-Kamerahalterungen, LED-Matrix-Spiele und Displaymenüs ist er das praktischste Eingabeelement. Das verbreitetste Modell ist auch als KY-023 bekannt.

Wie funktioniert ein Joystick-Modul?

Unter dem Stick sitzen zwei 10-kΩ-Potentiometer im rechten Winkel zueinander: Eines erfasst die Bewegung auf der X-Achse, das andere auf der Y-Achse. Jedes Potentiometer arbeitet als Spannungsteiler; in der Mittelstellung liefert der Schleifer etwa 2,5 V und analogRead() liest etwa 512. Schiebst du den Stick an ein Ende, nähert sich der Wert 0, am anderen Ende 1023. Drückst du von oben auf den Stick, verbindet ein kleiner Taster den Pin SW mit GND.

Welche Richtung 0 und welche 1023 ergibt, hängt davon ab, wie du das Modul hältst. Weichen die Richtungen von dieser Tabelle ab, wenn die Pins zu dir zeigen, ist das kein Problem: Im Code drehst du eine Achse einfach um, indem du den Wert von 1023 abziehst.

Pinbelegung und Anschluss des Joysticks

Joystick mit dem Arduino auslesen

Der folgende Code liest beide Achsen und den Taster und gibt sie im seriellen Monitor aus. Da der Taster beim Drücken mit GND verbunden wird und die meisten Module keinen Pull-up-Widerstand haben, muss der SW-Pin als INPUT_PULLUP definiert werden; so liest du losgelassen HIGH und gedrückt LOW.

1const int X_PIN = A0;
2const int Y_PIN = A1;
3const int SW_PIN = 2;
4
5void setup() {
6  pinMode(SW_PIN, INPUT_PULLUP);   // basınca LOW / LOW when pressed
7  Serial.begin(9600);
8}
9
10void loop() {
11  int x = analogRead(X_PIN);       // 0–1023, ortada ~512 / ~512 at center
12  int y = analogRead(Y_PIN);
13  bool pressed = digitalRead(SW_PIN) == LOW;
14
15  Serial.print("X: ");  Serial.print(x);
16  Serial.print("  Y: "); Serial.print(y);
17  Serial.print("  Buton / button: ");
18  Serial.println(pressed ? "basılı / pressed" : "-");
19  delay(100);
20}

Totzone und Kalibrierung

In der Praxis liest der losgelassene Stick nicht genau 512, sondern etwa 495 oder 525 und zittert um einige Stellen. Korrigierst du das nicht, kriecht dein Roboterauto vorwärts oder der Servo zuckt, obwohl du den Joystick nicht berührst. Die Lösung hat zwei Schritte: beim Start den Mittelwert messen und speichern (Kalibrierung) und kleine Abweichungen um die Mitte ignorieren (Totzone). Die folgende Funktion macht aus jeder Achse einen sauberen Wert von -100 bis +100 mit der Mitte genau bei 0:

1int centerX, centerY;
2const int DEAD_ZONE = 40;
3
4int readAxis(int pin, int center) {
5  int v = analogRead(pin) - center;
6  if (abs(v) < DEAD_ZONE) return 0;                              // ölü bölge / dead zone
7  if (v > 0) return map(v, DEAD_ZONE, 1023 - center, 0, 100);    // sağ ya da aşağı / right or down
8  return map(v, -center, -DEAD_ZONE, -100, 0);                   // sol ya da yukarı / left or up
9}
10
11void setup() {
12  Serial.begin(9600);
13  centerX = analogRead(A0);   // açılışta joystick'e dokunma / don't touch it at startup
14  centerY = analogRead(A1);
15}
16
17void loop() {
18  Serial.print(readAxis(A0, centerX));
19  Serial.print(", ");
20  Serial.println(readAxis(A1, centerY));
21  delay(50);
22}

Richtungen erkennen: oben, unten, links, rechts

In Spielen und Menüs brauchst du oft nur die Richtung, nicht die genaue Position. Vergleichst du die Werte mit zwei Schwellen, wird der Joystick zum Steuerkreuz mit vier Richtungen. In Menüs soll jede Bewegung nur als ein Schritt zählen, deshalb nutzt der Code eine kurze Pause oder wartet, bis der Stick wieder in die Mitte zurückkehrt.

1void loop() {
2  int x = analogRead(A0);
3  int y = analogRead(A1);
4  if (x < 300)      Serial.println("Sol / left");
5  else if (x > 700) Serial.println("Sağ / right");
6  else if (y < 300) Serial.println("Yukarı / up");
7  else if (y > 700) Serial.println("Aşağı / down");
8  delay(150);
9}

Servomotor mit dem Joystick steuern

Bildest du eine Achse des Joysticks auf 0–180 Grad ab, kannst du einen Servomotor von Hand lenken; mit zwei Achsen und zwei Servos entsteht eine Pan-Tilt-Halterung, die eine Kamera nach links-rechts und oben-unten schwenkt. Zum Anschluss und zur Versorgung des Servos siehe Was ist ein Servomotor?

1#include <Servo.h>
2
3Servo panServo;
4
5void setup() {
6  panServo.attach(9);
7}
8
9void loop() {
10  int x = analogRead(A0);
11  int angle = map(x, 0, 1023, 0, 180);   // joystick → açı / joystick → angle
12  panServo.write(angle);
13  delay(15);
14}

Joystick mit ESP32 und Raspberry Pi Pico

Der ADC des ESP32 hat 12 Bit und liefert Werte von 0 bis 4095; da er nicht linear ist, liegt die Mitte aber oft bei 1800–1950 statt 2048. Die Kalibrierung von oben ist am ESP32 deshalb noch wichtiger. Nutzt du WLAN, schließ die Achsen an ADC1-Pins (GPIO 32–39) an. Beim Pico sind GP26–GP28 die Analogeingänge, und read_u16() liefert Werte von 0 bis 65535:

1from machine import ADC, Pin
2import time
3
4x_axis = ADC(26)                        # GP26 → VRx
5y_axis = ADC(27)                        # GP27 → VRy
6button = Pin(15, Pin.IN, Pin.PULL_UP)   # SW, basınca 0 / 0 when pressed
7
8while True:
9    x = x_axis.read_u16()               # 0–65535, ortada ~32768 / ~32768 at center
10    y = y_axis.read_u16()
11    print(x, y, "BASILI / PRESSED" if button.value() == 0 else "")
12    time.sleep(0.1)

Projektideen mit dem Joystick

• Fernsteuerung für ein Roboterauto: den Joystick an eine Senderplatine anschließen und Befehle per nRF24L01 oder Bluetooth ans Auto schicken.
• Pan-Tilt-Kamera: mit zwei Servos und einem Joystick die Kamera in jede Richtung drehen.
• Snake auf einer LED-Matrix: die Schlange auf einer 8x8-Matrix mit dem Joystick steuern.
• Displaymenü: mit oben-unten durch die Optionen blättern und per Taster auswählen; für das Display siehe I2C-LCD-Display verwenden.
• Farbwähler: eine RGB-LED steuern – X-Achse für die Farbe, Y-Achse für die Helligkeit.
• Computermaus: mit einem Arduino Leonardo oder Pro Micro den Joystick in eine echte USB-Maus verwandeln.

Typische Fehler und ihre Lösungen

• Der Taster wirkt gedrückt, obwohl er es nicht ist: Der SW-Pin ist nicht INPUT_PULLUP; der Pin hängt in der Luft und liest Zufallswerte.
• In Ruhe nicht 512 und zitternd: Das ist normal; kalibriere beim Start und ergänze eine Totzone.
• Achsen sind umgedreht oder vertauscht: Das liegt an der Lage des Moduls; zieh den Wert von 1023 ab oder tausche die Kabel von VRx und VRy.
• Am ESP32 ist die Mitte nicht 2048: Der ADC des ESP32 ist nicht linear; miss die Mitte beim Start und rechne damit.
• Der Servo zittert oder der Arduino startet neu: Der Servo überlastet die 5 V des Arduino; versorge ihn aus einer eigenen 5-V-Quelle und verbinde die Massen.

Ein Joystick besteht eigentlich nur aus zwei Potentiometern und einem Taster, deshalb vertiefen Was ist ein Potentiometer? und Taster an den Arduino anschließen das hier Gelernte. In der BlueGrays-App findest du Projekte zur LED- und Servosteuerung per Joystick sowie ein Snake-Spiel auf der LED-Matrix mit Schaltplänen und Code.