Arduino-basierter 6-DoF Roboterarm mit Nunchuk-Steuerung

Komponenten und Zubehör

6 DoF Roboterarm	1
Nunchuk-Controller	1
Arduino Mega 2560	1
Control Shield	1

Apps und Online-Dienste

• Arduino IDE

Über dieses Projekt

Roboterarme sind faszinierend! Fabriken weltweit nutzen sie zum Lackieren, Löten und präzisen Bewegen. Sie finden sich in der Raumfahrt, Unterwasser-ROVs und sogar in medizinischen Anwendungen.

Und jetzt können Sie eine günstigere Version zu Hause, im Büro oder Labor haben! Müde von repetitiven Aufgaben? Programmieren Sie Ihren eigenen Roboter zur Hilfe... oder zum Chaos! :D

In diesem Tutorial zeige ich, wie man einen Roboterarm montiert und mit einem Arduino Mega programmiert. Als Steuerung dient ein Nintendo Nunchuk – günstig, leicht zu beschaffen und voller Sensoren.

Es gibt mehrere Nutzungsmöglichkeiten: Ohne Roboterarm-Kit können Sie Arduino-Programmierung und Nunchuk-Interfacing lernen. Oder Sie üben Elektronik- und Mechanik-Fähigkeiten.

Schritt 1: Werkzeuge und Materialien

Verwendete Werkzeuge und Materialien:

• Lötkolben und Draht. Zum Anlöten von Anschlüssen an die Nunchuk-Kabel für die Arduino-Verbindung;
• Schrumpfschlauch. Für bessere Isolation der Leiter;
• Schraubendreher. Die Struktur wird mit Schrauben und Muttern montiert;
• 6-Achsen mechanischer Desktop-Roboterarm (Link). Das zuverlässige, einfach zu montierende Kit enthält bereits viele Komponenten;
• 12V Netzteil (2A oder mehr);
• Nunchuk-Controller (Link). Wird für die Armsteuerung an den Arduino angeschlossen;
• Male Jumper-Kabel (4 Stück);
• Arduino Mega (Link). Das verwendete Kit enthält bereits ein Board-Controller-Bundle mit Arduino. Andere Arduino-Boards sind ebenfalls möglich;

Später wurde ich auf einen Nunchuk-Adapter hingewiesen, der die Breadboard-Verbindung erleichtert (Link). Eine gute Option, um Lötzeit zu sparen und den Originalstecker nicht zu zerstören (wie in Schritt 9 beschrieben).

Der SainSmart 6-Achsen-Arm enthält bereits:

• Arduino Mega 2560 R3
• Control Board Shield
• NRF24L01+ Wireless Transceiver
• MPU6050 3-Achsen Gyroskop & Beschleunigungssensor
• 71 × M3×8 Schrauben, 47 × M3 Muttern
• 2 × U-Halter, 5 × Servo-Halter
• 4 × 9kg Servos, 2 × 20kg Servos
• 6 × Metall-Servo-Tabletts, 3 × U-Halter
• 21 × Winkelhalter, 3 × Flanschlager, 1 × Greifer

Andere Roboterarm-Kits finden Sie online oder Sie entwerfen Ihren eigenen (z. B. 3D-druckbar).

In den folgenden 7 Schritten zeige ich den Arm-Aufbau vor der Verkabelung. Wenn Sie kein ähnliches Kit haben, können Sie Schritte überspringen. Andere Kits aufbauen und direkt zu Elektronik/Programmierung springen.

Jeder Schritt enthält ein animiertes GIF (nur Desktop-Version der Website).

Schritt 2: Roboterarm montieren – Teil 1: Basis

Der erste Teil ist die Basis: zwei U-förmige Halter, rückseitig mit vier M3-Schrauben und Muttern verbunden. Der einfachste Montageschritt.

Schritt 3: Roboterarm montieren – Teil 2: Servo #1

Der erste Servomotor wird senkrecht zur Basis mit einem Servo-Halter montiert (4 M3-Schrauben). Servo #1 oben drauf, ebenfalls mit 4 M3-Schrauben. Ein kreisförmiges Metallhorn wird auf die Servo-Achse gesetzt. Die mitgelieferten Plastikhörner werden nicht verwendet.

Schritt 4: Roboterarm montieren – Teil 3: Servo #2

Ein weiterer Servo-Halter wird senkrecht zum vorherigen montiert, mit 4 Schrauben am Horn von Servo #1 befestigt. Servo #2 wird installiert (4 M3-Schrauben/Muttern, Metallhorn). Ein U-Halter wird am Horn befestigt (4 Schrauben). Eine M3-Schraube gegenüber der Servo-Achse gibt Stabilität; ein Lager sitzt auf dieser Schraube und wird mit einer M3-Mutter fixiert. So ist der U-Halter fest mit der Servo-#2-Zentralachse verbunden.

Schritt 5: Roboterarm montieren – Teil 4: Servo #3

Ein weiterer U-Halter wird mit 4 M3-Schrauben/Muttern montiert. Am anderen Ende wird Servo #3 mit Metallhorn und 4 Schrauben installiert. Ein Servo-Halter verbindet sich mit dem Motor, ein L-Profil linkt zum Servo-Halter. Wieder wird ein Lager gegenüber der Servo-Achse verwendet.

Schritt 6: Roboterarm montieren – Teil 4: Servo #4

Ein U-Halter verbindet sich mit dem L-Profil (4 M3-Schrauben/Muttern). Servo #4 wird am U-Halter montiert (4 Schrauben). Ein weiterer Servo-Halter verbindet sich mit dem Servo.

Schritt 7: Roboterarm montieren – Teil 4: Servo #5

Der fünfte Servo wird senkrecht zu Servo #4 mit einem weiteren Servo-Halter verbunden (4 M3-Schrauben/Muttern).

Schritt 8: Roboterarm montieren – Teil 4: Servo #6

Der Greifer wird an die Servo-#5-Achse angeschlossen. Oben drauf wird Servo #6 mit Schrauben, Muttern und Metallhorn befestigt. Der Greifer hat Zahnräder, die die Servodrehung in lineare Greiferbewegung umwandeln.

Schritt 9: Nunchuk-Controller vorbereiten

Gründe für den Nintendo Nunchuk:

• Günstig! Replikas minderer Qualität reichen für dieses Projekt;
• Leicht zu finden! Viele Originale und günstige Replikas online;
• Viele Sensoren! Zwei Tasten (Z, C), 2-Achsen-Joystick (X, Y), 3-Achsen-Beschleunigungssensor;
• Arduino-Bibliothek! Robert Eisele entwickelte eine großartige, einfach zu nutzende Bibliothek: xarg.org

Unglücklicherweise hat der Nunchuk einen komplizierten Stecker. Um ihn an den Arduino anzuschließen, musste ich das Kabel durchtrennen und die Adern freilegen – danach funktioniert er nicht mehr an der Wii... :/

Zuerst Stecker abschneiden, Isolierung entfernen. Mit Multimeter und Aderfarben die Funktion jeder Ader bestimmen (Vcc, GND, SCL, SDA) anhand des Stecker-Schemas. Aderfarben sind nicht standardisiert; hier drei Varianten:

Original: SDA=grün, SCL=gelb, 3V3=rot, GND=weiß

Replika #1: SDA=gelb, SCL=weiß, 3V3=grün, GND=rot

Replika #2: SDA=blau, SCL=weiß, 3V3=rosa, GND=grün

Ich lötete die Adern an Male-Jumper für einfachere Arduino-Verbindung (Lötkolben, Schrumpfschlauch). Der erwähnte Nunchuk-Adapter erleichtert die Breadboard-Verbindung.

Schritt 10: Schaltungen verdrahten

Nach Strukturmontage und Nunchuk-Anschluss geht es an die Verkabelung. Ich nutzte das mitgelieferte Control Board Shield, das spezifische Anschlüsse für Servos, Netzteil etc. hat.

Nunchuk-Verbindung (Arduino Mega / Shield):

• Nunchuk Pin 6 (SCL) → Arduino Mega Pin 21 (SCL)
• Nunchuk Pin 1 (SDA) → Arduino Mega Pin 20 (SDA)
• Nunchuk Pin 3 (Vcc) → Arduino Mega 3V3
• Nunchuk Pin 4 (GND) → Arduino Mega GND

Bei Arduino Uno andere Pins:

• SCL → A5, SDA → A4, Vcc → 3V3, GND → GND

Servos (Control Shield Terminals):

• Terminal 11 → Servo #1, 12 → #2, 13 → #3, 8 → #4, 9 → #5, 10 → #6

Ohne Shield (direkt Arduino):

• Pin 11 → Servo #1, 12 → #2, 13 → #3, 8 → #4, 9 → #5, 10 → #6
• GND → Servos GND, 6V Netzteil → Servos Vcc

Externes 12V-Netzteil (>2A) nötig – Servos verbrauchen viel Strom. Bei zu schwachem Netzteil vibrieren Servos, werden heiß, verlieren Kraft. Netzteil erst nach Code-Upload anschließen (Power-Button auf Shield auf OFF). USB-Kabel an Arduino stecken und weiter.

Schritt 11: Arduino IDE einrichten

1. Neueste Arduino IDE herunterladen & installieren (Windows, Linux, macOS): arduino.cc

2. Bibliotheken hinzufügen

Robert Eisele's Nunchuk-Bibliothek: Website, Download: GitHub

In Arduino IDE: Sketch → Include Library → Manage Libraries → Bibliothek hinzufügen.

Bibliotheksfunktionen:

• nunchuk_buttonZ(): 1 wenn Z gedrückt, sonst 0
• nunchuk_buttonC(): 1 wenn C gedrückt, sonst 0
• nunchuk_joystickX(): X-Wert (-127 bis 127)
• nunchuk_joystickY(): Y-Wert (-127 bis 127)
• nunchuk_pitch(): Nickwinkel in Radiant (-180° bis 180°)
• nunchuk_roll(): Rollwinkel in Radiant (-180° bis 180°)

Winkel werden in Radiant zurückgegeben – im Code in Grad umgerechnet.

Schritt 12: Arduino-Code

Arduino-Sketch herunterladen. USB an Computer, Code hochladen (dauert etwas – Zeit für Like/Share! :D). Nach Upload USB abziehen, Netzteil anschließen, Power-Button einschalten. Code startet sofort.

Warnung: Beim Start bewegt sich der Arm sehr schnell in die Startposition – Vorsicht vor Verletzungen oder Schäden!

Startwinkel der Servos müssen je nach Montage angepasst werden.

Code-Erklärung:

Vor setup(): Bibliotheken (nunchuk.h, wire.h, servo.h) importieren, Pins definieren, globale Variablen deklarieren. angle# = Startposition jedes Servos (bei anderer Startposition Werte ändern). servo#_speed = Bewegungsgeschwindigkeit (höher = schneller). angle#min/max = Winkelbegrenzungen zur Kollisionsvermeidung.

// Bibliotheken
#include <nunchuk.h>
#include <wire.h>
#include <servo.h>

// Pins definieren
#define SERV1 8
#define SERV2 9
#define SERV3 10
#define SERV4 11
#define SERV5 12
#define SERV6 13

Servo s1, s2, s3, s4, s5, s6;

// Startwinkel
int angle1 = 90, angle2 = 30, angle3 = 0;
int angle4 = 90, angle5 = 90, angle6 = 45;

// Geschwindigkeiten
int servo1_speed = 3, servo2_speed = 3, servo3_speed = 3;
int servo4_speed = 1, servo5_speed = 1;

// Winkelbegrenzungen
int angle1min = 0, angle1max = 180;
int angle2min = 0, angle2max = 180;
int angle3min = 0, angle3max = 180;
int angle4min = 0, angle4max = 180;
int angle5min = 0, angle5max = 180;
int angle6min = 0, angle6max = 180;

boolean display_angles = true;

setup(): Servos an Pins anhängen, Startpositionen setzen. Serial (9600) und I2C (Nunchuk) starten.

void setup() {
  s1.attach(SERV1); s1.write(angle1);
  s2.attach(SERV2); s2.write(angle2);
  s3.attach(SERV3); s3.write(angle3);
  s4.attach(SERV4); s4.write(angle4);
  s5.attach(SERV5); s5.write(angle5);
  s6.attach(SERV6); s6.write(angle6);
  Serial.begin(9600);
  Wire.begin(); nunchuk_init();
}

loop(): Nunchuk jede Iteration auslesen. Je nach Werten verschiedene Aktionen.

void loop() {
  if (nunchuk_read()) {
    int x = nunchuk_joystickX();
    int y = nunchuk_joystickY();
    boolean z = nunchuk_buttonZ();
    boolean c = nunchuk_buttonC();
    float pitch = nunchuk_pitch();
    float roll = nunchuk_roll();

Joystick X steuert Servo #1 (Links/Rechts). Rauschunterdrückung: nur bei |x| > 90 reagieren.

// Links drehen
if (x > 90) {
  angle1 -= servo1_speed; display_angles = true;
  if (angle1 < angle1min) angle1 = angle1min;
}
// Rechts drehen
if (x < -90) {
  angle1 += servo1_speed; display_angles = true;
  if (angle1 > angle1max) angle1 = angle1max;
}
s1.write(angle1);

Joystick Y steuert Servo #3 (Hoch/Runter), Servo #2 bleibt fix.

Greifer-Rotation via Roll/Pitch (Beschleunigungssensor) – nur bei gedrückter C- oder Z-Taste aktualisiert.

Nur C gedrückt: Roll-Winkel als Sollwert für Servo #5. Geschwindigkeit proportional zum Fehler. Ähnlich für Servo #4 mit Pitch.

// Beschleunigungssensor nur bei gedrückten Tasten aktivieren
// Greifer rotieren (nur Z gedrückt)
if (c && !z) {
  roll = roll * 57.0 + 90.0; // in Grad
  servo5_speed = abs(angle5 - roll)/10 + 1;
  if (roll > angle5) { angle5 += servo5_speed; display_angles = true; }
  if (roll < angle5) { angle5 -= servo5_speed; display_angles = true; }
  s5.write(angle5);
}

Greifer schließt bei gedrückten C UND Z. Bei Loslassen einer Taste öffnet er sich.

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

Am Ende: Serial Monitor zeigt aktuelle Servowinkel (hilfreich für Startwinkel-Wahl).

nunchuk.ino

Schritt 13: Bedienung

Alles bereit – Roboter einschalten und Spaß haben!

Der Nunchuk steuert fünf Bewegungen (siehe Bilder): Rechts/Links-Drehung, Hoch/Runter, Greifer-Rotation, Greifer Hoch/Runter, Greifer Öffnen/Schließen. Bewegungen lassen sich kombinieren.

Code kann für andere Bewegungs-Kombinationen (Tasten + Joystick-Winkel) angepasst werden.

Code

nunchuk.ino (Arduino)

Keine Vorschau (nur Download).

GitHub

https://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk