Arduino-Roboter mit PS2-Controller (PlayStation 2-Joystick)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

In diesem Tutorial zeige ich Ihnen, wie Sie einen drahtlosen PlayStation 2 (PS2)-Joystick verwenden, um einen Roboterpanzer zu steuern. Im Kern dieses Projekts wurde ein Arduino Uno-Board verwendet. Es empfängt Befehle vom drahtlosen Controller und stellt die Geschwindigkeit der Motoren ein. Es können auch andere Entwicklungsboards verwendet werden (NodeMCU, Firebeetle usw.), und die in diesem Tutorial vorgestellten Prinzipien können auf andere Roboter- und Gerätemodelle angewendet werden.

Ich habe zuvor einen von Blynk gesteuerten Roboterpanzer entworfen. Es stellt eine Verbindung zu einem Wi-Fi-Netzwerk her und empfängt Befehle vom Blynk-Server. Als Fernbedienung wurde ein Smartphone mit der Blynk-App verwendet, und es wurden verschiedene Eingabemethoden verwendet:Drucktasten, Schieberegler und sogar der Beschleunigungsmesser des Smartphones. Mehr zu diesem Projekt finden Sie hier:https://www.hackster.io/igorF2/wi-fi-controlling-robot-using-wemos-d1-esp8266-and-blynk-464198

Ich habe auch einige Experimente mit Sprachbefehlen gemacht. Dies kann nützlich sein, wenn Sie einen Roboter fernsteuern möchten, ohne Ihre Hände zu verwenden, oder wenn Sie ihn für jemanden mit eingeschränkten Bewegungen zugänglich machen möchten. Man könnte zum Beispiel an einen robotergesteuerten, sprachgesteuerten Rollstuhl denken. Ein DIY-Roboter-Kit wurde zusammen mit einigen meiner Lieblingstools verwendet:Adafruit.io, IFTTT und Arduino IDE. Vollständige Anweisungen hier:

https://www.hackster.io/igorF2/wi-fi-voice-controlling-robot-using-google-assistant-79802c

Sie können verschiedene Bausätze verwenden oder sogar Ihre eigenen Roboter aus einfachen Materialien entwerfen, ohne komplexe Werkzeuge wie 3D-Drucker und Laserschneidmaschinen verwenden zu müssen. Ein Beispiel finden Sie in einem meiner vorherigen Tutorials:

https://www.hackster.io/igorF2/widc-wi-fi-kontrolliert-fpv-robot-8f1e09

Schritt 1:Werkzeuge und Materialien

Die folgenden Tools wurden in diesem Projekt verwendet:

• Lötkolben und Draht (Link / Link). Die Gleichstrommotoren wurden bereits mit an die Klemmen gelöteten Drähten geliefert ... Aber sie werden irgendwann kaputt gehen und Sie müssen sie möglicherweise neu löten. Erwägen Sie also, einen guten Lötkolben und Draht in der Nähe zu haben.
• EVA-Schaumstoffplatte (oder anderes nichtleitendes Material). Das Roboterchassis, das ich in diesem Projekt verwendet habe, besteht aus Aluminium, und auf diesen Metallteilen sind Leiterplatten installiert. Ich habe zwischen den Platten und der Metallplatte eine Schicht Schaumstoffplatte verwendet, um mögliche Kurzschlüsse zu vermeiden.
• Doppelseitiges Klebeband . Es wurde zum Aufkleben der Schaumstoffplatten auf die Leiterplatten und zum Einbau des H-Brückenmoduls verwendet.
• Schere , zum Schneiden einiger Rechtecke aus Schaumstoffplatten.

Ich habe folgende Hardwareteile für mein Projekt verwendet:

• Arduino Uno-basiertes Entwicklerboard (Link / Link / Link / Link). Es wird als Hauptcontroller des Roboters verwendet. Es ist wirklich einfach zu bedienen und mit Arduino IDE zu programmieren, ideal für Anfänger in Elektronik und Programmierung.

• L298N Zweikanal-H-Brückenmodul (Link / Link / Link / Link). Mit diesem Modul können die 3,3-V-Signale des Wemos (oder eines Arduino) auf die für die Motoren benötigten 12 V verstärkt werden.

• DIY-Roboter-Chassis-Tank (Verknüpfung). Dieser fantastische Bausatz enthält alles, was Sie zum Bau eines Panzers benötigen:zwei Gleichstrommotoren, Zahnräder, Ketten, Schrauben, Muttern usw. Es wird bereits mit den Werkzeugen geliefert, die Sie zum Zusammenbau des Chassis benötigen, was ideal für Anfänger ist!

• PS2-Wireless-Fernbedienung (Verknüpfung). Dieser Videospiel-Controller kann Befehle drahtlos an einen Empfänger senden, der über serielle Kommunikation mit einem Mikrocontroller verbunden werden kann.

• 18650 3,7-V-Batterien (x3) (Link / Link). Früher habe ich die gesamte Schaltung mit Strom versorgt. Dieser Tank verwendet 12V-Motoren. Ich habe drei 3,7-V-Batterien in Reihe verwendet, um sie mit Strom zu versorgen.

• 3S 18650 Batteriehalter (Link / Link / Link). Er kann drei 18650er Akkus in Serie aufnehmen und lässt sich einfach an der Rückseite des Tanks befestigen.

• 18650-Akkuladegerät (Link / Link). Ihre Batterien werden irgendwann leer sein. Wenn das passiert, wird Ihnen ein Batterieladegerät zu Hilfe kommen.
• Pullover (Link / Link). Ich habe 6 männlich-weibliche Jumper für Signale zwischen der H-Brücke und dem Wemos verwendet und 2 männlich-männliche Jumper für 5V und Gnd. Möglicherweise benötigen Sie mehr, wenn Sie einige Sensoren hinzufügen möchten.
• USB-Kabel Typ B . Sie benötigen diese zum Hochladen Ihres Codes. Die meisten Boards werden bereits mit einem eigenen Kabel geliefert.

Die obigen Links sind nur ein Vorschlag, wo Sie die in diesem Tutorial verwendeten Elemente finden können (und möglicherweise meine zukünftigen Tutorials unterstützen). Fühlen Sie sich frei, woanders danach zu suchen und in Ihrem bevorzugten lokalen oder Online-Shop zu kaufen.

Schritt 2:Zusammenbau des Roboters

Der erste Teil dieses Projekts war die Montage der Roboterstruktur.

In früheren Projekten habe ich die Struktur meines eigenen Roboters mit leicht zugänglichen Materialien entwickelt (ohne komplexe Werkzeuge, 3D-Drucker oder Laserschneidmaschinen). Sie finden dieses Projekt unter dem folgenden Link:

https://www.hackster.io/igorF2/widc-wi-fi-kontrolliert-fpv-robot-8f1e09

Später beschloss ich, einem Roboterbausatz aus einem Online-Shop eine Chance zu geben. Einen Link zum Roboterchassis finden Sie unter folgendem Link:http://bit.ly/2ycI8fP. Wenn Sie nach einem Kit suchen, denke ich, dass es eine gute Option ist! Ich habe es in zwei anderen Tutorials verwendet, wie Sie auf den folgenden Links sehen können:

https://www.hackster.io/igorF2/wi-fi-controlling-robot-using-wemos-d1-esp8266-and-blynk-464198

https://www.hackster.io/igorF2/wi-fi-voice-controlling-robot-using-google-assistant-79802c

Zuerst schien es, als ob die Montage komplex wäre oder ich auf Probleme wie das Fehlen von Teilen stoßen würde (angesichts der Anzahl der Teile, aus denen der Bausatz besteht). Aber dieses Set hat mich wirklich überrascht! Alle Teile scheinen mir von guter Qualität zu sein, und mehrere Ersatzteile begleiteten den Bausatz. Eine verlorene Schraube unter der Werkbank macht es also nicht unmöglich, Ihr Projekt durchzuführen, was ich für hervorragend empfand (insbesondere nach dem Verlust einiger Schrauben).

Ein weiterer positiver Punkt ist, dass alle Werkzeuge, die zur Montage des Roboters benötigt werden, im Kit enthalten sind (ein paar Inbusschlüssel und der Schraubendreher). Ich glaube, das macht das Kit hervorragend für Anfänger, die nicht viele Werkzeuge haben!

Als negativen Aspekt möchte ich die fehlende Dokumentation hervorheben. Der Montagemann des Roboters

ual (eine Tabellenkalkulationsdatei auf Chinesisch) ist nicht sehr benutzerfreundlich, und es gibt nicht viele Online-Tutorials für diesen Panzer. Und so habe ich mich entschlossen, den Montageprozess meines Roboters im obigen Video zu dokumentieren! Ein weiterer Aufmerksamkeitspunkt betrifft das Material der Roboterstruktur. Der Sockel besteht komplett aus Aluminium, was zu Kurzschlüssen führen kann, wenn die Pins der Leiterplatten den Rahmen berühren.

Es gibt andere Online-Kits, die Sie verwenden können. Sie können sogar Ihre eigene Struktur erstellen, wie ich unten beschrieben habe.

Schritt 3:Verdrahten der Schaltung

Auf der Rückseite des Roboters wurde ein Kraftpaket aus drei 18650er Akkus verbaut. Es versorgt den Roboter mit 11,1 V (3 x 3,7 V). Das reicht aus, um die 12-V-DC-Motoren anzutreiben.

Für die Ansteuerung der Motoren wurde eine L298N Dual Channel H-Brücke verwendet. Es empfängt einige 5V-Signale des Arduino-Boards und liefert höhere Spannungen für die Motoren. Es ermöglicht auch, dass die Motoren in beide Richtungen laufen, abhängig von der Kombination dieser Eingangssignale.

Jedes Gerät wurde gemäß den Schaltplänen angeschlossen.

Folgt einer Liste der Pins, die Sie zum Verbinden benötigen:

Arduino Uno-Ein-/Ausgänge:

• Digitaler Pin 3 => H-Brücke ENA-Pin
• Digitaler Pin 5 => H-Brücke IN1-Pin
• Digitaler Pin 4 => H-Brücke IN2-Pin
• Digitaler Pin 8 => H-Brücke IN3-Pin
• Digitaler Pin 7 => H-Brücke IN4-Pin
• Digitaler Pin 6 => H-Brücken-ENB-Pin
• 5V-Pin => H-Brücke 5V-Pin
• Gnd-Pin => H-Brücke Gnd-Pin
• Digitaler Pin 10 => PS2-Empfänger Pin 6
• Digitaler Pin 11 => PS2-Empfänger Pin 2
• Digitaler Pin 12 => PS2-Empfänger Pin 1
• Digitaler Pin 13 => PS2-Empfänger Pin 7
• 3,3-V-Pin => PS2-Empfänger-Pin 5
• Gnd-Pin => PS2-Empfänger-Pin 4

H-Brücken-Ein-/Ausgänge:

• ENA-Pin => Arduino digitaler Pin 3
• IN1-Pin => Arduino digitaler Pin 5
• IN2-Pin => Arduino digitaler Pin 4
• IN3-Pin => Arduino digitaler Pin 8
• IN4-Pin => Arduino digitaler Pin 7
• ENB-Pin => Arduino digitaler Pin 6
• 5V-Pin => Arduino 5V-Pin
• Gnd-Pin => Arduino-Gnd-Pin
• Gnd-Pin => Minuskabel des Batteriepacks
• 12-V-Pin => Batteriepack-Pluskabel
• OUT1 => Minuskabel des rechten Motors
• OUT2 => Positives Kabel des rechten Motors
• OUT3 => Positives Kabel des linken Motors
• OUT4 => Minuskabel des linken Motors

PS2-Empfänger:

• Pin 1 (Daten) => Arduino digitaler Pin 12
• Pin 2 (Befehl) => Arduino digitaler Pin 11
• Pin 4 (Masse) => Arduino Gnd-Pin
• Pin 5 (Strom) => Arduino 3.3V-Pin
• Pin 6 (Achtung) => Arduino digital Pin 10
• Pin 7 (Uhr) => Arduino digitaler Pin 13

Schritt 4:Arduino-IDE einrichten

Für dieses Projekt habe ich Arduino IDE zum Programmieren des Arduino-Boards verwendet.

1. Laden Sie die neueste Version der Arduino IDE herunter und installieren Sie sie

Die neueste Version für Windows, Linux oder MAC OSX finden Sie auf der Arduino-Website:https://www.arduino.cc/en/main/software

Laden Sie es kostenlos herunter, installieren Sie es auf Ihrem Computer und starten Sie es.

2. Hinzufügen der Bibliotheken

In diesem Projekt verwende ich die Arduino PS2X-Bibliothek.

Laden Sie die Bibliothek unter https://github.com/madsci1016/Arduino-PS2X herunter. Entpacken Sie die Datei und kopieren Sie die Ordner in die Arduino IDE-Bibliotheken/Tools-Ordner.

............

Nun, da Ihre Entwicklungsumgebung bereit ist, gehen wir zum nächsten Schritt über!

Schritt 5:PS2-Wireless-Controller-Bibliothek erklärt

Ein PS2-Wireless-Controller ist ein großartiges Werkzeug für Ihre Robotik-Projekte. Es hat unglaublich viele Tasten:20 digitale Drucktasten und 2 analoge Sticks. Auf diese Weise gibt es endlose Möglichkeiten, Ihren Roboter zu steuern.

Ich habe die PS2X-Bibliothek von Bill Porter (https://github.com/madsci1016/Arduino-PS2X) verwendet, um den Controller mit einem Arduino Uno-Board zu verbinden.

Es definiert eine PS2X-Klasse für den Controller, die einige Methoden zum Lesen analoger und digitaler Eingaben vom Joystick enthält. Ein Objekt dieser Klasse wird mit folgendem Code erstellt (vor oder während der Einrichtung):

PS2X ps2x;  

Nachdem das Objekt definiert wurde, muss es mit der folgenden Funktion mit Arduino I/O-Pins verknüpft werden:

error =ps2x.config_gamepad(Uhr,Befehl,Aufmerksamkeit,Daten,Druck?,Rumble?);  

Diese Funktion kann einige Fehler zurückgeben, wenn etwas mit den Verbindungen oder mit dem Controller selbst nicht stimmt.

Die wichtigsten aus der Bibliothek verwendeten Funktionen sind das Lesen von digitalen und analogen Eingängen. Zum Lesen und Digitaleingang wird die folgende Methode verwendet:

ps2x.Button(button);  

In welcher Schaltfläche ist der Name der zu lesenden Schaltfläche. Jede Schaltfläche ist wie folgt zugeordnet:

Richtungsschaltflächen:

• PSB_PAD_UP =D-Pad-Aufwärtstaste;
• PSB_PAD_DOWN =D-Pad-Down-Taste;
• PSB_PAD_LEFT =Linke D-Pad-Taste
• PSB_PAD_RIGHT =D-Pad rechte Taste

Aktionsschaltflächen:

• PSB_GREEN oder PSB_TRIANGLE =Schaltfläche mit grünem Dreieck
• PSB_RED oder PSB_CIRCLE =rote Kreistaste
• PSB_BLUE oder PSB_CROSS =blaue x-Schaltfläche
• PSB_PINK oder PSB_SQUARE =​​rosafarbene quadratische Schaltfläche

Auslöser:

• PSB_L1 =linke Auslösetaste 1
• PSB_R1 =Auslösetaste 1 auf der rechten Seite
• PSB_L2 =linke Auslösetaste 2
• PSB_R2 =Auslösetaste 2 rechts

Stöcke:

• PSB_L3 =linker Stick-Druckknopf (ja, man kann den Stick als Druckknopf drücken)
• PSB_R3 =Rechter Stick-Druckknopf

Menü:

• PSB_SELECT =Schaltfläche auswählen
• PSB_START =Starttaste

Um den Analogwert (mit dem Umwandler in eine ganze Zahl zwischen 0 und 255) der Sticks zu lesen, verwenden Sie die folgende Methode:

ps2x.Analog(stick_axis);  

In welcher stick_axis stellt den Stick und die zu lesende Richtung wie folgt dar:

• PSS_LY =y-Position des linken Sticks
• PSS_LX =x-Position des linken Sticks
• PSS_RY =y-Position des rechten Sticks
• PSS_RX =x-Position des rechten Sticks

Mit diesen grundlegenden Funktionen sind Sie bereit, den PS2-Controller in Ihrem Projekt zu verwenden! In den folgenden Schritten zeige ich einige Arduino-Skizzenbeispiele, die diese Tasten kombinieren!

Schritt 6:Skizze Nr. 1 - Dpad-Tasten

Alte Videospiele wie SEGA Master System und Mega Drive und Nintendo SNES hatten keine kraftempfindlichen Tasten. Die Richtungstasten waren nur Ein/Aus-Tasten. Für dieses erste Beispiel wollte ich die Art von Steuerung emulieren, die man in alten Videospielen dieser Konsolen hat.

Für diese erste Skizze habe ich Dpad-Tasten als Eingaben für den Roboter verwendet. Jeder Knopf wurde vom Roboter verwendet, um eine der Grundbewegungen auszuführen:vorwärts bewegen, rechts abbiegen, links abbiegen oder zurückgehen.

Diese Tasten haben binäre Ausgänge. Auf diese Weise erkennt der Mikrocontroller nur, dass die Tasten gedrückt wurden, aber nicht, wie stark sie gedrückt wurden. Auf diese Weise laufen die Motoren nach dem Klicken auf eine bestimmte Schaltfläche mit voller Geschwindigkeit.

Wenn Sie alles nach meinem Schaltplan angeschlossen haben, haben Sie die folgenden Ausgänge:

• PSB_PAD_UP =vorwärts gehen
• PSB_PAD_DOWN =zurück bewegen
• PSB_PAD_LEFT =links abbiegen
• PSB_PAD_RIGHT =rechts abbiegen

Wie ich bereits sagte, bewegt sich der Motor mit einer festen Geschwindigkeit. Beim Drehen nach links oder rechts laufen die Motoren in entgegengesetzte Richtungen, sodass sich der Roboter um seine Achse dreht.

Arduino-Code:

Laden Sie den Code herunter und öffnen Sie ihn in der Arduino IDE. Wenn Sie dieselbe Pinbelegung wie ich verwenden, müssen Sie wahrscheinlich nichts am Code ändern (obwohl dies möglicherweise erforderlich ist, wenn die Ausrichtung der Motoren unterschiedlich ist

Um den Code hochzuladen, wählen Sie die Platine 'Arduino/Genuino Uno', wählen Sie den richtigen COM-Port, stecken Sie die Platine auf den USB-Port Ihres Computers und laden Sie den Code hoch.
Nachdem der Upload abgeschlossen war, ziehen Sie das USB-Kabel ab und stecken Sie das Batterien. Der Code wird ausgeführt und das Arduino-Board verbindet automatisch den PS2-Joystick. Öffnen Sie den seriellen Monitor bei der ersten Verwendung und überprüfen Sie den Status der Verbindung. Wenn keine Verbindung mit dem Joystick hergestellt werden kann, sollten Sie Folgendes tun:

• Setzen Sie das Arduino Uno-Board zurück. Probieren Sie es mehrmals aus (bei mir funktioniert es normalerweise nach dem dritten Reset);
• Überprüfen Sie, ob der Joystick eingeschaltet ist (und mit geladenen Akkus). Der Empfänger verfügt über einige LEDs, die anzeigen, ob der Joystick gekoppelt wurde. Überprüfen Sie auch, ob die RX- und TX-Pins von Arduino blinken, wenn neue Befehle empfangen werden (und der Status am seriellen Port aktualisiert wird);
• Überprüfen Sie die Verbindungen... möglicherweise stimmt etwas mit den Jumpern zwischen den Komponenten nicht.

Code erklärt:

In diesem Projekt musste ich nur die Bibliothek PS2X_lib.h verwenden. I wird am Anfang des Codes hinzugefügt.

#include   

Definieren Sie die Pins des Arduino, die mit der H-Brücke verbunden sind. Wenn Sie die gleichen Verbindungen wie ich verwenden, haben Sie die folgende Konfiguration. Wenn Sie andere Pins verwenden möchten, aktualisieren Sie diesen Teil des Codes.

// Diese werden verwendet, um die Richtung des Brückentreibers festzulegen. #define ENA 3 //ENA #define MOTORA_1 4 //IN3 #define MOTORA_2 5 //IN4 #define MOTORB_1 8 //IN1 #define MOTORB_2 7 //IN2 #define ENB 6 //ENB  

Einige globale Variablen wurden vor dem Setup deklariert (p2sx , Fehler , tippe und vibrieren ). Die erste ist eine Instanz der PS2X-Klasse. Fehlerstatus während der Verbindung wird auf Fehler gespeichert ganze Zahl. Typ und vibrieren zeigt den Typ des Controllers (DualShock- oder GuitarHero-Controller) an und ob er bei einem bestimmten Befehl vibrieren soll.

Das erste, was ich während des Setups tat, war, den Status der I/O-Pins (als Ausgang) zu konfigurieren und die Enable-Pins auf LOW zu setzen. Auf diese Weise deaktivieren Sie beide Motoren beim Start und der Roboter bewegt sich nicht zufällig, während er auf den Rest des Codes wartet.

// Ausgangspins konfigurieren pinMode(ENA, OUTPUT); pinMode (MOTORA_1, AUSGANG); pinMode (MOTORA_2, AUSGANG); pinMode (ENB, AUSGANG); pinMode (MOTORB_1, AUSGANG); pinMode (MOTORB_2, AUSGANG); // Beide Motoren deaktivieren digitalWrite (ENA, 0); digitalWrite(ENB,0);  

Dann habe ich die Kommunikation über die serielle Schnittstelle gestartet (nützlich zum Debuggen des Codes). Wählen Sie eine geeignete Baudrate und stellen Sie dieselbe Geschwindigkeit am Serial Monitor ein.

// Serielle Kommunikation starten Serial.begin(57600);  

Schließlich konfigurieren Sie das ps2x-Objekt mit den Pins des Arduino, die mit dem Joystick-Empfänger verbunden waren (Uhr, Befehl, Aufmerksamkeit bzw. Daten). Möglicherweise wird ein Fehler zurückgegeben (der auf dem seriellen Monitor angezeigt wird). Der Controller-Typ wird auch angezeigt (obwohl Sie wahrscheinlich bereits wissen, welchen Controller-Typ Sie zu diesem Zeitpunkt in Ihren Händen halten :D).

error =ps2x.config_gamepad(13,11,10,12, true, true); // Setup-Pins und Einstellungen:GamePad (Uhr, Befehl, Aufmerksamkeit, Daten, Druck?, Rumble?) Auf Fehler prüfen // Auf Fehler prüfen if (error ==0) {Serial.println ( "Controller gefunden, erfolgreich konfiguriert" ); } else if(error ==1) Serial.println("Kein Controller gefunden, Verkabelung überprüfen oder Arduino zurücksetzen"); else if(error ==2) Serial.println("Controller gefunden, aber keine Befehle akzeptiert"); else if(error ==3) Serial.println("Controller weigert sich, in den Druckmodus zu wechseln, unterstützt ihn möglicherweise nicht."); // Überprüfen Sie den Controllertyp type =ps2x.readType(); Schalter (Typ) { Fall 0:Serial.println ( "Unbekannter Controller-Typ"); brechen; Fall 1:Serial.println ("DualShock Controller gefunden"); brechen; Fall 2:Serial.println ("GuitarHero Controller gefunden"); brechen; }  

Während der Hauptschleife liest das Arduino jede D-Pad-Taste (UP, DOWN, LEFT und RIGTH) und stellt die verschiedenen Werte für die Ausgangspins ein, um die Räder zu bewegen. Nach einer kurzen Verzögerung wird eine neue Schleife gestartet.

Der folgende Abschnitt zeigt, wie der Roboter vorwärts bewegt wird, wenn die AUF-Taste gedrückt wurde. Die Pins MOTORA_1 und MOTORA_2 definieren die Drehrichtung für Motor A. ENA legt fest, ob die Bewegung aktiviert ist oder nicht (Motor EIN/AUS). Beachten Sie, dass es sich um einen "analogen" Ausgang (eigentlich einen PWM-Ausgang) handelt. Der Wert sollte zwischen 0 und 1023 liegen. Dies moduliert die PWM und ändert die durchschnittliche Spannung am Ausgang der H-Brücke (zwischen 0 und 12 V). Wenn die durchschnittliche Spannung zu niedrig ist, kann sich der Motor überhaupt nicht bewegen.

// VORWÄRTS WEGEN if(ps2x.Button(PSB_PAD_UP)) { digitalWrite(MOTORA_1,LOW); digitalWrite (MOTORA_2, HOCH); digitalWrite (MOTORB_1, HOCH); digitalWrite (MOTORB_2, LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println ( "Vorwärts bewegen"); }  

*Ich habe PWM-Ausgänge für die ENA- und ENB-Pins verwendet. Auf diese Weise würde 1023 einen Puls mit der größten Länge darstellen (Pin immer an) und 0 das Fehlen von Pulsen (Pin immer aus). Wenn hier ein anderer (kleinerer) Wert verwendet wird, wird erwartet, dass die Motoren langsamer laufen, da die durchschnittliche Spannung an ihren Klemmen kleiner ist.

Schritt 7:Skizze #2 - Analogstick und digitale Tasten (L2 und R2)

Zu einem bestimmten Zeitpunkt nahmen alle Konsolen Joysticks mit zwei Analogsticks an. Diese neuen Eingaben ermöglichten kraftsensitive Eingaben, die Aktionen mit variabler Geschwindigkeit erzeugten und in jeder Art von Videospielen beliebt wurden.

In diesem zweiten Beispiel wollte ich einen analogen Schalter zum Lenken des Tanks und ein Paar Druckknöpfe als Gas und Bremsen / Rückwärtsgang verwenden. Diese Art der Konfiguration ist in vielen Rennspielen, wie zum Beispiel Mario Kart, sehr beliebt. Drücken Sie die R2-Taste zum Beschleunigen des Panzers, L2 zum Rückwärtsfahren und stellen Sie die Bewegungsrichtung basierend auf der x-Position des linken Sticks ein.

Die Art von Roboterbausatz, den ich verwendet habe, hat nicht viel Trägheit (wenn die Spannung an den Motoren auf 0 V eingestellt ist, bewegt sie sich für eine Weile nicht weiter). Auf diese Weise musste kein Befehl zum Bremsen des Roboters definiert werden.

Der größte Teil des Codes wurde bereits im vorherigen Schritt erklärt. Ein Unterschied besteht darin, dass ich zwei Variablen definiert habe, die die Geschwindigkeit jedes Motors speichern (von 0 bis 1023).

int motor_right_speed =0;
int motor_left_speed =0;  

In der Main-Schleife liest der Arduino die x-Position des linken Sticks. Es empfängt einen Wert zwischen 0 und 255 und bildet ihn zwischen -1023 und 1023 ab.

Dieser Wert wird zur Geschwindigkeit jedes Motors addiert (oder subtrahiert), um einen Unterschied zwischen der Geschwindigkeit jeder Spur zu erzeugen und den Roboter nach links oder rechts drehen zu lassen.

int nJoyL =ps2x.Analog(PSS_LX); // linken Stick lesen nJoyL =map (nJoyL, 0, 255, 1023, -1023); motor_right_speed =1023; motor_left_speed =1023; if (nJoyL <0) { motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) { motor_left_speed =motor_left_speed - nJoyL; }  

Wenn die Taste R2 gedrückt wird, bewegt sich der Tank vorwärts. Auf diese Weise stellt das Arduino geeignete Werte für die Motorpins ein. ENA und ENB erzeugen 'analoge' Ausgänge für jeden Motor mit einem Wert proportional zur gewünschten Geschwindigkeit für jeden Motor (basierend auf der x-Position des linken Sticks).

L2 wird etwas Ähnliches tun, aber die Richtung des Motors umkehren.

if(ps2x.Button(PSB_R2)) { digitalWrite(MOTORA_1,LOW); digitalWrite (MOTORA_2, HOCH); digitalWrite (MOTORB_1, HOCH); digitalWrite (MOTORB_2, LOW); analogWrite (ENA, motor_right_speed); analogWrite (ENB, motor_left_speed); } if (ps2x.Button (PSB_L2)) { digitalWrite (MOTORA_1, HIGH); digitalWrite (MOTORA_2, LOW); digitalWrite (MOTORB_1, NIEDRIG); digitalWrite (MOTORB_2, HOCH); analogWrite (ENA, motor_right_speed); analogWrite (ENB, motor_left_speed); } if (!ps2x.Button (PSB_L2) ​​&&!ps2x.Button (PSB_R2)) { analogWrite (ENA, 0); analogWrite (ENB, 0); }  

Wenn keine der Tasten gedrückt wurde, werden die Motoren deaktiviert.

Schritt 8:Skizze Nr. 3 - Linker und rechter Analogstick (Differentialantrieb)

Dies ist meine Lieblingsmethode, um den Panzer zu kontrollieren (obwohl es in Bezug auf die Ressourcen nicht optimal ist)! Es gibt mir das Gefühl, eine richtig große Maschine mit beiden Händen zu steuern!

In diesem Code habe ich beide Sticks verwendet, um die Richtung und Geschwindigkeit jedes Tracks einzustellen. Der linke Stick steuert die linke Spur und der rechte Stick steuert die rechte Spur.

Der Code ist fast der gleiche wie zuvor beschrieben. Aber diesmal wollte ich die y-Position beider Sticks lesen:

int nJoyL =ps2x.Analog(PSS_LY); // linken Stick lesen int nJoyR =ps2x.Analog(PSS_RY); // rechten Stick lesen nJoyL =map (nJoyL, 0, 255, 1023, -1023); nJoyR =map(nJoyR, 0, 255, -1023, 1023);  

Abhängig von der Position des Sticks legt der Code die digitalen Pins fest, um die Richtung jedes Motors festzulegen.

Ich habe beim Aktivieren einen festen Wert (1023) verwendet, aber ich würde einen variablen Wert verwenden, der auf dem tatsächlichen Wert des Analogsticks basiert. Ich habe eine Totzone (+-50) definiert, in der der Mikrocontroller die Motoren deaktiviert.

// Bewegungen basierend auf beiden Analogsticks ausführen if(nJoyR>50) { digitalWrite(MOTORA_1,HIGH); digitalWrite (MOTORA_2, LOW); analogWrite(ENA, 1023); aufrechtzuerhalten. Wenn (nJoyR <-50) { DigitalWrite (MOTORA_1, LOW); digitalWrite (MOTORA_2, HOCH); analogWrite(ENA, 1023); aufrechtzuerhalten. Wenn (abs (nJoyR) <50) { AnalogWrite (ENA, 0); }  

Schritt 9:Skizze #4 - Nur linker Analogstick

In dieser letzten Sketch-App habe ich einen einzigen Joystick verwendet, um den Roboter zu steuern. Es ist ein Optimum in Bezug auf die Ressourcennutzung (Sie haben noch viele Schaltflächen für verschiedene Aktionen, die konfiguriert werden müssen), aber es ist ziemlich schwer zu verstehen.

Die Geschwindigkeit jeder Spur wird in Abhängigkeit von den x- und y-Positionen des Joysticks definiert. Auf diese Weise ist es möglich, auf jeder Spur unterschiedliche Geschwindigkeiten anzuwenden und den Roboter mit unterschiedlichen Geschwindigkeiten/Richtungen zu bewegen. Der hier verwendete Code wurde aus dem folgenden Tutorial abgeleitet. Schau es dir an!

https://www.impulseadventure.com/elec/robot-differential-steering.html

Schritt 10:Abschließende Überlegungen

Ich habe viel Mühe in dieses Projekt gesteckt, um es so klar und lehrreich wie möglich zu machen. Wenn es Ihnen gefallen hat, vergessen Sie bitte nicht, es zu „liken“ und zu „teilen“. Ihre Unterstützung ist mir sehr wichtig! :D

Wenn Sie meinen Tutorials immer noch nicht folgen, werfen Sie einen Blick auf die anderen Tutorials zur Robotik! Ich hoffe sie gefallen euch!

https://www.hackster.io/igorF2/joy-robot-robo-da-alegria-bba54f

https://www.hackster.io/igorF2/widc-wi-fi-kontrolliert-fpv-robot-8f1e09

https://www.hackster.io/igorF2/nunchuk-kontrolliert-robotic-arm-with-arduino-b1c0fa

https://www.hackster.io/igorF2/wi-fi-browser-controlled-robotic-arm-89b63d

Bitte erwägen Sie, meine zukünftigen Projekte mit einer kleinen Bitcoin-Spende zu unterstützen! :D

BTC-Einzahlungsadresse:1FiWFYSjRaL7sLdr5wr6h86QkMA6pQxkXJ

Code

• Skizze Nr. 1
• Skizze #2
• Skizze #3
• Skizze #4

Skizze #1Arduino

// PS2 Tank von Igor Fonseca @2019// Steuert einen Roboterpanzer mit einem PS2-Joystick, mit D-Pad-Tasten // basierend auf einem Beispiel mit der PS2X-Bibliothek von Bill Porter 2011// Der gesamte obige Text muss enthalten sein in jeder Neuverteilung.// Include-Bibliotheken#include // Diese werden verwendet, um die Richtung des Bridge-Treibers festzulegen.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4 #define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBPS2X ps2x; // PS2-Controller-Klasse erstellen // Im Moment unterstützt die Bibliothek KEINE Hot-Plug-fähigen Controller, dh // Sie müssen Ihr Arduino immer neu starten, nachdem Sie den Controller angeschlossen haben, // oder config_gamepad (pins) erneut aufrufen, nachdem Sie den Controller angeschlossen haben. int-Fehler =0; Bytetyp =0;Byte vibrieren =0;void setup () {// Ausgangspins konfigurieren PinMode (ENA, OUTPUT); pinMode (MOTORA_1, AUSGANG); pinMode (MOTORA_2, AUSGANG); pinMode (ENB, AUSGANG); pinMode (MOTORB_1, AUSGANG); pinMode (MOTORB_2, AUSGANG); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); brechen; case 1:Serial.println("DualShock Controller Found"); brechen; case 2:Serial.println("GuitarHero Controller Found"); brechen; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller // Perform movements based on D-pad buttons // MOVE FORWARD if(ps2x.Button(PSB_PAD_UP)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Move forward"); } // TURN RIGHT if(ps2x.Button(PSB_PAD_RIGHT)){ digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Turn right"); } // TURN LEFT if(ps2x.Button(PSB_PAD_LEFT)){ digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Turn left"); } // MOVE BACK if(ps2x.Button(PSB_PAD_DOWN)){ digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Move back"); } if (!ps2x.Button(PSB_PAD_DOWN) &&!ps2x.Button(PSB_PAD_UP) &&!ps2x.Button(PSB_PAD_RIGHT) &&!ps2x.Button(PSB_PAD_LEFT)) { analogWrite(ENB, 0); analogWrite(ENA, 0); } delay(50); } }

Sketch #2Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using D-pad buttons// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include // These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBint motor_right_speed =0;int motor_left_speed =0;PS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); brechen; case 1:Serial.println("DualShock Controller Found"); brechen; case 2:Serial.println("GuitarHero Controller Found"); brechen; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyL =ps2x.Analog(PSS_LX); // read left stick nJoyL =map(nJoyL, 0, 255, 1023, -1023); int motor_right_speed =1023; int motor_left_speed =1023; if (nJoyL <0) { motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) { motor_left_speed =motor_left_speed - nJoyL; } if(ps2x.Button(PSB_R2)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(ps2x.Button(PSB_L2)) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(!ps2x.Button(PSB_L2) &&!ps2x.Button(PSB_R2)) { analogWrite(ENA, 0); analogWrite(ENB, 0); } delay(50); } }

Sketch #3Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using D-pad buttons// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include // These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBPS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); brechen; case 1:Serial.println("DualShock Controller Found"); brechen; case 2:Serial.println("GuitarHero Controller Found"); brechen; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyL =ps2x.Analog(PSS_LY); // read left stick int nJoyR =ps2x.Analog(PSS_RY); // read right stick nJoyL =map(nJoyL, 0, 255, 1023, -1023); nJoyR =map(nJoyR, 0, 255, -1023, 1023); // Perform movements based on both analog sticks if(nJoyR>50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); analogWrite(ENA, 1023); } if(nJoyR<-50) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); analogWrite(ENA, 1023); } if (abs(nJoyR)<50) { analogWrite(ENA, 0); } if(nJoyL>50) { digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); } if(nJoyL<-50) { digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); } if (abs(nJoyL)<50) { analogWrite(ENB, 0); } delay(50); } }

Sketch #4Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using left analog stick// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include  //for v1.6// These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBint motor_right_speed =0;int motor_left_speed =0;PS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); brechen; case 1:Serial.println("DualShock Controller Found"); brechen; case 2:Serial.println("GuitarHero Controller Found"); brechen; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyX =ps2x.Analog(PSS_LX); // read x-joystick int nJoyY =ps2x.Analog(PSS_LY); // read y-joystick nJoyX =map(nJoyX, 0, 255, -1023, 1023); nJoyY =map(nJoyY, 0, 255, 1023, -1023); // OUTPUTS int nMotMixL; // Motor (left) mixed output int nMotMixR; // Motor (right) mixed output // CONFIG // - fPivYLimt :The threshold at which the pivot action starts // This threshold is measured in units on the Y-axis // away from the X-axis (Y=0). A greater value will assign // more of the joystick's range to pivot actions. // Allowable range:(0..+127) float fPivYLimit =1023.0; // TEMP VARIABLES float nMotPremixL; // Motor (left) premixed output float nMotPremixR; // Motor (right) premixed output int nPivSpeed; // Pivot Speed float fPivScale; // Balance scale between drive and pivot // Calculate Drive Turn output due to Joystick X input if (nJoyY>=0) { // Forward nMotPremixL =(nJoyX>=0)? 1023.0 :(1023.0 + nJoyX); nMotPremixR =(nJoyX>=0)? (1023.0 - nJoyX) :1023.0; } else { // Reverse nMotPremixL =(nJoyX>=0)? (1023.0 - nJoyX) :1023.0; nMotPremixR =(nJoyX>=0)? 1023.0 :(1023.0 + nJoyX); } // Scale Drive output due to Joystick Y input (throttle) nMotPremixL =nMotPremixL * nJoyY/1023.0; nMotPremixR =nMotPremixR * nJoyY/1023.0; // Now calculate pivot amount // - Strength of pivot (nPivSpeed) based on Joystick X input // - Blending of pivot vs drive (fPivScale) based on Joystick Y input nPivSpeed =nJoyX; fPivScale =(abs(nJoyY)>fPivYLimit)? 0.0 :(1.0 - abs(nJoyY)/fPivYLimit); // Calculate final mix of Drive and Pivot nMotMixL =(1.0-fPivScale)*nMotPremixL + fPivScale*( nPivSpeed); nMotMixR =(1.0-fPivScale)*nMotPremixR + fPivScale*(-nPivSpeed); motor_left_speed =nMotMixL; motor_right_speed =nMotMixR; if (motor_right_speed> 50) { digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); } else if (motor_right_speed <-50) { digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2, HIGH); } else { digitalWrite(MOTORB_1, LOW); digitalWrite(MOTORB_2, LOW); } if (motor_left_speed> 50) { digitalWrite(MOTORA_1, LOW); digitalWrite(MOTORA_2, HIGH); } else if (motor_left_speed <-50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); } else { digitalWrite(MOTORA_1, LOW); digitalWrite(MOTORA_2, LOW); } analogWrite(ENA, abs(motor_left_speed)); analogWrite(ENB, abs(motor_right_speed)); if (abs(motor_left_speed> 50) || abs(motor_left_speed> 50)) { Serial.println("Moving!"); } delay(50); } }

Schaltpläne