Intelligenter Arduino-Roboterarm bauen: Einfaches DIY-Tutorial

Benötigte Komponenten

Arduino UNO	1
Mikro-Servos (z. B. SG90 / MG90S)	5
Potentiometer (10 kΩ)	5
Steckplatine (Breadboard)	1
Stromversorgung (5 V Netzteil oder Batterie)	1
Baumaterial (Eisstiele, Pappe, Holz, Sunboard, Acryl – was verfügbar ist)	nach Bedarf

Zusätzlich: Arduino IDE installiert.

Projektbeschreibung

In diesem Tutorial baue ich einen einfachen Roboterarm, der über einen „Master-Arm“ (Potentiometer-Arm) gesteuert wird. Der Arm merkt sich Bewegungen und spielt sie nacheinander ab. Idee inspiriert von „Mini Robotic Arm“ von Stoerpeak. Lange gewollt, früher fehlte Programmierwissen – jetzt einfach, günstig und geteilt.

Schritt 1: Materialbeschaffung

• 5× Servomotoren
• 5× Potentiometer (10 kΩ)
• 1× Arduino UNO
• 5 V Stromversorgung (Netzteil empfohlen)
• 1× Breadboard
• Konstruktionsmaterial (Eisstiele, Karton, Holz…)

Schritt 2: Mechanik bauen

Arme aus Eisstielen: Servos mit doppelseitigem Klebeband fixieren, mit Schrauben sichern. Master-Arm: Potentiometer auf Eisstiele kleben, als Gelenke verbinden. Alles auf DIN-A4-Leinwandplatte als Basis montieren. Design ist einfach, nicht perfekt stabil – wer mag, kann bessere Mechanik entwerfen.

Schritt 3: Verkabelung

• Alle Servos parallel an Stromversorgung: Rot → +5 V, Braun/Schwarz → GND
• Signalleitungen (Orange/Gelb) an PWM-Pins: D3, D5, D6, D9, D10
• Potentiometer: Außenbeinchen parallel an +5 V und GND, Mittelabgriff an Analog-Eingänge A0–A4
• Wichtig: GND der Servos muss mit Arduino-GND verbunden sein, sonst funktioniert die Steuerung nicht!

Zuordnung: Servo an D3 ↔ Poti an A0, Servo an D5 ↔ Poti an A1, … Servo an D10 ↔ Poti an A4.

Schritt 4: Programmierung

Logik: Potentiometer-Werte in Array speichern, bei Wiedergabe Array durchlaufen und Servos entsprechend ansteuern. Referenz: „Arduino Potentiometer Servo Control & Memory“. Code als Datei Record-Play.ino beigefügt.

Globale Variablen

#include <Servo.h>
Servo Servo_0, Servo_1, Servo_2, Servo_3, Servo_4;
int Pot_0, Pot_1, Pot_2, Pot_3, Pot_4;
int Servo_0_Pos, Servo_1_Pos, Servo_2_Pos, Servo_3_Pos, Servo_4_Pos;
int Prev_0_Pos, Prev_1_Pos, Prev_2_Pos, Prev_3_Pos, Prev_4_Pos;
int Current_0_Pos, Current_1_Pos, Current_2_Pos, Current_3_Pos, Current_4_Pos;
int Servo_Position, Servo_Number;
int Storage[600]; // Aufzeichnungsspeicher (größer = mehr RAM)
int Index = 0;
char data = 0; // Serial-Eingabe

setup()

void setup() {
  Serial.begin(9600);
  Servo_0.attach(3); Servo_1.attach(5); Servo_2.attach(6);
  Servo_3.attach(9); Servo_4.attach(10);
  Servo_0.write(100); Servo_1.write(100); Servo_2.write(100);
  Servo_3.write(100); Servo_4.write(100);
  Serial.println("Press 'R' to Record and 'P' to play");
}

Funktion Map_Pot() – Potis einlesen & Servos live steuern

void Map_Pot() {
  // Servos auf 1–179° begrenzen (180° brummt oft)
  Pot_0 = analogRead(A0); Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179); Servo_0.write(Servo_0_Pos);
  Pot_1 = analogRead(A1); Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179); Servo_1.write(Servo_1_Pos);
  Pot_2 = analogRead(A2); Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179); Servo_2.write(Servo_2_Pos);
  Pot_3 = analogRead(A3); Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179); Servo_3.write(Servo_3_Pos);
  Pot_4 = analogRead(A4); Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179); Servo_4.write(Servo_4_Pos);
}

loop() – Aufnahme & Wiedergabe

void loop() {
  Map_Pot();
  while (Serial.available() > 0) {
    data = Serial.read();
    if (data == 'R') Serial.println("Recording Moves...");
    if (data == 'P') Serial.println("Playing Recorded Moves...");
  }

  if (data == 'R') { // AUFNAHME
    Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos;
    Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos;

    Map_Pot(); // Neu einlesen zum Vergleich

    // Für jeden Servo: wenn Position geändert → im Array speichern
    // Offset +0, +100, +200, +300, +400 kodiert Servonummer
    if (abs(Prev_0_Pos - Servo_0_Pos) > 0) { // Korrigiert: Differenz prüfen
      if (Current_0_Pos != Servo_0_Pos) { Storage[Index] = Servo_0_Pos + 0; Index++; }
      Current_0_Pos = Servo_0_Pos;
    }
    if (abs(Prev_1_Pos - Servo_1_Pos) > 0) {
      if (Current_1_Pos != Servo_1_Pos) { Storage[Index] = Servo_1_Pos + 100; Index++; }
      Current_1_Pos = Servo_1_Pos;
    }
    if (abs(Prev_2_Pos - Servo_2_Pos) > 0) {
      if (Current_2_Pos != Servo_2_Pos) { Storage[Index] = Servo_2_Pos + 200; Index++; }
      Current_2_Pos = Servo_2_Pos;
    }
    if (abs(Prev_3_Pos - Servo_3_Pos) > 0) {
      if (Current_3_Pos != Servo_3_Pos) { Storage[Index] = Servo_3_Pos + 300; Index++; }
      Current_3_Pos = Servo_3_Pos;
    }
    if (abs(Prev_4_Pos - Servo_4_Pos) > 0) {
      if (Current_4_Pos != Servo_4_Pos) { Storage[Index] = Servo_4_Pos + 400; Index++; }
      Current_4_Pos = Servo_4_Pos;
    }

    // Serial-Monitor Ausgabe (Tabellarisch)
    Serial.print(Servo_0_Pos); Serial.print("\t");
    Serial.print(Servo_1_Pos); Serial.print("\t");
    Serial.print(Servo_2_Pos); Serial.print("\t");
    Serial.print(Servo_3_Pos); Serial.print("\t");
    Serial.println(Servo_4_Pos);
    Serial.print("Index = "); Serial.println(Index);
    delay(50);
  }

  if (data == 'P') { // WIEDERGABE
    for (int i = 0; i < Index; i++) {
      Servo_Number = Storage[i] / 100;      // 0–4
      Servo_Position = Storage[i] % 100;    // 1–179
      switch (Servo_Number) {
        case 0: Servo_0.write(Servo_Position); break;
        case 1: Servo_1.write(Servo_Position); break;
        case 2: Servo_2.write(Servo_Position); break;
        case 3: Servo_3.write(Servo_Position); break;
        case 4: Servo_4.write(Servo_Position); break;
      }
      delay(50);
    }
  }
}

Hinweis: Im Originalcode war die Bedingung abs(Prev_0_Pos == Servo_0_Pos) fehlerhaft (vergleicht bool). Korrigiert auf Differenzprüfung.

Schritt 5: Testen

1. Code hochladen, Serial Monitor öffnen (9600 Baud) – Arduino resettet.
2. Arm per Master-Arm steuern – noch keine Aufzeichnung.
3. 'R' eingeben → Aufzeichnung startet. Gewünschte Bewegungen ausführen.
4. 'P' eingeben → Aufgezeichnete Bewegungen werden abgespielt (solange nicht resetet).

Die Bewegung ist noch nicht so flüssig wie beim Original von Stoerpeak. Verbesserungsvorschläge willkommen!

Dateien

• Record-Play.ino (vollständiger Sketch)

Schaltplan