4-DOF Robot Arm Kit

Was es ist

Ein 4-DOF-Roboterarm-Bausatz ist das mechanische Skelett eines Tisch-Manipulators: ein Satz lasergeschnittener Acryl- oder Aluminiumwinkel, eine Drehbasis und Befestigungsschlitze für vier Servos. Allein tut er nichts – er ist der Rahmen, der Servos in eine Maschine verwandelt, die greift, positioniert und zupackt. Servos einschrauben, mit einem PCA9685 ansteuern, und daraus wird ein Arm, den du zu einem Punkt im Raum befehlen kannst.

Die vier Gelenke

Jeder Freiheitsgrad ist ein Servo mit einer Aufgabe:

• Basis – dreht den ganzen Arm links und rechts (Gieren), richtet die Arbeitsebene aus.
• Schulter – hebt das obere Glied; das erste der zwei Gelenke, die Reichweite und Höhe setzen.
• Ellbogen – beugt den Unterarm; zusammen mit der Schulter platziert er das Werkzeug überall in einer Vertikalebene.
• Greifer – öffnet und schließt die Backen, um ein Objekt zu halten.

Schulter und Ellbogen sind das Paar, das die Zweiglied-Inverskinematik löst: Zu einem Zielpunkt in der Arbeitsebene des Arms berechnet sie die zwei Gelenkwinkel, die ihn erreichen. Die Basis schwenkt diese Ebene dann in die Zielrichtung, und der Greifer greift zu.

Wann man ihn verwendet

Greife zu einem 4-DOF-Arm-Bausatz, wenn du Manipulation statt Mobilität lernen willst – Pick-and-Place, Klötze stapeln, Zeichnen oder eine Kamera auf einer positionierbaren Halterung. Er ist das Arm-Gegenstück zu einem 2WD-Chassis: die gemeinsame Struktur, auf die eine ganze Projektklasse aufbaut. Er ist bewusst leicht gebaut; behandle ihn als Lehrplattform, nicht als Arbeitstier.

Für schwerere oder präzisere Arbeit steige auf Metallgetriebe-Servos, einen steiferen Rahmen oder einen 5–6-DOF-Arm mit Handgelenk um. Für mobile Roboter ist stattdessen das Chassis der richtige Rahmen.

Verdrahtung und Fallstricke

• Ein Servo pro Gelenk, je ein Kanal. Nummeriere die Kanäle (0 = Basis, 1 = Schulter, …) und halte die Zuordnung im Code, damit ein „Bewege den Ellbogen“-Befehl das richtige Servo treibt.
• Servos separat versorgen. Vier sich gemeinsam bewegende Servos treiben den Strom in Spitzen; speise sie über die V+-Klemme des PCA9685, niemals über den Arduino.
• Vor der Montage auf Null stellen. Setze jedes Servo auf einen bekannten Winkel (z. B. 90°), bevor du die Hörner aufsteckst, damit die Nullpose des Arms zur Null deines Codes passt.
• Respektiere die Reichweite. Das Werkzeug erreicht nur einen Kreisring, den die Gliedlängen setzen; einen Punkt außerhalb zu befehlen ist unerreichbar, egal welche Gelenkwinkel – siehe Roboterarm-Simulator.
• Beachte den Hebel. Nutzlast fällt schnell, wie der Arm ausfährt; halte Lasten leicht, sonst bleiben Servos stehen und Nylon­zahnräder verlieren Zähne.

Die Maße, die du vor jedem Code brauchst

Inverskinematik ist Arithmetik über Gliedlängen. Miss sie falsch, und der Arm greift selbstbewusst an die falsche Stelle, ohne dass der Code schuld wäre.

Miss zwischen Gelenkachsen, nicht zwischen Halterkanten. Die Achse ist die Mitte der Servo-Abtriebswelle und liegt oft 5–10 mm innerhalb des sichtbaren Halters. Bei einem 95-mm-Glied sind 10 mm Fehler über 10 % – was sich als systematisch zu kurzer Arm zeigt und durch kein Tuning zu beheben ist.

Diese zwei Längen geben dir den Arbeitsraum direkt:

maximum reach = L1 + L2
minimum reach = |L1 - L2|

Mit L1 = 100 und L2 = 90 reicht der Arm zwischen 10 mm und 190 mm ab der Schulter – ein Kreisring, keine Scheibe. In der Mitte ist ein Loch, das er physisch nicht erreichen kann, und es ist beim ersten Mal eine echte Überraschung, wenn ein Ziel nahe der Basis als unerreichbar zurückkommt. Sind beide Glieder gleich, verschwindet das Loch und der Arm kann sich auf sich selbst falten.

Servodrehmoment: warum der Arm ausgestreckt durchhängt

Das Schulter-Servo trägt alles dahinter, und der Drehmomentbedarf steigt, je weiter die Masse vom Gelenk sitzt.

Für einen voll ausgestreckten Arm mit L1 = L2 = 95 mm, der 30 g Nutzlast hält, bei Gliedern von je grob 20 g:

Shoulder torque ~= (forearm+elbow mass x 0.095) + (payload x 0.190)
                ~= (0.05 kg x 9.5 cm) + (0.03 kg x 19 cm)
                ~= 0.48 + 0.57 = 1.05 kg.cm

Das Blockiermoment eines SG90 liegt bei etwa 1,8 kg·cm bei 4,8 V. 1,05 kg·cm zu halten heißt 58 % des Blockiermoments im Dauerbetrieb, was deutlich jenseits des Punkts liegt, an dem ein Hobby-Servo genau bleibt – er hängt unter dem befohlenen Winkel durch, brummt und wird heiß.

Drei praktische Folgen. Die Genauigkeit des Arms ist voll ausgestreckt am schlechtesten, genau dort, wo auch eine Singularität lebt, also plane Bahnen innerhalb der Grenze. Nutze MG90S-Servos mit Metallgetriebe für die Schulter, selbst wenn der Rest SG90s sind – es ist das Gelenk, das zuerst versagt, und Nylon­zahnräder verlieren unter Dauerlast Zähne. Und halte gegen, wenn du kannst: Ein Gummiband vom oberen Glied zurück zur Basis nimmt dem Schulter-Servo überraschend viel statische Last gratis ab.

So montieren, dass die Mathematik stimmt

Die Reihenfolge zählt, und ein Schritt lässt sich danach fast nicht mehr rückgängig machen.

1. Jedes Servo auf Mitte stellen, bevor ein Horn montiert wird. Servo mit Strom versorgen, 90° befehlen, und erst dann das Horn aufstecken. Ein Servohorn ist verzahnt – etwa 20 oder 24 Zähne –, lässt sich also nur in diskreten Positionen montieren, und die feinste Einstellung ist grob 15–18°. Wer den Arm erst montiert und danach kalibriert, findet womöglich ein Gelenk, dessen nutzbarer Bereich um 40° versetzt ist und sich mechanisch gar nicht korrigieren lässt.

2. Hörner in der Pose montieren, die als Null gelten soll. Für die Schulter heißt das meist: oberes Glied senkrecht. Für den Ellbogen: Unterarm waagerecht. Lege die Konvention fest, schreibe sie auf und baue danach.

3. Vor dem Festziehen den vollen Weg jedes Gelenks prüfen. 0° und 180° befehlen und prüfen, dass nichts mit dem Rahmen kollidiert. Ein Gelenk, das bei 160° an den eigenen Halter stößt, hat eine wirksame Grenze von 160°, und dein Code muss das wissen.

4. Offsets und Vorzeichen pro Gelenk festhalten. Manche Gelenke drehen wegen der Anlenkung gegen deine mathematische Konvention. Einmal erfassen:

struct Joint {
  uint8_t channel;
  int      offsetDeg;   // servo angle when the joint is at its mathematical zero
  int8_t   sign;        // +1 or -1
  int      minDeg, maxDeg;  // mechanical limits, measured
};

const Joint BASE     = {0,  90, +1,  -85,  85};
const Joint SHOULDER = {1,  90, -1,  -10, 120};
const Joint ELBOW    = {2,  90, +1, -120,  10};
const Joint GRIPPER  = {3,  20, +1,    0,  55};

int servoAngle(const Joint &j, float jointDeg) {
  float clamped = constrain(jointDeg, j.minDeg, j.maxDeg);
  return constrain((int)(j.offsetDeg + j.sign * clamped), 0, 180);
}

Dieses Struct ist die gesamte Brücke zwischen Kinematik und Hardware, und es explizit zu haben ist der Unterschied zwischen einem Arm, über den du nachdenken kannst, und einem, an dem du ständig herumpfuschst.

Vier Servos versorgen

Vier sich gemeinsam bewegende Mikro-Servos liegen weit jenseits dessen, was ein Mikrocontroller liefern kann, und die Versagensart des Arms macht es schlimmer: Wenn der Arm an den eigenen Rahmen stößt oder etwas Festes greift, bleiben alle Servos der Kette gleichzeitig stehen.

Lege die Versorgung auf den Blockierwert aus. Eine separate 5–6-V-Versorgung in die V+-Klemme des PCA9685, mit 470–1000 µF Kondensator darüber, und Massen mit dem Controller verbunden. Etwas davon über den 5-V-Pin des Arduino zu betreiben, schickt das Board in Brown-out – und weil es nur passiert, wenn der Arm eine bestimmte Position erreicht, liest es sich überzeugend wie ein Softwarefehler.

Bewege ihn sanft

Ein Servo, dem ein neuer Winkel befohlen wird, fährt dorthin mit voller Geschwindigkeit. An einem mobilen Roboter ist das nur abrupt; an einem Arm ist es ein echtes Problem: eine heftige Bewegung, eine Stromspitze und ein mechanischer Schlag durch Nylon­zahnräder, mit dem Hebel des Arms multipliziert.

// Interpolate every joint together so the tool moves in a straight-ish line
// and no single servo takes the whole load at once.
void moveTo(float base, float shoulder, float elbow, int steps, int stepMs) {
  static float cur[3] = {0, 0, 0};
  float target[3] = {base, shoulder, elbow};

  for (int s = 1; s <= steps; s++) {
    float t = (float)s / steps;
    for (int j = 0; j < 3; j++) {
      float a = cur[j] + (target[j] - cur[j]) * t;
      pwm.setPWM(JOINTS[j].channel, 0, countsFor(JOINTS[j], a));
    }
    delay(stepMs);
  }
  memcpy(cur, target, sizeof(cur));
}

Alle Gelenke gemeinsam zu interpolieren zählt ebenso wie das Glätten. Gelenke nacheinander zu bewegen schickt das Werkzeug auf einen seltsamen Weg durch den Arbeitsraum, was langsamer ist und unterwegs viel eher irgendwo anstößt.

Fehlerbehebung

Wann du über diesen Bausatz hinauswächst

Ein 4-DOF-Acryl-Bausatz ist eine Lehrplattform, und er steht dazu. Seine Grenzen, in der Reihenfolge, in der du sie triffst:

Nutzlast. Dutzende Gramm. Alles Schwerere, und das Schulter-Servo hält es nicht.

Wiederholgenauigkeit. Spiel in den Servogetrieben plus Biegung in Acrylgliedern heißt: Zum selben befohlenen Punkt zurückzukehren landet Millimeter auseinander. Vier Grad Spiel an der Schulter sind über 190 mm Reichweite über 13 mm am Werkzeug.

Handgelenks­orientierung. Mit vier Freiheitsgraden kannst du das Werkzeug irgendwo platzieren, aber nicht unabhängig wählen, aus welchem Winkel es sich nähert. Ein 5- oder 6-DOF-Arm fügt ein Handgelenk hinzu, was erst „heb das von der Seite auf“ möglich macht.

Nichts davon ändert die Mathematik. Die Zweiglied-Kinematik, die du für diesen Bausatz schreibst, ist derselbe Löser, den ein besserer Arm nutzt – genau deshalb lohnt sich der billige Rahmen zuerst.