Ansteuerung des UR3 Roboters mit Matlab und URSim mittels Realtime Schnittstelle: Unterschied zwischen den Versionen
| Zeile 71: | Zeile 71: | ||
Der Technische Systementwurf kann hier heruntergeladen werden: [[Datei:Technischer Systementwurf UR3MitLego.pptx]] | Der Technische Systementwurf kann hier heruntergeladen werden: [[Datei:Technischer Systementwurf UR3MitLego.pptx]] | ||
== ''' | == '''Komponentenspezifikation''' == | ||
Bei der Komponentenspezifikation wird für jede Komponente die Aufgabe, das Verhalten, der innere Aufbau und Schnittstellen zu anderen Teilsystemen detailliert beschrieben und durch Skizzen oder Bilder unterstützt. | Bei der Komponentenspezifikation wird für jede Komponente die Aufgabe, das Verhalten, der innere Aufbau und Schnittstellen zu anderen Teilsystemen detailliert beschrieben und durch Skizzen oder Bilder unterstützt. | ||
Version vom 19. Januar 2022, 21:18 Uhr
→ zurück zur Seite Praktikum Produktionstechnik
Autoren:
WS 2020/21: Jan Pinter und Rina Mucaj
WS 2021/22: Haris Adrovic, Maik Spinnrath und Franziska Troja
Betreuer: Prof. Dr. Mirek Göbel und Marc Ebmeyer
Einleitung
Im Rahmen des Studiengangs Mechatronik findet im 7.Semester das Produktionstechnik-Praktikum statt. In diesem Praktikum können alle zuvor im Studium gelernten Inhalte noch einmal angewendet werden. Dazu werden in Kleingruppen verschiedene einzelne mechatronische Projekte semesterbegleitend bearbeitet. In diesem Artikel geht es um die Ansteuerung eines UR3-Roboters (siehe Abbildung XY) von Universal Robots [1] , welcher von der HSHL zur Verfügung gestellt wird. Dieser soll mit Hilfe von MATLAB und der eigenen Software URSim programmiert werden. Diese Aufgabe wurde in zwei Semestern (WS 2020/21 und WS 2021/22) von Studierenden bearbeitet.
Projektaufgabe
Der Roboter soll ein im Vorfeld festgelegtes Bild mit Klemmbausteine legen, dazu muss dieser auf die Steine aus einem Magazin entnehmen und auf einer Platte absetzen. An dem Roboter befindet sich ein Greifer als Endeffektor, der wiederholsicher diese Steine greifen und an definierter Position absetzen muss. Die Steine können aus einem Magazin entnommen werden. Da der Roboter kontinuierlich eine Schnittstelle in Echtzeit mit spezifischen Informationen über beispielsweise die Gelenkwinkel, -geschwindigkeiten und -beschleunigung schreibt, kann diese Realtime-Schnittstelle zur Unterstützung bei der Ansteuerung genutzt werden. Zusätzlich mussten auch noch die Greifbacken des Roboters an die Projektaufgabe angepasst werden, da die vorherigen nicht spezifisch an die Klemmbausteine zum Greifen und Absetzen geeignet waren. Ebenso wird ein größeres Magazin für die Anzahl an Steinen benötigt, da für das geplante „Bild“ insgesamt 26 Klemmbausteine von dem Magazin gefasst werden müssen. Dieses wurde dementsprechend auch noch neu designt.
Das V-Modell
Das V-Modell in Abbildung XY ist eine konkrete Vorgehensweise zum Planen und Durchführen von Entwicklungsprojekten. Dieses Vorgehen wurde auch für dieses Projekt angewandt. Dadurch konnte eine konkrete Planung und gute Struktur des Projektes geschafft werden. Alle notwendigen Schritte zur Bewältigung eines erfolgreichen Projektes sind dort dargestellt. Für die Dokumentation wurde das Tortoise SVN genutzt, dort wurde ein gleichnamiger Ordner erstellt, der auch in die einzelnen Projektschritte noch einmal unterteilt wurde. Dort liegen alle Dateien, die während des Praktikums erstellt worden sind.
SVN-Ordner WS 2020/21
SVN-Ordner WS 2021/22
Anforderungsdefinition
In der Anforderungsliste bzw. dem Lastenheft für das Projekt „Ansteuerung des UR3 Roboters mit MATLAB und URSim mittels Realtime Schnittstelle“ wurden die spezifischen Anforderungen, die an dieses Projekt gestellt worden sind, definiert.
Diese wurden unterteilt in:
- Funktion
- Was ist die Aufgabe des Projekts?
- Was soll das Ergebnis sein?
- Aufbau
- Welchen Anforderungen werden an die Strukturierung der Station?
- Schnittstellen
- Was für Schnittstellen zwischen dem Roboter und dem Computer genutzt?
- Wofür werden die Schnittstellen genutzt?
- Software / Werkzeuge
- Welche Programme werden benötigt?
- Werden Toolboxen genutzt?
- Dokumentation
- Wie wird die Dokumentation durchgeführt?
- Wo wird dokumentiert?
- Optional
- Was kann bei vorhandener Zeit noch bearbeitet/ergänzt werden?
Die Anforderungsliste kann hier heruntergeladen werden: Datei:Anforderungsliste UR3MitLego.xlsx
Funktionaler Systementwurf
Mittels Software soll die Ansteuerung des UR3-Roboters geschehen. Dazu muss eine wiederholsichere Ausführung gewährleistet werden. Im Groben wird von dem Roboter immer ein Stein aufgenommen und an vorher festgelegter Position abgesetzt, dies wird wiederholt durchgeführt.
Originaldatei des Funktionalen Systementwurfs: Datei:Funktionaler Systementwurf UR3MitLego.xlsx
Technischer Systementwurf
In dem Technischen Systementwurf wird die Projektaufgabe genauer spezifiziert. Es wird die konkrete Verbindung zwischen den verschiedenen Komponenten dargestellt und wie diese miteinander kommunizieren können.
Der Technische Systementwurf kann hier heruntergeladen werden: Datei:Technischer Systementwurf UR3MitLego.pptx
Komponentenspezifikation
Bei der Komponentenspezifikation wird für jede Komponente die Aufgabe, das Verhalten, der innere Aufbau und Schnittstellen zu anderen Teilsystemen detailliert beschrieben und durch Skizzen oder Bilder unterstützt.
Die vollständige Komponentenspezifikation kann hier entnommen werden: Datei:Komponentenspezifikation UR3 Lego WS 21 22.xlsx
MATLAB Programm
Das MATLAB Programm ist das Kernstück des Projektes. In diesem laufen alle Informationen der anderen Komponenten zusammen, werden verarbeitet, zu Befehlen neugeformt und an die entsprechenden Komponenten weitergeleitet. Mit diesem Programm kann dem Roboter ein Muster in Form einer Excel Liste übergeben werden, welche der Roboter wiederholsicher auf der Noppenplatte mit Klemmbausteinen legt, welche er dem Magazin entnimmt.
Realtime Schnittstelle
Der UR3 gibt kontinuierlich eine Vielzahl an Zustandswerten des Roboters aus, wie beispielsweise Gelenkwinkel und Gelenkgeschwindigkeiten, welche zur Überwachung des Roboters benötigt werden. Die Werte kommen als aneinanderhängende Bytes, welche zunächst den jeweiligen Eigenschaften zugeordnet und in lesbare Werte umgewandelt werden. Diese werden von der Funktion in einer vorher angelegten Datenstruktur abgespeichert und können jederzeit einzeln mit dem Punktoperator abgerufen werden.
Roboter
Der Roboter ist ein UR3 von Universal Robots. Er verfügt über sechs rotierende Gelenke welche sechs Freiheitsgrade ermöglichen. Seine maximale Reichweite beträgt 500mm. Programmiert werden kann er entweder über das angeschlossene Terminal in der mitgelieferten Polyscope Software oder über einen angeschlossenen Computer in einer kompatiblen Entwicklungsumgebung. Zur weiteren Ansteuerung besitzt er sowohl 16 digitale als auch zwei analoge Ein- und Ausgänge. Außerdem ist ein RG2 Greifer der Firma OnRobot montiert. Bei diesem handelt es sich um einen elektrischen zwei Finger Greifer mit einer maximalen Greifkraft von 40 Newton.
Magazin
Die Komponente Magazin beinhaltet die Klemmbausteine, welche der Roboter legen soll. Damit dieser die Steine wiederholsicher aufnehmen kann, muss die Position des auszunehmenden Steins bis auf eine minimale Toleranz immer gleich sein. Außerdem muss sich das Magazin dafür im Greifraum des Roboters befinden. Zusätzlich müssen die nachfolgenden Steine aus dem Magazin automatisch an die Entnahmestelle befördert werden.
Magazin V1
Das Magazin in Abbildung 6 wurde mit CAD konstruiert. Die Maße wurden an eine vorhandene Rutsche angepasst, sodass ein störungsfreier Rutschvorgang gewährleistet werden kann. Die Steine rutschen auch ohne verwendeten Druckluftanschluss an der Rutsche bis zur Endposition (siehe Abbildung 7). Damit dies gewährleistet werden kann, müssen in das gedruckte Magazin zwei zusammengebaute Klemmbausteine wie in Abbildung 8 eingelegt werden, die für eine glatte Rutschfläche auch auf dem gedruckten Bauteil sorgen. Durch das Langloch als Befestigung kann die Position nahezu beliebig angepasst werden, sodass die optimale Rutschposition gefunden werden kann.
 |
 |
 |
Das CAD Modell vom Magazin kann hier heruntergeladen werden: Datei:MagazinCAD.SLDPRT
Die Originaldatei von der Abbildung 8 kann hier[5] im SVN gefunden werden.
Magazin V2
Das Magazin in der Version 1 funktioniert gut, jedoch war die Kapazität zu gering, um größere Formationen zu legen. Daraufhin wurde mit dem vorhandenen Konzept eine größere Variante entwickelt. Diese besteht aus vier Parallel verlaufenden Rutschen wodurch die Kapazität entsprechend vervierfacht wurde. Die Kapazität beträgt nun 32 Steine. Das Magazin verfügt nun über vier Entnahmestellen was in der Programmierung entsprechend angepasst werden muss.
Da die vorher benutzen Druckluftschienen sehr kostenintensiv sind, mussten andere Materialien verwendet werden. Diese Version besteht aus 3D gedruckten Teilen welche auf einer zugeschnittenen Holzplatte zusammengesteckt, geschraubt und geklebt wurden. Die 3D gedruckten Teile wurden vorher in der CAD Software SolidWorks konstruiert und in der hochschuleigenen Projektwerkstatt gefertigt.
Da auch andere Gruppen des Praktikums viele 3D Druck Teile benötigten waren die Wartezeiten teilweise lang. Dadurch verzögerten sich die Montage und Tests des Magazins. Die Tests ergaben, dass die Oberfläche der Holzplatte nicht glatt genug ist und so der letzte Stein einer Rutsche nicht vollständig in die Entnahmestelle rutscht. Alle vorherigen Steine einer Rutsche rutschen, wie geplant, in die Entnahmestellen. Somit reduziert sich die Kapazität auf 28 Steine.
 |
 |
Die CAD-Dateien zum 3D-Drucken als Download:
| Bauteil | Anzahl | Originaldatei |
|---|---|---|
| Platte groß (aus Holz zugeschnitten) | 1 | Datei:Holzplatte.SLDPRT |
| Platte kurz (aus Holz zugeschnitten) | 1 | Datei:Holzplatte kurz.SLDPRT |
| Abstandshalter der Schienen | 1 | Datei:Abstandshalter.SLDPRT |
| Adapterstütze Magazin links | 1 | Datei:Adapter Stütze Magazin.SLDPRT |
| Adapterstütze Magazin rechts | 1 | Datei:Adapter Stütze Magazin gespiegelt.SLDPRT |
| Entnahme-Kamm | 1 | Datei:Entnahme Kamm.SLDPRT |
| Schienen | 5 | Datei:Schienen Magazin.SLDPRT |
| Winkel zur Verbindung der beiden Holzplatten | 2 | Datei:Winkel.SLDPRT |
| Magazin vollständig (Hilfsbauteile vorhanden) | 1 | Datei:Magazin komplett.SLDASM |
Greifbacken
Die originalen Greifbacken sind zu sperrig, um auf der Noppenplatte Steine aneinander zu legen. Außerdem sind sie nicht für die Aufnahme von Klemmbausteinen optimiert. Deswegen wurden neue Greifbacken entwickelt. Diese wurden ebenfalls wie die Magazine zunächst in der CAD Software SolidWorks konstruiert und dann in der Projektwerkstatt 3D gedruckt. Die ersten gedruckten Greifbacken wurden aus PLA gedruckt und hatten das Problem, dass die Steine manchmal aus dem Greifer rutschten. Daraufhin wurde eine zweite Version aus TPU gedruckt, bei dieser tritt das Problem nicht mehr auf und bieten zusätzlich mehr Flexibilität beim Setzen der Steine.
Die Greifbacken sind nun kleiner und für die Form der Klemmbausteine optimiert. Dadurch können die Steine auf der Noppenplatte enger aneinandergelegt werden. Außerdem verfügen sie über eine Zentriervorrichtung, welche die Noppen der Steine nutzt, um den Stein immer mittig im Greifer zu packen. So können kleine Toleranzen in der Entnahmestelle des Magazins ignoriert werden. Zusätzlich können die Steine mit der Zentriervorrichtung auch stärker auf die Platte gedrückt werden.
 |
 |
 |
Die CAD-Datei zum Nachdrucken kann hier heruntergeladen werden: Datei:Greifbacken HSHL.SLDPRT.
Steinpositionierung mit Excel-Datei
Damit der Roboter Steine auf einer Platte absetzen kann, muss dieser die notwendigen Informationen über die unterschiedlichen Steine erhalten. Dies soll mit einer Excel-Datei realisiert werden, da hier sehr einfach die Positionierung der Steine geändert werden kann. Ein Vorteil einer Excel-Datei ist zudem, dass dort die Platte, auf der die Klemmbausteine positioniert werden sollen, imitiert werden kann. Denn diese kann mit den einzelnen Zellen die Noppen der Klemmbausteine darstellen. Da eine Excel-Datei aus sehr vielen Zeilen und Spalten bestehen kann, muss die Größe der Platte jeweils mit einer „0“ eingegrenzt werden. In Abbildung XY ist das Beispielbild, welches mit dem Roboter gesetzt werden soll, erkennbar.
Die Excel-Datei mit Steinkoordinaten herunterladen: Datei:Legosteine Positionierung.xlsx
Ansteuerung des Roboters
Die Ansteuerung des UR3-Roboters mit MATLAB ist sowohl mit Hilfe der eigenen Polyscope-Software als auch mit MATLAB realisierbar.
Innerhalb des Polyscopes können dem Roboter mehrere Positionen angegeben, die dieser in der Reihenfolge nacheinander wiederholt abfährt. Die festgelegten Positionen werden von dem Roboter mit einer sehr hohen Genauigkeit angefahren. Über das Polyscope ist auch eine Ansteuerung des Greifers sehr einfach durchführbar. So war es vergleichsweise schnell machbar, dass ein Klemmbaustein gegriffen und abgesetzt werden.
Das Ansteuern des UR3-Roboters mit MATLAB ist ebenso möglich, jedoch nicht einfach. Die Programmierung in MATLAB erwies sich als schwierig, da viele Funktionen, die im Polyscope verfügbar sind, nicht direkt in MATLAB gibt. Die Verwendung der "Robotics Toolbox" von Peter Corke [6] schafft zwar eine Lösungsmöglichkeit, jedoch muss man hier bereits genau wissen, wie die einzelnen Befehle anzuwenden sind, da es sonst zu Fehlern oder Abbrüchen des Programms kommt. Ebenso werden einige nützliche Polyscopebefehle nicht unterstützt. Abhilfe muss hier über andere Wege geschafft werden, wie über die Variablentabelle der Realtime TCP Verbindung, da es sonst dazukommen kann, dass der Roboter von MATLAB den nächsten Punkt anfahren will, bevor die vorherige Position erreicht worden ist. Sind jedoch alle Befehle bekannt und lassen sich die Funktionen umsetzen, bietet die Programmierung über MATLAB jedoch den Vorteil, dass weitere Funktionalitäten aus MATLAB eingezogen werden können, wie das Auslesen einer Excel-Tabelle für die Steinkoordinaten. Eine Simulation der Bewegungen kann in MATLAB auch erfolgen. Diese wäre jedoch auch ohne MATLAB mit URSim (eigene Simulationssoftware) möglich. Durch die Verwendung von MATLAB wird der Umgang mit Skripthandbüchern erlernt, die für die Anwendung von nicht selbst programmierten Befehlen nötig sind.
Herstellung der Verbindung und einfache Bewegungen mit MATLAB
Um mit dem Roboter über eine Ethernet-Verbindung kommunizieren zu können, muss ein TCP Port geöffnet werden.
- Der Port für die Realtime Kommunikation zum Roboter ist 30003. [7]
- Die IP des Roboters muss gegebenenfalls auf statisch festgelegt werden anstatt DHCP.
Für das Erzeugen einer Bewegung gibt es im Skripthandbuch von UR bestimmte Befehle. So ist eine Bewegung aller Achsen des Roboters auf bestimmte Zielwinkel „q“ mit der Funktion „movej(q, a, v, t=0, r=0)“ möglich. Die zu übergebenden Variablen sind hier ebenfalls beschrieben.
- q = Gelenkwinkel der einzelnen Achsen (Jeder Achse wird ein Winkel in Radiant zugeordnet. Jede Achse dreht sich beim Anfahren des neuen Bewegungsbefehls somit auf seinen vorgegebenen Wert. Bei dem UR3 gibt es 6 Achsen, somit auch 6 unterschiedliche q (q1, q2, q3, q4, q5, q6).)
- a = Beschleunigung der Achsen
- v = maximale Geschwindigkeit der Achsen
Dieser Befehl muss als String, also nicht als Variablen, an die Steuerung des Roboters übergeben werden. Dies kann in MATLAB mit „num2str“ so umgesetzt werden:
function [commandString] = command2string(q,a,v,t,r)
commandString = ['movej([' num2str(q(1)) ', ' num2str(q(2)) ', ' num2str(q(3)) ', ' num2str(q(4))...
', ' num2str(q(5)) ', ' num2str(q(6)) '], ' num2str(a) ', ' num2str(v) ', ' num2str(t)...
', ' num2str(r) ')'];
end
Hier kann die originale MATLAB-Funktion heruntergeladen werden: Datei:Command2string.m. Diese muss sich am Ende des Hauptprogramms oder mit demselben Namen im gleichen Pfad befinden.
Anschließend muss dieser String über die Verbindung mit „fprintf“ gesendet werden.
Socket_conn = tcpip(Robot_IP,Port_NR); fprintf(Socket_conn; command2string(q,a,v,t,r));
Bewegungsarten
Unterschied Lineare und Joint Bewegung
Der Roboter kann die Zielposition entweder durch direkte Drehung der Achsen anfahren oder seine resultierende Bewegung vorher berechnen und für den Greifer eine lineare, gradlinige Bewegung erzeugen. Mit der linearen Bewegung lässt sich besser die Bewegung des Roboters abschätzen, da er sich im Joint Modus auch bei kleinen Bewegungen um seine eigene Achse drehen kann. Damit es hierbei zu keinen unerwarteten Problemen, wie das Verfahren durch Hindernisse, bei einem Programmstart kommt, fahren wir den Roboter zunächst in eine Ausgangsposition, in welcher er senkrecht nach oben zeigt. Analog zu „movej“ gibt es hierzu den Befehl „movel“.
Zielangaben
Die Zielkoordinaten einer Bewegung können über unterschiedliche an den Roboter übergeben werden. Beispielsweise kann dies entweder als direkte Winkel der Achsen (q1, q2, q3, q4, q5, q6) oder als Transformationsmatrix T angegeben werden. Die Umrechnung erfolgt über ikine und fkine und erfordert ein aktives Robotermodell, das mit dem Befehl „mdl_ur3;“ aktiviert wird. Dieser Befehl wird einmal zu Beginn des MATLAB-Programms aufgerufen und ausgeführt. Die Transformationsmatrix ist in Abbildung 14 dargestellt. Aus ihr lassen sich die Drehmatrix und der Verschiebevektor erkennen. Die Drehmatrix gibt an, wie der Tool-Center-Point gedreht ist. Der Verschiebevektor gibt die kartesischen Koordinaten von diesem im Raum an. Diese können als x-, y- und z-Koordinaten abgelesen werden.
Die Originaldatei von der Abbildung 14 kann hier im SVN gefunden werden.
Ikine-Befehl
Mit ikine lassen sich aus einer Transformationsmatrix T neue Zielwinkel q bestimmen. Dies ist der Befehl für die Inverse Kinematik. Er berechnet aus den Zielkoordinaten die einzelnen Gelenkwinkel q des Roboters, so dass der Tool-Center-Point des Roboters sich anschließend an der gewünschten kartesischen Koordinate befindet.
Hierzu werden jedoch noch Startwinkel für die Berechnung benötigt. Es empfiehlt sich, für den Startwinkel die aktuellen Winkel der Gelenke zu nutzen. Sollte die Berechnung mittels MATLAB nicht funktionieren, müssen andere Startwinkel gewählt werden oder geprüft werden, ob das Ziel im erreichbaren Roboterbereich liegt.
Der Code für ikine sieht so aus:
q = ur3.ikine(T,'q0',q_Startwinkel);
Fkine-Befehl
Mit "fkine" lässt sich aus einem q (Zielwinkel) eine Transformationsmatrix T errechnen. Dies kann folgend umgesetzt werden:
T = ur3.fkine(q_neu);
Koordinatensystem des Roboters und der Noppenplatte
Der Roboter verfügt über insgesamt drei vordefinierte Koordinatensysteme, in denen dieser bewegt werden kann: Fuß, Basis und Werkzeug.
Ebenso können für den Roboter eigene Koordinatensysteme festgelegt werden. Dabei kann die positive Richtung der drei Koordinatenachsen (x-, y- und z-Achse) selbst gewählt werden. Hierzu wird ein eigener Ursprung festgelegt und von dort aus dann die Richtung bestimmt.
Dadurch, dass bei dem UR3-Roboter für das Positionieren der Klemmbausteine ein Greifer befestigt ist, ist es sehr aufwendig und schwierig mit dem Greifer ein neues, geeignetes Koordinatensystem festzulegen. Denn durch den Greifer ist ein sehr langer Hebel gegeben, der es erschwert den Mittelpunkt des Endeffektors exakt im Lot für dem benötigten Ursprung zu setzen. Das würde nur mit einem sehr langen „Trial und Error“ zu einem zufriedenstellenden Ergebnis führen. Denn auch nur eine minimale Abweichung macht ein genaues Absetzen der Klemmbausteine an den definierten Positionen unmöglich.
In Abbildung XY ist eine Skizze des Aufbaus in dem Labor erkennbar, dort ist die Ausrichtung des Koordinatensystems „Ansicht“, welches eine Grundeinstellung des Roboters ist, eingezeichnet, mit einer Drehmatrix kann von einem geeigneteren Koordinatensystem von der Noppenplatte in das Koordinatensystem „Ansicht" gedreht werden. Auf die Transformationsmatrix des Koordinatensystems „Ansicht“ kann zugegriffen werden. Diese besteht, wie in Abbildung XY (Die Transformationsmatrix), erkennbar aus der Drehmatrix und dem Verschiebevektor. Der Verschiebevektor kann sowohl ausgelesen als auch neu beschrieben werden. Hingegen kann die Drehmatrix nur gelesen werden und nicht überschrieben werden. Denn die Abspeicherung für der Informationen des Roboters erfolgt in einem SE3, welche bestimmte Möglichkeiten aber auch Einschränkungen mit sich bringt.
Realtime-Schnittstelle des Roboters
Wie schon bei den Komponentenspezifikationen erwähnt, schreibt der Roboter kontinuierlich Daten über einen Port. Da dies kontinuierlich geschieht, muss die Anzahl der maximalen Ausleselänge in MATLAB beschränkt werden. Nach 1060 Bytes fängt die Übertragung wieder mit dem ersten Byte an, weshalb die Ausleselänge auf diese Größe begrenzt wird. Dies kann mit dem Befehl "Socket_conn.InputBufferSize = 1060" eingestellt werden. Je nach Version des Polyscope-Programms auf dem Roboter werden unterschiedlich viele Werte übertragen. Diese Bytes müssen zunächst zusammengefasst und einzelnen Werten zugeordnet werden. Die Zuordnung kann über eine von Universal Robots bereitgestellte Liste erfolgen. Diese Werte enthalten Daten über den Zustand des Roboters, beispielsweise die aktuellen Achswinkel, -geschwindigkeiten und Motorlast. Das Schreiben der Informationen geschieht mit 125Hz in Echtzeit, welche zur Überwachung des Roboters genutzt werden können. Die Werte der Gelenkgeschwindigkeiten werden nach einem Bewegungsbefehl immer wieder ausgelesen und abgeglichen. Wenn alle null sind, ist der Roboter mit der Bewegung fertig und der nächste Befehl kann gesendet werden. Die Realtime-Schnittstelle kann nur zum Auslesen genutzt werden, es ist keine Befehlsübergabe über diese Schnittstelle möglich.
Greiferansteuerung
Programmierung und Quellcode
Der gesamte Quellcode befindet sich im SVN. Ein externer Nutzer oder bei fehlerhafter Verbindung kann auf diesen Pastebin zurückgegriffen werden: Verknüpfung zu PasteBin
Die Funktionalität der Funktionen beginnend mit „test“ oder auskommentierter Code ist nicht gewährleistet, und muss vor Verwendung geprüft werden.
Hauptprogramm zur Ansteuerung des UR3-Roboters
In dem Hauptprogramm, der den UR3-Roboter ansteuert, werden auf unterschiedliche nutzerdefinierte Funktionen zugegriffen. Zunächst wird die Verbindung zu dem Roboter aufgebaut und bestimmte Variablen zur Ansteuerung des Roboters werden festgelegt. Die Programmierung des Roboters erfolgt mit MATLAB und einer Server-Client-Verbindung. Die Server-Client-Verbindung wird zur Ansteuerung des Greifers an dem Roboter benötigt. Diese Funktionen ermöglichen eine übersichtliche Arbeitsweise und können ebenfalls bei nachfolgenden Projekten einfacher wiederverwendet werden. Im Folgenden wird näher auf die einzelnen Funktionen eingegangen.
Programmablaufplan des Hauptprogramms und für die einzelnen Funktionen:Datei:PAP UR3 mit Lego.zip
Berechnung der Steinkoordinaten
Für die Positionierung der Klemmbausteine, die der UR3-Roboter auf einer Platte absetzen soll, wird die Excel-Datei, in der die Steine positioniert sind, benötigt. Diese Datei wird mithilfe einer MATLAB-Funktion eingelesen und ausgewertet. Das Ergebnis der Funktion ist eine Matrix, die so viele Zeilen wie Anzahl an Steinen und fünf Spalten hat. Es ist nicht vorgegeben, wie viele Steine in der Datei enthalten sind, dies wird von der Funktion selbst ermittelt. Abhängig von der Steinnummer, die jedem Stein in der Excel-Datei zugeordnet worden ist, wird die entsprechende Zeile gefüllt.
Von dem jeweiligen Stein wird die Koordinate des Mittelpunktes abgespeichert. In die ersten drei Spalten werden die Koordinatenpunkte x, y und z des jeweiligen Steins an der zugehörigen Steinnummer geschrieben. Für das Anfahren der Noppen muss ein Umrechnungsfaktor ermittelt werden, da in der Excel-Liste mit einem Abstand von 1 gerechnet wurde. Der reale Abstand zwischen den Zwischenräumen ist ca. 8mm (siehe Abbildung XY). Es muss ggf. die y-Koordinate negativ gesetzt werden. Dies ist abhängig von dem Koordinatensystem, in dem sich der Roboter bewegt, und ist sehr einfach in dem Programmcode realisierbar. Die vierte Spalte enthält dann die Ausrichtung des Steins, ist der Stein horizontal („0“) oder vertikal („1“) angeordnet. Die Funktion überprüft abhängig von der ersten „Noppe“, die sie in der Excel-Datei findet, wie die Orientierung der Steine ist. Da die Orientierung des letzten Gelenks .Rx, .Ry und .Rz relativ von der Ausrichtung sind, kann hierüber die Orientierung des Greifers angegeben werden, dies ist aktuell in dem Programmcode noch nicht implementiert. Da unser Magazin vier Schienen enthält, die mit verschieden farbigen Steinen gefüllt ist und das Bild auf der Platte eine bestimmte Anordnung der Farben enthält, steht in der fünften Spalte die Magazinnummer.
Der Rückgabewert der Funktion ist eine Matrix (26x5) mit den Mittelpunktkoordinaten der Steine, Ausrichtung und Magazinnummer (siehe Abbildung XY) und zusätzlich wird noch die Anzahl der Steine in der Excel-Datei zurückgegeben.
function [position,Anzahl_Steine] = steinkoordinaten()
steine = xlsread('Legosteine Positionierung.xlsx'); %Einlesen der Excel-Datei mit den Positionen der Steine und "Legoplatte"
steinnummer = 0; %Laufvariable fuer die Steine iniitiert
[i,j] = size(steine); %Groesse der "Legoplatte" auslesen
steine_gefunden = true; %Boolsche Variable fuer Abbruchbedingung
while steine_gefunden == true %Wiederholen, solange Steine auf "Legoplatte" gefunden werden
steinnummer = steinnummer + 1; %Steine nacheinander in der Matrix "steine" suchen
for m = 1:i %Zeilen durchgehen
for n = 1:j %Spalten durchgehen
if steine(m,n) == steinnummer %Steinnummer an Position in Array Ueberpruefen, ob die sich dort befindet
% Stein liegt horizontal
if steine(m,n+2) == steinnummer %Ueberpruefen, ob Stein horizontal liegt
%Mittelpunkt der Koordinate des Steins berechnen
%-> fuer Weitergabe an Roboter zum Absetzen des Steins
x = n + 1.5 - 2.5;
y = m + 0.5 - 2.5;
ausrichtung = 0; % Stein liegt horizontal, wenn ausrichtung = 0
%Abspeicherung der Koordinaten und Ausrichtung des Stein
position(steinnummer,1) = x;
position(steinnummer,2) = -y;
position(steinnummer,3) = 0;
position(steinnummer,4) = ausrichtung;
% Stein liegt vertikal
else %Gegenereignis -> Stein muss vertikal liegen
%Mittelpunkt der Koordinate des Steins berechnen
%-> fuer Weitergabe an Roboter zum Absetzen des Steins
x = n + 0.5 - 2.5;
y = m + 1.5 - 2.5;
ausrichtung = 1; % Stein liegt vertikal, wenn ausrichtung = 1
%Abspeicherung der Koordinaten und Ausrichtung des Stein
position(steinnummer,1) = x;
position(steinnummer,2) = -y;
position(steinnummer,3) = 0;
position(steinnummer,4) = ausrichtung;
end
break;
end
if steine(m,n) == steinnummer % for-Schleife fuer n abbrechen, wenn erste Koordinate der Steinnummer gefunden wurde
break
end
end
if steine(m,n) == steinnummer % for-Schleife fuer m abbrechen, wenn erste Koordinate der Steinnummer gefunden wurde
break
end
end
%am Ende der "Legoplatte" angekommen
if m == i && n == j
Anzahl_Steine = steinnummer - 1; %Ausgabe der Anzahl der gefundenen Steine
steine_gefunden = false; %Abbruchbedingung fuer while-Schleife
end
end
%Ergaenzung der Matrix fuer Zuordnung der Magazine zu Legosteinnummerentnahme
for i = 1:Anzahl_Steine
%Magazin 1/rot
if i >= 1 && i <= 4
position(i,5) = 1;
end
%Magazin 2/gelb
if i >= 5 && i <= 8
position(i,5) = 2;
end
%Magazin 3/schwarz
if i >= 9 && i <= 15
position(i,5) = 3;
end
%Magazin 4/blau
if i >= 16 && i <= 21
position(i,5) = 4;
end
%die übrigen schwarzen Steine müssen auf die anderen Magazine verteilt werden
if i >= 22
position(i,5) = 1;
if i >= 22 && i <= 24
position(i,5) = 1;
else
position(i,5) = 2;
end
end
end
Auslesen der Realtime-Schnittstelle
Für die Auswertung der Roboterbewegung wird die Realtime-Schnittstelle, die kontinuierlich von dem Roboter unter anderem über den Port 30003 beschrieben wird, genutzt. Wie schon bei den Komponentenspezifikationen erwähnt, werden von dem Roboter kontinuierlich Daten über einen Port geschrieben. Da über diesen Port kontinuierlich geschrieben wird, muss die Anzahl der maximalen Ausleselänge in MATLAB beschränkt werden. Ab dem 1060. Byte wiederholt sich das große Datenpaket, weshalb es auf diese Größe begrenzt wird. Dies kann mit dem Befehl "Socket_conn.InputBufferSize = 1060" maximiert werden. Je nach Version des Polyscope-Programms auf dem Roboter werden unterschiedlich viele Werte übertragen. Die Zuordnung kann über eine von Universal Robots bereitgestellte Liste erfolgen. Diese enthält nützliche Daten zur Ansteuerung des Roboters, beispielsweise die Achswinkel, -geschwindigkeiten und Motorlast. Deren Interpretation erfolgt anhand einer von UR (Universal Robots) breitgestellten Liste. Das Schreiben der Informationen über den Roboter geschieht in Echtzeit mit 125Hz, wodurch dies für die Programmierung der Ansteuerung des Roboters genutzt werden kann. Diese Informationen müssen noch strukturiert werden, da nur mit dem Auslesen der Schnittstelle die Daten einem nicht sinnvoll für die weitere Nutzung zur Verfügung stehen. Hierbei hilft ebenfalls die Liste von UR. In diesem Projekt wird die Realtime-Schnittstelle nur zum Lesen genutzt, es erfolgt keine Befehlsübergabe über diese Schnittstelle.
function realtime = realtime_schnittstelle(Robot_IP, Port_NR)
Socket_conn = tcpip(Robot_IP,Port_NR);
Socket_conn.InputBufferSize = 1060;
% Auslesen der Schnittstelle
fclose(Socket_conn); %ggf. bestehende Verbindung trennen
fopen(Socket_conn); %Verbindung zur Schnittstelle starten
flushinput(Socket_conn);
realtime = fread(Socket_conn); %Verbindung zur Schnittstelle schließen
end
Die Originaldatei kann hier heruntergeladen werden: Datei:Realtime schnittstelle.m
Strukturierung ausgewählter Daten der Realtime-Schnittstelle
Für die Übersichtlichkeit, an welchem Byte welche Information geschrieben wird, wurde eine Excel-Datei erstellt. Diese Bytes müssen anschließend in einen double-Wert umgewandelt werden. Es muss dabei darauf geachtet werden, dass die Bytenummer von links nach rechts sinkt. Dies kann mit dem folgenden Code erfolgen:
„typecast(uint8([Byte8, Byte7, Byte6, Byte5, Byte4, Byte3, Byte2, Byte1]),'double')“
Die Zuordnung der Bytes kann dieser Excel-Liste entnommen werden: Datei:RealtimeDaten Bedeutung.xlsx
Da die Gelenkgeschwindigkeiten zunächst für die Auswertung der Bewegung des Roboters genutzt werden, werden diese in für eine einfache Handhabung in einem Struct abgespeichert. Anhand der zuvor verlinkten Excel-Datei ist erkennbar, dass diese Informationen in den Bytes 301 bis 348 steht. So wird in der Variable realtime alle aktuell benötigten Variablen übersichtlich hinterlegt. Dies geschieht ebenfalls über eine Funktion, die innerhalb der Funktion auch noch einmal auf die Funktion zum Auslesen der Realime-Schnittstelle zugreift.
function realtime = struktur_realtime(Robot_IP, Port_NR)
daten_realtime = realtime_schnittstelle(Robot_IP, Port_NR);
A = daten_realtime; %fuer Uebersichtlichkeit Daten der Realtime-Schnittstelle kuerzer abgespeichert
% Struktur fuer Geschwindigkeiten der Gelenke
v_g(6)= zeros;
v_g(1)= typecast(uint8 ([A(308), A(307), A(306) ,A(305), A(304), A(303), A(302), A(301)]),'double');
v_g(2)= typecast(uint8 ([A(316), A(315), A(314) ,A(313), A(312), A(311), A(310), A(309)]),'double');
v_g(3)= typecast(uint8 ([A(324), A(323), A(322) ,A(321), A(320), A(319), A(318), A(317)]),'double');
v_g(4)= typecast(uint8 ([A(332), A(331), A(330) ,A(329), A(328), A(327), A(326), A(325)]),'double');
v_g(5)= typecast(uint8 ([A(340), A(339), A(338) ,A(337), A(336), A(335), A(334), A(333)]),'double');
v_g(6)= typecast(uint8 ([A(348), A(347), A(346) ,A(345), A(344), A(343), A(342), A(341)]),'double');
realtime.v = v_g; % Info ueber Gelenkgeschwindigkeiten
end
Die originale MATLAB-Funktion kann hier heruntergeladen werden: Datei:Struktur realtime.m
Überprüfung der Roboterbewegung
Die vorher beschriebene Funktion, in der die Daten für die Gelenkgeschwindigkeiten strukturiert werden, kann für die Überprüfung der Roboterbewegung genutzt werden. Hier werden so lange die Daten der Realtime-Schnittstelle abgerufen und abgeglichen, bis alle sechs Gelenke des Roboters stehen, also die Geschwindigkeit null ist. Diese Funktion wird nach allen Bewegungen, die der Roboter anfahren soll, aufgerufen, so dass sichergegangen wird, dass der Roboter seine Bewegungen korrekt ausführt.
function Roboter_steht(Robot_IP, Port_NR)
realtime = struktur_realtime(Robot_IP, Port_NR);
while realtime.v ~= 0
realtime = struktur_realtime(Robot_IP, Port_NR);
pause(1);
end
end
Die originale MATLAB-Datei kann hier heruntergeladen werden: Datei:Roboter steht.m
Berechnung der neuen Positionen für den Roboter
Die Berechnung muss auf Basis der Excel-Datei für die Steinpositionen erfolgen. Diese ist die Grundlage für die neuen Positionen für den Roboter. In den ersten drei Spalten stehen die Koordinatenpunkte für die Positionen der Steinnummern auf der Noppenplatte.
Zunächst muss eine Startposition für den Roboter definiert werden. Die Startposition sollte am „Ursprung“ der Noppenplatte liegen. Da auch ausgehend von dieser Startposition die Koordinatenpunkte aus der Excel-Datei berechnet werden. Die Basis für die Berechnung der neuen Gelenkwinkel, die das Ergebnis der Berechnung sein müssen, ist die Startposition. Denn ausgehend von dieser wird jedes Mal der neue Verschiebevektor der jeweiligen Steinnummer berechnet. Wie schon in dem Kapitel Programmierung beschrieben, werden die Gelenkwinkel über die aktuelle Transformationsmatrix des Roboters ermittelt. Für die korrekte Berechnung muss im Vorhinein das richtige Koordinatensystem ausgewählt werden, da davon die Drehmatrix der Transformationsmatrix abhängig ist. Die ermittelten Gelenkwinkel werden an den Roboter übergeben und dieser wird sich zu der neu berechneten Position bewegen.
Realisierung der Greiferansteuerung
URSim Simulationssoftware
Eine Anleitung zur Installation der Simulationssoftware URSim befindet sich unter dem folgenden Link: Anleitung URSim [9]. Kleine Programmabschnitte können hiermit programmiert und überprüft werden. Diese können somit vorab auf ihre Funktionsfähigkeit getestet werden. Wie die Einstellungen für die Simulation des UR3-Roboter mittels der "virtuellen Maschine" durchgeführt werden kann, kann in dem Artikel Universal Robots nachgelesen werden.
Ist die Verbindung mit der richtigen IP-Adresse gewählt, lässt sich auch ein Befehl aus MATLAB an die Virtuelle Maschine des URSim´s senden. In Abbildung XY auf der rechten Seite ist das MATLAB-Programm zu sehen. Der Befehl wird ausgeführt und die Bewegung des Roboters wird simuliert. Die Simulation ist auf dem Bild oben rechts zu erkennen. Auch hierbei ist es möglich, die TCP Realtime Variablen mit MATLAB auszulesen. Unten rechts auf dem Bild wird die Bewegung zusätzlich in der virtuellen Maschine simuliert.
Herunterladen der Testdatei: Datei:Test simulation.m.
Ausblick
Greifer ansteuern
Die Ansteuerung des Greifers funktioniert im Polyscope mit dem Befehl: RG2(10,40,0.0,True,False,False)
Dieser wird nicht ausgeführt, wenn er als Skriptbefehl gesendet wird. In Absprache mit dem UR Support ist dies nicht möglich. Hierfür könnte jedoch ein anderer Skriptbefehl genutzt werden:
set_tool_digital_out(0,True) bzw. set_tool_digital_out(1,True)
Hierzu muss jedoch im Polyscope (siehe Abbildung 17) noch eine Anpassung vorgenommen werden:
Sollte dieser Befehl nicht funktionieren, muss ggf. das „UR Caps“ Programm des Greifers im Polyscope deinstalliert werden, da es sich Exklusivrechte für diesen Skriptbefehl einräumen kann.
Greifer je nach Anforderung Drehen
Der Greifer muss sich mit „moveTo_XYZ“ auch drehen können, um auch ein gedrehtes Magazin nutzen zu können oder Steine horizontal oder vertikal drehen zu können vor der Ablage auf der Noppenplatte. Die Drehung könnte jeweils auf einer Sicherheitsposition überprüft werden und bei Bedarf gedreht werden. So ließe sich moveTo_XYZ auch weiter nutzen.
Kompletten Bewegungsablauf für das Platzieren eines Steines erstellen
- Excel auslesen für Steinkoordinaten
Geplant war, eine Excel-Liste auszulesen, in welcher die Steinkoordinaten anschaulich eingetragen werden. Die Verwendung von „MergedCells“ ist in MATLAB nicht möglich oder liefert nur „NaN“ Werte. Daher müsste ein Stein in jedem Feld eine Zahl besitzen (siehe Abbildung 18). Die Zahl stünde für die Reihenfolge des Platzierens. Die Spalten und Zeilenbreite von Excel ist gleich, sodass die Noppenplatte quadratisch abgebildet wird.
Diese Excel-Liste soll mit MATLAB ausgelesen werden. Damit das Array nicht automatisch in MATLAB gekürzt wird, kann man in die äußeren Ecken eine „0“ setzen, damit ein Wert vorliegt. Das ausgelesene Array muss weiterbearbeitet werden, sodass die Steine am Ende nur durch ihre Platzierreihenfolge, ihren Mittelpunkt und ihre Drehung (horizontal oder vertikal) definiert sind. Diese können anschließend in einer Schleife im Hauptprogramm abgearbeitet werden.
- Steinplatzierungsfunktion und Entnahmefunktion erstellen
Ein aufgenommener Stein muss von der Ausgangssicherheitsposition auf die Noppenplatte platziert werden und anschließend zurück zur Sicherheitsposition fahren. Hierzu muss die Zielkoordinate aus der von Excel errechneten Steinkoordinate ausgewertet werden und über einen Sicherheitsabstand angefahren werden (vgl. testPlateCoordinate() ). Die Entnahme der Steine aus dem Magazin wird analog zu Steinplatzierungsfunktion erstellt.
In Abbildung 19 ist ein möglicher Bewegungsablauf dargestellt. Die Reihenfolge der Bewegungsschritte ist wie folgt:
(Position 2 und 5 sind jeweils senkrecht 10cm über 3 bzw. 6; Startposition ist immer Position 1)
- Stein aus Magazin nehmen - 1; 2; langsam; 3; Greifer schließen; 2; schnell; 1;
- Stein auf Platte platzieren - 1; 4; 5; langsam; 6; Greifer öffnen; 5; schnell; 4; 1.
Die Originaldatei von der Abbildung 20 kann hier im SVN gefunden werden.
Zum Auslesen der kartesischen Koordinaten muss der Roboter in seine Startposition 1 gefahren werden, sodass der Greifer passend zur Platte ausgerichtet ist (zB mit dem Einstellparameter „StopOnCalibrationPosition“). Nun muss er manuell über die in Abbildung 20 gezeigten Schaltflächen verfahren werden, bis die nächste Zielposition erreicht ist.
Die abgebildeten Gelenkwinkel können in MATLAB zu den gewünschten Koordinaten für die Funktion moveTo_XYZ() wie in Abbildung 21 umgewandelt werden. Diese können nun direkt im Hauptprogramm eingetragen werden.
Die Originaldatei von der Abbildung 21 kann hier im SVN gefunden werden.
- Mehrere Schichthöhen der Steine
Die Klemmbausteine könnten auch übereinandergestapelt werden, nachdem eine Ebene vollständig abgearbeitet wurde. Hierzu können analog zu ersten Excel Tabelle weitere angelegt werden, die die nächsthöhere abdecken.
Zusammenfassung
Eine Verbindung zwischen Roboter und MATLAB ist aufgebaut und kann für den Datenaustausch verwendet werden. Bewegungen lassen sich sowohl linear als auch im joint Modus umsetzen und können einfach durch die Angabe der Zielkoordinaten mit moveTo_XYZ() erreicht werden. Die aufgetretenen Probleme wurden teilweise schon gelöst. Zu nicht gelösten Aufgaben und Problemen wurden Ansätze und Lösungsstrategien im Wiki festgehalten. Zur Erweiterung der Funktionalität in MATLAB können Daten über die TCP Schnittstelle des Roboters abgefragt werden.
Alle Originaldateien können hier [12] im SVN gefunden werden.
Literaturverzeichnis
- ↑ Universal Robots
- ↑ Quelle Das V-Modell: Produktionstechnik Praktikum, Prof. Dr. Göbel
- ↑ Foto: Marc Ebmeyer
- ↑ Foto: Marc Ebmeyer
- ↑ Originale Bilder
- ↑ "Robotics Toolbox" von Peter Corke
- ↑ TCP Ports
- ↑ Original ohne Anmerkung: Montage- und Handhabungstechnik, Prof.Dr.Göbel, FolienID: 210.0
- ↑ Anleitung URSim
- ↑ Foto von UR3-Support
- ↑ Eigenes Foto
- ↑ Originaldateien zum Nachbau des Projektes
→ zurück zur Seite Praktikum Produktionstechnik