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 Werte 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 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 in deinem Projekt später keinen Button benötigst, brauchst du ihn nicht mit deinem Microcontroller 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
int swValue = analogRead(joyPinSW); // Button auslesen
// Richtung ermitteln
String direction = "Mitte";
if (xValue > 600) {
direction = "Rechts";
} else if (xValue < 400) {
direction = "Links";
}
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);
Serial.print(" | Button: ");
Serial.print(swValue);
if (swValue < 20) {
Serial.println(" | Gedrückt!");
} else {
Serial.println(" | ");
}
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
int swValue = analogRead(joyPinSW); // Button auslesen
// Richtung ermitteln
String direction = "Mitte";
if (xValue > 600) {
direction = "Rechts";
} else if (xValue < 400) {
direction = "Links";
}
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.
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);
Serial.print(" | Button: ");
Serial.print(swValue);
if (swValue < 20) {
Serial.println(" | Gedrückt!");
} else {
Serial.println(" | ");
}
delay(100); // Kurze Pause
}Eine Besonderheit des Arduino Joysticks ist, dass du an einem Analog-Pin ermitteln musst, ob der Button gedrückt wurde. Der ungedrückte Button liefert an seinem Pin SW immer einen Wert von ungefähr 500. Erst wenn du ihn betätigst fällt dieser Wert auf Null. Diesen Moment fängst du im Code oben mit einer If-Abfrage ein und gibst entsprechend ein Gedrückt! im Seriellen Monitor aus.
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 Möglichkeiten sind möglich, denn diese sind nichts anderes als eine Kombination von x- und y-Werten. Ersetze in deinem Sketch den Teil Richtung ermitteln durch folgenden Code:
// Richtung ermitteln
String 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. Das ermöglicht dir weitere Möglichkeiten für deine Steuerung – 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.
