Das Joystick-Modul ist ein vielseitiges Eingabegerät, das häufig in Maker-Projekten verwendet wird. In diesem Artikel erfährst du, wie du einen Arduino Joystick an einen Arduino UNO anschließt, wie er funktioniert und wie du ihn in deinem nächsten Projekt einsetzen kannst.
So funktioniert der Joystick
Das Joystick-Modul verwendet Potentiometer für die x- und y-Achse. Wenn der Joystick bewegt wird, ändert sich der Widerstand der Potentiometer, was zu einer Änderung der Ausgangsspannung führt. Diese Spannung wird vom Arduino ausgelesen und in einen Zahlenwert zwischen 0 und 1023 umgewandelt.
Mit diesen Werten kannst du dann weiterarbeiten: Die Höhe des Werts zeigt dir an, in welche Richtung der Joystick bewegt wurde, also nach oben, unten, links oder rechts. Neben den Potis für die x- und y-Achse findest du meistens noch einen Button, den du betätigst, indem du den Stick drückst. Auch das kannst du natürlich in deinem Sketch auslesen und bei Bedarf in deinem Projekt verwenden.
Und so schließt du ihn an
Ein typischer Arduino Joystick hat fünf Pins. Die Stromversorgung und die beiden Anschlüsse für die x- und y-Achse sind hierbei obligatorisch. Der Pin SW ist mit dem Button verbunden – wenn du in deinem Projekt später keinen Button benötigst, brauchst du ihn nicht mit deinem Mikrocontroller zu verbinden. Im Folgenden verwenden wir jedoch alle fünf Anschlüsse:
___STEADY_PAYWALL___
Beachte, dass die Beschriftung der Pins je nach Modell variieren kann: Meistens findest du jedoch VRx für die horizontale x-Achse (HOR) und VRy für die vertikale y-Achse (VER).
Ein erster Test mit dem Arduino Joystick
Nun, wo du den Joystick angeschlossen hast, wird es Zeit für einen ersten Test. Hierbei liest du einfach die Bewegungen des Sticks und den Button aus und zeigst deine Aktionen entsprechend im Seriellen Monitor an.
Kopiere den folgenden Sketch und lade ihn auf deinen Arduino:
const int joyPinX = A0; // Pin für die x-Achse des Joysticks
const int joyPinY = A1; // Pin für die y-Achse des Joysticks
const int joyPinSW = A2; // Pin für den Button des Joysticks
void setup() {
pinMode(joyPinSW, INPUT_PULLUP); // Button-Pin als Eingang mit internem Pull-up-Widerstand
Serial.begin(9600); // Serielle Kommunikation starten
}
void loop() {
int xValue = analogRead(joyPinX); // x-Achse auslesen
int yValue = analogRead(joyPinY); // y-Achse auslesen
bool buttonPressed = (digitalRead(joyPinSW) == LOW); // Button auslesen: LOW = gedrückt
// Richtung ermitteln
const char* direction = "Mitte";
if (xValue > 600) {
direction = "Rechts";
} else if (xValue < 400) {
direction = "Links";
} else if (yValue > 600) {
direction = "Unten";
} else if (yValue < 400) {
direction = "Oben";
}
// Werte im seriellen Monitor anzeigen
Serial.print("Richtung: ");
Serial.print(direction);
Serial.print(" | X: ");
Serial.print(xValue);
Serial.print(" | Y: ");
Serial.print(yValue);
if (buttonPressed) {
Serial.println(" | Button: Gedrückt!");
} else {
Serial.println(" | Button: -");
}
delay(100); // Kurze Pause
}Teste nun deinen Joystick – siehst du im Seriellen Monitor die Richtungen und einen Hinweis, wenn du den Button drückst? Falls du dich wunderst, dass die ermittelten Richtungen nicht mit deinen Absichten übereinstimmen: Dann positioniere deinen Arduino Joystick bitte wie auf diesem Foto. 😉
So funktioniert der Sketch
Zunächst legst du die Pins fest, an denen dein Joystick mit dem Arduino UNO verbunden ist:
const int joyPinX = A0; // Pin für die x-Achse des Joysticks
const int joyPinY = A1; // Pin für die y-Achse des Joysticks
const int joyPinSW = A2; // Pin für den Button des JoysticksIm Setup legst du fest, dass der Button des Arduino Joysticks den internen Pullup-Widerstand nutzt, damit du seine Werte zuverlässig auslesen kannst. Außerdem startest du den Seriellen Monitor:
void setup() {
pinMode(joyPinSW, INPUT_PULLUP); // Button-Pin als Eingang mit internem Pull-up-Widerstand
Serial.begin(9600); // Serielle Kommunikation starten
}Der Loop beginnt damit, dass dein Arduino die aktuellen Werte des Joysticks einliest und basierend darauf die gedrückte Richtung ermittelt:
void loop() {
int xValue = analogRead(joyPinX); // x-Achse auslesen
int yValue = analogRead(joyPinY); // y-Achse auslesen
bool buttonPressed = (digitalRead(joyPinSW) == LOW); // Button auslesen: LOW = gedrückt
// Richtung ermitteln
const char* direction = "Mitte";
if (xValue > 600) {
direction = "Rechts";
} else if (xValue < 400) {
direction = "Links";
} else if (yValue > 600) {
direction = "Unten";
} else if (yValue < 400) {
direction = "Oben";
}Wie eingangs erwähnt sind im Arduino Joystick zwei Potentiometer verbaut, für jede Achse eines. Am Beispiel der x-Achse bedeutet das: Ein Drücken nach links bis zum Anschlag erzeugt den Wert 0. Diese Werte steigen an, bis sie in der Ruheposition des Sticks im Bereich von 500 liegen. Dein Drücken nach rechts lässt die Werte weiter steigen, bis sie am Anschlag den vollen Wert 1023 erreichen.
Wichtig ist hier die durchgehende else if-Kette: Sobald eine Richtung feststeht, überspringt dein Arduino alle weiteren Prüfungen. Bewegst du den Stick diagonal, gewinnt in diesem ersten Sketch also die x-Achse – ein Druck nach rechts oben erscheint als „Rechts“. Das ist eine bewusste Entscheidung und keine Einschränkung des Joysticks: Wie du beide Achsen zu echten diagonalen Richtungen kombinierst, siehst du gleich weiter unten.
Fehlen noch zwei Dinge: Die Ausgabe der Richtungen im Seriellen Monitor und der Check, ob du den Button des Sticks gedrückt hast:
// Werte im seriellen Monitor anzeigen
Serial.print("Richtung: ");
Serial.print(direction);
Serial.print(" | X: ");
Serial.print(xValue);
Serial.print(" | Y: ");
Serial.print(yValue);
if (buttonPressed) {
Serial.println(" | Button: Gedrückt!");
} else {
Serial.println(" | Button: -");
}
delay(100); // Kurze Pause
}Der Button unterscheidet sich grundlegend von den beiden Achsen: Während die Potentiometer stufenlose Zwischenwerte liefern, ist er nichts weiter als ein simpler Taster, der den Pin SW mit GND verbindet. Er kennt also nur zwei Zustände – offen oder geschlossen. Genau deshalb liest du ihn nicht mit analogRead() aus, sondern mit digitalRead().
Und dafür brauchst du den internen Pull-up-Widerstand, den du im Setup mit INPUT_PULLUP aktiviert hast. Er zieht den Pin im Ruhezustand auf 5 V, sodass digitalRead() ein HIGH zurückgibt. Drückst du den Stick, schließt der Taster den Pin gegen Masse kurz und der Wert fällt auf LOW. Ohne den Pull-up hinge der Pin im ungedrückten Zustand in der Luft und würde dir zufällige Werte liefern. Dass ein gedrückter Button also LOW bedeutet und nicht etwa HIGH, wirkt zunächst verkehrt herum – es ist aber die übliche und zuverlässigste Art, Taster anzuschließen.
Dass der Button hier ausgerechnet an A2 hängt, ist übrigens reine Bequemlichkeit – so liegen alle drei Signalleitungen des Joysticks ordentlich nebeneinander. Die Analog-Pins des Arduino UNO lassen sich nämlich genauso als ganz normale Digital-Pins verwenden. Wenn du deine Analog-Pins in einem größeren Projekt für Sensoren brauchst, kannst du den Button also bedenkenlos auf einen der Pins 2 bis 13 umziehen.
Analog-Stick und diagonale Bewegungen
Wie du im Seriellen Monitor erkennst, ermittelt dein Arduino Werte, die von der Intensität deiner Bewegungen abhängen. Das heißt konkret, dass zum Beispiel der Wert bei einer Bewegung nach rechts immer weiter ansteigt, bis er ab einer Größe von 600 als „nach rechts gedrückt“ gilt. Damit kannst du aber auch feine Bewegungen erkennen, ähnlich wie bei einem Analog-Stick eines herkömmlichen Controllers für die Playstation, Xbox oder Switch.
Falls du also für dein Projekt sowohl schnelle als auch langsame Bewegungen erkennen möchtest, setze bei den Werten mehrere Schwellenwerte: Der Wert 600 könnte dann ein gemächliches Schleichen sein, der Maximalwert von 1023 (also der Anschlag des Joysticks nach rechts) dann die volle Geschwindigkeit.
Auch diagonale Bewegungen sind möglich, denn diese sind nichts anderes als eine Kombination von x- und y-Werten. Der Trick besteht darin, die Diagonalen zuerst zu prüfen: Sie sind die spezielleren Fälle, und sobald eine davon zutrifft, sind die einfachen Richtungen darunter kein Thema mehr. Ersetze in deinem Sketch den Teil Richtung ermitteln durch folgenden Code:
// Richtung ermitteln
const char* direction = "Mitte";
if (xValue > 600 && yValue > 600) {
direction = "Rechts-Unten";
} else if (xValue > 600 && yValue < 400) {
direction = "Rechts-Oben";
} else if (xValue < 400 && yValue > 600) {
direction = "Links-Unten";
} else if (xValue < 400 && yValue < 400) {
direction = "Links-Oben";
} else if (xValue > 600) {
direction = "Rechts";
} else if (xValue < 400) {
direction = "Links";
} else if (yValue > 600) {
direction = "Unten";
} else if (yValue < 400) {
direction = "Oben";
}Hier wird zum Beispiel eine Bewegung nach links oben erkannt, wenn sowohl der x-Wert als auch der y-Wert unter 400 liegt. Entsprechend behandelst du die anderen drei diagonalen Richtungen. Damit stehen dir statt vier nun acht Richtungen für deine Steuerung zur Verfügung – mit etwas Fleißarbeit sind sogar noch weitere Abstufungen möglich.
Wie geht es weiter?
Jetzt wo du weißt, wie du deinen Arduino Joystick anschließt und verwendest, möchtest du bestimmt ein passendes Projekt bauen. In diesem Tutorial lernst du, wie du den Spieleklassiker Snake auf einem Arduino und ESP32 umsetzt.
