Skip to content

Mit KI weiterarbeiten

Mit KI weiterarbeiten

Roboterhandling / Sonstige Befehle ​

Hier werden verschiedene Befehle beschrieben

Programme ​

Laufzeit nach Programmstart ​

Der Befehl getRuntime() gibt die Laufzeit seit Programmstart in Sekunden an.

getRuntime();

Exit ​

Die Methode exit() beendet das Programm und wechselt zusätzlich zurück in den Simulationsmodus. Die Bremsen werden aktiviert und halten den Roboter in seiner aktuellen Position, wodurch er weniger Strom verbraucht.

joints(-20.00, 0.00, -23, 90.00, -92, 15.72, 0.5);
exit();
jointsLinear(20.00, 0.00, -23, 90.00, -92, 15.72, 0.5);

Die Methode exitRobotScript() beendet nur das Programm und der Roboter verbleibt im Modus der "Programmausführung".

joints(-20.00, 0.00, -23, 90.00, -92, 15.72, 0.5);
exitRobotScript();
jointsLinear(20.00, 0.00, -23, 90.00, -92, 15.72, 0.5);

Abbildung: Exit

Programm aus Programm laden ​

Die Funktion runProgram(programName) sorgt dafür, dass das angegebene Programm geladen und gestartet wird. Das aktuelle Programm wird dafür beendet. Ein Zurückspringen an diese Stelle des ersten Programms ist nicht möglich.

Beispiel:

runProgram("myProgramName");

Initialisierungsstatus abfragen ​

Wird ein Programm für das Initialisieren des Roboters genutzt, so macht es Sinn abzufragen, welche Achsen schon initialisiert sind, um darauf reagieren zu können.

Dafür gibt es zwei Befehle:

  1. isJointInitialized Der Befehl isJointInitialized(jointNumber) überprüft, ob eine bestimmte Achse initialisiert wurde. Der Parameter ist die Nummer der Achse (1 bis 6). Der Rückgabewert ist ein Boolean, der angibt, ob die Achse initialisiert ist. var joint3_initialized = isJointInitialized(3);
  2. areAllJointsInitialized Der Befehl areAllJointsInitialized() überprüft, ob alle Achsen des Roboters initialisiert sind. Der Rückgabewert ist ein Boolean, der angibt, ob alle Achsen initialisiert sind var robot_initialized = areAllJointsInitialized();

Um den Roboter zu initialisieren, muss jede Achse um bis zu 20° in eine Richtung bewegt werden.


Tool, Werkzeug, TCP & Gewicht ​

Öffnen/Schließen ​

Die Funktion openGripper() / closeGripper() öffnet/schließt den Greifer. Es müssen weder Parameter übergeben werden, noch wird ein Ergebnis zurückgeliefert.

Mit dieser Funktion können manche Greifer geöffnet werden. Dies hängt natürlich vom Hersteller des Greifers ab, funktioniert also nicht mit jedem Greifer.

TCP - Offset ermitteln ​

Es ist möglich, den Versatz des Werkzeugmittelpunkts (TCP) aus vier vorgegebenen Roboterposen mithilfe des Befehls calculateTCPOffset() zu bestimmen. Um den TCP zu ermitteln, wird ein fester Punkt aus verschiedenen Richtungen mit dem zu kalibrierenden Werkzeug angefahren. Die Positionen der Flansche sollten möglichst weit voneinander entfernt sein. Im besten Fall bilden sie einen Tetraeder um den Mittelpunkt.

Aus den vier Roboterposen (Gelenkkonfigurationen) werden die jeweiligen Positionen des Flansches berechnet. Im Folgenden werden diese Punkte, die auf einer Kugelschale liegen, zur Bestimmung des Kugelmittelpunktes verwendet. Der Versatz des TCP ergibt sich aus den Vektoren zwischen dem Zentrum und den Flanschpositionen.

Je genauer der Fixpunkt im Zentrum bei der Kalibrierung anvisiert wird, desto genauer ist das Ergebnis. Darüber hinaus ist es möglich, fünf statt vier Roboterkonfigurationen zu verwenden. Die besten vier Konfigurationen werden dann automatisch ausgewählt.

Wenn die Abstände zwischen den Flanschpositionen zu klein sind oder die Punkte in einer gemeinsamen Ebene liegen, ist die Kalibrierung nicht möglich und es wird ein Fehler ausgegeben.

Verwendung des Befehls in horstOS ​

Die vier/fünf Gelenkkonfigurationen werden an die Funktion 'calculateTCPOffset()' übergeben. Diese können von der aktuellen Roboterposition über die Schaltfläche 'Achswerte' übernommen werden.

Abbildung: Verwendung des Befehls in horstOS

Beispielhaft ist hier die Verwendung der Funktion programmiert für den H1000:

// H1000
calculateTCPOffset ({ 
    "calibrationJoints": [
        {"joints": [ -1.528, 25.627, 22.704, 23.386, 6.472, -71.733]},
        {"joints": [ 4.927, 53.429, -24.310, -20.278, 90.981, 103.912]},
        {"joints": [ -8.614, 48.885, -16.167, 28.605, 81.420, -181.406]},
        {"joints": [ -0.448, 37.943, -3.433, -1.424, 56.950, -42.952]},
    ]});

Anzeige Berechnungsergebnis ​

Als Ergebnis erhält man den Offset des TCP und die Standardabweichung in Millimetern als Info-Meldung angezeigt. Die Werte können anschließend als TCP-Werte beim Anlegen eines Tools verwendet werden (vgl. Tools importieren und erstellen).

TCP-Offset verändern ​

Das Offset des Tools kann dynamisch während des Programmablaufs angepasst werden. Diese Anpassung ist dauerhaft. Der Befehl dazu lautet changeToolOffset(name, x, y, z, rx, ry, rz) Der Befehl hat sieben Parameter. Der erste gibt den Namen des zu ändernden Tools an. Die weiteren sechs geben den offset in x,y,z,rx,ry und rz an. x,y und z werden in Metern angegeben. rx, ry und rz werden in Eulerwinkeln angegeben.

Beispiel:

changeToolOffset("nameOfMyTool", 0.0, 0.0, 0.1417, 0.0, 0.0, 45.0);

Warten auf / Pausieren ​

Pausieren ​

Der Befehl sleep(timeMillis) hat nur einen Parameter, dieser gibt an wie lange das Programm an dieser Stelle pausieren soll. Die Zeit wird in Millisekunden angegeben. Der Codeausschnitt in dem Beispiel würde das Programm also 1 Sekunde schlafen lassen (1000 Millisekunden).

sleep(1000);

Warten auf ​

Die Funktion waitfor(inputName, value) wartet solange auf den übergebenen Eingang bis dieser den übergebenen Wert erreicht.

  • 1 Parameter: Name des Eingangs (z. B. "INPUT_1")
  • 2 Parameter: Wert auf den gewartet wird (0 oder 1)
waitfor("INPUT_1", 0);

Koordinatensystem ​

Standardmäßig ist bei jedem Programm das Basis-Koordinatensystem hinterlegt. Über die Konfigurationen können weitere selbst definierte Koordinatensysteme hinzugefügt werden. Diese müssen hierfür bereits eingelernt sein. Möchte man das Koordinatensystem während des Programms ändern, ist dies durch den Befehl setCoordSystem() möglich. Dieser findet vor allem im Zusammenhang mit Wegpunkten mit variablem Koordinatensystem Anwendung.

setCoordSystem("Example_CoordSystem");

Meldungen und Pop-ups ​

Meldungen ​

Hinweis auf dem Bedienpanel anzeigen, der das Programm nicht blockiert:

showHint("");

Text in einem Pop-up-Fenster anzeigen, das das Programm blockiert:

showInfo(""), showWarning("") und showError("") unterscheiden sich nur im Layout. Dem Namen entsprechend werden Warn- bzw. Fehlersymbole angezeigt.

Pop-Up mit Eingabe ​

Es ist möglich einen Wert über ein Pop-up-Fenster einzugeben:

var user_input = getUserInput("Pop-up title", "Insert Text:", "Enter a number...");

Es existieren die folgenden Variationen:

0 Parameter:leeres Pop-up-Fenster nur mit Textfeld
1 Parameter:Pop-up-Titel
2 Parameter:Pop-up-Titel, Text/Beschreibung
3 Parameter:Pop-up-Titel, Text/Beschreibung, Beispiel/Eingabeaufforderung

Einige Eingabegeräte, z. B. Messuhren, geben Werte aus, indem sie eine Tasteneingabe simulieren, die mit Enter beendet wird. Da in diesem Fall keine Person die Eingabe vornimmt, ist es nicht nötig ein Pop-up anzuzeigen. Sobald die Methode activateReadFromKeyboard() aufgerufen wird, zeichnet horstOS alle Tasteneingaben auf. Die Methode readFromKeyboard() blockiert das Programm, bis es ein Enter registriert und gibt dann die gesamte Eingabe als String zurück.

activateReadFromKeyboard();
showInfo(readFromKeyboard());

Bereich prüfen ​

Die Funktion checkPoseConditions() überprüft, ob sich der Roboter gerade im angegebenen Bereich befindet und gibt true/false zurück. Der zu überprüfende Bereich kann über eine Map in drei Formaten angegeben werden:

1. "conditionType": "CUBOID_CORNERS" ​

Es werden die Koordinaten von 4 Eckpunkten des Quaders angegeben. Ihre Anordnung ist in der grafischen Bedienoberfläche nach Aufruf des Blocks "Bereich prüfen" visualisiert.

checkPoseConditions({
    "conditionType": "CUBOID_CORNERS",
    "tool": "No Tool",
    "C1": [0.0, 0.0, 0.0],
    "C2": [0.2, 0.0, 0.0],
    "C3": [0.0, 0.2, 0.0],
    "C4": [0.0, 0.0, 0.2]
}, "ex 1");

2. "conditionType": "CUBOID_XYZ" ​

Es werden die Koordinaten von einem Eckpunkt angegeben, gefolgt von den Abständen in x-, y- und z-Richtung zu den drei Nachbarecken.

checkPoseConditions({
    "conditionType": "CUBOID_XYZ",
    "tool": "No Tool",
    "C1": [0.1, 0.2, 0.3],
    "x": 0.05,
    "y": 0.1,
    "z": 0.2
}, "ex 2");

3. "conditionType": "JOINTS" ​

Für jede Achse wird ein Bereich in Grad angegeben.

checkPoseConditions({
    "conditionType": "JOINTS",
    "tool": "No Tool",
    "J1": [-50.0, 20.0],
    "J2": [-5.0, 54.0],
    "J3": [0.0, 30.0],
    "J4": [12.0, 56.0],
    "J5": [-56.0, 19.0],
    "J6": [8.0, 148.0]
}, "ex 3");

Der letzte Parameter ist ein Name, der dem gerade angegebenen Bereich gegeben werden kann.


Parallele Prozesse ​

Parallele Prozesse werden verwendet, um Skripte unabhängig voneinander auszuführen. Dadurch können parallel zum Hauptprogramm weitere Aktionen/Befehle ausgeführt werden.

Parallelen Prozess starten ​

Mit den folgenden beiden Befehlen werden parallele Prozesse gestartet: runThread(name, target) und runThread(name, target, cycleTime)

Der Parameter name gibt den Namen der Variablen an, die den parallelen Prozess referenziert. Diese wird nur benötigt, wenn man mit joinThread() im Hauptprogramm darauf warten möchte bis ein paralleler Prozess abgearbeitet ist.

Der Parameter target gibt den Namen des parallelen Prozesses an, der ausgeführt werden soll. Wird der Parameter cycleTime gesetzt, wird der Prozess periodisch alle x ms ausgeführt. Der Wert für cycleTime muss mindestens 10 betragen.

Beispiel:

runThread("myThread", "anyFunction");

//some more code...
joinThread("myThread");

Auf parallelen Prozess warten ​

Mit dem Befehl jointThread(name) wird auf einen bestimmten parallelen Prozess gewartet, bis er fertig ist:

Der Parameter name gibt den Namen des Prozesses an auf den gewartet werden soll.

Beispiel:

runThread("myThread", "anyFunction");

//some more code...
joinThread("myThread");

Aufräum-Prozess ​

Prozesse können als Aufräum-Prozesse registriert werden, welche nach dem Beenden des Hauptprogramms in der Reihenfolge der Registrierung nacheinander ausgeführt werden. Damit wird sichergestellt, dass eine vordefinierte Endsituation erreicht wird. Beispielsweise kann dadurch ein Gerät ausgeschaltet oder die Kommunikation zu einer Kamera geschlossen werden. Über diesen Befehl kann ein Prozess registriert werden: registerCleanUpThread(target)

Der Parameter target gibt den Namen des Prozesses an, der am Ende des Programms ausgeführt werden soll.

Beispiel:

registerCleanUpThread("anyFunction");

Geteilte Variablen ​

Geteilte Variablen werden verwendet, um Variablen zwischen allen parallelen Prozessen und dem Hauptprogramm zu teilen. Im Vergleich zur lokalen Prozess-Variable, welche nur für den eigenen Prozess ist, können auf geteilte Variablen alle parallelen Prozesse zugreifen.

Die Methode getSharedVar(key) gibt den Wert der entsprechenden Variable zurück falls für die Variable bereits ein Wert gesetzt wurde.

Die Methode setSharedVar(key, value) setzt die Variable key auf den Wert value und gibt diesen zurück.

Die Methode comparedSetSharedVar(key, expected, value) gibt 'true' zurück, wenn der aktuelle Wert der entsprechenden Variable dem erwartetem Wert entspricht, ansonsten 'false'. Der Wert wird nur im true-Fall auf den angegebenen Wert gesetzt.

Beispiel:

var myVar = 1;
setSharedVar("myVar", 2);
showInfo(getSharedVar("myVar"));

Achsbeschränkungen wechseln ​

Mit der Funktion setJointLimitation(name) kann die Achsbeschränkung geändert werden. Diese muss zuvor im Projekt definiert werden. Der Parameter name gibt den Namen der Achsbeschränkung an, die angewendet werden soll.

Beispiel:

setJointLimitation("myJointLimitation");