DIY SCARA-Roboter mit Arduino bauen – Schritt-für-Schritt-Anleitung

In diesem Tutorial lernen wir, einen Arduino-basierten SCARA-Roboter zu bauen. Ich zeige den kompletten Prozess: vom Design bis zur eigenen GUI zur Steuerung.

Video ansehen oder schriftliche Anleitung unten lesen.

Überblick

Roboter: 4 Freiheitsgrade, 4 NEMA-17-Schrittmotoren. Zusätzlich kleiner Servo für Endeffektor (Greifer). Gehirn: Arduino UNO + CNC-Shield + 4× A4988 Schrittmotortreiber.

DIY SCARA-Roboter mit Arduino bauen – Schritt-für-Schritt-Anleitung

GUI in Processing mit Forward & Inverse Kinematics:

Forward Kinematics: Gelenkwinkel manuell einstellen (Slider links) → Endeffektor-Position (X, Y, Z) wird berechnet & rechts angezeigt.
Inverse Kinematics: Gewünschte Endeffektor-Position (X, Y, Z) eingeben → Programm berechnet Gelenkwinkel automatisch.

Beide Modi gleichzeitig auf einem Bildschirm nutzbar – Winkel & Position immer synchron sichtbar.

Automatikbetrieb: „Save“ speichert Positionen/Bewegungen, „Run“ führt sie in Endlosschleife aus. Geschwindigkeit & Beschleunigung in GUI einstellbar.

SCARA-Roboter 3D-Modell

3D-Modell ansehen:

Entworfen mit 3DEXPERIENCE SOLIDWORKS (Video-Sponsor).

3DEXPERIENCE SOLIDWORKS = SOLIDWORKS + Cloud über 3DEXPERIENCE-Plattform. Daten/Modelle weltweit jederzeit zugänglich. Produktivitäts- & Management-Apps inklusive.

Beispiele: Project Planner (Aufgaben, Deadlines), 3D Markup (Modelle auf jedem Gerät ansehen/kommentieren). Browser-Modellierer SOLIDWORKS xDesign – modellieren überall, jedes Gerät.

Danke an SolidWorks für Bildungs-Sponsoring. Test-Links:

Kostenlos testen: www.solidworks.com/HTMTryNow

Mehr erfahren: www.solidworks.com/HTMLearnMore

Design-Ziel: Maximale 3D-Druckbarkeit. Alle Teile druckbar auch auf kleinen Druckbetten (z. B. Ender 3). GT2-Riemenscheiben parametrisch designed – Zahzahl ändern → alle Maße aktualisieren automatisch.

1. Gelenk: 20:1 Übersetzung in 2 Stufen (Custom-Pulleys). 2 GT2-Riemen (Endlos, 200 & 300 mm). Gelenke: 2 Axiallager + 1 Radiallager.

2. Gelenk: 16:1 (gleiches Prinzip). 3. Gelenk: 4:1 (einstufig). Gelenke hohl → Kabeldurchführung (Motoren, Mikroschalter). Riemenspannung: Slots für Umlenkrollen.

Greifer: MG996R-Servo, austauschbare Greiferbacken für verschiedene Größen. Z-Achse: 8-mm-Trapezgewindespindel, Arm-Gleitführung auf 4× 10-mm-Präzisionswellen + Linearkugellager. Höhe = Wellenlänge (hier 40 cm). Spindel 2 cm kürzer oder Z-Motor per Distanzhülsen 2 cm höher.

3D-Modell auf Thangs finden, erkunden, herunterladen:

Assembly-3D-Modell bei Thangs herunterladen.

STL-Dateien für 3D-Druck:

Roboter-Teile 3D-drucken

Gedruckt auf Creality CR-10 (günstig, gut). Teile passen auf kleine Betten (Ender 3).

Meist PLA+ (blau), normale PLA für Pulleys & Greifer. ~120 h Druckzeit @ 60 mm/s. Basis größtes Teil (~32 h). Höhere Geschwindigkeit → schneller.

Siehe auch: Beste 3D-Drucker für Einsteiger & Maker [2021 Update]

Alle 3D-gedruckten Teile:

Hinweis: Horizontal Expansion −0,1 mm im Slicer aktiviert → maßhaltigere Teile, bessere Passung zu Lagern, Wellen, Schrauben.

Roboter zusammenbauen

Mechanik-Teileliste (Elektronik siehe Schaltplan):

4× Präzisionswelle 10 mm, 400 mm ……… Amazon / Banggood / AliExpress
1× Trapezgewindespindel 8 mm, 400 mm ………………… Amazon / Banggood / AliExpress
4× Linearlager 10 mm …………………..……. Amazon / Banggood / AliExpress
1× Axiallager 40×60×13 mm …..… Amazon / AliExpress
2× Axiallager 35×52×12 mm …..… Amazon / AliExpress
5× Radiallager 8×22×7 mm ……………. Amazon / Banggood / AliExpress
Diverse M3, M4, M5 Schrauben & Muttern

Benötigte Schraubenlängen:

Basis: Radiallager (35/47 mm) einsetzen. Dann 1. Axiallager (40/60 mm) zwischen Pulley & Basis.

Basis-Unterseite: 2. Axiallager (40/60 mm) + Gelenkkupplung.

Pulley & Oberteil mit 4× M4×55 mm verschrauben. Selbstsichernde Muttern, fest aber frei drehbar.

Mittlerer Pulley: Mit Gelenk-Pulley per 300-mm-GT2-Riemen gekoppelt. 2× 608-Lager (oben/unten Basis), M8×45 mm Schraube + Unterlegscheibe + Selbstsichernde Mutter.

Schrittmotor 1. Gelenk: Kupplung mit mittlerem Pulley per 200-mm-Riemen. 4× M3-Schrauben an Basis. Vor Anziehen: Riemen maximal spannen. M8-Schraube für mittleren Pulley später mit Kopf nach unten (Platz in Basis).

Riemenspannung prüfen. Bei Bedarf Umlenkrollen (Slots an Riemen) nutzen. Ich: M5×35 mm + Muttern als Spannrolle.

Beidseitig gespannt. 1. Gelenk fertig.

Endschalter 1. Gelenk: Vor Montage Kabel anlöten (eng danach). M3×20 mm + Mutter. Kupplung nah am Schalter → nur 1 Schraube, 2. Loch: kürzere Schraube + Kleben.

Z-Achse: Auf Gelenkkupplung Z-Achsen-Bodenplatte schrauben. 4 Klemmen für Präzisionswellen drauf. Wellen einsetzen (Presspassung, bis auf Kupplung). Klemmen mit M4 anziehen.

Spindellager einsetzen. Abdeckkappe aufschieben (sauberer Look).

1. Arm: 2 Teile, verschraubt. 1. Teil: Linearlager für Wellen (Presspassung, evtl. schwer). Druckgenauigkeit entscheidend → Horizontal Expansion an Drucker anpassen. Bei mir: 2 Lager nicht ganz durchgängig, aber ok.

2 Arm-Teile verbinden: 4× M5×25 mm.

Schrittmotor 2. Gelenk: 3D-gedruckter GT2-Pulley (20 Zähne, parametrisch). Spindelmutter sichern.

Riemen & Pulleys 2. Gelenk: 400 mm & 300 mm (wie 1. Gelenk). Kleinere Lager: Radial 30/42 mm, Axial 35/52 mm.

Vor 2. Gelenkkupplung: 6× M4×20 mm in Sechskantnuten (für 2. Arm Befestigung).

Riemenspannung notfalls per Umlenkrollen. 2. Endschalter montieren. 1. Arm fertig.

2. Arm an Gelenkkupplung: Vorher eingesetzte Schrauben in Kupplung nutzen für Oberteil-Befestigung.

Spiel-Test: Erwartetes Riemenspiel OK, aber starkes Spiel zwischen Gelenkteilen. Ursache: Bohrungen etwas größer als Schrauben. Lösung: Passung enger.

Bei mir: 4,5-mm-Bohrer → M5 statt M4. 3D-Modell aktualisiert: Bohrungen 3,5 mm → M4 passt. Auch 1. Gelenk nachgebessert. Spiel fast weg (nur Riemen-Backlash).

2. Arm (unterer Teil): Schrittmotor 3. Gelenk (kürzerer NEMA 17, 24 cm, leichter).

Riemen/Pulley 3. Gelenk: einstufig 4:1, 400-mm-Riemen. Vor Montage unterer Armteil: Motor- & Endschalterkabel durch 2. Gelenk führen.

Endeffektor-Kabel (4-adrig aus Schrittmotorkabel, Servo braucht 3) einziehen.

M4-Muttern in Oberarm-Slots für untere Arm-Befestigung.

Kabel vor Verschrauben unter Haken führen (weg von bewegten Teilen).

Kabel aus 2. Gelenk können an Pulley-Muttern hängenbleiben → simpler Kabelhalter gedruckt.

Kabel einseitig führen (kein Kontakt zu Bewegungen). 1. Arm-Abdeckung (Snap-Fit) drauf.

Arm-Montage fertig. Gesamte Arm-Assembly auf Z-Achsen-Wellen schieben.

Z-Achsen-Top-Platte: Endschalter Z + 4 Klemmen an Platte.

Vor Top-Platte: Abdeckkappe (wie unten) aufschieben. Dann Top-Platte auf Wellen & per Klemmen festziehen.

Trapezgewindespindel einsetzen (meine: 38 cm, mit Metallsäge gekürzt). 4. Schrittmotor montieren: 5-auf-8-mm-Wellenkupplung Motor↔Spindel.

Kabel durch Abdeckung, diese mit 2 Schrauben an Top-Platte.

Kabelmanagement: Kabelschläuche + Kabelbinder. Vorher Kabel markieren (Verpolungsschutz).

Endeffektor (Greifer): MG996R-Servo, 2× 6-mm-Stangen für Gleitbacken.

Gleitbacken ↔ Servo: Servohorn, 3D-gedruckte Gestänge, M3-Schrauben/Muttern. Gesamter Greifer M3. Vollständige Schraubenliste im Web-Artikel. Enger Bauraum → Geduld nötig.

Vorteil: Greiferbacken einfach tauschbar (breiter, schmaler, Form). Greifer per M4 an Arm.

Servo an vorbereitete Kabel anschließen. Mechanik fertig – jetzt Elektronik.

SCARA-Roboter Schaltplan

Arduino UNO + CNC-Shield + 4× A4988.

Alternativ: Arduino MEGA + RAMPS 1.4 (3D-Drucker-Controller).

Arduino UNO Gehäuse (3D-Druck) an Basis. 1/4-Schritt (Quarter-Stepping) → Jumper gesetzt. Schrittmotoren & Endschalter an CNC-Shield.

Schaltplan:

Komponenten:

Schrittmotor – NEMA 17………………
A4988 Schrittmotortreiber…………………..…
Arduino CNC Shield ………………………. Amazon / Banggood / AliExpress
Arduino Uno………………………………..…
MG996R Servo………………….….
Endschalter …………………………………. Amazon / Banggood / AliExpress
DC-Netzteil …………………………. Amazon / Banggood / AliExpress

Netzteil: 12 V, mind. 4 A (empfohlen 6 A). Abhängig von Treiber-Strombegrenzung – möglichst niedrig einstellen.

Kabel in Gehäuse verstauen, Kühlkörper frei lassen, Deckel drauf.

Montage abschließen

Roboter fertig – Basis befestigen. 20-mm-Holzplatte. Roboter-Basis: 12 Befestigungslöcher. Basis-Zeichnung ausgedruckt → Löcher in Holz bohren.

Unterseitig versenken (Senkkopfschrauben bündig). M4-Muttern in Basis-Slots, Holzplatte an Roboter-Basis schrauben.

Ideal: Am Tisch verschrauben. Ich: Schraubzwingen.

SCARA-Roboter mechanisch komplett. Jetzt Funktion testen.

Siehe auch: DIY Arduino Roboterarm mit Smartphone-Steuerung

Funktionsweise des SCARA-Roboters

Zwei Positioniermethoden: Vorwärts- & Inverse Kinematik.

Forward Kinematics: Endeffektor-Position & Orientierung aus gegebenen Gelenkwinkeln berechnen.

Inverse Kinematics: Gelenkwinkel für gegebene Endeffektor-Position berechnen. Sinnvoller für Robotik: Werkzeug auf bestimmte X/Y/Z koord. positionieren.

Gleichungen basieren auf Trigonometrie.

SCARA-Roboter programmieren – Arduino & Processing Code

Codes am Artikelende.

Forward Kinematik in Processing:

// FORWARD KINEMATICS void forwardKinematics() { float theta1F = theta1 * PI / 180; // degrees to radians float theta2F = theta2 * PI / 180; xP = round(L1 * cos(theta1F) + L2 * cos(theta1F + theta2F)); yP = round(L1 * sin(theta1F) + L2 * sin(theta1F + theta2F)); }

X, Y aus Gelenkwinkeln theta1, theta2 & Armlängen L1, L2.

Inverse Kinematik: Gelenkwinkel theta2, theta1 aus X, Y.

/ INVERSE KINEMATICS void inverseKinematics(float x, float y) { theta2 = acos((sq(x) + sq(y) - sq(L1) - sq(L2)) / (2 * L1 * L2)); if (x < 0 & y < 0) { theta2 = (-1) * theta2; } theta1 = atan(x / y) - atan((L2 * sin(theta2)) / (L1 + L2 * cos(theta2))); theta2 = (-1) * theta2 * 180 / PI; theta1 = theta1 * 180 / PI; // Angles adjustment depending in which quadrant the final tool coordinate x,y is if (x >= 0 & y >= 0) { // 1st quadrant theta1 = 90 - theta1; } if (x < 0 & y > 0) { // 2nd quadrant theta1 = 90 - theta1; } if (x < 0 & y < 0) { // 3d quadrant theta1 = 270 - theta1; phi = 270 - theta1 - theta2; phi = (-1) * phi; } if (x > 0 & y < 0) { // 4th quadrant theta1 = -90 - theta1; } if (x < 0 & y == 0) { theta1 = 270 + theta1; } // Calculate "phi" angle so gripper is parallel to the X axis phi = 90 + theta1 + theta2; phi = (-1) * phi; // Angle adjustment depending in which quadrant the final tool coordinate x,y is if (x < 0 & y < 0) { // 3d quadrant phi = 270 - theta1 - theta2; } if (abs(phi) > 165) { phi = 180 + phi; } theta1=round(theta1); theta2=round(theta2); phi=round(phi); cp5.getController("j1Slider").setValue(theta1); cp5.getController("j2Slider").setValue(theta2); cp5.getController("j3Slider").setValue(phi); cp5.getController("zSlider").setValue(zP); }

Quadranten-Korrekturen via if-Statements. 3. Winkel „phi“ = Greifer-Orientierung (parallel zu X-Achse).

GUI via controlP5 Library (Processing): Buttons, Slider, Textfelder einfach erstellen.

Links: Slider für Gelenkwinkel. Rechts: Textfelder für Zielposition. Jede Aktion → Daten per Serial an Arduino.

if (gripperValuePrevious != gripperValue) { if (activeIK == false) { // Check whether the inverseKinematics mode is active, Executre Forward kinematics only if inverseKinematics mode is off or false gripperAdd = round(cp5.getController("gripperValue").getValue()); gripperValue=gripperAdd+50; updateData(); println(data); myPort.write(data); } }

Datenstring: Save/Run-Status, Gelenkwinkel (3), Z-Pos, Greiferwert, Speed, Acceleration.

public void updateData() { data = str(saveStatus) +","+str(runStatus) +","+str(round(cp5.getController("j1Slider").getValue())) +","+str(round(cp5.getController("j2Slider").getValue())) +","+str(round(cp5.getController("j3Slider").getValue())) +","+str(round(cp5.getController("zSlider").getValue())) +","+str(gripperValue) +","+str(speedSlider) +","+str(accelerationSlider); }

Arduino: String parsen → Array data[].

if (Serial.available()) { content = Serial.readString(); // Read the incomding data from Processing // Extract the data from the string and put into separate integer variables (data[] array) for (int i = 0; i < 10; i++) { int index = content.indexOf(","); // locate the first "," data[i] = atol(content.substring(0, index).c_str()); //Extract the number from start to the "," content = content.substring(index + 1); //Remove the number from the string } /* data[0] - SAVE button status data[1] - RUN button status data[2] - Joint 1 angle data[3] - Joint 2 angle data[4] - Joint 3 angle data[5] - Z position data[6] - Gripper value data[7] - Speed value data[8] - Acceleration value */

SAVE gedrückt → aktuelle Winkel in Arrays speichern (in Steps: Winkel × AngleToSteps).

// If SAVE button is pressed, store the data into the appropriate arrays if (data[0] == 1) { theta1Array[positionsCounter] = data[2] * theta1AngleToSteps; //store the values in steps = angles * angleToSteps variable theta2Array[positionsCounter] = data[3] * theta2AngleToSteps; phiArray[positionsCounter] = data[4] * phiAngleToSteps; zArray[positionsCounter] = data[5] * zDistanceToSteps; gripperArray[positionsCounter] = data[6]; positionsCounter++; }

RUN gedrückt → gespeicherte Steps abfahren.

Schrittmotoren via AccelStepper Library. Limitation: Bei Multi-Stepper keine Beschleunigung/Rampen (wichtig für sanfte Bewegung). Workaround implementiert, aber nicht perfekt smooth.

stepper1.moveTo(stepper1Position); stepper2.moveTo(stepper2Position); stepper3.moveTo(stepper3Position); stepper4.moveTo(stepper4Position); while (stepper1.currentPosition() != stepper1Position || stepper2.currentPosition() != stepper2Position || stepper3.currentPosition() != stepper3Position || stepper4.currentPosition() != stepper4Position) { stepper1.run(); stepper2.run(); stepper3.run(); stepper4.run(); }

Vollständige Arduino & Processing Codes im Artikel.

Fazit

Code auf Arduino, Processing starten, Strom an → Roboter fährt in Home-Position.

Dann: Manuell spielen oder Automatik. Beliebigen Endeffektor anbaubar: 3D-Drucker-Hotend → 3D-Drucker, Laser → Lasercutter (geplant für zukünftige Videos – Kanal abonnieren!).

Anmerkungen: Roboter nicht so steif wie erhofft.

Problem: Ganzer Arm & Z-Achse nur über 1. Gelenk abgestützt. Gewicht + Trägheitskräfte → Basis (Kunststoff) biegt durch. Riemen haben Backlash → weitere Steifigkeitsreduktion. Aber: Projekt gut zum Lernen von SCARA-Prinzipien & Mutmacher für Eigenbau.

Fragen in Kommentaren, Arduino-Projekte-Sammlung anschauen.