5 DOF Roboterarm: Arduino-Programme für Kinematik u. inverse Kinematik?

[HaWe]

hallo,
ich vermute, es gibt nur sehr wenige, hoffe aber dennoch wenigstens ein paar hier im Forum, die sich damit auskennen und es auch schon benutzen:

Wer hat Erfahrung mit Arduino-Programmen für 5-6 DOF Roboterarme für Kinematik u. inverse Kinematik?
Literatur gibt es zwar zuhauf, aber extrem vermathematischt und mit irrsinnig viel Matrizenrechnung, die mich ehrlich gesagt überfordert, um sie in arduinisch zu programmieren.

In meinem Fall handelt es sich um diesen Robotarm hier (5 drehbare Achsen plus Greifer, die erste Ache (Schulter) und die letzte Achse (Handgelenk) vor dem Greifer sind rotierbar entlang der Auslenkung, die anderen knicken senkrecht zur Auslenkung) :

https://www.ebay.de/itm/Assembled-6D...53.m1438.l2649

Was das Ziel sein soll:
Nach Definition der Armlängen und Rotationsachs-Dimensionen (Knicken oder rotieren innerhalb der Achse) sollte man folgendes machen können:

a) Kinematik:
Wenn man eine beliebige Kombination von Drehwinkeln für jede einzelne Achse eingibt (alpha, beta, gamma, delta, epsilon), dann soll als Ergebnis die absolute Raumposition (x,y,z) errechnet werden (z.B. für die Greifer-Mitte);

b) Inverse Kinematik:
Nach Eingabe einer absoluten Ziel-Koordinate (x,y,z) z.B. für die Greifer-Mitte soll für alle Servos eine Lösung für die erforderlichen absoluten Drehwinkel berechnet werden, sodass man sie per analogWrite-pwm dann dorthin bewegen kann (es gibt u.U. mehrere Lösungen, welche man dann bekommt oder verwendet, wäre dann noch zu überlegen).

Wer kennt sich damit selber wirklich gut aus?

[Moppi]

Hmm, immer noch nicht weiter gekommen?

Ich kenne mich mit Deiner Problemstellung nicht aus. Aber ein Tipp von mir:
Die Position auf einer Kreisbahn kannst Du über den Radius berechnen. Stichwort: Berechnungen im Kreis oder Kreisberechnungen.
Damit kannst Du die Positionen ausrechnen, die Du auf einer Kreisbahn, ausgehend von einem Mittelpunkt (die Achse eines Motors) unter Angabe des Radius (Armlänge/Armteillänge bis zum nächsten Gelenk), maximal erreichen kannst.
Ist eine Position nicht erreichbar, müsste man auf den nächsten Drehpunkt übergehen (zum Beispiel einen zurück) und von dort aus rechnen.

Gemacht habe ich das noch nicht, aber das wäre mein Ansatz.

MfG, Moppi

[Mxt]

Ich denke der Lösungsweg ist nicht das Problem. Es wird halt jemand gesucht, der ihn gehen soll.

Weg a) geht im Prinzip so
https://de.wikipedia.org/wiki/Denavi...Transformation

Weg b) macht man wohl heute meist mit einer Kombination aus
https://de.wikipedia.org/wiki/Jacobi-Matrix
https://de.wikipedia.org/wiki/Pseudoinverse

Eigentlich muss man das aber nicht wirklich wissen, weil es diverse C++ Bibliotheken gibt, die das schon fertig können.
http://roboop.sourceforge.net/
https://moveit.ros.org/
http://www.orocos.org/kdl
Die sind aber nicht geeignet, weil keine fertigen Portierungen auf Arduino existieren oder möglich sind.

Auch Rechnen mit mehr Handarbeit mit den gängigen C++ Matrix Libs wie z.B.
http://eigen.tuxfamily.org/index.php?title=Main_Page
http://arma.sourceforge.net/
ist wohl nicht gefragt, weil es zumindest keine fertigen Portierungen auf Arduino gibt.

Das ist alles, was ich beitragen könnte, ist aber keine fertige Lösung, daher zu verwerfen.

[Moppi]

Ich halte von so fertigen Sachen nicht wirklich viel. Es sei denn, es wäre sehr sehr kompliziert. Dass man nicht selbst einen Lösungsweg suchen könnte. Es gibt für viele , per mathematischer Formel sehr komplizierte Sachen einfache Lösungswege, auch für 8-Bit-Computer oder 16 Bit Computer. Als Beispiel sehe ich immer auf Doom, was ich als erstes 3D-Spiel hatte. Echtzeit 3D-Berechnung der Grafik-Engine hätte mit komplexen mathematischen Formeln, auf den damaligen leistungsschwachen Computern gar nicht funktioniert. Da werden Punkte im 3D-Koordinatensystem in Echtzeit auf einer 16MHz-CPU berechnet. Innerhalb Bruchteilen von Sekunden sind das oft mehr als 8 Punkte pro Objekt. Wenn man dann sieht, wie es gemacht wird, staunt man, wie einfach die Lösung gewesen ist. Daher denke ich, lohnt es, zu versuchen, das selber zu lösen. Da weiß man hinterher, warum es funktioniert oder warum auch etwas nicht funktioniert.

[Mxt]

Richtung a) ist nicht rechenaufwändig. Ohne das würde kein Industrieroboter funktionieren. Ging natürlich schon mit den allerersten und bevor es überhaupt Prozessoren als eigenständiges IC gab.

Mit b) ist das zumindest "live" während der Bewegung anders. Bei den japanischen Robotern, mit denen ich an der Arbeit zu tun habe, kam das erst bei den Modellen in den 1990ern, die schon 32 Bit Prozessoren hatten (damals Intel i960).

[HaWe]

wer immer die inverse Kinematik auf Arduino selber portieren möchte, möge das gerne tun!
Bewährt hat sich wohl die Denavit–Hartenberg Konvention
https://en.wikipedia.org/wiki/Denavi...erg_parameters

IMO wäre es als User-Schnittstelle am einfachsten, und für verschiedene Robotarm-Designs am flexibelsten, wenn der Nutzer seine Robotmaße einfach eingeben könnte in eine Reihe von arrays. Statt die genauen Achs-Positionen einzugeben, könnte man sich auch auf "TILT" fürs abknicken und "ROTATE" fürs drehen in der Armlängsrichtung beschränken, für lineare Aktuatoren und auch für die virtuelle Greifposition in der Zange auch Typ "LINEAR":

// cusomize your arbitrary robot arm dimensions and design. 

#define MAXJOINTS 6


Jtype[0] = ROTATE; // turntable joint
Jangl[0] = 270;  // max turn angle
Lleng[0] = 95;   // turntable height in mm

Jtype[1] = TILT; // shoulder joint
Jangl[1] = 180;  // max turn angle
Lleng[1] = 105;   // upper arm length in mm

Jtype[2] = TILT; // elbow joint
Jangl[2] = 180;  // max turn angle
Lleng[2] = 97;   // forarm length in mm

Jtype[3] = TILT;  // wrist tilt
Jangl[3] = 90;    // max turn angle
Lleng[3] = 65;  // wrist length: not exaclty linear mounted!

Jtype[4] = ROTATE;  // metacarpal rotate.
Jangl[4] = 90;       // max turn angle   
Lleng[4] = 50;    // metacarpal  length

Jtype[5] = LINEAR;  //  longitudinal finger length (not opening!!)
Jangl[5] = 0;     // virtual grab position, no motor used  (claw open/close external cmd)
Lleng[5] = 60;   // finger length = grab area length metacarpal to fingertip

Bild hier  

und das Robot-Programm verkettet dann diese Werte zur Kette der Teil-Arme, in dem es sie in seine Matrizen einsetzt.

Für mich persönlich überschreitet das meine Kompetenzen bei weitem, sonst würde ich es selber machen.
Daher, insb. @moppi: wenn du es dir zutraust: Immer gerne!

Zum Rechnen würde sich sicher ein M3 (Due) oder auch ein M4 mit fpu anbieten.