Robotik · Eigenentwicklung

ArmControl –
ich habe einen Roboterarm zum Leben erweckt

Aus einem China-Bausatz mit drei Schrittmotoren und einer Linearschiene ist ein voll steuerbarer Roboterarm geworden – mit eigener Firmware, inverser Kinematik, 3D-Simulation und einer Weboberfläche, mit der ich Punkte und Bahnen speichern und abfahren kann. Unten kannst du den Arm direkt ausprobieren.

Arduino Mega 2560 RAMPS 1.4 4 Achsen + Schiene Python-Backend Inverse Kinematik Eigene C++-Firmware
Interaktiv

Steuere den Arm – direkt hier im Browser

Das ist dieselbe inverse Kinematik wie in der echten Software: Du gibst ein Ziel vor, der Rechner bestimmt die Gelenkwinkel. Zieh mit dem Finger oder der Maus, um die Ansicht zu drehen, und steuere den Arm mit den Reglern oder Buttons. Kein Server, keine Installation – alles läuft live.

TCP
Gelenke
⚠ außerhalb der Reichweite
Ziehen = drehen · Mausrad = zoom

Zielposition (kartesisch)

Jog

Werkzeug & Demo

Bereit.
Was drinsteckt

Vom Bausatz zur echten Steuerung

Die Original-Software des Bausatzes war eine simple Fernbedienung. Ich habe alles neu gebaut – Firmware und PC-Software – damit der Arm wirklich das tut, was er soll.

Inverse Kinematik

Ich gebe kartesische X/Y/Z-Koordinaten in Millimetern ein – die Software rechnet daraus die Gelenkwinkel und fährt echte Linearbahnen, unterteilt in feine Segmente.

3D-Simulation

Eine live mitlaufende 3D-Ansicht zeigt jederzeit, wie der Arm gerade steht – drehbar, zoombar, komplett selbst gerendert ohne externe Bibliotheken.

Punkte & Bahnen

Positionen speichern, benennen und wieder anfahren. Aus Wegpunkten, Pausen und Greifer-Aktionen lassen sich ganze Abläufe zusammenbauen und in Schleife abspielen.

Sicherheit

Eigene Firmware mit Endschalter-Überwachung während jeder Fahrt, Software-Verfahrgrenzen gegen Anschläge und ein echter Not-Aus per Tastendruck.

Lichtschranke

Für die Drehachse habe ich den mechanischen Endschalter durch eine optische Lichtschranke ersetzt – inklusive passend konfigurierter Signal-Logik in der Firmware.

Reverse Engineering

Das Kommunikations-Protokoll der Original-Firmware habe ich per Disassembly entschlüsselt – Grundlage, um es später durch eine komplett eigene Firmware zu ersetzen.

Technik

Der Stack

Bewusst schlank gehalten: läuft lokal, ohne Cloud, ohne schwere Abhängigkeiten.

Hardware: Arduino Mega 2560 + RAMPS 1.4, 3× Schrittmotor + Linearspindel
Firmware: C++ / Arduino, AccelStepper, eigener G-Code-Parser
Backend: Python (Standardbibliothek), pyserial, HTTP + Server-Sent-Events
Frontend: reines HTML / CSS / JavaScript, Canvas-3D
Mathematik: Inverse & Vorwärtskinematik, Bahn-Interpolation
Elektronik

Alle Verbindungen auf einen Blick

Das Herz ist ein Arduino Mega 2560 mit einem RAMPS-1.4-Shield – die klassische Plattform für Motorsteuerung. Drei Schrittmotoren treiben die Gelenke, ein vierter die Linearschiene. Besonderheit: An der Drehachse sitzt statt eines mechanischen Endschalters eine optische Lichtschranke, damit die Achse im Zweifel gefahrlos durchdrehen kann.

Komplette Verkabelung des Roboterarms
Vollständige Verkabelung: Motoren, Endschalter/Lichtschranke, Bluetooth, Spannungsversorgung.
FunktionAnschluss (RAMPS)Pin
Oberarm-Gelenk (X)Treiber-SteckplatzSTEP/DIR/EN
Unterarm-Gelenk (Y)Treiber-SteckplatzSTEP/DIR/EN
Drehachse (Z)Treiber-SteckplatzSTEP/DIR/EN
Linearschiene (E)E0-TreiberSTEP/DIR/EN
Endschalter OberarmX-minD3
Endschalter UnterarmY-minD14
Lichtschranke DrehachseZ-min (S/−/+)D18
Greifer / Sauger / LüfterFET-AusgängeD10 / D9 / D8
SpannungsversorgungNetzteil12 V DC
Mathematik

Inverse Kinematik – wie der Arm „weiß", wohin

Ich möchte einen Punkt im Raum angeben – der Arm soll seine Gelenke selbst passend stellen. Das ist die inverse Kinematik. Der Arm ist eine klassische Zwei-Gelenk-Kette auf einem Drehteller, dadurch lässt sie sich exakt in geschlossener Form lösen.

Grundplatte / Schiene Höhe h₀ a b Schulter Ellbogen Ziel (TCP) Reichweite r Höhe z

So wird gerechnet

Zuerst dreht sich der Teller so, dass der Zielpunkt in der Armebene liegt. Der Drehwinkel folgt direkt aus den Seitwärts- und Vorwärts-Anteilen:

Basis = atan2( X , Y )

In dieser Ebene bleibt ein Zwei-Gelenk-Problem: Reichweite r und Höhe z ergeben die direkte Distanz d zum Ziel. Mit dem Kosinussatz fallen daraus die beiden Armwinkel:

d = √( r² + z² )
Ellbogen = acos( (a² + b² − d²) / (2ab) )
Schulter = atan2( z , r ) + acos( (a² + d² − b²) / (2ad) )

Liegt d größer als a + b (zu weit) oder kleiner als |a − b| (zu nah), ist der Punkt unerreichbar – dann verweigert die Software die Fahrt, statt gegen einen Anschlag zu laufen.

Umgekehrt rechnet die Vorwärtskinematik aus gemessenen Gelenkwinkeln die tatsächliche Position zurück – so weiß die 3D-Ansicht immer, wo der Arm wirklich steht. Beide Richtungen habe ich gegeneinander geprüft: Die Rückrechnung stimmt auf unter ein tausendstel Millimeter.

Handbuch

Technisches Handbuch

Von der Installation bis zum ersten Programm – kompakt zusammengefasst.

1 · Software starten

Python 3 installieren, einmalig pip install pyserial, dann Start_Windows.bat. Der Browser öffnet die Oberfläche unter localhost:8000 – komplett lokal, keine Cloud.

2 · Firmware flashen

In der Arduino IDE die Bibliothek AccelStepper installieren, RobotArmFW.ino öffnen, Board „Mega 2560" wählen und hochladen. Die Werks-Firmware bleibt als Sicherung.

3 · Verbinden & prüfen

Port wählen, verbinden. Mit M119 die Endschalter testen – bei der Lichtschranke soll „unterbrochen = 1" erscheinen. Erst danach kleine Jog-Schritte fahren.

4 · Referenzfahrt

Mit G28 fährt jede Achse ihren Endschalter an (grob → Rückzug → fein) und setzt den Nullpunkt. Jederzeit abbrechbar per Not-Aus (Leertaste, Button oder !).

5 · Kalibrieren

Je Achse eine bekannte Strecke fahren, nachmessen, „Schritte pro Einheit" anpassen. Danach stimmen die kartesischen Millimeter maßstabsgetreu.

6 · Sicherheit

Endschalter-Überwachung während jeder Fahrt, Software-Verfahrgrenzen gegen Anschläge, unerreichbare Ziele werden abgelehnt, echter Not-Aus stoppt sofort alles.

Befehlsreferenz (G-Code)

BefehlFunktion
G0 / G1 X Y Z E FGelenk-/Achsbewegung (koordiniert, mit Rampen)
G4 S<s>Pause / Wartezeit
G28 [X Y Z]Referenzfahrt (abbrechbar)
G90 / G91Absolut- / Relativmodus
G92 X Y Z Eaktuelle Position setzen
M17 / M18Motoren ein / aus
M42 P<pin> S<0..255>Ausgang schalten (Greifer/Sauger/Lüfter)
M112 oder !Not-Aus – stoppt sofort alles
M114Position ausgeben
M119Endschalter-Zustände ausgeben

Die vollständige Anleitung inklusive Kalibrierung liegt dem Download als FIRMWARE_ANLEITUNG.md und LIESMICH.md bei.

Galerie

Der Arm in verschiedenen Posen

Aus der 3D-Simulation – so wird jede Gelenkstellung live dargestellt.

Ein Blick in den Code

Inverse Kinematik, das Herzstück

Aus einem Zielpunkt im Raum werden die drei Gelenkwinkel berechnet – klassische Zwei-Gelenk-Trigonometrie plus Basisdrehung.

server.py – inverse Kinematik
def ik(x, y, z, geo):
    # kartesisch -> Gelenkwinkel (Rückgabe: Winkel oder None)
    a, b = geo["lower_arm"], geo["upper_arm"]
    base = math.degrees(math.atan2(x, y))            # Basisdrehung
    r  = math.hypot(x, y) - geo["tool_offset_h"]     # Reichweite
    zz = z - geo["base_height"]                     # Höhe über Schulter
    d  = math.hypot(r, zz)
    if d > a + b or d < abs(a - b):
        return None                                 # nicht erreichbar
    q2       = math.acos((a*a + d*d - b*b) / (2*a*d))
    shoulder = math.atan2(zz, r) + q2                # Unterarm
    elbow    = math.acos((a*a + b*b - d*d) / (2*a*b))
    upper    = shoulder + elbow - math.pi            # Oberarm absolut
    return {"z": base, "y": deg(shoulder), "x": deg(upper)}
Orientierung

Welche Achse ist welche?

X, Y und Z bedeuten hier an zwei Stellen etwas Verschiedenes – als Koordinate im Raum und als Gelenkname im G-Code. Das ist die häufigste Stolperstelle beim Arbeiten mit dem Arm. Klick auf eine Zeile, um die Achse hervorzuheben.

BuchstabeAls Koordinate (Eingabefelder, kartesischer Jog) Als Gelenk (G-Code, Gelenk-Jog, Firmware)
Xlinks / rechts in mmOberarm-Absolutwinkel in Grad
Yvor / zurück in mmUnterarmwinkel über Horizont in Grad
ZHöhe in mm Basisdrehung in Grad
ESchiene in mm
Der klassische Fehlgriff.

Ein G1 Z50 fährt nicht 50 mm nach oben – es dreht die Basis auf 50°. Wer in die Höhe will, nutzt den kartesischen Jog oder die Koordinateneingabe; die schicken die Zielposition durch die inverse Kinematik und erzeugen daraus erst die Gelenkwinkel.

Inverse Kinematik

Warum eine Gerade Rechenarbeit ist

Zwei Punkte, dazwischen eine gerade Linie – für einen Menschen selbstverständlich, für einen Gelenkarm nicht. Fährt man die Gelenke einfach gleichmäßig von Start- auf Zielwinkel, beschreibt die Spitze einen Bogen. Für eine echte Gerade muss die Bahn in kleine Schritte zerlegt und für jeden einzelnen die inverse Kinematik gerechnet werden – genau das macht move_cart(linear=True) in der Software, mit cart_step als Schrittweite.

X
Y
Z
X
Y
Z
Strecke
Schritte
Bahn erreichbar
Größter Gelenksprung
Bogenfehler ohne IK

Draufsicht · X / Y

Seitenansicht · Reichweite / Höhe

Gelenkwinkel entlang der Bahn

Linearfahrt mit IK – echte Gerade Gelenkinterpolation – Bogen unerreichbar
Open Source

Projekt herunterladen

Firmware, Steuerungssoftware und Anleitungen – alles in einem Paket. Läuft auf jedem PC mit Python; die Firmware lädst du über die Arduino IDE auf den Controller.

⭳ ArmControl.zip anfragen
enthält: server.py · static/index.html · firmware/RobotArmFW.ino · Anleitungen · Doku
Download auf Anfrage – anmelden und freischalten lassen.

Fragen zu diesem Projekt?

Wie etwas gebaut ist, warum es so gebaut ist, ob es sich auf einen anderen Fall übertragen lässt – schreib einfach. Die Nachricht geht als E-Mail an mich, sonst passiert damit nichts.

Rechenaufgabe Rechenaufgabe als Bild

Kein Google-Captcha, keine Weitergabe an Dritte, keine Cookies. Die Rechenaufgabe wird von diesem Server gezeichnet und geprüft. Wenn sie nicht lesbar ist oder das Formular klemmt: info@timobritz.de geht genauso.