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.
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.
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.
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.
Eine live mitlaufende 3D-Ansicht zeigt jederzeit, wie der Arm gerade steht – drehbar, zoombar, komplett selbst gerendert ohne externe Bibliotheken.
Positionen speichern, benennen und wieder anfahren. Aus Wegpunkten, Pausen und Greifer-Aktionen lassen sich ganze Abläufe zusammenbauen und in Schleife abspielen.
Eigene Firmware mit Endschalter-Überwachung während jeder Fahrt, Software-Verfahrgrenzen gegen Anschläge und ein echter Not-Aus per Tastendruck.
Für die Drehachse habe ich den mechanischen Endschalter durch eine optische Lichtschranke ersetzt – inklusive passend konfigurierter Signal-Logik in der Firmware.
Das Kommunikations-Protokoll der Original-Firmware habe ich per Disassembly entschlüsselt – Grundlage, um es später durch eine komplett eigene Firmware zu ersetzen.
Bewusst schlank gehalten: läuft lokal, ohne Cloud, ohne schwere Abhängigkeiten.
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.
| Funktion | Anschluss (RAMPS) | Pin |
|---|---|---|
| Oberarm-Gelenk (X) | Treiber-Steckplatz | STEP/DIR/EN |
| Unterarm-Gelenk (Y) | Treiber-Steckplatz | STEP/DIR/EN |
| Drehachse (Z) | Treiber-Steckplatz | STEP/DIR/EN |
| Linearschiene (E) | E0-Treiber | STEP/DIR/EN |
| Endschalter Oberarm | X-min | D3 |
| Endschalter Unterarm | Y-min | D14 |
| Lichtschranke Drehachse | Z-min (S/−/+) | D18 |
| Greifer / Sauger / Lüfter | FET-Ausgänge | D10 / D9 / D8 |
| Spannungsversorgung | Netzteil | 12 V DC |
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.
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:
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:
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.
Von der Installation bis zum ersten Programm – kompakt zusammengefasst.
Python 3 installieren, einmalig pip install pyserial, dann Start_Windows.bat.
Der Browser öffnet die Oberfläche unter localhost:8000 – komplett lokal, keine Cloud.
In der Arduino IDE die Bibliothek AccelStepper installieren,
RobotArmFW.ino öffnen, Board „Mega 2560" wählen und hochladen. Die Werks-Firmware bleibt als Sicherung.
Port wählen, verbinden. Mit M119 die Endschalter testen –
bei der Lichtschranke soll „unterbrochen = 1" erscheinen. Erst danach kleine Jog-Schritte fahren.
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 !).
Je Achse eine bekannte Strecke fahren, nachmessen, „Schritte pro Einheit" anpassen. Danach stimmen die kartesischen Millimeter maßstabsgetreu.
Endschalter-Überwachung während jeder Fahrt, Software-Verfahrgrenzen gegen Anschläge, unerreichbare Ziele werden abgelehnt, echter Not-Aus stoppt sofort alles.
| Befehl | Funktion |
|---|---|
| G0 / G1 X Y Z E F | Gelenk-/Achsbewegung (koordiniert, mit Rampen) |
| G4 S<s> | Pause / Wartezeit |
| G28 [X Y Z] | Referenzfahrt (abbrechbar) |
| G90 / G91 | Absolut- / Relativmodus |
| G92 X Y Z E | aktuelle Position setzen |
| M17 / M18 | Motoren ein / aus |
| M42 P<pin> S<0..255> | Ausgang schalten (Greifer/Sauger/Lüfter) |
| M112 oder ! | Not-Aus – stoppt sofort alles |
| M114 | Position ausgeben |
| M119 | Endschalter-Zustände ausgeben |
Die vollständige Anleitung inklusive Kalibrierung liegt dem Download als
FIRMWARE_ANLEITUNG.md und LIESMICH.md bei.
Aus der 3D-Simulation – so wird jede Gelenkstellung live dargestellt.
Aus einem Zielpunkt im Raum werden die drei Gelenkwinkel berechnet – klassische Zwei-Gelenk-Trigonometrie plus Basisdrehung.
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)}
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.
| Buchstabe | Als Koordinate (Eingabefelder, kartesischer Jog) | Als Gelenk (G-Code, Gelenk-Jog, Firmware) |
|---|---|---|
X | links / rechts in mm | Oberarm-Absolutwinkel in Grad |
Y | vor / zurück in mm | Unterarmwinkel über Horizont in Grad |
Z | Höhe in mm | Basisdrehung in Grad |
E | – | Schiene in mm |
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.
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.
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 anfragenWie 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.