Präzisions-Roboterarm bauen: Schritt-für-Schritt-Anleitung (Arduino, Servos)

Wiederholbare, präzise Bewegungen sind die Domäne von Roboterarmen. Ob Bestückung, Lab-Handling, 3D-Druck-Nachbearbeitung, Qualitätsprüfung oder Lehre – ein selbstgebauter 5-DOF-Arm (Degrees of Freedom) mit Arduino und Servos vermittelt die Grundlagen der Kinematik, Steuerung und Mechanik. Kosten: < 100 €. Dieser Guide führt von der Mechanik über Elektronik bis zum Code mit Record/Playback-Funktion.

1. Was ist ein Roboterarm?

Ein serieller Manipulator aus Gliedern (Links) und Gelenken (Joints). Jedes Gelenk = 1 DOF. Typische Konfiguration: Basis (Drehung), Schulter, Ellenbogen, Handgelenk (Pitch/Yaw), Greifer. 5–6 DOF für beliebige Pose im Raum (Position + Orientierung).

2. Benötigte Hardware

Wichtig: Servo-Stromversorgung

Servos ziehen unter Last 1–2 A pro Servo. Arduino 5-V-Regler liefert < 500 mA → externe 5-V-Quelle für Servos, nur GND & Signal mit Arduino verbinden.

3. Mechanischer Aufbau (Master-Arm + Slave-Arm)

Konzept: Master-Arm (passiv, mit Potis an jedem Gelenk) wird manuell geführt. Slave-Arm (mit Servos) folgt den Poti-Werten. Nach „Record“ speichert Arduino die Positionen und spielt sie ab.

1. Master-Arm bauen: 5 Glieder (Eisstiele, Alu-Flachprofile, 3D-Druck), jedes Gelenk mit Poti (Welle = Gelenkachse).
2. Slave-Arm bauen: Identische Kinematik, Servos an Gelenken.
3. Basis: Stabiler Fuß (Holzbrett, 20×20 cm), Kugellager für Basis-Drehung.
4. Verkabelung: Poti-Außenanschlüsse an 5 V / GND, Mittelabgriffe an A0–A4. Servo-Signal an D3, D5, D6, D9, D10 (PWM-Pins). Servo-VCC/GND an externes Netzteil.

4. Elektronik & Verdrahtung

Arduino       Master-Potis          Slave-Servos
GND    ────── GND (alle)            GND (Netzteil)
5V     ────── VCC (alle Poti-Außen)  ──── (NICHT verbinden!)
A0     ────── Poti 0 Mitte
A1     ────── Poti 1 Mitte
A2     ────── Poti 2 Mitte
A3     ────── Poti 3 Mitte
A4     ────── Poti 4 Mitte
D3     ────────────────────────── Servo 0 (Basis)
D5     ────────────────────────── Servo 1 (Schulter)
D6     ────────────────────────── Servo 2 (Ellenbogen)
D9     ────────────────────────── Servo 3 (Handgelenk)
D10    ────────────────────────── Servo 4 (Greifer)

5. Arduino-Code (Record / Playback)

#include <Servo.h>

const int NUM_JOINTS = 5;
const int potPins[NUM_JOINTS] = {A0, A1, A2, A3, A4};
const int servoPins[NUM_JOINTS] = {3, 5, 6, 9, 10};

Servo servos[NUM_JOINTS];
int potVals[NUM_JOINTS];
int servoPos[NUM_JOINTS];

// Recording
const int MAX_STEPS = 500;
int recordedPos[MAX_STEPS][NUM_JOINTS];
int stepCount = 0;
bool recording = false;
bool playing = false;
int playIndex = 0;

void setup() {
  for (int i = 0; i < NUM_JOINTS; i++) {
    servos[i].attach(servoPins[i]);
  }
  Serial.begin(9600);
  Serial.println("Befehle: R=Record, P=Play, S=Stop, C=Clear");
}

void loop() {
  // Poti lesen & Servo folgen (Live-Mode)
  if (!playing) {
    for (int i = 0; i < NUM_JOINTS; i++) {
      potVals[i] = analogRead(potPins[i]);
      servoPos[i] = map(potVals[i], 0, 1023, 0, 180);
      servos[i].write(servoPos[i]);
    }
  }

  // Serial Commands
  if (Serial.available()) {
    char cmd = Serial.read();
    switch (cmd) {
      case 'R': case 'r':
        recording = true; playing = false; stepCount = 0;
        Serial.println("Recording...");
        break;
      case 'P': case 'p':
        if (stepCount > 0) { playing = true; recording = false; playIndex = 0; Serial.println("Playing..."); }
        break;
      case 'S': case 's':
        recording = false; playing = false; Serial.println("Stopped.");
        break;
      case 'C': case 'c':
        stepCount = 0; Serial.println("Cleared.");
        break;
    }
  }

  // Recording Logic
  if (recording && stepCount < MAX_STEPS) {
    for (int i = 0; i < NUM_JOINTS; i++) {
      recordedPos[stepCount][i] = servoPos[i];
    }
    stepCount++;
    delay(50); // 20 Hz Abtastung
  }

  // Playback Logic
  if (playing && playIndex < stepCount) {
    for (int i = 0; i < NUM_JOINTS; i++) {
      servos[i].write(recordedPos[playIndex][i]);
    }
    playIndex++;
    delay(50);
    if (playIndex >= stepCount) { playing = false; Serial.println("Done."); }
  }
}

6. Erweiterte Projektideen

• Gesture Control (Kinect / MediaPipe Handtracking): Webcam → Python (OpenCV/MediaPipe) → Joint-Winkel → Serial → Arduino.
• Web-Interface: ESP32 + WebServer (WebSocket) → Browser-Joystick/Slider → Servo.
• Nunchuk (I²C): Wii Nunchuk an A4/A5 → Joystick + 2 Buttons + Accelerometer → Armsteuerung.
• Bluetooth (HC-05) + Android App: MIT App Inventor / Flutter → Slider pro Gelenk.
• Drahtlose Hand (Flex-Sensoren im Handschuh): 5 Flex-Sensoren → ADC → Servo-Position.
• Bartender-Roboter: Pumpen + Ventile + Arm → Cocktail-Rezepte aus Array.
• Computer Vision (OpenCV + Arduino): Objekt-Erkennung → Inverse Kinematik → Greifen.

7. Inverse Kinematik (IK) – Der nächste Schritt

Bisher: Joint-Space-Control (direkte Winkel). Profi: Cartesian Control (X,Y,Z, Pitch, Roll) → IK berechnet Gelenkwinkel. Bibliotheken: IKFast, Trac-IK, MoveIt (ROS), für Arduino: vereinfachte 2-Link/3-Link analytische Lösung.

Fazit

Ein 5-DOF-Roboterarm mit Arduino und Servos ist der ideale Einstieg in Robotik: Mechanik, Elektronik, Echtzeitsteuerung, Teach-In/Playback. Für Präzision: Schrittmotoren + Encoder + Closed-Loop, starrere Mechanik (Alu/Carbon), IK-Solver. Für Industrie: Cobots (UR, Franka, Doosan) mit Safety-Rating. Wir helfen bei Mechanik-Design, Servo-Auswahl, IK-Implementierung und ROS-Integration.