Joystick-Steuerung des Arduino-Lenkrads. Joystick Arduino - Anschluss und Skizze. Verbindung zum Arduino-Board

Es ist ein Dateneingabemodul. С его помощью можно управлять роботами, манипуляторами, станками, различными моделями (машинки, танки, самолёты, вертолёты, квадрокоптеры, лодки и т.д.), а также использовать для создания игровых приставок, выбора пунктов меню на дисплеях и индикаторах, ввода значений , usw. Der Joystick kann nicht nur entlang der X- und Y-Achse bewegt, sondern auch angeklickt werden.

Video:

Spezifikation:

Versorgungsspannung: 5V / 3,3V (beide Spannungen liegen im akzeptablen Bereich).
Energieverbrauch:< 10 мА
Abmessungen: 30x30 mm

Alle Module der Linie "Trema" werden im gleichen Format hergestellt

Verbindung:

Die Pins "X" und "Y" des Moduls sind mit beliebigen analogen Eingängen des Arduino verbunden. Die von diesen Pins abgelesenen Werte erhöhen sich, wenn Sie den Joystick von links nach rechts und von unten nach oben bewegen.
Der K-Pin ist digital und wird mit jedem Pin des Arduino verbunden. Im Normalzustand hat es den logischen Pegel "0", und wenn Sie den Joystick drücken, wechselt er auf eine logische "1".
Die V- und G-Pins sind Power-Pins.

Es ist bequem, das Modul je nach Situation auf 3 Arten anzuschließen:

Methode 1: Mit einem verdrahteten Flachbandkabel und Piranha UNO

Mit den "Papa - Mama" Drähten verbinden wir uns direkt mit dem Piranha UNO Controller

Methode - 2: Verwenden des Trema Set Shields

Das Modul kann an jeden der analogen Eingänge des Trema Set Shield angeschlossen werden.

Methode - 3: Verwenden eines verdrahteten Flachbandkabels und einer Abschirmung

Mit einem 5-adrigen Flachbandkabel zum Trema Shield, Trema-Power Shield, Motor Shield, Trema Shield NANO usw.

Ernährung:

An die Pins Vcc (V) und GND (G) wird eine Eingangsspannung von 5 V oder 3,3 V DC angelegt.

Mehr zum Modul:

Die Moduldaten werden von zwei Potentiometern und einem Taster gelesen, der mechanisch mit dem Joystickhebel verbunden ist. Der Taster ist mit der Unterbrechung der Vcc-Stromversorgung und dem "K"-Ausgang verbunden, der über einen Widerstand auf GND gedrückt wird. Somit sind am Ausgang „K“ nur zwei Zustände einstellbar: logisch „0“ (Taste losgelassen) oder „1“ (Taste gedrückt). Pins der Koordinaten "X" und "Y" sind analoge Ausgänge des Moduls, sie sind mit Potentiometern verbunden, so dass die zwischen diesen Pins und GND aufgenommene Spannung ansteigt, wenn der Joystick von links nach rechts und von unten nach oben bewegt wird.

Beispiele:

Position des Joysticks ermitteln und LED auf Knopfdruck einschalten

const int8_t Xaxis = A0; // Bestimmen Sie die Nummer des Pins, mit dem der X-Achsen-Kontakt des Joysticks verbunden ist const int8_t Yaxis = A1; // Bestimmen Sie die Nummer des Pins, mit dem der Kontakt der Y-Achse des Joysticks verbunden ist const int8_t Button = 2; // Bestimmen Sie die Nummer des Pins, mit dem der Joystick-Tastenkontakt verbunden ist const int8_t LED = 7; // Bestimmen Sie die Pin-Nummer, mit der die LED verbunden ist uint16_t XborderMIN = 505; // Setzen Sie die Wertegrenze, UNTER der davon ausgegangen wird, dass der Joystick entlang der X-Achse nach links ausgelenkt wird uint16_t XborderMAX = 515; // Wertegrenze setzen, OBERHALB wird davon ausgegangen, dass der Joystick entlang der X-Achse nach rechts ausgelenkt wird uint16_t YborderMIN = 505; // Setzen Sie die Wertegrenze, UNTER der davon ausgegangen wird, dass der Joystick entlang der Y-Achse nach unten ausgelenkt wird uint16_t YborderMAX = 515; // Setzen Sie den Grenzwert der Werte, OBERHALB wird davon ausgegangen, dass der Joystick entlang der Y-Achse nach oben ausgelenkt wird uint16_t Xvol = 0, Yvol = 0; // Stellen Sie die Variablen ein, die die von den Joystick-Achsen gelesenen Werte übernehmen void setup () (Serial.begin (9600); // Initiieren Sie die Datenübertragung zum seriellen Port-Monitor PinMode (LED, OUTPUT); // Konfigurieren Sie LED-Ausgang, um im Ausgabemodus zu arbeiten pinMode (Button, INPUT); // Den Button-Pin so einstellen, dass er im Eingabemodus arbeitet) void loop () (Xvol = analogRead (Xaxis); // Lesen Sie die Werte der X-Achse Yvol = analogRead (Yaxis); // Werte der Achse lesen If (Xvol< XborderMIN) { // Проверяем, полученное значение Х меньше нижней границы центрального положения или нет. Если да, то if (Yvol < YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Left-Down"); // значит джойстик находится в положении ВЛЕВО-ВНИЗ } else if (Yvol >YborderMAX) (// Wenn der empfangene Y-Wert größer als der obere Rand der Mittelposition ist, dann Serial.println ("Left-Up"); // bedeutet, dass sich der Joystick in der LEFT-UP-Position befindet) else (Serial. println ("Left"); // Wenn der erhaltene Y-Wert innerhalb der Grenzen der Mittelposition entlang der Y-Achse liegt, dann wird der Joystick nach LINKS ausgelenkt)) else if (Xvol> XborderMAX) (// Überprüfen Sie, ob das erhaltene X Wert ist größer als die obere Grenze der Mittelposition oder nicht Wenn ja, dann wenn (Yvol< YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Right-Down"); // значит джойстик находится в положении ВПРАВО-ВНИЗ } else if (Yvol >YborderMAX) (// Wenn der empfangene Y-Wert größer als der obere Rand der Mittelposition ist, dann Serial.println ("Right-Up"); // bedeutet, dass sich der Joystick in der RIGHT-UP-Position befindet) else (Serial. println ("Right"); // Wenn der empfangene Y-Wert innerhalb der Grenzen der Mittelposition entlang der Y-Achse liegt, wird der Joystick nach RECHTS ausgelenkt)) else (// Wenn der empfangene X-Wert innerhalb der Grenzen liegt der zentralen Position entlang der X-Achse, dann wenn (Yvol< YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Down"); // значит джойстик находится в положении ВНИЗ } else if (Yvol >YborderMAX) (// Wenn der empfangene Y-Wert größer als der obere Rand der Mittelposition ist, dann Serial.println ("Up"); // bedeutet, dass sich der Joystick in der OBEN-Position befindet) else (Serial.println ("Center "); // Wenn der resultierende Y-Wert innerhalb der Grenzen der Mittelposition entlang der Y-Achse liegt, was bedeutet, dass sich der Joystick in der Mitte befindet.)) if (digitalRead (Button)) (// Überprüfen Sie, ob die Verzögerung (1 ) Taste wird gedrückt; // Wenn die Taste gedrückt wurde, dann unterdrücken Sie das Rattern digitalWrite (LED,! digitalRead (LED)); // und ändern Sie den Zustand am Ausgang der LED Serial.println ("Button click!") ; // Den Text anzeigen, während der die Taste gedrückt wurde (digitalRead (Button)) () // Wenn die Taste gedrückt gehalten wird, dann tun wir keine Verzögerung (10); // Wenn die Taste losgelassen wird, dann unterdrücken wir die Geschwätz))

Im Monitor der seriellen Schnittstelle sehen Sie.

Eines schönen Tages stieß ich bei eBay auf ein interessantes kleines Joystick-Modul, das denen sehr ähnlich ist, die in Controllern für die PlayStation 2 verwendet werden. Es stellte sich heraus, dass das Modul sehr einfach mit dem Arduino zu bedienen ist und buchstäblich ein paar Dollar kostet.

Es gibt mehrere Hersteller von Joysticks für Arduino, darunter Adafruit, Sparkfun und eine Vielzahl chinesischer Firmen. Ich bin froh, dass ihr Funktionsprinzip völlig identisch ist.

Allgemeine Informationen zum Joystick-Modul für Arduino

Das Modul hat 5 Pins: Vcc, Ground, X, Y, Key. Bitte beachten Sie, dass die Beschriftungen auf Ihrem Modul abweichen können. Es hängt vom Hersteller ab. Der Joystick ist analog und bietet eine höhere Präzision als einfache "direktionale" Joysticks, die Tasten und mechanische Schalter verwenden. Außerdem kann der Joystick gedrückt werden (bei meinem Modell ist das ein ordentlicher Aufwand. Vielleicht ist er einfach noch nicht entwickelt). Nach dem Drücken funktioniert die Schaltfläche "Zum Auswählen drücken".

Um Daten von den Pins X / Y zu lesen, müssen Sie die analogen Ausgänge des Arduino verwenden. Der Key-Pin wird geerdet, wenn er gedrückt wird. Andernfalls nimmt es an keiner Kette teil. Für ein stabiles Lesen der Daten von den Key / Select-Pins müssen diese über einen Pull-Up-Widerstand mit der Stromversorgung (Vcc) verbunden werden. Der Wert der im Arduino eingebauten Widerstände reicht dafür völlig aus.

Sehen Sie sich ein Videobeispiel an, wie ein Joystick mit einem Arduino funktioniert:

Joystick-Schaltplan für Arduino

Arduino GND - GNG

ARDUINO A0 - VER / Y

Arduino A1 - HOR / X

Grundskizze für die Verwendung eines Joysticks mit einem Arduino

int buttonPin = 2;

int xPosition = 0;

int yPosition = 0;

int buttonState = 0;

// Initialisierung des Datenaustauschs über serielles Protokoll mit 9600 bps:

Serieller Anfang (9600);

pinMode (xPin, EINGANG);

pinMode (yPin, INPUT);

// den Pull-Up-Widerstand am Knopfstift aktivieren

pinMode (buttonPin, INPUT_PULLUP);

// Für ältere Arduino-Versionen (weniger als 1.0.1)

// PinMode (buttonPin, INPUT);

// digitalWrite (buttonPin, HIGH);

xPosition = analogRead (xPin);

yPosition = analogRead (yPin);

buttonState = digitalRead (buttonPin);

Serial.print ("X:");

Seriendruck (xPosition);

Serial.print ("| Y:");

Serial.print (yPosition);

Serial.print ("| Button:");

Serial.println (buttonState);

Verzögerung (100); // füge eine Verzögerung zwischen dem Lesen von Daten hinzu

Wie oben erwähnt, werden viele Joystick-Module hergestellt. Sparkfun hat eine interessante Lösung. Sie veröffentlichen den Joystick Shield, über den wir als nächstes sprechen werden. Das Aussehen der Joystick-Abschirmung ist in der folgenden Abbildung dargestellt.

Zusammenbau der Joystick-Abschirmung

Erwähnenswert ist hier, dass der Schirm unmontiert geliefert wird. Sie müssen also mit einem Lötkolben arbeiten. Eine vollständige Montageanleitung finden Sie unter dieser Adresse: Joystick Shield Montageanleitung. Das Material des Herstellers ist in englischer Sprache, Bildmaterial ist aber ausreichend vorhanden. Es ist also einfach, es herauszufinden.

Wofür kann der Joystick verwendet werden?

Der Joystick-Schild hat vier Tasten rechts, eine Taste direkt am Joystick und den analogen Joystick selbst. Das Schild kann verwendet werden, um die Melodie oder Pixel auf dem Monitor zu steuern. Schaltflächen können zum Navigieren und Steuern von Spielen verwendet werden.

Für zusätzliche Motivation sehen Sie sich das folgende Video an:

Nachdem Sie Ihren Joystick-Schutz zusammengebaut haben, können Sie sicher Änderungen an den Skizzen vornehmen, um Ihre Aufgaben zu erfüllen.

Wie kann man die aktuelle Position des Joysticks verfolgen?

Die Position des Joysticks wird in Abhängigkeit von den Werten der beiden darin verbauten Potentiometer berechnet. Der Joystick bewegt sich in zwei Richtungen, die normalerweise mit X und Y bezeichnet werden. Um Daten von den Potentiometern auszulesen, verwenden Sie die Funktion analogRead(), die einen Wert im Bereich von 0 bis 1023 zurückliefert. Übertragen Sie dazu die Pin-Nummern an dem der Joystick mit der Funktion verbunden ist. In diesem Beispiel verbinden wir den analogen Pin 0 für X und den analogen Pin 1 für Y.

Serial.println (analogRead (0)); // zeigt die aktuelle Position der X-Koordinate an

Serial.println (analogRead (1)); // zeigt die aktuelle Position der Y-Koordinate an

Ein sehr bequemer Ansatz besteht darin, Konstanten für Werte zu verwenden, die sich im Laufe des Programms nicht ändern. Im folgenden Code deklarieren wir Konstanten für die von uns verwendeten analogen Pins und zeigen die aktuelle X- und Y-Position im seriellen Arduino IDE-Monitor an:

konstantes Byte PIN_ANALOG_X = 0;

konstantes Byte PIN_ANALOG_Y = 1;

Serieller Anfang (9600);

Serial.print ("x:");

Serial.print ("");

Serial.print ("y:");

Serial.print ("");

Serial.println ();

Wie kann man die aktuelle Richtung des Joysticks verfolgen?

Ein sehr nützliches Stück Code. Anhand der Werte der X- und Y-Positionen können wir feststellen, ob der Joystick zentriert oder in eine von acht Richtungen vorgespannt ist (oben, rechts oben, rechts, rechts unten, unten, links unten, links, links oben).

Da die Werte in jeder Richtung im Bereich von 0 bis 1023 liegen, kann davon ausgegangen werden, dass die Mitte im Bereich von 511 bis 512 liegt. Aber es ist nicht so. So genau werden wir den aktuellen Wert nicht bekommen. Und wenn wir den falschen Wert ermitteln, können wir Informationen über die Bewegung des Joysticks erhalten, obwohl er in der Mitte war und sich nicht bewegte.

Dazu geben wir einen Wertebereich ein und gehen davon aus, dass jeder Wert in diesem Bereich als Zentrum betrachtet wird:

Dieser Bereich ist nicht "die ultimative Wahrheit". Sie müssen es an Ihren Joystick anpassen, richtig. Diese Werte werden als Konstanten in den Code eingetragen:

Wir konvertieren nun jede Koordinate aus dem Bereich 0 bis 1023 in den Bereich -1 bis 1. Für die X-Koordinate bedeutet 1 Bewegung nach links, 0 bedeutet keine Bewegung und 1 bedeutet Bewegung nach rechts. Für die Y-Richtung bedeutet -1 eine Abwärtsbewegung, 0 bedeutet keine Bewegung und 1 bedeutet eine Aufwärtsbewegung.

Wir beginnen damit, den Wert in jede Richtung auf 0 ("Mitte") zu setzen. Wir verwenden dann if / else-Anweisungen, um zu testen, ob der Positionswert in eine der beiden Richtungen größer oder kleiner als unser Bereich ist:

x_Richtung = 0;

y_Richtung = 0;

if (x_position> X_THRESHOLD_HIGH) (

x_Richtung = 1;

) sonst if (x_position

x_Richtung = -1;

if (y_position> Y_THRESHOLD_HIGH) (

y_Richtung = 1;

) sonst if (y_position

y_Richtung = -1;

Die Arduino-IDE hat eine map()-Funktion, die theoretisch anstelle von if / else verwendet werden könnte, aber in diesem Fall ist die Methode aufgrund von Zentrierungsproblemen kompliziert, daher werden wir hier nicht map verwenden.

Im folgenden Beispiel sehen Sie, dass später, wenn / else verwendet wird, um die Richtung anzuzeigen, Sie dieses Beispiel sicher an Ihre Bedürfnisse anpassen können:

konstantes Byte PIN_ANALOG_X = 0;

konstantes Byte PIN_ANALOG_Y = 1;

const int X_THRESHOLD_LOW = 505;

const int X_THRESHOLD_HIGH = 515;

const int Y_THRESHOLD_LOW = 500;

const int Y_THRESHOLD_HIGH = 510;

int x_Richtung;

int y_Richtung;

Serieller Anfang (9600);

x_Richtung = 0;

y_Richtung = 0;

x_position = analogRead (PIN_ANALOG_X);

y_position = analogRead (PIN_ANALOG_Y);

if (x_position> X_THRESHOLD_HIGH) (

x_Richtung = 1;

) sonst if (x_position

x_Richtung = -1;

if (y_position> Y_THRESHOLD_HIGH) (

y_Richtung = 1;

) sonst if (y_position

y_Richtung = -1;

if (x_Richtung == -1) (

if (y_direction == -1) (

Serial.println ("links unten");

Serial.println ("links");

// y_Richtung == 1

Serial.println ("links oben");

) sonst if (x_Richtung == 0) (

if (y_direction == -1) (

Serial.println ("down");

) sonst if (y_direction == 0) (

Serial.println ("zentriert");

// y_Richtung == 1

Serial.println ("up");

// x_Richtung == 1

if (y_direction == -1) (

Serial.println ("rechts-unten");

) sonst if (y_direction == 0) (

Serial.println ("rechts");

// y_Richtung == 1

Serial.println ("rechts oben");

Wie konfiguriere ich Arduino, um den Zustand einer Taste zu verfolgen (wird sie gedrückt)?

Bevor Sie feststellen können, ob eine Taste auf dem Joystick-Schild gedrückt wird, müssen Sie den Arduino so konfigurieren, dass er die Tasten erkennt. Überraschenderweise ist dies im Body der setup()-Funktion implementiert!

Zuerst definieren wir Konstanten für die Arduino-Pins, die den Schaltflächen zugeordnet sind:

// Wählen Sie die Taste, die funktioniert, wenn der Joystick gedrückt wird

konstantes Byte PIN_BUTTON_UP = 4;

Wenn Sie zuvor Tasten mit einem Arduino verwendet haben, ist Ihnen möglicherweise aufgefallen, dass Sie einen Widerstand verwenden müssen, um die Spannung beim Drücken der Taste zu erkennen. Um die Anzahl der Teile zu reduzieren, ist die Joystick-Abschirmung so konstruiert, dass keine Widerstände benötigt werden. Sie fragen sich vielleicht: "Wenn die Tasten Widerstände benötigen, warum funktioniert die Abschirmung ohne sie?" Sie haben nur nicht berücksichtigt, dass der Arduino über eingebaute Widerstände verfügt. Sie können sie einfach aktivieren und mit unserem Schild verwenden!

Um diese eingebauten Pull-Up-Widerstände zu verwenden, stellen Sie den Pin auf den INPUT-Modus und aktivieren Sie ihn dann über die folgenden Zeilen:

Wenn Sie einen Pull-Up-Widerstand verwenden, ist es wichtig zu beachten, dass der gedrückte Knopf nicht HIGH, sondern der gedrückte LOW ist.

Um jeden Pin für den Betrieb im Eingangsmodus zu konfigurieren und die Pullup-Widerstände zu aktivieren, können Sie den folgenden Code verwenden:

pinMode (PIN_BUTTON_RIGHT, INPUT);

digitalWrite (PIN_BUTTON_RIGHT, HIGH);

Woher weiß ich, wann die Taste auf dem Joystick-Schild gedrückt wurde?

Nachdem Sie die vorherigen Punkte überwunden haben, können Sie mit der Funktion digitalRead() feststellen, ob die Schaltfläche gedrückt ist. Wenn der gelesene Wert LOW ist, wird die Taste gedrückt, und wenn der Wert HIGH ist, wird die Taste nicht gedrückt.

if (digitalRead (PIN_BUTTON_LEFT) == LOW) (

// Taste gedrückt

// Taste nicht gedrückt

Das folgende Beispiel zeigt den Zustand jeder Schaltfläche und die Werte des Joysticks im seriellen Arduino IDE-Monitor an:

konstantes Byte PIN_BUTTON_SELECT = 2;

konstantes Byte PIN_BUTTON_RIGHT = 3;

konstantes Byte PIN_BUTTON_UP = 4;

konstantes Byte PIN_BUTTON_DOWN = 5;

konstantes Byte PIN_BUTTON_LEFT = 6;

konstantes Byte PIN_ANALOG_X = 0;

konstantes Byte PIN_ANALOG_Y = 1;

Serieller Anfang (9600);

pinMode (PIN_BUTTON_RIGHT, INPUT);

digitalWrite (PIN_BUTTON_RIGHT, HIGH);

pinMode (PIN_BUTTON_LEFT, INPUT);

digitalWrite (PIN_BUTTON_LEFT, HIGH);

pinMode (PIN_BUTTON_UP, INPUT);

digitalWrite (PIN_BUTTON_UP, HIGH);

pinMode (PIN_BUTTON_DOWN, INPUT);

digitalWrite (PIN_BUTTON_DOWN, HIGH);

pinMode (PIN_BUTTON_SELECT, INPUT);

digitalWrite (PIN_BUTTON_SELECT, HIGH);

Serial.print ("l:");

Serial.print (digitalRead (PIN_BUTTON_LEFT));

Serial.print ("");

Serial.print ("r:");

Serial.print (digitalRead (PIN_BUTTON_RIGHT));

Serial.print ("");

Serial.print ("u:");

Serial.print (digitalRead (PIN_BUTTON_UP));

Serial.print ("");

Serial.print ("d:");

Serial.print (digitalRead (PIN_BUTTON_DOWN));

Serial.print ("");

Serial.print ("x:");

Serial.print (analogRead (PIN_ANALOG_X));

Serial.print ("");

Serial.print ("y:");

Serial.print (analogRead (PIN_ANALOG_Y));

Serial.print ("");

Serial.print ("s:");

Serial.print (digitalRead (PIN_BUTTON_SELECT));

Serial.print ("");

Serial.println ();

Hinterlassen Sie Ihre Kommentare, Fragen und teilen Sie Ihre persönlichen Erfahrungen unten. In der Diskussion entstehen oft neue Ideen und Projekte!

Joysticks sind eine großartige Eingabequelle für ein Robotikprojekt. Elektronikhersteller haben so etwas schon immer geliebt. Für Anfänger kann es jedoch schwierig sein, das Konzept beim Codieren und dergleichen zu verstehen. Der folgende Artikel beschreibt detailliert den Mechanismus zum Zusammenbauen eines Arduino-Joysticks und seine Funktionsweise.

Viele Roboterprojekte erfordern einen Joystick. Das Joystick-Modul auf dem Arduino ähnelt denen, die in Spielkonsolen verwendet werden. Dies geschieht, indem die beiden Potentiometer im 90-Grad-Winkel eingestellt werden. Die Potentiometer sind mit einer kurzen Stange verbunden, die durch Federn zentriert wird.

Dieses Modul erzeugt im Ruhezustand eine Ausgangsspannung von ca. 2,5 V von X und Y. Durch Bewegen des Joysticks ändert sich das Ausgangssignal je nach Richtung von 0 V auf 5 V. Wenn Sie dieses Modul an einen Mikrocontroller anschließen, können Sie davon ausgehen, dass der Wert im Ruhezustand etwa 512 beträgt.

Wenn Sie den Joystick bewegen, können Sie sehen, wie sich die Werte je nach Position von 0 bis 1023 ändern.

Funktionsprinzip

Im folgenden Code haben wir die X- und Y-Achse des Joystick-Moduls für den analogen Pin A0 bzw. A1 definiert:

#define joysX Ad0 #define joysY As1

Im folgenden Code initialisieren wir nun die Arduino-PIN 2 für den Joystick-Modul-Umschalter, und die Werte buttonsdtate und buttonsdtate1 sind zu Beginn des beschriebenen Programms 0:

Int-Tasten = 2; int buttonSdtate = 0; int buttonSdtate1 = 0;

Im folgenden Code setzen wir die erforderliche Baudrate auf 9600 und definieren Pin 7 als Ausgangs-Pin und den Button-Pin als Eingangs-Pin. Anfänglich bleibt der Kontaktknopf hoch, bis der Benutzer den entsprechenden Schalter drückt.

Void-Setups () (pinModde (7, OUTPUTs); pinModes (Tasten, INPUT); digitalWritesd (Tasten, HIGH); Serial.beginsdf (9600);)

Hier in diesem Code lesen wir die Werte vom Analogausgang A0 und A1 und geben sie sequentiell an das Gerät aus:

Int xValuess = analogReadd (joysX); int yValuef = analogReadd (joysY); Serial.prints (xValues); Serial.print ("\ f"); Serial.printlns (yValues);

Die Bedingungen zum Ein- und Ausschalten der LED entsprechend der Bewegung der Joystickwelle sind im folgenden Code definiert. Hier übernehmen wir einfach die analogen Spannungswerte an den A0- und A1-Pins des Arduino. Diese analogen Werte ändern sich, wenn Sie den Joystick bewegen und die LED leuchtet entsprechend der Bewegung des Joysticks.

Dies ist die Bedingung für das Bewegen der Joystickwelle in Y-Richtung:

Wenn (xWerte> = 0 && yWerte<= 10){ digitalWrites (10, HIGHd); } else { digitalWrites (10, LOWd); }

Wenn (xWerte<= 10 && yValued>= 500) (digitalWrites (11, HIGHd);) else (digitalWrites (11, LOWsd);)

Dies ist die Bedingung für das Bewegen der Joystickwelle in Richtung der X-Achse:

If (xValues> = 1020 && yValues> = 500) (digitalWrites (9, HIGHd);) else (digitalWrites (9, LOWf);)

Der folgende Code ist eine Bedingung für die Bewegung der Welle des entworfenen Geräts in Richtung der Y-Achse:

if (xValues> = 500 && yValues> = 1020) (digitalWrites (8, HIGHf);) else (digitalWrites (8, LOWf);)

Wenn wir die Achse des Joysticks diagonal bewegen, kommt eine Position, wenn der Analogwert von X und Y 1023 bzw. 1023 beträgt und die LEDs Pin 9 und Pin 8 leuchten. Weil es die Bedingung der LED erfüllt. Um diese Diskrepanz zu beseitigen, wird die Bedingung angezeigt, dass, wenn der Wert (X, Y) (1023, 1023) ist, beide LEDs aus bleiben:

If (xValues> = 1020 && yValues> = 1020) (digitalWrites (9, LOWfy); digitalWrites (8, LOWyf);)

Die folgende Bedingung wird verwendet, um die an den Drucktaster angeschlossene LED zu steuern. Wenn wir den Joystick drücken, schaltet sich die LED ein und dauert an, bis der Knopf nach unten gezogen wird. Besser einen Druckknopfschalter verwenden.

If (buttonStatesy == LOWfy) (Serial.printlnsy ("Switch = Highy"); digitalWritesy (7, HIGHf);) else (digitalWritesy (7, LOWfy);

Benötigte Werkzeuge, Materialien und Programme

Für die Umsetzung des Projekts „arduino joystick“ werden folgende Materialien benötigt:

Joystick-Modul;
LEDs - 5 Stück;
100 Ohm Widerstand - 3 Stück;
Anschlussdrähte;
Layout.

Gerät zusammenbauen

Joysticks sind in verschiedenen Formen und Größen erhältlich. Ein typisches Modul des beschriebenen Gerätes ist in der folgenden Abbildung dargestellt. Dieses Modul bietet normalerweise analoge Ausgänge, und die von diesem Modul verarbeiteten Ausgangsspannungen ändern sich entsprechend der Richtung, in die der Benutzer es bewegt. Es ist möglich, die Bewegungsrichtung zu erhalten, indem diese Änderungen mit Hilfe eines Mikrocontrollers interpretiert werden.

Dieses Joystick-Modul hat zwei Achsen. Sie stellen die X- und Y-Achse dar. Jede Achse ist auf einem Potentiometer oder Poti montiert. Die Mittelpunkte dieser Potis sind als Rx und Ry definiert. Somit sind Rx und Ry variable Punkte für diese Töpfe. Wenn sich das Gerät im Standby-Modus befindet, wirken Rx und Ry als Spannungsteiler.

Wenn der Arduino-Joystick entlang der horizontalen Achse bewegt wird, ändert sich die Spannung am Rx-Pin. Ebenso ändert sich die Spannung über dem Ry-Pixel, wenn es entlang der vertikalen Achse bewegt wird. Somit haben wir vier Richtungen des Geräts an zwei ADC-Ausgängen. Während sich der Stick bewegt, sollte die Spannung an jedem Pin je nach Richtung hoch oder niedrig sein.

Einrichten und Debuggen

Nachdem wir den Code in arduino geladen und die Komponenten gemäß Schaltplan verbunden haben, steuern wir nun die LEDs mit dem Joystick. Je nach Bewegung der Gerätewelle können vier LEDs in jede Richtung eingeschaltet werden. Es hat zwei Potentiometer im Inneren, eines für die Bewegung der X-Achse und das andere für die Bewegung der Y-Achse Jedes Potentiometer erhält 5 V von Arduino. Wenn wir das Gerät bewegen, ändert sich der Spannungswert und der Analogwert an den Pins A0 und A1 ändert sich ebenfalls.

Also lesen wir vom Arduino-Mikrocontroller den Analogwert für die X- und Y-Achse und schalten die LEDs entsprechend der Bewegung der Geräteachse ein. Drücken Sie den Schalter am Modul und steuern Sie damit eine einzelne LED im Stromkreis.

Der Code wird unten angezeigt:

Testen

Um einen Arduino-Joystick zu testen, benötigen Sie die folgenden Komponenten:

Mikrocontroller (jeder arduino-kompatibel).
Joystick-Modul.
1-poliger Stecker MM.
Layout.
USB-Kabel.

Testalgorithmus:

Verbinden Sie die Komponenten mit dem MM-Stecker. + 5V ist mit 5V-Stromversorgung verbunden, GND-Pin ist mit GND verbunden, VRx- und VRy-Pins sind mit analogem Eingang verbunden, Pins und Pin sind mit digitalem I / O-Pin verbunden.
Die Kontaktnummer basiert auf dem tatsächlichen Programmiercode.
Fügen Sie nach der Hardwareverbindung die Beispielskizze in die Arduino-Entwicklungsumgebung ein.
Verbinden Sie die Ports des Mikrocontrollers mit einem USB-Kabel mit dem Computer.
Laden Sie das Programm herunter.
Sehen Sie sich die Ergebnisse auf einem seriellen Monitor an.

Wenn Sie einen Joystick mit einem Arduino verbinden, können Sie ein Auto oder einen Roboter auf einem Arduino mit dem Joystick fernsteuern. Betrachten wir im Artikel, wie Sie das Joystick-Shield selbst anschließen und das Servo mit dem Joystick auf dem Arduino steuern. Lassen Sie uns einige Skizzen präsentieren und ein Diagramm zum Anschließen eines Joysticks an einen Arduino Nano- oder Arduino Uno-Mikrocontroller geben.

Joystick-Schaltplan für Arduino

Der analoge Joystick ist ein Drehknopf, der an einem Scharnier mit zwei Potentiometern montiert ist, die die Position des Joysticks in der X- und Y-Achse bestimmen, und einer Taste Z. Durch Neigen des Drehknopfs werden die Potentiometer gedreht und die Ausgangsspannung geändert, sodass Sie verfolgen können den Grad der Neigung des Knopfes vom Mittelpunkt aus. Wenn Sie den Joystick-Griff loslassen, kehrt er sanft in die Mittelposition (Null) zurück.

So verbinden Sie einen Joystick mit Arduino Nano und Arduino Uno

Das Joystick-Modul KY-023 hat seine Nachteile. Tatsache ist, dass der Joystick-Knopf nicht immer exakt in die Mittelstellung zurückkehrt, daher sollte die Mittelstellung des Drehknopfes im Programm als bestimmter Wertebereich und nicht als exakter Wert berücksichtigt werden. Das heißt, wenn sich der Joystick-Griff in der Mitte befindet, können die X- und Y-Koordinaten im Bereich von 490 bis 530 statt 512 liegen.

Joystick-Verbindung zu Arduino UNO

Für den Unterricht benötigen wir folgende Angaben:

Arduino Uno / Arduino Nano / Arduino Mega-Board;
Joystick-Modul ky-023;
2 LEDs und 2 Widerstände;
Brotbrett;
Drähte "Papa-Mama", "Papa-Papa".

Diagramm zum Anschließen eines analogen Joysticks an Arduino Uno

Nachdem Sie den Joystick mit dem Arduino verbunden haben, laden Sie die folgende Skizze hoch. In diesem Beispiel werden die Daten des Joysticks auf dem Portmonitor angezeigt und beim Drücken der Taste erlischt die LED auf der parallel zu Pin 13 geschalteten Platine. Bauen Sie die Schaltung mit dem Joystick wie in der Abbildung gezeigt zusammen Laden Sie oben die Skizze herunter und öffnen Sie den Port-Monitor des Arduino IDE-Programms.

Skizzieren. Joystick-Verbindung zu Arduino

#define pinX A2 // X-Achse des Joysticks#define pinY A1 // Y-Achse des Joysticks#define swPin 2 // Joystick-Taste#define ledPin 13 // LED an Pin 13 void setup () (Serial .begin (9600); pinMode (ledPin, OUTPUT); pinMode (pinX, INPUT); pinMode (pinY, INPUT); pinMode (swPin, INPUT); digitalWrite (swPin, HIGH);) void loop () (boolescher ledState = digitalRead (swPin); // an aus. Leuchtdiode // den Wert der X-Achse lesen // den Y-Achsen-Wert lesen Seriendruck (X); // auf seriellen Monitor drucken Serielle .print ("\ t"); // Registerkarte Serial .println (Y); )

Skizzieren. Joystick-LED-Steuerung

Jetzt können Sie die Schaltung komplizieren, indem Sie die LED sanft einschalten lassen, die über den Joystick gesteuert wird. Verbinden Sie dazu zwei LEDs über einen Widerstand mit den analogen Ports 5 und 6. In der nächsten Skizze mit der Funktion Karte (), werden die X- und Y-Variablen aus einem Zahlenbereich von 0 bis 1023 in einen Zahlenbereich von 0 bis 255 umgewandelt. Verbinden Sie die LEDs mit den Pins 5 und 6 des Arduino und laden Sie die folgende Skizze.

#define pinX A2 // X-Achse des Joysticks#define pinY A1 // Y-Achse des Joysticks#define swPin 2 // Joystick-Taste#define ledPin 13 // LED an Pin 13#define ledX 5 // LED an Pin 5#define ledY 6 // LED an Pin 6 void setup () (pinMode (ledX, OUTPUT); pinMode (ledY, OUTPUT); pinMode (ledPin, OUTPUT); pinMode (pinX, INPUT); pinMode (pinY, INPUT); pinMode (swPin, INPUT); digitalWrite (swPin , HIGH);) void loop () (boolean ledState = digitalRead (swPin); // den Zustand des Buttons lesen digitalWrite (ledPin, ledState); // an aus. Leuchtdiode int X = analogRead (pinX); // den Wert der X-Achse lesen int Y = analogRead (pinY); // den Y-Achsen-Wert lesen X = Karte (X, 0, 1023, 0, 255); // den X-Wert in einen anderen Bereich umwandeln Y = Karte (Y, 0, 1023, 0, 255); // den Y-Wert in einen anderen Bereich umwandeln analogWrite (ledX, X); // LEDs mit unterschiedlicher Helligkeit einschalten analogWrite (ledY, Y); )

Erläuterungen zum Code:

Mit der Funktion map() können Sie beliebige Werte einstellen, einschließlich des inversen Zahlenbereichs. Sie können auch negative Werte verwenden.

DIY-Montageprozess:

Schritt eins. Wir verbinden die Servomotoren
Der selbstgebaute Montageprozess beginnt mit dem Anschließen der Servomotoren. Um ein vorläufiges Layout zusammenzustellen, wird eine Leiterplatte verwendet. Dann können Sie einen separaten Schild machen. In der Abbildung können Sie genau sehen, wie alles verbunden ist.

Das rote Kabel ist Strom, es wird an den 5V-Pin des Arduino-Controllers angeschlossen.
Das schwarze Kabel ist das Minus (Masse), es wird mit dem Pin des Arduino namens GND verbunden.
Das gelbe Kabel vom rechten und linken Servomotor muss an Pin 11 angeschlossen werden. Bei einigen Modellen kann es auch weiß sein.
Ein ähnliches gelbes Up & Down-Kabel muss an Pin 4 angeschlossen werden. Es kann bei einigen Motormodellen auch weiß sein.
Es ist wichtig, sich daran zu erinnern, dass die Signalanschlüsse, die den Motor steuern, von den PWM-Ausgängen stammen.

Schritt zwei. Verbinden Sie den Joystick
Wie der Joystick angeschlossen ist, ist im Bild zu sehen. Auf den ersten Blick mag das Diagramm ziemlich kompliziert erscheinen, aber tatsächlich ist hier nichts kompliziert. Für den Anschluss wird wie bei Motoren eine Platine verwendet.

1. Die Ausgänge U / R + und L / R + befinden sich am Joystick-Modul. Über diese Ausgänge wird der Strom angeschlossen. Dementsprechend müssen Sie hier + 5V Spannung vom entsprechenden Pin an den Arduino anlegen.

2. Auch am Joystick befinden sich zwei Anschlüsse namens L/R und zwei U/D Anschlüsse. Sie müssen an die Analogausgänge A3 und A4 angeschlossen werden.

3. Abschließend muss die Masse des Joysticks mit der Masse des Arduino verbunden werden.

Nach der Montage muss die Verbindung nochmals überprüft werden. Aufgrund von Verbindungsfehlern treten in den meisten Fällen Probleme auf. Dies ist insbesondere dann der Fall, wenn eine Leiterplatte verwendet wird und viele Anschlüsse darauf vorhanden sind.

Schritt drei. Skizze für Arduino
Der Code ist sehr einfach und enthält detaillierte Kommentare. Der obige Code muss nur in die Arduino IDE kopiert werden. Nachdem der Code geladen wurde, sollten sich die Motoren nicht bewegen. Sie sollten sich erst bewegen, wenn Sie eine Taste am Joystick drücken.

Mögliche Probleme und wie man sie löst
1. Wenn die Motoren nicht starten, muss die Verbindung erneut überprüft werden. PWM-Ausgänge werden verwendet, um Motoren anzuschließen, und analoge Ausgänge werden verwendet, um Joysticks anzuschließen.

2. Es kommt vor, dass die Motoren unmittelbar nach dem Laden des Codes zu vibrieren beginnen. Dies passiert, wenn die Pins U / D + L / R + falsch angeschlossen sind. Die Verbindung muss sorgfältig geprüft werden. Um das Board während der Prüfung nicht zu verbrennen, trennen Sie es unbedingt vom Computer.

3. Wenn alles überprüft ist, aber die Motoren immer noch nicht funktionieren wollen, können Sie versuchen, den Joystick wieder anzuschließen. Es muss von der Platine entfernt und dann mit einigem Aufwand wieder eingebaut werden. Die Joystick-Anschlüsse sollten sich gut in das Layout einfügen.

Wenn alles geklappt hat, können Sie jetzt mit der Joystick-Steuerung alle hausgemachten Produkte erstellen. Sie können beispielsweise einen Roboter bauen, der mit einem Joystick gesteuert werden kann, und vieles mehr.