Nunchuk-gesteuerter Roboterarm (mit Arduino)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Roboterarme sind genial! Fabriken auf der ganzen Welt haben sie, wo sie mit Präzision lackieren, löten und Sachen transportieren. Sie können auch in der Weltraumforschung, ferngesteuerten Unterwasserfahrzeugen und sogar in medizinischen Anwendungen gefunden werden!

Und jetzt können Sie eine günstigere Version davon zu Hause, im Büro oder im Labor haben! Haben Sie es satt, einen sich wiederholenden Job zu machen? Programmieren Sie Ihren eigenen Roboter, um Ihnen zu helfen ... oder Dinge durcheinander zu bringen! :D

In diesem Tutorial zeige ich Ihnen, wie Sie einen Roboterarm montieren und mit einem Arduino Mega programmieren. Für dieses Projekt wollte ich auch eine andere Methode zur Steuerung eines Roboterarms erleben:mit einem Nintendo Nunchuk! Sie sind billig, leicht zu finden und verfügen über eine Reihe von Sensoren.

Es gibt mehrere Möglichkeiten, dieses Tutorial zu verwenden. Wenn Sie kein Roboterarm-Kit haben (und keins kaufen oder bauen möchten), können Sie es trotzdem verwenden, um etwas über die Arduino-Programmierung zu lernen und wie Sie einen Wii Nunchuk mit Ihren eigenen Projekten verbinden. Sie können es auch verwenden, um Ihre elektronischen und mechanischen Fähigkeiten zu üben.

Schritt 1:Werkzeuge und Materialien

Die folgenden Werkzeuge und Materialien wurden in diesem Projekt verwendet:

Werkzeuge und Materialien:

• Lötkolben und Draht. Ich musste einige Anschlüsse an Nunchuks Drähte anlöten, um sie mit dem Arduino zu verbinden;

• Schrumpfschlauch. Zur besseren Isolierung der Leiter wurden einige Schrumpfschlauchstücke verwendet;

• Schraubendreher. Die Struktur wird mit einigen Schrauben und Muttern montiert;

• Mechanischer 6-Achsen-Desktop-Roboterarm (Verknüpfung). Dieser tolle Bausatz kommt bereits mit mehreren Komponenten wie unten beschrieben. Es ist zuverlässig und einfach zu montieren;

• 12-V-Netzteil (2A oder mehr);

• Nunchuk-Controller (Verknüpfung). Es ist mit dem Arduino-Board verbunden und wird verwendet, um den Roboterarm zu steuern;

• Männliche Überbrückungsdrähte (4 Drähte);

• Arduino Mega (Link / Link / Link). Beachten Sie, dass das von mir verwendete Roboterarm-Kit auch ein Board- und Controller-Bundle enthält, das bereits mit diesem Arduino-Board geliefert wird. Wenn Sie eines dieser Kits nicht verwenden, können Sie auch andere Arduino-Boards verwenden;

Später wurde mir mitgeteilt, dass es einen Nunchuk-Adapter gibt, der erleichtert den Anschluss an ein Steckbrett (Link / Link). Dies ist eine gute Option, wenn Sie beim Löten etwas Zeit haben möchten und den Originalstecker nicht wie in Schritt 9 beschrieben zerstören möchten.

Der mechanische 6-Achsen-Desktop-Arm von Sain Smart wird bereits mit den folgenden Komponenten geliefert:

• Arduino Mega 2560 R3 (Link)

• Steuerplatinen-Abschirmung (Link)

• NRF24L01+ Funk-Transceiver-Modul (Link)

• MPU6050 3-Achsen-Gyroskop und ein 3-Achsen-Beschleunigungsmesser (Link)

• 71 x M3X8 Schraube

• 47 x M3-Mutter

• 2 x U-Halterung

• 5 x Servohalterung

• 4 x 9kg Servo (Link)

• 2 x 20kg Servo (Link)

• 6 x Metallservotablett

• 3 x U-Klammer

• 21 x rechtwinklige Klammer

• 3 x Flanschlager

• 1 x Greifer

Vielleicht finden Sie andere Roboterarm-Kits online oder entwerfen sogar Ihre eigenen. Es gibt einige tolle Projekte, die Sie zum Beispiel in 3D drucken können.

In den folgenden 7 Schritten zeige ich Ihnen, wie Sie das Arm-Kit zusammenbauen, bevor Sie die Stromkreise verdrahten. Wenn Sie kein ähnliches Kit haben, können Sie einige Schritte überspringen. Sie können ein anderes Roboterarm-Kit verwenden, es zusammenbauen und direkt zu den Elektronik- und Programmierschritten springen.

Bei jedem Schritt gibt es ein animiertes Gif, das zeigt, wie mein Roboterarm zusammengebaut wurde. Es läuft nur auf der Desktop-Version der Website.

Schritt 2:Zusammenbau des Roboterarms Pt1 - Basis

Das erste zu montierende Teil ist die Basis des Roboters.

Es besteht aus zwei U-förmigen Halterungen, die Rücken an Rücken mit vier M3-Schrauben und Muttern verbunden sind, wie in den Bildern gezeigt. Dies ist wahrscheinlich das am einfachsten zu montierende Teil.

Schritt 3:Zusammenbau des Roboterarms Pt2 - Servo #1

Der erste Servomotor wird mit einer Servohalterung senkrecht zur Basis montiert. Dieses Profil wird mit vier M3-Schrauben und Muttern an der Basis befestigt, wie auf den Bildern gezeigt. Servo Nr. 1 wird oben platziert und mit vier M3-Schrauben und Muttern befestigt.

An der Servoachse ist ein kreisförmiges Metallhorn angebracht. Der Bausatz wird mit mehreren Kunststoffhörnern geliefert. Sie werden nicht zum Zusammenbauen des Roboters verwendet.

Schritt 4:Zusammenbau des Roboterarms Pt3 - Servo #2

Eine weitere Servohalterung wird senkrecht zur vorherigen montiert. Es ist mit vier M3-Schrauben mit dem Horn des Servos Nr. 1 verbunden. Servo #2 wird mit vier M3-Schrauben und Muttern installiert und verwendet auch ein kreisförmiges Metallhorn.

Anschließend wird eine U-Halterung mit vier Schrauben an der Hupe befestigt. Beachten Sie, dass gegenüber der Servoachse eine M3-Schraube verwendet wird. Es gibt der Struktur Stabilität. Auf diese Schraube passt ein Lager, das mit einer anderen M3-Mutter in Position arretiert wird. Auf diese Weise wird die U-Halterung fest an der Mittelachse von Servo Nr. 2 befestigt.

Schritt 5:Zusammenbau des Roboterarms Pt4 - Servo #3

Eine weitere U-Halterung wird mit vier M3-Schrauben und Muttern montiert.

Am anderen Ende wird Servo Nr. 3 mit einem runden Metallhorn und vier Schrauben installiert. Eine Servohalterung ist mit dem Servomotor verbunden und ein L-förmiges Profil ist mit einigen Schrauben und Muttern mit der Servohalterung verbunden.

Beachten Sie, dass ein anderes Lager gegenüber der Servoachse verwendet wird, wie zuvor beschrieben.

Schritt 6:Zusammenbau des Roboterarms Pt4 - Servo #4

Eine weitere U-Halterung wird mit einem Satz von vier M3-Schrauben und Muttern mit dem L-förmigen Profil verbunden. Ähnlich wie im vorherigen Schritt wird Servo Nr. 4 mit vier Schrauben an der U-Halterung befestigt. Eine weitere Servohalterung ist mit dem Servo verbunden.

Schritt 7:Zusammenbau des Roboterarms Pt4 - Servo #5

Das fünfte Servo wird senkrecht zu Servo Nr. 4 mit einer weiteren Servohalterung verbunden, die mit vier M3-Schrauben und Muttern installiert wird.

Schritt 8:Zusammenbau des Roboterarms Pt4 - Servo #6

Der Greifer wird dann mit der Achse des Servos Nr. 5 verbunden. Oben ist Servo #6 mit einigen Schrauben, Muttern und einem Metallhorn verbunden. Der Greifer hat einige Zahnräder, die die Drehung des Servos in eine lineare Bewegung des Greifers umwandeln.

Schritt 9:Vorbereiten des Nunchuk-Controllers

Für dieses Projekt habe ich mich aus mehreren Gründen für die Verwendung eines Nintendo Nunchuk-Controllers entschieden:

• Sie sind billig! Replikate mögen eine minderwertige Qualität haben, aber ich brauchte für dieses Projekt keinen robusten Controller;

• Sie sind leicht zu finden! Es gibt mehrere originale und kostengünstige Repliken online.

• Es hat viele Sensoren! Jeder Controller verfügt über zwei Tasten (Z- und C-Tasten), einen zweiachsigen Joystick (X und Y) und einen dreiachsigen Beschleunigungsmesser;

• Es hat eine Arduino-Bibliothek. Robert Eisele hat eine erstaunliche und einfach zu verwendende Bibliothek zum Lesen des Nunchuk-Sensors entwickelt. Schau es dir an:https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Leider haben Nunchuk-Joysticks einen komplizierten Anschluss, der schwer mit anderer Elektronik zu verbinden ist. Um es mit dem Arduino zu verbinden, musste ich das Kabel abschneiden und die Drähte freilegen. Auf diese Weise funktioniert es nicht mehr mit einer Nintendo Wii... :/

Zuerst musste ich den Stecker des Joysticks durchtrennen und die Isolierung der Drähte entfernen. Mit einem Multimeter und basierend auf der Farbe jedes Drahtes habe ich die Funktion jedes Drahtes (Vcc, GND, SCL und SDA) anhand des im Bild gezeigten Schaltplans bestimmt. Die Farbe der Drähte hat keinen Standard. Von folgenden Möglichkeiten habe ich schon gehört:

Original:

• SDA =grün

• SCL =gelb

• 3V3 =rot

• GND =weiß

Replik Nr. 1:

• SDA =gelb

• SCL =weiß

• 3V3 =grün

• GND =rot

Replik #2:

• SDA =blau

• SCL =weiß

• 3V3 =rosa

• GND =grün

Ich lötete die Drähte an einen männlichen Jumper, um eine einfachere Verbindung zum Arduino-Board zu ermöglichen. Dafür habe ich einen Lötkolben und einen Schrumpfschlauch verwendet, wie auf den Bildern zu sehen ist.

Später wurde mir mitgeteilt, dass es einen Nunchuk-Adapter gibt, der den Anschluss an ein Steckbrett erleichtert (Link/Link). Es ist eine gute Option, wenn Sie einige Zeit beim Löten haben möchten und den Originalstecker nicht zerstören möchten.

Schritt 10:Verdrahten der Schaltkreise

Sobald die Struktur zusammengebaut ist und die Nunchuk-Steckverbinder fertig sind, können Sie die Stromkreise verdrahten. Ich habe den Steuerplatinenschutz verwendet, der mit meinem Roboterarm-Kit geliefert wurde. Es erleichtert den Anschluss der Komponenten, da es bereits mit spezifischen Steckern für die Servomotoren, Stromversorgung usw. geliefert wird.

Verbinden Sie die Komponenten wie folgt:

Nunchuk:

• Nunchuk Pin 6 (SCL) => Arduino Mega Pin 21 (SCL) (auf dem Schild)

• Nunchuk Pin 1 (SDA) => Arduino Mega Pin 20 (SDA) (auf dem Schild)

• Nunchuk Pin 3 (Vcc) => Ardino Mega Pin 3V3 (auf dem Schild)

• Nunchuk Pin 4 (Gnd) => Arduino Mega Pin Gnd (auf dem Schild)

Wenn Sie ein Arduino Uno verwenden, müssen die SCL- und SDA-Pins von Nunchuk wie folgt mit verschiedenen Arduino-Pins verbunden werden:

• Nunchuk Pin 6 (SCL) => Arduino Uno Pin A5

• Nunchuk Pin 1 (SDA) => Arduino Uno Pin A4

• Nunchuk Pin 3 (Vcc) => Ardino Uno Pin 3V3

• Nunchuk Pin 4 (Gnd) => Arduino Uno Pin Gnd

Servos:

• Steuerschirm Klemme 11 => Servo #1

• Steuerschirm Klemme 12 => Servo #2

• Steuerschirm Klemme 13 => Servo #3

• Steuerschirm Klemme 8 => Servo #4

• Steuerschirm Klemme 9 => Servo #5

• Steuerschirm Klemme 10 => Servo #6

Wenn Sie das Steuerschild nicht verwenden, sollten Sie die folgende Pinbelegung verwenden:

• Arduino Pin 11 => Servo #1 (Sgn)

• Arduino Pin 12 => Servo #2 (Sgn)

• Arduino Pin 13 => Servo #3 (Sgn)

• Arduino Pin 8 => Servo #4 (Sgn)

• Arduino Pin 9 => Servo #5 (Sgn)

• Arduino Pin 10 => Servo #6 (Sgn)

• Arduino Gnd => Servos Gnd

• 6V Stromversorgung => Servos Vcc

Außerdem müssen Sie ein externes 12-V-Netzteil anschließen. Ich empfehle eine mit mehr als 2A Leistung. Die Servos verbrauchen viel Strom, und wenn die Stromversorgung nicht ausreicht, vibrieren die Servos und werden richtig heiß. Sie werden auch ihre Kraft verlieren.

Schließen Sie die Stromquelle nicht an, bis Sie den Arduino-Code hochgeladen haben (in späteren Schritten gezeigt). Auf dem Schild befindet sich ein Netzschalter. Lassen Sie es ausgeschaltet.

Schließen Sie ein USB-Kabel an den Arduino an und fahren Sie mit dem nächsten Schritt fort.

Schritt 11:Arduino-IDE einrichten

Jetzt, da die Hardware bereit ist, ist es Zeit, am Arduino-Code zu arbeiten.

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

Für dieses Projekt habe ich die erstaunliche Nunchuk Arduino-Bibliothek von Robert Eisele verwendet! Mehr dazu findet ihr auf seiner Website:

https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Laden Sie die Bibliothek unter https://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk herunter

Navigieren Sie zu Skizze-> Bibliothek einschließen -> Bibliotheken verwalten ... auf Ihrer Arduino IDE zum Hinzufügen der Bibliothek.

Wie funktioniert die Bibliothek?

Die Nunchuk-Bibliothek enthält eine Reihe von Funktionen zum Lesen der Sensoren des Controllers:

nunchuk_buttonZ() :gibt 1 zurück, wenn die Z-Taste gedrückt wird, oder 0, wenn dies nicht der Fall ist; nunchuk_buttonC() :gibt 1 zurück, wenn die C-Taste gedrückt wird, oder 0, wenn dies nicht der Fall ist; nunchuk_joystickX() :gibt den x-Wert des Joysticks zurück (zwischen -127 und 127); nunchuk_joystickY() :gibt den y-Wert des Joysticks zurück (zwischen -127 und 127); nunchuk_pitch() :gibt den Winkel des Controllers im Bogenmaß zurück (zwischen -180º und 180º); nunchuk_roll() :gibt den Rollwinkel des Controllers im Bogenmaß zurück (zwischen -180º und 180º).

Die Winkel werden im Bogenmaß zurückgegeben. Ich habe diese Werte in meinem Arduino-Code in Grad umgewandelt.

Schritt 12:Arduino-Code

Laden Sie die Skizzendatei von Arduino herunter.

Stecken Sie das USB-Kabel in den USB-Port Ihres Computers und laden Sie den Code hoch. Das Hochladen des Codes dauert einige Zeit. Sie können diese Zeit nutzen, um dieses Tutorial zu "liken" und zu "teilen", während Sie warten! :D

Nachdem der Upload abgeschlossen ist, ziehen Sie das USB-Kabel ab, schließen Sie das Netzteil an und schalten Sie den Netzschalter ein. Der Code wird sofort ausgeführt.

Warnung:Wenn der Code zu laufen beginnt, bewegt sich der Roboterarm sehr schnell in seine Ausgangsposition. Passen Sie auf, dass Sie sich während des Startvorgangs nicht verletzen oder Geräte in der Nähe beschädigen!

Möglicherweise müssen Sie den Startwinkel jedes Servomotors ersetzen, je nachdem, wie Ihre Servos montiert sind.

Code erklärt:

Vor dem Setup importiert der Code die im Sketch verwendeten Bibliotheken (nunchuk.h, wire.h und servo.h ).

Zu verwendende Pins werden definiert und globale Variablen werden deklariert. Der Winkel# Integer-Variablen speichern die Anfangsposition für jedes Servo. Wenn Ihr Roboter an einer anderen Position starten soll, ändern Sie die Werte dieser Variablen.

servo#_speed Variablen definieren die Geschwindigkeit der Bewegung jedes Servos. Wenn Sie möchten, dass sich ein bestimmtes Servo schneller bewegt, erhöhen Sie seinen Wert. Winkel#min und Winkel#max Variablen werden verwendet, um den maximalen und minimalen Winkel für jedes Servo zu begrenzen. Sie können diese Variablen einstellen, um Kollisionen zwischen aufeinanderfolgenden Gelenken des Roboters zu vermeiden.

//Bibliotheken einschließen#include #include #include //Define-Variablen#define SERV1 8 //Servo 1 auf digitalem Port 8#define SERV2 9 //Servo 2 auf Digitalport 9#define SERV3 10 //Servo 3 auf Digitalport 10#define SERV4 11 //Servo 4 auf Digitalport 11#define SERV5 12 //Servo 5 auf Digitalport 12#define SERV6 13 / /servo 6 am digitalen Port 13Servo s1; //Servo 1Servo s2; //Servo 2Servo s3; //Servo 3Servo s4; //Servo 4Servo s5; //Servo 5Servo s6; // Servo 6 // Startwinkel für jedes Servo definieren // eine sichere Position zum Starten wählen // es wird versuchen, sich beim Einschalten sofort in diese Position zu bewegen! // Diese Winkel hängen vom Winkel jedes Servos während des ab Montagewinkel1 =90; // Servo 1 aktueller angleint angle2 =30; // Servo 2 aktueller angleint angle3 =0; // Servo 3 aktueller angleint angle4 =90; // Servo 4 aktueller angleint angle5 =90; // Servo 5 aktueller angleint angle6 =45; // Servo 6 aktueller Winkelint servo1_speed =3; // Servo 1 speedint servo2_speed =3; // Servo 2 speedint servo3_speed =3; // Servo 3 speedint servo4_speed =1; // Servo 4 speedint servo5_speed =1; // Servo-5-Geschwindigkeit // Beschränkungen für jedes Servo definieren // Diese Winkel hängen vom Winkel jedes Servos während der Montage ab angle1min =0; // Servo 1 minimaler Winkelint angle1max =180; // Servo 1 maximaler Winkelint angle2min =0; // Servo 2 minimaler Winkelint angle2max =180; // Servo 2 maximaler Winkelint angle3min =0; // Servo 3 minimaler Winkelint angle3max =180; // Servo 3 maximaler Winkelint angle4min =0; // Servo 4 minimaler Winkelint angle4max =180; // Servo 4 maximaler Winkelint angle5min =0; // Servo 5 minimaler Winkelint angle5max =180; // Servo 5 maximaler Winkelint angle6min =0; // Servo 6 minimaler Winkelint angle6max =180; // Servo 6 maximaler Winkelboolean display_angles =true; // Boolean verwendet, um den Winkel jedes Servos auf Serial Monitor zu aktualisieren 

Während des Setups wird jedes Servo an einem bestimmten Pin befestigt und seine Position wird gestartet.

Die serielle Kommunikation (zum seriellen Monitor) und die I2C-Kommunikation mit dem Nunchuk werden ebenfalls hier gestartet.

 // SETUPvoid ​​setup () { // jedes Servo an einen Pin anschließen und seine Position starten s1.attach (SERV1); s1.write (Winkel1); s2.attach(SERV2); s2.write (Winkel2); s3.attach(SERV3); s3.write (Winkel3); s4.attach(SERV4); s4.write (Winkel4); s5.attach(SERV5); s5.write (Winkel5); s6.attach(SERV6); s6.write (Winkel6); // Serielle Kommunikation starten Serial.begin (9600); // Nunchuk Wire.begin () starten; nunchuk_init();} 

Die Hauptschleife wird immer wieder wiederholt. Der Nunchuk-Status wird bei jedem Zyklus gelesen. Abhängig von den Messwerten werden unterschiedliche Befehle ausgeführt.

void loop () { // Nunchuk-Sensoren lesen if (nunchuk_read ()) {int x =nunchuk_joystickX (); // Joystick-X-Position int y =nunchuk_joystickY (); // Joystick Y-Position Boolean z =nunchuk_buttonZ(); // z-Tastenstatus boolesch c =nunchuk_buttonC (); // c-Tastenstatus Float Pitch =nunchuk_pitch (); // Nickwinkel-Float-Roll =nunchuk_roll (); //Rollwinkel 

Joystick X wird verwendet, um das Servo Nr. 1 zu bewegen.

Der folgende Codeblock wurde verwendet. Zuerst wird überprüft, ob der Wert des Joysticks groß genug ist. Auf diese Weise werden Rauschen und kleine Schwankungen vernachlässigt. Wenn der Wert den Anforderungen entspricht, wird der Winkel des Servos bei einer bestimmten Geschwindigkeit vergrößert/verkleinert.

 // Links/rechts abbiegen (mit fester Geschwindigkeit) // Links abbiegen if (x> 90) { angle1 -=servo1_speed; display_angles =wahr; if (angle1  angle1max) { angle1 =angle1max; } } s1.write (Winkel1); // Servoposition aktualisieren 

Ein ähnlicher Block wird für Joystick y verwendet. Es wird verwendet, um den Winkel von Servo Nr. 3 zu ändern. Servo #2 wird in diesem Code festgehalten.

Die Drehung des Greifers wird durch die Roll- und Nickwinkel des Controllers bestimmt, die von seinem Beschleunigungsmesser gemessen werden. Um die Steuerung des Arms zu erleichtern, wird der Winkel des Greifers nur aktualisiert, wenn die C- oder Z-Taste gedrückt wird.

Wenn nur die C-Taste gedrückt wird, liest der Code den Rollwinkel und verwendet ihn als Sollwert. Servo Nr. 5 wird gedreht, bis der Sollwert erreicht ist. Seine Geschwindigkeit ist proportional zum Fehler zwischen Ist- und Sollposition. Ein ähnlicher Code wird für Servo Nr. 4 verwendet, der den Nickwinkel von Nunchuk verfolgt.

 // Beschleunigungsmesser nur aktivieren, wenn die Tasten gedrückt werden // Greifer drehen (nur Z-Taste gedrückt) if (c &&!z) { roll =roll * 57.0 + 90.0; // Grad umwandeln servo5_speed =abs (angle5 - roll) / 10 + 1; // Geschwindigkeitsproportional macht den Fehler zwischen dem tatsächlichen und dem gewünschten Winkel if (Roll> angle5) { angle5 + =servo5_speed; display_angles =wahr; aufrechtzuerhalten. Wenn (Roll  

Der Greifer wird geschlossen, wenn sowohl die C- als auch die Z-Taste gedrückt wird. Wenn eine dieser Tasten losgelassen wird, öffnet der Roboter seinen Greifer.

 // Greifer öffnen/schließen (beide Tasten gedrückt) if(z &&c) { s6.write(90); // Greifer schließen display_angles =true; aufrechtzuerhalten. Sonst { s6.write (45); // Greifer öffnen} 

Am Ende der Skizze befindet sich ein Codeblock. Auf dem seriellen Monitor wird der tatsächliche Winkel jedes Servomotors angezeigt. Dies kann bei der Auswahl des Startwinkels jedes Motors hilfreich sein.

nunchuk.ino

Schritt 13:Verwendung

Jetzt, wo alles fertig ist, schalte den Roboter ein und hab Spaß!

Der Nunchuk wird verwendet, um die fünf in den Bildern gezeigten Bewegungen zu steuern:Rechts-/Linksdrehung, Auf-/Abbewegung, Greiferdrehung, Greifer-Auf-/Ab-Bewegung und Greifer-Auf-/Zu-Bewegungen. Sie können diese Bewegungen kombinieren, um verschiedene Aufgaben auszuführen.

Sie können den Code für verschiedene Bewegungen basierend auf einer Kombination der Tasten und Winkel des Joysticks ändern.