Robotik · Eigenentwicklung

ArmControl:
Roboterarm mit eigener Steuerung

Timo Britz hat aus einem Bausatz einen voll steuerbaren Roboterarm gemacht, mit eigener Firmware, inverser Kinematik, 3D-Simulation und einer Weboberfläche für Punkte und Bahnen.

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

Der Arm, bedienbar im Browser

Dieselbe inverse Kinematik wie in der echten Software: Ziel vorgeben, der Rechner stellt die Gelenke.

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 war eine simple Fernbedienung. Timo Britz hat Firmware und PC-Software neu gebaut.

Inverse Kinematik

X, Y und Z in Millimetern eingeben, die Software rechnet die Gelenkwinkel. Der Greifer bleibt waagerecht.

3D-Simulation

Eine mitlaufende 3D-Ansicht zeigt jederzeit die Stellung des Arms, selbst gerendert ohne Bibliotheken.

Punkte & Bahnen

Positionen speichern und anfahren. Aus Wegpunkten, Pausen und Werkzeug-Aktionen entstehen ganze Abläufe, auch in Schleife.

Sicherheit

Fahrten enden vor den mechanischen Anschlägen, unerreichbare Ziele werden abgelehnt. STOP hält an, der Not-Aus schaltet die Motoren ab.

Lichtschranke

An der Drehachse ersetzt eine Lichtschranke den mechanischen Endschalter.

Reverse Engineering

Das Protokoll der Original-Firmware wurde per Disassembly entschlüsselt. Heute läuft eine komplett eigene Firmware.

Einmess-Assistent

Zehn geführte Schritte prüfen Endschalter und Drehrichtungen und messen den Arm ein.

Achsgleichlauf

Alle Achsen starten und stoppen gemeinsam, keine eilt voraus.

WLAN-Brücke

Optional ersetzt ein ESP32 das USB-Kabel.

Technik

Der Stack

Läuft lokal, ohne Cloud und ohne schwere Abhängigkeiten.

Hardware: Arduino Mega 2560 + RAMPS 1.4, 3× Schrittmotor + Linearspindel, optional ESP32 als WLAN-Brücke
Firmware: C++ / Arduino, AccelStepper, eigener G-Code-Parser
Backend: Python, pyserial, HTTP + Server-Sent-Events
Frontend: HTML / CSS / JavaScript, Canvas-3D
Mathematik: Inverse & Vorwärtskinematik für das Parallelogramm-Getriebe, Achsgleichlauf
Elektronik

Alle Verbindungen auf einen Blick

Ein Arduino Mega 2560 mit RAMPS-1.4-Shield steuert drei Schrittmotoren für die Gelenke und einen für die Schiene. An der Drehachse sitzt statt eines Endschalters eine Lichtschranke, damit die Achse gefahrlos durchdrehen kann.

Komplette Verkabelung des Roboterarms
Verkabelung: Motoren, Endschalter, Lichtschranke, Bluetooth, Stromversorgung.
FunktionAnschluss (RAMPS)Pin
Hauptarm (X, 1. Gelenk)Y-Treiber-SteckplatzSTEP/DIR/EN
Vorderarm (Y, 2. Gelenk)X-Treiber-SteckplatzSTEP/DIR/EN
Drehachse (Z)Z-Treiber-SteckplatzSTEP/DIR/EN
Linearschiene (E)E0-TreiberSTEP/DIR/EN
Endschalter VorderarmX-minD3
Endschalter HauptarmY-minD14
Lichtschranke DrehachseZ-min (S/−/+)D18
Greifer / Sauger / LüfterFET-AusgängeD9 / D10 / D8
ESP32-WLAN-Brücke (optional)AUX-4 (Serial2)D16 TX2 / D17 RX2
SpannungsversorgungNetzteil12 V DC
Mathematik

Wie der Arm zielt

Ein Punkt im Raum wird vorgegeben, der Arm stellt seine Gelenke selbst: Das ist inverse Kinematik. Für diese Zwei-Gelenk-Kette auf einem Drehteller gibt es eine exakte Lösung.

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

So wird gerechnet

Zuerst dreht sich der Teller, bis das Ziel in der Armebene liegt:

Basis = atan2( X , Y )

Reichweite r und Höhe z ergeben die Distanz d. Der Kosinussatz liefert die Armwinkel:

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

Ist d größer als a + b oder kleiner als |a − b|, ist das Ziel unerreichbar. Die Software fährt dann nicht los.

Die Vorwärtskinematik rechnet aus den Gelenkwinkeln die echte Position zurück. So zeigt die 3D-Ansicht immer, wo der Arm steht.

Handbuch

Technisches Handbuch

Von der Installation bis zum ersten Programm.

1 · Software starten

Python 3 installieren, einmalig pip install pyserial, dann Start_Windows.bat. Die Oberfläche öffnet sich im Browser unter localhost:8000.

2 · Firmware flashen

In der Arduino IDE die Bibliothek AccelStepper installieren, RobotArmFW.ino öffnen, Board „Mega 2560“ wählen und hochladen.

3 · Verbinden & prüfen

Port wählen (USB oder „ESP32-Brücke“) und verbinden. Mit M119 die Endschalter testen. Die Lichtschranke zeigt „unterbrochen = 1“. Erst dann kleine Jog-Schritte fahren.

4 · Referenzfahrt

Mit G28 fährt jede Achse an ihren Endschalter und setzt den Nullpunkt. Abbruch per STOP (Knopf oder !) oder Not-Aus (Leertaste).

5 · Einmessen

Der Assistent führt in zehn Schritten durch das Einmessen. Danach werden die Grenzen vor den Anschlägen angelernt.

6 · Sicherheit

Fahrten enden vor den eingemessenen Grenzen, unerreichbare Ziele werden abgelehnt. STOP hält an, die Motoren bleiben bestromt. Der Not-Aus schaltet sie ab.

Befehlsreferenz (G-Code)

BefehlFunktion
G0 / G1 X Y Z E F [S0]Achsbewegung, alle Achsen im Gleichlauf; S0 fährt sie unabhängig
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)
!STOP: bricht jede Bewegung ab, die Motoren bleiben bestromt
M112Not-Aus: stoppt sofort und schaltet die Motoren ab
M114Position ausgeben
M119Endschalter-Zustände ausgeben

Die ganze Anleitung liegt dem Download als FIRMWARE_ANLEITUNG.md und LIESMICH.md bei.

Galerie

Der Arm in verschiedenen Posen

Stellungen aus der 3D-Simulation.

Ein Blick in den Code

Inverse Kinematik, das Herzstück

Aus einem Zielpunkt werden die Gelenkwinkel berechnet: Zwei-Gelenk-Trigonometrie plus Basisdrehung.

server.py: inverse Kinematik (gekürzt)
def cart_to_joints(self, x, y, z, e):
    # Weltkoordinaten [mm] -> Gelenkwinkel des Parallelogramm-Arms
    a, b = g["lower_arm"], g["upper_arm"]
    dx   = x - e                                  # Arm-Basis sitzt auf der Schiene
    base = math.degrees(math.atan2(dx, y))        # Basisdrehung
    r = math.hypot(dx, y) - g["tool_offset_h"]                  # Reichweite
    h = z + g["tool_offset_v"] - g["base_height"]      # Höhe über Schulter
    d = math.hypot(r, h)
    if d > a + b:
        raise ValueError("Punkt zu weit weg")
    th1 = math.atan2(h, r) + math.acos((a*a + d*d - b*b) / (2*a*d))  # Hauptarm
    th2 = math.atan2(h - a*math.sin(th1), r - a*math.cos(th1))   # Vorderarm, absolut
    # … Winkelgrenzen und Scherenwinkel prüfen, in Gelenk-Einheiten umrechnen
    return joints, angles
Orientierung

Welche Achse ist welche?

X, Y und Z bedeuten als Koordinate etwas anderes als im G-Code. Ein Klick auf eine Zeile hebt die Achse hervor.

BuchstabeAls Koordinate Als Gelenk (G-Code)
Xlinks / rechts in mmHauptarm-Winkel (Gelenk 1)
Yvor / zurück in mmVorderarm-Winkel (Gelenk 2)
ZHöhe in mm Basisdrehung
E-Schiene in mm
Der klassische Fehlgriff.

Ein G1 Z50 fährt nicht 50 mm nach oben, sondern dreht die Basis. Für die Höhe den kartesischen Jog oder die Koordinateneingabe nutzen.

Inverse Kinematik

Warum eine Gerade Rechenarbeit ist

Drehen sich alle Gelenke gleichmäßig, fährt die Spitze einen Bogen. Für eine echte Gerade wird die Bahn in kleine Schritte zerlegt und für jeden einzelnen die inverse Kinematik gerechnet. Die Vorführung zeigt beide Wege.

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
Quellcode auf Anfrage

Projekt herunterladen

Firmware, Steuerungssoftware und Anleitungen in einem Paket. Läuft auf jedem PC mit Python.

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

Kontakt

Fragen zur Bauweise, zu den Entscheidungen dahinter oder zur Übertragbarkeit auf einen anderen Fall.

Rechenaufgabe Rechenaufgabe als Bild

Ihre Angaben werden zur Beantwortung der Anfrage verarbeitet. Näheres in der Datenschutzerklärung.

Kein Google-Captcha, keine Cookies, keine Weitergabe an Dritte. Alternativ per E-Mail an info@timobritz.de.