referenzanleitung val3 d28056202b - 06/2005 - eule-roboter.de

© Stäubli Faverges 2005 

D28056202B - 06/2005 

REFERENZANLEITUNG VAL3 

Version 5.2

2 / 122 D28056202B - 06/2005

REFERENZANLEITUNG VAL3 - Version 5.2 

EINLEITUNG....................................................................................................................... 9 

ELEMENTE DER SPRACHE VAL3.................................................................................. 10 

APPLIKATIONEN ................................................................................................................. 10 

Definition........................................................................................................................................ 10 

Vorprogrammierte Inhalte .............................................................................................................. 10 

Starten und Beenden der Applikation ............................................................................................ 10 

Parameter der Applikation ............................................................................................................. 10 

Längeneinheit............................................................................................................................................ 11 

Größe des Ausführungsspeichers............................................................................................................. 11 

PROGRAMME...................................................................................................................... 11 

Definition........................................................................................................................................ 11 

Wiedereinsprung............................................................................................................................ 11 

Programm start()........................................................................................................................... 11 

Programm stop() ........................................................................................................................... 11 

DATENTYP .......................................................................................................................... 12 

Definition........................................................................................................................................ 12 

Einfache Typen.............................................................................................................................. 12 

Strukturierte Typen ........................................................................................................................ 12 

KONSTANTEN ..................................................................................................................... 12 

Definition........................................................................................................................................ 12 

Konstanten einfachen Typs ........................................................................................................... 12 

Konstanten strukturierten Typs...................................................................................................... 12 

Konstantentabelle .......................................................................................................................... 13 

VARIABLEN ......................................................................................................................... 13 

Definition........................................................................................................................................ 13 

Gültigkeitsbereich einer Variablen ................................................................................................. 13 

Zugriff auf den Wert einer Variablen.............................................................................................. 13 

"By value"-Parameter .................................................................................................................... 14 

"By Reference"-Parameter ............................................................................................................ 14 

ANWEISUNGEN ZUR ABLAUFSTEUERUNG..................................................................... 15 

Bemerkung // ...................................................................................................................................... 15 

Aufruf des Unterprogramms call ......................................................................................................... 15 

Rückkehr aus dem Unterprogramm return......................................................................................... 16 

Anweisung if........................................................................................................................................ 16 

Anweisung while................................................................................................................................. 17 

Anweisung do ... until......................................................................................................................... 17 

Anweisung for ..................................................................................................................................... 18 

Anweisung switch............................................................................................................................... 19 

EINFACHE TYPEN ........................................................................................................... 20 

Anweisungen ................................................................................................................................. 20 

num size(Variable) .............................................................................................................................. 20 

TYP BOOL ........................................................................................................................... 21 

Definition........................................................................................................................................ 21 

Operatoren..................................................................................................................................... 21 

TYP NUM ............................................................................................................................. 21 

Definition........................................................................................................................................ 21 

Operatoren..................................................................................................................................... 22 

Anweisungen ................................................................................................................................. 22 

num sin(num Winkel) ......................................................................................................................... 22 

num asin(num Wert) .......................................................................................................................... 23 

num cos(num Winkel) ........................................................................................................................ 23 

num acos(num Wert) ......................................................................................................................... 23 

num tan(num Winkel) ......................................................................................................................... 24 

num atan(num Wert) .......................................................................................................................... 24 

num abs(num Wert) ........................................................................................................................... 24 

num sqrt(num Wert) ........................................................................................................................... 25 

num exp(num Wert) ........................................................................................................................... 25 

num ln(num Wert) .............................................................................................................................. 26 

D28056202B - 06/2005 3 / 122

num log(num Wert) ............................................................................................................................ 26 

num roundUp(num Wert) .................................................................................................................. 27 

num roundDown(num Wert) ............................................................................................................. 27 

num round(num Wert) ....................................................................................................................... 27 

num min(num x, num y) ..................................................................................................................... 28 

num max(num x, num y) .................................................................................................................... 28 

num limit(num Wert, num Mini, num Maxi) ........................................................................................ 28 

num sel(bool Bedingung, num Wert1, num Wert2) ............................................................................ 29 

TYP STRING ........................................................................................................................ 30 

Definition........................................................................................................................................ 30 

Operatoren..................................................................................................................................... 30 

Anweisungen ................................................................................................................................. 30 

string toString(string Format, num Wert) ........................................................................................... 30 

string toNum(string Kette, num& Wert, bool& Bericht) ...................................................................... 31 

string chr(num ASCII-Code) .............................................................................................................. 32 

num asc(string chaîne, num position) ................................................................................................ 33 

string left(string Kette, num Größe) ................................................................................................... 33 

string right(string Kette, num Größe) ................................................................................................. 34 

string mid(string Kette, num Größe, num Position) ............................................................................ 34 

string insert(string Kette, string Einfügen, num Position) .................................................................. 35 

string delete(string Kette, num Größe, num Position) ........................................................................ 35 

num replace(string Kette, string Ersetzen, num Größe, num Position) ............................................. 36 

num find(string Kette1, string Kette2) ................................................................................................ 36 

num len(string Kette) .......................................................................................................................... 37 

TYP DIO ............................................................................................................................... 38 

Definition........................................................................................................................................ 38 

Operatoren..................................................................................................................................... 38 

Anweisungen ................................................................................................................................. 39 

void dioLink(dio& Variable, dio Quelle) ............................................................................................. 39 

num dioGet(dio dTabelle) .................................................................................................................. 39 

num dioSet(dio dTabelle, num Wert) ................................................................................................. 40 

TYP AIO ............................................................................................................................... 41 

Definition........................................................................................................................................ 41 

Anweisungen ................................................................................................................................. 41 

void aioLink(aio& Variable, aio Quelle) ............................................................................................. 41 

num aioGet(aio Eingang) ................................................................................................................... 41 

num aioSet(aio Ausgang, num Wert) ................................................................................................. 42 

TYP SIO ............................................................................................................................... 43 

Definition........................................................................................................................................ 43 

Operatoren..................................................................................................................................... 43 

Anweisungen ................................................................................................................................. 44 

void sioLink(sio& Variable, sio Quelle) .............................................................................................. 44 

num clearBuffer(sio Eingang) ........................................................................................................... 44 

num sioGet(sio Eingang, num& Daten) ............................................................................................. 44 

num sioSet(sio Ausgang, num& Daten) ............................................................................................ 45 

BENUTZERSCHNITTSTELLE.......................................................................................... 46 

Bedienerseite................................................................................................................................. 46 

Anweisungen ................................................................................................................................. 46 

void userPage(), void userPage(bool fix)........................................................................................... 46 

void gotoxy(num x, num y) ................................................................................................................. 47 

void cls() ............................................................................................................................................. 47 

void put() void putln() ......................................................................................................................... 47 

void title(string Kette).......................................................................................................................... 48 

num get()............................................................................................................................................. 48 

num getKey() ...................................................................................................................................... 50 

bool isKeyPressed(nom code)........................................................................................................... 50 

void popUpMsg(string Kette).............................................................................................................. 50 

void logMsg(string Kette).................................................................................................................... 51 

string getProfile()................................................................................................................................ 51 



TASKS .............................................................................................................................. 52 

Definition........................................................................................................................................ 52 

Fortsetzen nach einer Fehlermeldung ........................................................................................... 52 

Starten und Beenden der Applikation ............................................................................................ 52 

Sequentielles Ordnen .................................................................................................................... 53 

Synchronisierung ........................................................................................................................... 54 

Gemeinsame Nutzung von Ressourcen ........................................................................................ 55 

Anweisungen ................................................................................................................................. 56 

void taskSuspend(string Name)......................................................................................................... 56 

void taskResume(string Name, num Sprung) .................................................................................... 56 

void taskKill(string Name) .................................................................................................................. 57 

num taskStatus(string Name) ............................................................................................................ 58 

void taskCreate string Name, num Priorität, Programm(...) ............................................................... 59 

void wait(bool Bedingung) .................................................................................................................. 60 

void delay(num Sekunden) ................................................................................................................. 60 

num clock()......................................................................................................................................... 61 

bool watch(bool Bedingung, num Sekunden)..................................................................................... 61 

BIBLIOTHEKEN................................................................................................................ 62 

Definition........................................................................................................................................ 62 

Schnittstelle ................................................................................................................................... 62 

Kennung der Schnittstelle.............................................................................................................. 62 

Inhalt .............................................................................................................................................. 62 

Im Speicher laden und aus dem Speicher entfernen..................................................................... 62 

Zugriffspfad.................................................................................................................................... 63 

Fehlercodes ................................................................................................................................... 63 

Anweisungen ................................................................................................................................. 64 

num identifiant:libLoad(string Weg).................................................................................................... 64 

num identifiant:libSave(), num libSave() ............................................................................................ 64 

num libDelete(string Weg).................................................................................................................. 64 

string identifiant:libPath(), string libPath().......................................................................................... 65 

bool libList(string Weg, string& contenu) ........................................................................................... 65 

STEUERUNG DES ROBOTERS ...................................................................................... 66 

Anweisungen ................................................................................................................................. 66 

void disablePower() ........................................................................................................................... 66 

void enablePower() ............................................................................................................................ 66 

bool isPowered() ................................................................................................................................ 66 

bool isCalibrated().............................................................................................................................. 67 

num workingMode(), num workingMode(num& Status)................................................................... 67 

num speedScale() .............................................................................................................................. 68 

num esStatus() ................................................................................................................................... 68 

ARMPOSITION ................................................................................................................. 69 

EINLEITUNG ........................................................................................................................ 69 

TYP JOINT ........................................................................................................................... 69 

Definition........................................................................................................................................ 69 

Operatoren..................................................................................................................................... 70 

Anweisungen ................................................................................................................................. 70 

joint abs(joint Position) ....................................................................................................................... 70 

joint herej() ......................................................................................................................................... 71 

bool isInRange(joint Position) ............................................................................................................ 71 

TYP TRSF ............................................................................................................................ 72 

Definition........................................................................................................................................ 72 

Orientierung ................................................................................................................................... 73 

Operatoren..................................................................................................................................... 75 

Anweisungen ................................................................................................................................. 75 

num distance(trsf Position1, trsf Position2) ....................................................................................... 75 

TYP FRAME......................................................................................................................... 76 

Definition........................................................................................................................................ 76 

Verwendung................................................................................................................................... 76 


Operatoren..................................................................................................................................... 77 

Anweisungen ................................................................................................................................. 77 

num setFrame(point Herkunft, point AchseOx, point PlanOxy, frame& Markierung) ........................ 77 

TYP TOOL............................................................................................................................ 77 

Definition........................................................................................................................................ 77 

Verwendung................................................................................................................................... 78 

Operatoren..................................................................................................................................... 78 

Anweisungen ................................................................................................................................. 79 

void open(tool Werkzeug) .................................................................................................................. 79 

void close(tool Werkzeug) ................................................................................................................. 79 

TYP POINT........................................................................................................................... 80 

Definition........................................................................................................................................ 80 

Operatoren..................................................................................................................................... 80 

Anweisungen ................................................................................................................................. 81 

num distance(point Position1, point Position2) ................................................................................. 81 

point compose(point Position, frame Markierung, trsf Umwandlung) ................................................ 82 

point appro(point Position, trsf Umwandlung) .................................................................................... 83 

point here(tool Werkzeug, frame Markierung) ................................................................................... 83 

point jointToPoint(tool Werkzeug, frame Markierung, joint Position) ................................................ 84 

bool pointToJoint(tool Werkzeug, joint anfänglich, point Position,joint& Angaben) ......................... 84 

trsf position(point Position, frame Markierung) ................................................................................. 85 

TYP CONFIG........................................................................................................................ 86 

Einleitung ....................................................................................................................................... 86 

Definition........................................................................................................................................ 86 

Operatoren..................................................................................................................................... 87 

Konfiguration (Arm RX/TX) ............................................................................................................ 87 

Konfiguration der Schulter......................................................................................................................... 87 

Konfiguration des Ellenbogens ................................................................................................................. 88 

Konfiguration des Handgelenks ................................................................................................................ 88 

Konfiguration (Arm RS).................................................................................................................. 89 

Anweisungen ................................................................................................................................. 90 

config config(joint Position) ............................................................................................................... 90 

BEWEGUNGSSTEUERUNG............................................................................................ 91 

BEWEGUNGSSTEUERUNG ............................................................................................... 91 

Bewegungstypen: Punkt-zu-Punkt, geradlinig, kreisförmig ........................................................... 91 

Verkettung von Bewegungen......................................................................................................... 93 

Glättung..................................................................................................................................................... 93 

Aufheben der Glättung.............................................................................................................................. 94 

Wiederaufnahme einer Bewegung ................................................................................................ 95 

Besonderheiten der kartesischen Bewegungen (geradlinig, kreisförmig)...................................... 96 

Interpolation der Ausrichtung .................................................................................................................... 96 

Änderung der Konfiguration (Arm RX/TX)................................................................................................. 98 

Singularitäten (Arm RX/TX).................................................................................................................... 100 

ANTIZIPATION VON BEWEGUNGEN............................................................................... 100 

Prinzip.......................................................................................................................................... 100 

Antizipation und Glättung............................................................................................................. 101 

Synchronisierung ......................................................................................................................... 101 

GESCHWINDIGKEITSSTEUERUNG ................................................................................ 102 

Prinzip.......................................................................................................................................... 102 

Einfache Einstellung .................................................................................................................... 102 

Komplexere Einstellungen ........................................................................................................... 102 

Schleppfehler............................................................................................................................... 103 

ONLINE-BEWEGUNGSSTEUERUNG............................................................................... 103 

TYP MDESC....................................................................................................................... 104 

Definition...................................................................................................................................... 104 

Operatoren................................................................................................................................... 104 

BEWEGUNGSANWEISUNGEN......................................................................................... 105 

void movej(joint joint, tool Werkzeug, mdesc desc)......................................................................... 105 

void movel(point Punkt, tool Werkzeug, mdesc desc)..................................................................... 106 



void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, mdesc desc) ............................................. 107 

void stopMove()............................................................................................................................... 108 

void resetMotion(), void resetMotion(joint Start) ............................................................................. 108 

void restartMove() ........................................................................................................................... 109 

void waitEndMove() ........................................................................................................................ 109 

bool isEmpty() ................................................................................................................................. 110 

bool isSettled() ................................................................................................................................ 110 

void autoConnectMove(bool aktiv), bool autoConnectMove() ..................................................... 110 

OPTIONEN...................................................................................................................... 111 

AUSGEGLICHENE BEWEGUNGEN MIT KRAFTSTEUERUNG....................................... 111 

Prinzip.......................................................................................................................................... 111 

Programmierung .......................................................................................................................... 111 

Steuerung der Kraft ..................................................................................................................... 111 

Begrenzungen ............................................................................................................................. 112 

Anweisungen ............................................................................................................................... 112 

void movejf(joint Position, tool Werkzeug, mdesc desc, num Kraft) ............................................... 112 

void movelf(point Punkt, tool Werkzeug, mdesc desc, num Kraft) ................................................. 113 

bool isCompliant() .......................................................................................................................... 114 

ANHANG......................................................................................................................... 115 

FEHLERCODES................................................................................................................. 115 

TASTENCODES DER BEDIENKONSOLE ........................................................................ 116 

ADDILDUNG................................................................................................................... 117 

INDEX.............................................................................................................................. 119 




EINLEITUNG 

VAL3 ist eine höhere Programmiersprache für die Steuerung von Stäubli-Robotern bei der Ausführung industrieller 

Handhabungs- und Montageaufgaben. 

VAL3 besitzt alle wichtigen Funktionen von gängigen Echtzeit-Programmiersprachen und zusätzlich die speziellen 

Steuerungsfunktionen für Industrieroboter: 

• Steuerungsprogramme des Roboters 

• Programme zur Erstellung geometrischer Modelle 

• Tools zur Ansteuerung der Ein-/Ausgänge 

In dem vorliegenden Handbuch sind alle zur Programmierung notwendigen Begriffe und Anweisungen der VAL3- 

Sprache eingehend erläutert. Es enthält die Kapitel: 

• Sprachelemente 

• Einfache Typen 

• Benutzerschnittstelle 

• Tasks 

• Bibliotheken 

• Steuerung des Roboters 

• Position des Roboterarms 

• Bewegungssteuerung 

Zum leichteren Auffinden sind die Anweisungen mit ihrer Syntax im Inhaltsverzeichnis angegeben. 


Die Sprache VAL3 enthält folgende Elemente: 

• Applikationen 

• Programme 

• Bibliotheken 

• Datentypen 

• Konstanten 

• Variablen (globale, lokale und Parameter) 

• Tasks 

APPLIKATIONEN 

ELEMENTE DER SPRACHE VAL3 

Definition 

Eine VAL3-Applikation ist ein eigenständiges Programm zur Programmierung des Roboters einer CS8-Steuerung. 

Eine VAL3-Applikation besteht aus folgenden Elementen: 

- einer Gruppe von Programmen: den auszuführenden VAL3-Anweisungen, 

- einer Gruppe von globalen Variablen: den Daten der Applikation 

- einer Gruppe von Bibliotheken: von der Applikation benutzte externe Anweisungen und Daten 

Während ihrer Ausführung enthält eine Applikation außerdem: 

- eine Gruppe von Tasks: die zu diesem Zeitpunkt ausgeführten Programme 

Vorprogrammierte Inhalte 

Eine VAL3-Applikation enthält immer die Programme start() und stop(), das Koordinatensystem world (Typ frame) 

und das Tool flange (Typ tool). 

Bei der Erstellung enthält eine VAL3-Applikation außerdem die speziellen Anweisungen und Daten des gewählten 

Modells. 

Diese Elemente werden in den entsprechenden Kapiteln detailliert beschrieben. 

Starten und Beenden der Applikation 

Applikationen können nicht mit VAL3-Anweisungen gehandhabt werden: Das Laden, Speichern, Starten und Beenden 

der Applikationen erfolgt ausschließlich über die Benutzerschnittstelle der CS8. 

Zum Starten einer VAL3-Applikation wird das Programm start() ausgeführt. 

Wenn die letzte Task beendet ist, schließt die VAL3-Applikation sich selbst: das Programm stop() wird dann 

ausgeführt. Alle eventuell verbleibenden, von den Bibliotheken erstellten Tasks werden in der umgekehrten 

Reihenfolge ihrer Erstellung gelöscht. 

Wird eine VAL3-Applikation von der Benutzerschnittstelle der CS8 aus unterbrochen, so wird die Start-Task, falls sie 

noch vorhanden ist, augenblicklich gelöscht. Dann wird das Programm stop() ausgeführt, worauf alle noch nicht 

ausgeführten Tasks der Applikation in der umgekehrten Reihenfolge ihrer Erstellung gelöscht werden. 

Parameter der Applikation 

Eine VAL3-Applikation wird mit folgenden Parametern konfiguriert: 

- Längeneinheit 

- Größe des Ausführungsspeichers 

Diese Parameter sind mit einer VAL3-Anweisung nicht zugänglich und können nur über die Benutzerschnittstelle der 

CS8 geändert werden. 



Längeneinheit 

In den VAL3-Applikationen werden Millimeter oder Inch als Längeneinheit verwendet. Sie dienen zur Beschreibung der 

geometrischen Daten von VAL3: Koordinatensysteme, Punkte, Transformationen, Werkzeuge oder Bahnglättungen. 

Die Längeneinheit wird bei Erstellung einer Applikation durch die im System geltende Längeneinheit festgelegt und 

kann anschließend nicht mehr geändert werden. 

Größe des Ausführungsspeichers 

Der Ausführungsspeicher einer VAL3-Applikation ist der für die einzelnen Tasks verfügbare Speicher, in dem unter 

anderem lokale Programmvariablen abgelegt werden. Der voreingestellte Wert beträgt 5000 Bytes. 

Dieser Wert kann jedoch für Applikationen mit besonders umfangreichen Tabellen lokaler Variablen oder rekursiven 

Algorithmen nicht ausreichen: Er muss in diesem Fall über die Benutzerschnittstelle der CS8 erhöht werden. 

PROGRAMME 

Definition 

Ein Programm enthält eine Reihe von VAL3-Anweisungen, die auszuführen sind. 

Es besteht aus folgenden Elementen: 

- einer Sequenz von Anweisungen: den auszuführenden VAL3-Anweisungen, 

- einer Gruppe von lokalen Variablen: den programminternen Daten, 

- einer Gruppe von Parametern: den Daten, die dem Programm beim Aufrufen geliefert werden. 

Programme dienen zur Zusammenfassung von Anweisungssequenzen, um sie an verschiedenen Stellen in einer 

Applikation verwenden zu können. Neben dem geringeren Programmierungsaufwand werden die Applikationen 

dadurch übersichtlicher, was die Programmierung und Wartung erleichtert und die Lesbarkeit verbessert. 

Die Anzahl der Programmanweisungen ist nur durch den im System verfügbaren Speicherplatz begrenzt. 

Die Anzahl der lokalen Variablen und Parameter ist nur durch den Ausführungsspeicher der Applikation begrenzt. 

Wiedereinsprung 

Die Programme erlauben den Wiedereinsprung (Reentrantprogramme), d.h. ein Programm kann sich selbst rekursiv 

aufrufen (Anweisung call) oder von mehreren Tasks gleichzeitig aufgerufen werden. Jeder Programmaufruf besitzt 

seine eigenen lokalen Variablen und Parameter. 

Programm start() 

Um die VAL3-Applikation zu starten, wird das Programm start() aufgerufen. Es kann keine Parameter besitzen. 

In diesem Programm befinden sich alle zum Start der Applikation erforderlichen Vorgänge: Initialisierung der globalen 

Variablen, der Ein-/Ausgänge, Starten der Tasks der Applikation.... 

Die Applikation ist am Ende des start()-Programms noch nicht unbedingt beendet, da noch andere Tasks dieser 

Applikation in der Ausführung sein können. 

Das start()-Programm kann, wie jedes andere Programm, in einem anderen Programm aufgerufen werden (Anweisung 

call). 

Programm stop() 

Das Programm stop() wird am Ende der Ausführung der VAL3-Applikation aufgerufen. Es kann keine Parameter 

besitzen. 

In diesem Programm finden sich im Allgemeinen alle zum korrekten Beenden der Applikation erforderlichen Vorgänge: 

Reinitialisierung der Ein-/Ausgänge, Beenden der Tasks der Applikation in einer bestimmten Reihenfolge.... 

Das stop()-Programm kann, wie jedes andere Programm, in einem anderen Programm aufgerufen werden (Anweisung 

call): Das Aufrufen des stop()-Programms führt nicht zum Abbruch der Applikation. 


DATENTYP 

Definition 

Der Typ einer VAL3-Konstanten oder -Variablen ist ein Merkmal, mit dem das System die diese enthaltenden 

Anweisungen und Programme steuern kann. 

Alle VAL3-Konstanten und -Variablen besitzen einen Typ. Damit ist beim Editieren eines Programms eine erste 

Überprüfung durch das System und die sofortige Erkennung bestimmter Programmierfehler möglich. 

Einfache Typen 

Die Sprache VAL3 unterstützt folgende einfache Typen: 

- Typ bool: für boolesche Werte (true/false) 

- Typ num: für digitale Werte 

- Typ string: für Zeichenketten 

- Typ dio: für digitale Ein-/Ausgänge 

- Typ aio: für numerische Ein-/Ausgänge (analog oder digital) 

- Typ sio: für Ein-/Ausgänge serieller Verbindungen und Ethernet-Socket 

Strukturierte Typen 

Ein strukturierter Typ enthält mehrere Datentypen, so genannte strukturierte Datenfelder. Strukturierte Datenfelder 

können mit ihrem Namen einzeln aufgerufen werden. 

Die Sprache VAL3 unterstützt folgende strukturierte Typen: 

- Typ trsf: für kartesische Koordinatentransformationen 

- Typ frame: für das kartesische Koordinatensystem 

- Typ tool: für die am Roboter montierten Tools 

- Typ point: für die kartesischen Toolpositionen 

- Typ joint: für die Winkelpositionen der Robotergelenke 

- Typ config: für die Roboterkonfigurationen 

- Typ mdesc: für die Bewegungsparameter des Roboters 

KONSTANTEN 

Definition 

Eine Konstante ist ein Datenelement, das direkt und ohne vorherige Deklaration in einem VAL3-Programm festgelegt 

ist. Der Typ einer Konstante ist implizit durch das System vorgegeben. 

Konstanten einfachen Typs 

Die genaue Syntax einer Konstante einfachen Typs ist im betreffenden Kapitel der einfachen Typen angegeben. 

Zum Beispiel 

bool bBool 

num nPi 

string sString 

bBool = true 

nPi = 3.141592653 

sString = "Dies ist eine konstante Kette" 

Konstanten strukturierten Typs 

Der Wert einer Konstante strukturierten Typs ist durch die aufeinanderfolgenden Werte ihrer Felder festgelegt. Die 

Reihenfolge ist im Kapitel über die strukturierte Typen angegeben. 



Zum Beispiel 

procedure dummy(trsf t, dio d) 

point p 

p = {{100, -50, 200, 0, 0, 0}, {sfree, efree, wfree}} 

call dummy({a+b, 2* c, 120, limit(c, 0, 90), 0, 0}, io:Ventil1) 

Konstantentabelle 

Eine Konstantentabelle muss für jeden einzelnen Eingang initialisiert werden. 

Zum Beispiel 

joint j[5 ] 

j[0] = {0, 0, 0, 0, 0, 0} 

j[1] = {90, 0, 90, 0, 0, 0} 

j[2] = {-90, 0, 90, 0, 0, 0} 

j[3] = {90, 0, 0, -90, 0, 0} 

j[4] = {-90, 0, 0, -90, 0, 0} 

VARIABLEN 

Definition 

Eine Variable ist ein Datenelement in einem Programm, das durch seinen Namen gekennzeichnet ist. 

Eine Variable ist definiert durch: 

- ihren Namen: eine Zeichenkette 

- ihren Typ: einen der oben beschriebenen VAL3-Typen 

- ihre Größe: z.B. die Anzahl der Datenelemente in einer Tabelle 

- ihren Gültigkeitsbereich: das (die) zur Verwendung dieser Variablen berechtigte(n) Programm(e) 

Der Name einer Variablen ist eine Zeichenkette mit 1 bis 12 Zeichen von "a..zA..Z0..9_". 

Alle Variablen können wie Tabellen verwendet werden. Einfache Variablen haben die Größe 1. Die Größe einer 

Variablen kann mittels der Anweisung size() in Erfahrung gebracht werden. 

Gültigkeitsbereich einer Variablen 

Eine Variable kann folgende Gültigkeitsbereiche haben: 

• global: Diese Variable kann von allen Programmen verwendet werden 

• lokal: Diese Variable kann nur in dem Programm verwendet werden, in dem sie deklariert wurde 

Haben eine globale und eine lokale Variable den gleichen Namen, wird das Programm, in dem die lokale Variable 

deklariert ist, die lokale Variable verwenden und nicht auf die globale Variable zugreifen. 

Die Parameter eines Programms sind lokale Variablen, die nur in dem Programm, in dem sie deklariert wurden, 

verwendet werden können. 

Zugriff auf den Wert einer Variablen 

Auf die Datenelemente einer Tabelle kann mit dem in Klammern gesetzten Index zugegriffen werden ‘[‘ und ‘]’. Der 

Index muss einen Wert zwischen 0 und (Größe-1) besitzen, sonst wird bei der Ausführung eine Fehlermeldung 

generiert. 

Wenn kein Index spezifiziert wurde, wird der Index 0 verwendet: var[0] entspricht var. 

Die Felder von strukturierten Variablen sind mit einem ‘.’ gefolgt vom Namen des Feldes zugänglich. 

Wenn das Feld selbst strukturierten Typs ist, kann nicht direkt auf dessen Felder zugegriffen werden. 


Zum Beispiel 

num a // a ist eine Variable vom Typ num mit der Größe 1 

num b[10] // b ist eine Variable vom Typ num mit der Größe 10 

trsf t 

point p 

a = 0 // Initialisierung einer einfachen Variable 

a[0] = 0 // Korrekt: entsprechend a = 0 

b[0] = 0 // Initialisierung des ersten Datenelements der Tabelle b 

b = 0 // Korrekt: entsprechend b[0] = 0 

b[5] = 5 // Initialisierung des sechsten Datenelements der Tabelle b 

b[5.13] = 7 // Korrekt: entsprechend b[5] = 7 (nur der ganzzahlige Teil wird verwendet) 

b[-1] = 0 // Fehler: Index kleiner 0 

b[10] = 0 // Fehler: Index zu groß 

t = p.trsf // Initialisierung von t 

p.trsf.x = 100 // Fehler: x ist nicht direkt zugänglich 

t.x = 100 // Initialisierung des Feldes x einer Variable trsf 

p.trsf = t // Initialisierung des Feldes trsf einer Variablen point 

"By value"-Parameter 

Bei einer "By Value"-Parameter-Übergabe erstellt das System eine lokale Variable und initialisiert diese mit dem Wert 

der Variablen oder des Ausdrucks, der vom aufrufenden Programm geliefert wird. 

Die Variablen des aufrufenden Programms, die als By Value-Parameter verwendet werden, bleiben unverändert, auch 

wenn das aufgerufene Programm den Wert des Parameters geändert hat. 

Eine Datentabelle kann nicht "by value" übergeben werden. 

Zum Beispiel: 

procedure dummy(num x) // x per By Value-Übergabe 

begin 

x=0 

putln(x) // ergibt 0 

end 

num a 

a=10 

putln(a) // ergibt 10 

call dummy(a) // ergibt 0 

putln(a) // ergibt 10: a wird von dummy() nicht geändert 

"By Reference"-Parameter 

Bei einer "By Reference"-Parameter-Übergabe arbeitet das Programm nicht mehr mit einer Kopie des vom aufrufenden 

Programm übergebenen Datenelements, sondern mit dem Datenelement selbst, das nur lokal umbenannt wurde. 

Die Variablen des aufrufenden Programms, die als By Reference-Parameter verwendet werden, ändern ihren Wert, 

wenn das aufgerufene Programm den Wert des Parameters ändert. 

Alle Elemente einer "By Reference" übergebenen Tabelle können benutzt und geändert werden. Wird ein Element einer 

Tabelle "By Reference" übergeben, so können dieses Element und alle ihm folgenden Elemente benutzt und geändert 

werden. Der Parameter wird dann wie eine Tabelle betrachtet, die bei dem beim Aufruf übergebenen Element beginnt. 

Die Anweisung size() ermöglicht es, die effektive Größe eines Parameters in Erfahrung zu bringen. 

Wenn eine Konstante oder ein Ausdruck "By reference" übergeben wurde, hat eine Zuweisung des entsprechenden 

Parameters keinen Effekt: der Parameter behält den Wert der Konstanten oder des Ausdrucks bei. 



Zum Beispiel: 

procedure dummy(num& x) // x per By Reference-Übergabe 

begin 

x=0 

putln(x) // ergibt 0 

end 

procedure element(num& x) 

begin 

x[3] = 0 

putln(size(x)) 

end 

num a 

num b[10] 

a=10 

putln(a) // ergibt 10 

call dummy(a) // ergibt 0 

putln(a) // ergibt 0: a wird von dummy() geändert. 

b[2] = 2 

b[5] = 5 

call element(b[2]) // ergibt 8, die Elemente 0 und 1 von b wurden nicht übergeben 

putln(b[5]) // ergibt 0: b[5] wird von element() geändert. 

ANWEISUNGEN ZUR ABLAUFSTEUERUNG 

Syntax 

// 

Bemerkung // 

Funktion 

Eine Zeile, die mit « // » beginnt, wird nicht berücksichtigt, das Programm geht auf die nächste Zeile weiter. 

Zum Beispiel 

// Dies ist ein Beispiel für eine Bemerkung 

Syntax 

call Programm([Parameter1][,Parameter2]) 

Aufruf des Unterprogramms call 

Funktion 

Führt das aufgerufene Programm mit den angegebenen Parametern aus. 


Zum Beispiel 

// Ruft die Programme pick() und place() für i,j zwischen 1 und 10 auf. 

for i = 1 to 10 

for j = 1 to 10 

call pick (i, j) 

call place (i, j) 

endFor 

endFor 

Syntax 

return 

Rückkehr aus dem Unterprogramm return 

Funktion 

Das laufende Programm wird sofort verlassen. Wenn das Programm durch einen call aufgerufen worden war, wird die 

Programmausführung im aufrufenden Programm nach dem call fortgesetzt. Andernfalls (z. B. wenn das 

Unterprogramm das Programm start() oder der Startpunkt für eine Task ist) wird die laufende Task beendet. 

Anweisung if 

Syntax 

if 

 

[else 

] 

endIf 

Funktion 

Wenn die Überprüfung der booleschen Bedingung Bedingung wahr (true) ergibt, werden alle eventuell nachfolgenden 

Anweisungen bis zur Bedingung else oder endIf überprüft. 

Wenn der Ausdruck falsch (false) ist, werden die zwischen else und endIf liegenden Anweisungen überprüft, sofern 

else vorhanden ist. In jedem Fall wird die Ausführung des Programms nach der Anweisung endIf fortgesetzt. 

Parameter 

bool Bedingung zu überprüfender boolescher Ausdruck 

Zum Beispiel 

string s 

num a 

// s = "a=0" wenn a=0, sonst "a = ? " 

s = "a = ? " 

if a==0 

s = "a=0" 

endIf 

// s = "a=0" wenn a=0, sonst "a 0" 

s = "a = ? " 

if a==0 

s = "a = 0" 

else 

s = "a 0" 

endIf 



Anweisung while 

Syntax 

while 

 

endWhile 

Funktion 

Die Anweisungen zwischen while und endWhile werden solange ausgeführt, wie die boolesche Bedingung 

Bedingung wahr (true) ist. 

Wenn die boolesche Bedingung Bedingung bei der ersten Überprüfung nicht wahr ist, werden die Anweisungen 

zwischen while und endWhile nicht ausgeführt. 

Parameter 


Zum Beispiel 

dio dLampe 

// Bewirkt das Blinken eines Signals solange der Roboter nicht stillsteht 

dLampe = false 

while (isSettled()==false) 

dLampe = ! dLampe // Bildet den Kehrwert für die dLampe: true false 

delay(0.5) // Wartet ½ s 

endWhile 

dLampe = false 

Anweisung do ... until 

Syntax 

do 

 

until 

Funktion 

Die Anweisungen zwischen do und until werden solange ausgeführt, bis die boolesche Bedingung Bedingung wahr 

(true) ist. 

Die Anweisungen zwischen do und until werden ausgeführt, wenn die boolesche Bedingung Bedingung bei der 

erstmaligen Überprüfung wahr ist. 

Parameter 


Zum Beispiel 

num a 

// Warten auf Betätigung der Enter-Taste 

do 

a = get() // Warten auf Betätigen einer Taste 

until (a == 270) // Testet den Code der Enter-Taste 


Anweisung for 

Syntax 

for = to [step ] 

 

endFor 

Funktion 

Die Anweisungen zwischen for und endFor werden solange ausgeführt, bis Zähler den spezifizierte Wert Ende 

überschreitet. 

Der Zähler wird auf den Wert Anfang initialisiert. Wenn Anfang Ende überschreitet, werden die Anweisungen 

zwischen for und endFor nicht ausgeführt. Bei jedem Iterationsschritt wird Zähler um den Wert Schritt und die 

Anweisungen zwischen for und endFor werden, solange der Zähler den Wert Ende nicht überschreitet, wiederholt. 

Wenn Schritt positiv ist, hat der Zähler Ende dann überschritten, wenn er größer ist als Ende. Wenn Schritt negativ 

ist, hat der Zähler Ende überschritten, wenn er kleiner ist als Ende. 

Parameter 

num Zähler Variable des Typs num, die als Zähler verwendet wird 

num Anfang Numerischer Ausdruck zur Initialisierung des Zählers 

num Ende Numerischer Ausdruck zum Test des Schleifenendes 

[num Schritt] Numerischer Ausdruck zur Erhöhung des Zählers 

Zum Beispiel 

num i 

joint jDest 

jDest = {0,0,0,0,0,0} 

// Dreht die Achse 1 von 10° in Schritten von je 10 Grad 

for i = 90 to -90 step -10 

jDest.j1 = i 

movej(jDest, flange, mNomSpeed) 

waitEndMove() 

endFor 



Anweisung switch 

Syntax 

switch 

case [, ] 

 

break 

[case [, ] 

 

break ] 

[default 

 

break ] 

endSwitch 

Funktion 

Führt die Anweisungen für die spezifizierte Auswahl aus. 

Wenn für Auswahl ein nicht ganzzahliger Wert spezifiziert wurde oder für eine Fall (Fall Test), wird die nächstliegende 

ganze Zahl verwendet. 

Wenn kein Fall auf die spezifizierte Auswahl zutrifft, werden die Standardanweisungen ausgeführt, sofern vorhanden. 

Wenn der gleiche Wert für Fall mehrmals auftritt, wird nur das letzte Auftreten berücksichtigt. 

Parameter 

num Auswahl Variable numerischen Typs num zur Auswahl 

num Fall1 Numerische Konstante für den Testfall 




Zum Beispiel 

num nMenü 

string s 

// Testet, ob die Menütaste gedrückt ist 

nMenü = get() 

switch nMenü 

case 271 

s = "Menü 1" 

break 

case 272 

s= "Menü 2" 

break 

case 273, 274, 275, 276, 277, 278 

s = "Menü 3 à 8" 

break 

default 

s = "Diese Schaltfläche ist kein Menü" 

break 

endSwitch 


Anweisungen 

Syntax 

num size() 

EINFACHE TYPEN 

num size(Variable) 

Funktion 

Liefert die Größe der Variable. 

Wenn es sich bei Variable um einen "By Reference" übergebenen Programmparameter handelt, so hängt ihre Größe 

von dem beim Aufruf des Programms festgelegten Index ab. 

Parameter 

Variable Variable beliebigen Typs 

Zum Beispiel 

num nTabelle[10] 

program printSize(num& nParamètre) 

begin 

putln(size(nParamètre)) 

end 

call printSize(nTabelle) // ergibt 10 

call printSize(nTabelle[6]) // ergibt 4 



TYP BOOL 

Definition 

Variablen oder Konstanten des Typs bool können folgende Werte annehmen: 

- true: wahr 

- false: falsch 

Der vorprogrammierte Wert für eine Variable des Typs bool ist immer false. 

Operatoren 

Mit zunehmender Priorität: 

bool = 

bool or 

 

bool and 

 

bool xor 

bool 

bool != 

 

bool == 

 

TYP NUM 

Definition 

Der Typ num stellt einen numerischen Wert mit etwa 14 signifikanten Stellen dar. 

Numerische Berechnungen erfolgen daher mit einer durch die 14 Stellen beschränkten Genauigkeit. 

Dies ist bei der Prüfung der Gleichheit zweier numerischer Werte zu berücksichtigen: Deshalb muss in der Regel in 

einem Intervall geprüft werden. 

Zum Beispiel 

putln(sel(cos(90)==0,1,-1)) // ergibt -1 

putln(sel(abs(cos(90))

Operatoren 


num = Weist Wert der Variable Variable zu und überträgt den 

Wert. 

bool != Überträgt true, wenn Wert1 ungleich Wert2 ist, 

andernfalls false. 

bool == Überträgt true, wenn Wert1 gleich Wert2 ist, 


bool >= Überträgt true, wenn Wert1 größer gleich Wert2 ist, 


bool > Überträgt true, wenn Wert1 größer Wert2 ist, 


bool


Syntax 

num asin() 

num asin(num Wert) 

Funktion 

Liefert die Inverse des Sinus von Wert in Grad. Das Ergebnis liegt zwischen -90 und +90 Grad. 

Ist Wert größer als 1 oder kleiner als -1, wird eine Fehlermeldung generiert. 

Parameter 

num Wert Numerischer Ausdruck 

Zum Beispiel 

putln(asin(0.5)) // ergibt 30 

Syntax 

num cos() 

Funktion 

Liefert den Cosinus von Winkel. 

Parameter 

num Winkel Winkel in Grad 

Zum Beispiel 

putln(cos(60)) // ergibt 0.5 

Syntax 

num acos() 

num cos(num Winkel) 

num acos(num Wert) 

Funktion 

Liefert die Inverse des Cosinus von Wert in Grad. Das Ergebnis liegt zwischen 0 und 180 Grad. 

Ist Wert größer als 1 oder kleiner als -1, wird eine Fehlermeldung generiert. 

Parameter 


Zum Beispiel 

putln(acos(0.5)) // ergibt 60 


Syntax 

num tan() 

num tan(num Winkel) 

Funktion 

Liefert die Tangente von Winkel. 

Ist der Winkel zu groß oder zu klein (ungenügende Rechengenauigkeit), wird eine Fehlermeldung generiert. 

Parameter 

num Winkel Winkel in Grad 

Zum Beispiel 

putln(tan(45)) // ergibt 1.0 

Syntax 

num atan() 

num atan(num Wert) 

Funktion 

Liefert die Inverse des Tangens von Wert in Grad. Das Ergebnis liegt zwischen -90 und +90 Grad. 

Parameter 


Zum Beispiel 

putln(atan(1)) // ergibt 45 

Syntax 

num abs() 

Funktion 

Liefert den Absolutbetrag von Wert. 

Parameter 

Zum Beispiel 

num abs(num Wert) 


putln(sel(abs(45)==abs(-45),1,-1)) // ergibt 1 



Syntax 

num sqrt() 

Funktion 

Liefert die Quadratwurzel von Wert. 

Ist Wert negativ, wird eine Fehlermeldung generiert. 

Parameter 

num sqrt(num Wert) 


Zum Beispiel 

putln(sqrt(9)) // ergibt 3 

Syntax 

num exp() 

Funktion 

Liefert den Exponentialwert vonWert. 

Ist Wert zu groß, wird eine Fehlermeldung erzeugt. 

Parameter 

Zum Beispiel 

num exp(num Wert) 


putln(exp(1)) // ergibt 2.718282 


Syntax 

num ln() 

num ln(num Wert) 

Funktion 

Liefert den natürlichen Logarithmus von Wert. 

Ist Wert negativ oder null, wird eine Fehlermeldung generiert. 

Parameter 


Zum Beispiel 

putln(ln(2.718281828)) // ergibt 1 

Syntax 

num log() 

num log(num Wert) 

Funktion 

Liefert den Zehnerlogarithmus von Wert. 

Ist Wert negativ oder null, wird eine Fehlermeldung generiert. 

Parameter 


Zum Beispiel 

putln(log(10)) // ergibt 1 



Syntax 

num roundUp() 

Funktion 

Liefert den nächstgrößeren ganzzahligen Wert. 

Parameter 

num roundUp(num Wert) 


Zum Beispiel 

putln(roundUp(7.8)) // Ergibt den Wert 8 

putln(roundUp(-7.8)) // Ergibt den Wert -7 

Syntax 

num roundDown() 

Funktion 

Liefert den nächstkleineren ganzzahligen Wert. 

Parameter 

Zum Beispiel 

Syntax 

num round() 

Funktion 

Liefert den nächstliegenden ganzzahligen Wert. 

Parameter 

Zum Beispiel 

num roundDown(num Wert) 


putln(roundDown(7.8)) // Ergibt den Wert 7 

putln(roundDown(-7.8)) // Ergibt den Wert -8 

num round(num Wert) 


putln(round(7.8)) // Ergibt den Wert 8 

putln(round(-7.8)) // Ergibt den Wert -8 


Syntax 

num min(, ) 

Funktion 

Liefert den kleineren Wert von x und y. 

Parameter 

num min(num x, num y) 

num x Numerischer Ausdruck 

num y Numerischer Ausdruck 

Zum Beispiel 

putln(min(-1,10)) // Ergibt den Wert -1 

Syntax 

num max(, ) 

Funktion 

Liefert den größeren Wert von x und y. 

Parameter 

Zum Beispiel 

Syntax 

num max(num x, num y) 

num x Numerischer Ausdruck 

num y Numerischer Ausdruck 

putln(max(-1,10)) // Ergibt den Wert -10 

num limit(num Wert, num Mini, num Maxi) 

num limit(, , ) 

Funktion 

Liefert den durch die Werte Mini und Maxi begrenzten Wert. 

Parameter 


num Mini Numerischer Ausdruck 

num Maxi Numerischer Ausdruck 

Zum Beispiel 

putln(limit(30,-90,90)) // ergibt 30 

putln(limit(100,90,-90)) // ergibt 90 

putln(limit(-100,-90,90)) // ergibt -90 



Syntax 

num sel(bool Bedingung, num Wert1, num Wert2) 

num sel(, , ) 

Funktion 

Liefert Wert1, wenn Bedingung gleich true ist, ansonsten Wert2. 

Parameter 

bool Bedingung Boolescher Ausdruck 

num Wert1 Numerischer Ausdruck 

num Wert2 Numerischer Ausdruck 

Zum Beispiel 

putln(sel(bFlag,a,b)) 

// ist äquivalent zu 

if bFlag==true 

putln(a) 

else 

putln(b) 

endIf 


TYP STRING 

Definition 

Variablen des Typs Zeichenkette (string) dienen zur Speicherung von Texten. 

Zeichenketten können eine maximale Länge von 128 Zeichen haben. 

Der Typ string akzeptiert editierbare Zeichen ohne Akzente (ASCII-Codes 32 bis 126) mit Ausnahme des Zeichens ". 

Variablen des Typs string werden vorprogrammiert auf den Wert "" initialisiert (Länge null). 

Operatoren 


string = Weist der Variablen Variable die Zeichenkette zu und 

überträgt Kette. 

bool != Liefert true, wenn Kette1 und Kette2 nicht identisch 

sind, ansonsten false. 

bool == Liefert true, wenn Kette1 und Kette2 identisch sind, 

ansonsten false. 

string +


Syntax 

string toNum(string Kette, num& Wert, bool& Bericht) 

string toNum(, , bool& Bericht) 

Funktion 

Bestimmt den numerischen Wert am Anfang der genannten Kette, und übergibt Kette, in der alle Zeichen bis zum 

nächsten numerischen Wert entfernt worden sind. 

Befindet sich am Anfang von Kette kein numerischer Wert, so wird Bericht auf false gesetzt und Wert wird nicht 

geändert, andernfalls wird rapport auf true gesetzt. 

Parameter 

string Kette Ausdruck des Typs Zeichenkette 

num& Wert Variable des Typs num 

bool& Bericht Variable des Typs bool 

Zum Beispiel 

num nVal 

bool bOk 

putln(toNum("10 20 30", nVal, bOk)) // Zeigt «20 30» an, nVal nimmt den Wert 10, bOk den Wert true 

putln(toNum("a10 20 30", nVal, bOk)) // Zeigt «a10 20 30» an, nVal bleibt unverändert, bOk ist false 

putln(toNum("10 end", nVal, bOk)) // Zeigt «» an, nVal nimmt den Wert 10, bOk den Wert true 

buffer = "+90 0.0 -7.6 17.3" 

do 

buffer = toNum(buffer, nVal, bOk) 

putln(nVal) // Zeigt nacheinander an: 90, 0, -7.6, 17.3 

until (bOk ! = true) 

Siehe auch 

string toString(string Format, num Wert) 


Syntax 

string chr() 

string chr(num ASCII-Code) 

Funktion 

Übergibt das der Zahl ASCII Wert-Code entsprechende Zeichen, wenn dieses als Typ string erkannt wird, andernfalls 

eine leere Zeichenkette. 

In der nachstehenden Tabelle sind die ASCII-Code-Zahlen kleiner 128 zusammengestellt. Die grau dargestellten 

Zeichen werden nicht als Typ string erkannt: 

Parameter 

num Wert Ausdruck des Typs num 

Zum Beispiel 

putln(chr(65)) // ergibt «A» 

Siehe auch 

num asc(string chaîne, num position) 



Syntax 

num asc(, ) 

num asc(string chaîne, num position) 

Funktion 

Gibt den ASCII-Code des Indexzeichens Position wieder. 

Wird -1, wenn Position negativ oder größer als Kette ist. 

Parameter 


num Position Numerischer Ausdruck 

Zum Beispiel 

putln(asc("A",0)) // ergibt 65 

Siehe auch 

string chr(num ASCII-Code) 

string left(string Kette, num Größe) 

Syntax 

string left(, ) 

Funktion 

Liefert die Größe ersten Zeichen von Kette. Wenn Größe größer ist als die Länge von Kette, liefert diese Anweisung 

die Kette. 

Ist Größe negativ, wird eine Fehlermeldung generiert. 

Parameter 


num Größe Numerischer Ausdruck 

Zum Beispiel 

putln(left("hello world",5)) // ergibt «hello» 


Syntax 

string right(, ) 

string right(string Kette, num Größe) 

Funktion 

Liefert die Größe letzten Zeichen von Kette. Wenn die spezifizierte Anzahl größer ist, als die Länge von Kette, liefert 

diese Anweisung Kette. 

Ist Größe negativ, wird eine Fehlermeldung generiert. 

Parameter 



Zum Beispiel 

putln(right("hello world",5)) // ergibt «world» 

Syntax 

string mid(string Kette, num Größe, num Position) 

string mid(, , ) 

Funktion 

Liefert Größe Zeichen von Kette ab dem Zeichen Position bis zum Ende von Kette. 

Sind Größe oder Position negativ, wird eine Fehlermeldung generiert. 

Parameter 



num Position Stelle in der Zeichenkette (von 0 bis 127) 

Zum Beispiel 

putln(mid(«hello wild world»,4,6)) // ergibt «wild» 



Syntax 

string insert(string Kette, string Einfügen, num Position) 

string insert(, , ) 

Funktion 

Überträgt die Kette, in die Einfügen nach dem Zeichen an der Stelle Position eingefügt wurde. Ist Position größer als 

die Größe von Kette, so wird Einfügen am Ende von Kette angefügt. Das Ergebnis wird nach 80 Zeichen 

abgeschnitten. 

Ist Position negativ, wird eine Fehlermeldung generiert. 

Parameter 


string Einfügen Ausdruck des Typs Zeichenkette 


Zum Beispiel 

putln(insert("hello world","wild ",6)) // ergibt «hello wild world» 

Syntax 

string delete(string Kette, num Größe, num Position) 

string delete(, , ) 

Funktion 

Überträgt Kette, in der die Größe Zeichen nach dem Zeichen an der Stelle Position gelöscht wurden. Wenn Position 

größer ist als die Länge von Kette, überträgt die Anweisung Kette. 


Parameter 




Zum Beispiel 

string source 

putln(delete(source="hello wild world",5,6)) // ergibt «hello world» 

putln(source) // ergibt «hello wild world» 


num replace(string Kette, string Ersetzen, num Größe, num Position) 

Syntax 

string replace(, , , ) 

Funktion 

Überträgt Kette, in der die Größe Zeichen nach dem Zeichen an der Stelle Position durch Ersetzen ersetzt wurden. 

Wenn Position größer ist als die Länge von Kette, überträgt die Anweisung Kette. 


Parameter 


string Ersetzen Ausdruck des Typs Zeichenkette 



Zum Beispiel 

putln(replace("hello ? world","wild",1,6)) // ergibt «hello wild world» 

Syntax 

num find(, ) 

num find(string Kette1, string Kette2) 

Funktion 

Überträgt die Stelle (zwischen 0 und 127) des ersten Zeichens beim erstmaligen Auftreten von Kette2 in Kette1. Wenn 

Kette2 nicht in Kette1 enthalten ist, liefert die Anweisung -1. 

Parameter 

string Kette1 Ausdruck des Typs Zeichenkette 

string Kette2 Ausdruck des Typs Zeichenkette 

Zum Beispiel 

putln(find("hello wild world","wild")) // ergibt 6 



Syntax 

num len() 

Funktion 

Überträgt die Länge von Kette. 

Parameter 

num len(string Kette) 


Zum Beispiel 

putln(len("hello wild world")) // ergibt 16 


TYP DIO 

Definition 

Mit dem Typ dio kann eine VAL3-Variable einem digitalen Ein-/Ausgang des Systems zugewiesen werden. 

Die im System deklarierten Ein-/Ausgänge können direkt in einer VAL3-Applikation verwendet werden, ohne dass sie 

vorher in der Applikation als lokale oder globale Variable deklariert werden müssen. Der Typ dio dient daher vor allem 

zum Parametrieren eines Programms, in dem Ein- oder Ausgänge verwendet werden. 

Anweisungen, in denen eine Variable des Typs dio verwendet wird, die nicht einem im System deklarierten Ein-/ 

Ausgang zugewiesen wurde, bewirken eine Fehlermeldung. 

Eine Variable des Typs dio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung, 

wenn sie ohne Zuweisung verwendet wird. 

Operatoren 


bool = 

bool = 

bool != 

bool != 

bool == 

Ordnet den Status von Ein-/Ausgang dem Ausgang zu und 

überträgt diesen Status. Wenn Ausgang keinem digitalen 

Ausgang des Systems zugewiesen ist, wird eine 

Fehlermeldung erzeugt. 

Weist Bedingung dem Status des Ausgang zu und überträgt 

Bedingung. Wenn Ausgang keinem digitalen Ausgang des 

Systems zugewiesen ist, wird eine Fehlermeldung erzeugt. 

Überträgt true, wenn Eingang1 und Eingang2 nicht den 

gleichen Status haben, ansonsten false. 

Überträgt true, wenn der Status des Eingang nicht gleich 

Bedingung ist, ansonsten false. 

Überträgt true, wenn der Status des Eingang gleich 

Bedingung ist, ansonsten false. 

bool == Überträgt true, wenn Eingang1 und Eingang2 den gleichen 

Status haben, ansonsten false. 



Anweisungen 

Syntax 

void dioLink(, ) 

void dioLink(dio& Variable, dio Quelle) 

Funktion 

Weist Variable dem Ein-/Ausgang des Systems, an dem Quelle angeschlossen ist, zu. 

Wenn Quelle ein im System geschützter Ein-/Ausgang ist, wird eine Fehlermeldung erzeugt. 

Parameter 

dio& Variable Variable des Typs digitaler Ein-/Ausgang 

dio Quelle Ausdruck des Typs dio 

Zum Beispiel 

dio dZange1 

dio dZange2 

dioLink(dZange1, io:Ventil1) // Verbindet dZange1 mit dem Ein-/Ausgang des Systems Ventil1 

dioLink(dZange2, dZange1) // Verbindet dZange2 mit dem Ein-/Ausgang von dZange1, und somit 

mit Ventil1 

dioLink(dZange1, io:Ventil2) // dZange2 ist nun mit Ventil2 und dZange1 immer noch mit 

Ventil1 verbunden 

Syntax 

num dioGet() 

num dioGet(dio dTabelle) 

Funktion 

Übergibt den Zahlenwert der dTabelle von dio, welcher wie eine ganze Zahl in Binärschreibweise gelesen wird, das 

heißt: dTabelle[0]+2 dTabelle[1]+4 dTabelle[2]+...+2 k dTabelle[k], oder dTabelle[i] = 1 wenn dTabelle[i] 

gleich true ist, anderenfalls 0. 

Ist ein Element der dTabelle nicht an einem Ein-/Ausgang des Systems angeschlossen, so wird ein Ausführungsfehler 

erzeugt. 

Parameter 

dio nTabelle Ausdruck des Typs dio 

Zum Beispiel 

dio dCode[4] 

dCode[0] = false 



dCode[3] = true 

putln(dioGet(dCode)) // ergibt 10 = 0 + 2 1 + 4 0 + 8 1 

Siehe auch 

num dioSet(dio dTabelle, num Wert) 


Syntax 

num dioSet(, ) 

num dioSet(dio dTabelle, num Wert) 

Funktion 

Ordnet den binär geschriebenen ganzzahligen Teil von Wert den digitalen Ein-/Ausgängen der dTabelle zu und 

übergibt den tatsächlich zugeordneten Wert, das heißt: 

dTabelle[0]+2 dTabelle[1]+4 dTabelle[2]+...+2 k dTabelle[k], oder dTabelle[i] = 1 wenn dTabelle[i] gleich 

true ist, anderenfalls 0. 

Ist ein Element der dTabelle keinem Ausgang des Systems zugeordnet, wird ein Ausführungsfehler erzeugt. 

Parameter 

dio dTabelle Ausdruck des Typs dio 


Zum Beispiel 

dio dCode[4] 

? dioSet(dCode, 10) // ergibt 10 = 0 + 2 1 + 4 0 + 8 1 

? dioSet(dCode, 26) // ergibt 10, da code nicht ausreicht, um 26 vollständig in binär 

aufzunehmen 

Siehe auch 

num dioGet(dio dTabelle) 



TYP AIO 

Definition 

Der Typ aio ermöglicht es, eine Variable VAL3 einem numerischen Ein-/Ausgang (digital oder analog) des Systems 

zuzuordnen. 

Die im System deklarierten Ein-/Ausgänge können direkt in einer VAL3-Applikation verwendet werden, ohne dass sie 

vorher in der Applikation als lokale oder globale Variable deklariert werden müssen. Der Typ aio dient daher vor allem 

zum Parametrieren eines Programms, in dem Ein- oder Ausgänge verwendet werden. 

Anweisungen, in denen eine Variable des Typs aio verwendet wird, die nicht einem im System deklarierten Ein-/ 


Eine Variable des Typs aio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung, 


Anweisungen 

Syntax 

void aioLink(, ) 

void aioLink(aio& Variable, aio Quelle) 

Funktion 

Weist Variable dem Ein-/Ausgang des Systems, an dem Quelle angeschlossen ist, zu. 


Parameter 

aio& Variable Variable des Typs aio 

aio Quelle Ausdruck des Typs aio 

Zum Beispiel 

aio aCapteur1 

aio aCapteur2 

aioLink(aCapteur1, io:système1) // Verbindet aCapteur1 mit dem Ein-/Ausgang des Systems système1 

aioLink(aCapteur2, aCapteur1) // Verbindet aCapteur2 mit dem Ein-/Ausgang von aCapteur1, und somit mit 

système1 

aioLink(aCapteur1, io:système2) // aCapteur2 ist nun mit système2 und aCapteur1 immer noch mit 

système1 verbunden. 

Syntax 

num aioGet() 

num aioGet(aio Eingang) 

Funktion 

Übersendet den numerischen Wert von Eingang. 

Ist Eingang nicht mit einem Ein-/Ausgang des Systems verbunden, so wird ein Ausführungsfehler erzeugt. 

Parameter 

aio Tabelle Ausdruck des Typs aio 

Zum Beispiel 

aio aCapteur 

putln(aioGet(aCapteur)) // zeigt den aktuellen Wert des Sensors an 

Siehe auch 

num aioSet(aio Ausgang, num Wert) 


Syntax 

num aioSet(, ) 

num aioSet(aio Ausgang, num Wert) 

Funktion 

Ordnet Wert den Wert von Ausgang zu und sendet Wert zurück. 

Ist Ausgang mit keinem Ausgang des Systems verbunden, so wird ein Ausführungsfehler erzeugt. 

Parameter 

aio& Ausgang Ausdruck des Typs aio 


Zum Beispiel 

aio aCommande 

putln(aioSet(aCommande, -12.3)) // ergibt -12.3 

Siehe auch 

num aioGet(aio Eingang) 



TYP SIO 

Definition 

Der Typ sio ermöglicht es, eine VAL3-Variable einem seriellen Ein-/Ausgang des Systems oder einer Verbindung per 

Ethernet-Socket zuzuordnen. Ein sio-Ein-/Ausgang ist gekennzeichnet durch: 

• Im System definierte, dem Typ der Kommunikation eigene Parameter 

• Ein Zeichenketten-Endzeichen, um die Verwendung des Typs string zu ermöglichen 

• Eine Kommunikations-Wartefrist 

Die seriellen Ein-/Ausgänge des Systems sind ständig aktiviert. Die Verbindungen per Ethernet-Socket werden beim 

ersten Lese-/Schreibzugriff durch ein VAL3-Programm aktiviert. Bei Beendigung der VAL3-Anwendung, werden die 

Verbindungen per Ethernet-Socket automatisch deaktiviert. 

Die im System erklärten Ein-/Ausgänge sind in einer Applikation des Typs VAL3 direkt verwendbar, ohne dass sie in 

der Applikation als globale oder lokale Variable erklärt werden müssen. Der Typ sio dient daher vor allem zum 

Parametrieren eines Programms, in dem Ein- oder Ausgänge verwendet werden. 

Anweisungen, in denen eine Variable des Typs sio verwendet wird, die nicht einem im System deklarierten Ein-/ 


Eine Variable des Typs sio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung, 


Operatoren 

Wird die Kommunikations-Wartefrist beim Lesen oder Schreiben eines seriellen Ein-/Ausgangs erreicht, so wird ein 

Ausführungsfehler erzeugt. 

string = Schreibt nacheinander in Ausgang die Zeichen von 

Angabe, gefolgt vom Zeichenketten-Endzeichen, und 

übergibt Angabe. 

num = Schreibt in Ausgang die Angabe nähestliegende 

ganze Zahl, Modulo 256, und übergibt den tatsächlich 

übermittelten Wert. 

num = Liest ein Zeichen in Eingang und ordnet Angabe den 

ASCII-Code dieses Zeichens zu. 

string = Liest in Eingang eine Zeichenkette und ordnet dieser 

Angabe zu. Mit dem Typ string nicht kompatible 

Zeichen werden außer Acht gelassen. Die 

Zeichenkette endet, wenn das Zeichenketten- 

Endzeichen gelesen wird, oder wenn Angabe die 

maximale Größe des Typs string (128 Zeichen) 

erreicht hat. Das Zeichenketten-Endzeichen wird 

nicht in Angabe übertragen. 


Anweisungen 

Syntax 

void sioLink(, ) 

void sioLink(sio& Variable, sio Quelle) 

Funktion 

Verbindet Variable mit dem seriellen Ein-/Ausgang des Systems, an dem Quelle angeschlossen ist. 


Parameter 

sio& Variable Variable des Typs sio 

sio Quelle Ausdruck des Typs sio 

Zum Beispiel 

sio sCapteur1 

sio sCapteur2 

sioLink(sCapteur1, io: serial1) // Verbindet sCapteur1 mit dem Ein-/Ausgang des Systems serial1 

sioLink(sCapteur2, sCapteur1) // Verbindet sCapteur2 mit dem Ein-/Ausgang von sCapteur1, und 

somit mit serial1 

sioLink(sCapteur2, io: serial1) // Verbindet sCapteur2 mit serial1, sCapteur1 ist weiterhin mit 

serial1 verbunden 

Syntax 

num clearBuffer() 

num clearBuffer(sio Eingang) 

Funktion 

Leert den Lesepuffer von Eingang und teilt die Anzahl der so gelöschten Zeichen mit. 

Bei Verbindungen per Ethernet-Socket, übernimmt clearBuffer die Socket-Deaktivierung, falls diese schon 

stattgefunden hat, meldet clearBuffer -1. 

Wenn Eingang keiner seriellen Verbindung oder Ethernet-Socket zugewiesen ist, wird ein Ausführungsfehler erzeugt. 

num sioGet(sio Eingang, num& Daten) 

Syntax 

num sioGet(,) 

Funktion 

Liest eine Zeichentabelle in Eingang und teilt die Anzahl der gelesenen Zeichen mit. Der Lesevorgang wird 

beendet, wenn die Tabelle Angabe voll oder der Eingangs-Lesepuffer leer ist. 

Bei Verbindungen per Ethernet-Socket versucht sioGet zuerst die Verbindung herzustellen, wenn diese noch 

nicht aktiviert wurde. Nach dem Erreichen der Kommunikations-Wartefrist eines Eingangs meldet sioGet -1. 

Wenn die Verbindung aktiviert ist, aber keine Daten im Eingangs-Lesepuffer vorhanden sind, wartet sioGet 

solange, bis Daten empfangen werden oder die Kommunikations-Wartefrist abgelaufen ist. 

Wenn Eingang keiner seriellen Verbindung oder Ethernet-Socket zugewiesen ist oder Daten keine VAL3- 

Variable ist, wird ein Ausführungsfehler erzeugt. 



Syntax 

num sioSet(,) 

num sioSet(sio Ausgang, num& Daten) 

Funktion 

Schreibt eine Zeichentabelle in Ausgang und teilt die Anzahl der geschriebenen Zeichen mit. Die digitalen Werte 

werden vor der Übertragung in ganze Zahlen zwischen 0 und 255 umgewandelt, dabei wird jeweils die 

nähestliegende ganze Zahl Modulo 256 verwendet. 

Bei Verbindungen per Ethernet-Socket versucht sioSet zuerst die Verbindung herzustellen, wenn diese noch 

nicht aktiviert wurde. Nach dem Erreichen der Kommunikations-Wartefrist eines Ausgangs meldet sioSet -1. Die 

Anzahl der geschriebenen Zeichen kann unter der Größe von Daten liegen, wenn ein Kommunikationsfehler 

entdeckt wurde. 

Wenn Ausgang keiner seriellen Verbindung oder Ethernet-Socket zugewiesen ist, wird ein Ausführungsfehler 

erzeugt. 


BENUTZERSCHNITTSTELLE 

Bedienerseite 

Die über die Benutzerschnittstelle VAL3 eingegebenen Anweisungen erlauben: 

- die Anzeige von Meldungen auf dem Handbediengerät (MCP) für diese Applikation 

- die Erfassung der Eingaben auf der Tastatur des MCP 

Bedienerseite 

Die Bedienerseite hat 14 Zeilen mit je 40 Zeichen. Die letzte Zeile kann zur Erstellung von Menüs mit zugeordneter 

Taste verwendet werden. Eine weitere Zeile steht zur Anzeige eines Titels zur Verfügung. 

Anweisungen 

void userPage(), void userPage(bool fix) 

Syntax 

void userPage () 

void userPage () 

Funktion 

Bewirkt die Anzeige der Bedienerseite auf dem Display des MCP. 

Wenn der Parameter fix true ist, kann der Bediener nur auf die Bedienerseite zugreifen sowie über den Shortcut "Shift 

User" auf die Seite Profiländerung. Wenn diese Seite angezeigt wird, kann die Anwendung mit der Taste "Stop" 

gestoppt werden, falls das aktuelle Benutzerprofil dies erlaubt. 

Hat der Parameter den Wert false, so sind auch die anderen CS8-Seiten zugänglich. 



Syntax 

void gotoxy(, ) 

void gotoxy(num x, num y) 

Funktion 

Bewegt den Cursor der Bedienerseite auf die Koordinaten (x, y). Die linke obere Ecke hat die Koordinaten (0,0), die 

rechte untere Ecke (39, 13). 

Auf die Abszisse x wird Modulo 40 angewandt. Für die Ordinate y gilt Modulo 14. 

Parameter 

num x Abszisse des Cursors (von 0 bis 39) 

num y Ordinate des Cursors (von 0 bis 13) 

Siehe auch 

void cls() 

Syntax 

void cls() 

Funktion 

Löscht die Bedienerseite und bewegt den Cursor auf (0,0). 

Siehe auch 

void gotoxy(num x, num y) 

void cls() 

void put() void putln() 

Syntax 

void put() 

void put() 

void putln() 

void putln() 

Funktion 

Zeigt auf der Bedienerseite an der Stelle des Cursors die Kette oder den spezifizierten Wert an (mit 3 Dezimalstellen). 

Der Cursor wird anschließend auf das dem letzten Zeichen der angezeigten Meldung folgende Zeichen weiterbewegt 

(Anweisung put), oder auf das erste Zeichen der nächsten Zeile (Anweisung putln). 

Beim Erreichen des Zeilenendes, wird die Anzeige auf der nächsten Zeile fortgesetzt. 

Am Seitenende verschiebt sich die Anzeige der Benutzerseite eine Zeile nach oben. 

Parameter 



Siehe auch 

void popUpMsg(string Kette) 

void logMsg(string Kette) 

void title(string Kette) 


Syntax 

void title() 

void title(string Kette) 

Funktion 

Ändert den Titel der Bedienerseite. 

Die aktuelle Position des Cursors wird durch die Anweisung title() nicht geändert. 

Parameter 


num get() 

Syntax 

num get() 

num get() 

num get() 

Funktion 

Erfasst eine in die Tastatur der Konsole eingegebene Zeichenkette, eine Zahl oder eine Taste. 

Kette oder Wert wird an der aktuellen Position des Cursors angezeigt und kann vom Benutzer geändert werden. Die 

Eingabe wird mit einer Menütaste, mit Return oder Esc beendet. 

Die Anweisung überträgt den Code der Taste, mit der die Eingabe beendet wurde. 

Mit der Return- oder einer Menütaste wird die Variable Kette oder Wert aktualisiert. Mit der Esc-Taste bleibt sie 

unverändert. 

Wenn kein Parameter übertragen wurde, wartet die Anweisung get() auf einen beliebigen Tastendruck und sendet 

ihren Code zurück. Die gedrückte Taste wird nicht angezeigt. 

Die aktuelle Position des Cursors wird durch die Anweisung get() nicht geändert. 

Ohne Shift Mit Shift 

3 Caps Space 3 Caps Space 

283 - 32 Move 283 - 32 Move 

2 Shift Esc Help 

Ret. 

- 

Run 2 Shift Esc Help 

Ret. 

- 

Run 

282 - 255 - 270 - 282 - 255 - 270 - 

Menu Tab Up Bksp Stop Menu UnTab PgUp Bksp Stop 

- 259 261 263 - - 260 262 263 - 

1 User Left Down Right 1 User Home PgDn End 

281 - 264 266 268 281 - 265 267 269 

Menüs (mit und ohne Shift): 

F1 F2 F3 F4 F5 F6 F7 F8 

271 272 273 274 275 276 277 278 



Parameter 

Zum Beispiel 

Siehe auch 

num getKey() 

Bei Standardtasten wird der ASCII-Code des betreffenden Zeichens zurückgesandt: 

Ohne Shift 

q w e r t y u i o p 

113 119 101 114 116 121 117 105 111 112 

a s d f g h j k l < 

97 115 100 102 103 104 106 107 108 60 

z x c v b n m . , = 

122 120 99 118 98 110 109 46 44 61 

Mit Shift 

7 8 9 + * ; ( ) [ ] 

55 56 57 43 42 59 40 41 91 93 

4 5 6 - / ? : ! { } 

52 53 54 45 47 63 58 33 123 125 

1 2 3 0 " % - . , > 

49 50 51 48 34 37 95 46 44 62 

Mit doppeltem Shift 

Q W E R T Y U I O P 

81 87 69 82 84 89 85 73 79 80 

A S D F G H J K L } 

65 83 68 70 71 72 74 75 76 125 

Z X C V B N M $ \ = 

90 88 67 86 66 78 77 36 92 61 

string& Kette Variable des Typs string 

num& Wert Variable des Typs num 

num nValeur 

num nKey 

// Wartet auf die Return-Taste zum Validieren der Eingabe 

do 

nKey = get (nValeur) 

until (nKey == 270) 


Syntax 

num getKey() 

num getKey() 

Funktion 

Erfasst den Wert einer Taste der Pult-Tastatur. Liefert den Code der seit dem letzten Aufruf von getKey() zuletzt 

gedrückten Taste. Wurde seitdem keine Taste gedrückt, so wird der Code -1 übergeben. 

Im Gegensatz zur Anweisung get() übergibt die Anweisung getKey() den Wert sofort. 

Die gedrückte Taste wird nicht angezeigt und die aktuelle Cursorposition wird nicht geändert. 

Zum Beispiel 

// Anzeige der Systemuhr bis zum Drücken einer beliebigen Taste 

getKey() // Neuinitialisierung des Codes der zuletzt gedrückten 

Taste 

while (getKey()== -1) 

gotoxy(0,0) 

put(toString(«», clock()* 10)) 

endWhile 

Siehe auch 

num get() 

bool isKeyPressed(nom code) 

Syntax 

bool isKeyPressed() 

bool isKeyPressed(nom code) 

Funktion 

Liefert den Zustand der spezifizierten Taste durch ihren Code (siehe get()), true bei gedrückter Taste, ansonsten false. 

Siehe auch 

num getKey() 

Syntax 

void popUpMsg() 


Funktion 

Zeigt Kette in einem "popup"-Fenster über dem aktuellen MCP-Fenster an. Dieses Fenster bleibt so lange angezeigt, 

bis es im Menü mit Ok bestätigt oder die Esc-Taste gedrückt wird. 

Siehe auch 

void userPage(), void userPage(bool fix) 

void put() void putln() 



Syntax 

void logMsg() 

void logMsg(string Kette) 

Funktion 

Schreibt Kette in die Protokollliste des Systems. Die Meldung wird mit Datum und Uhrzeit registriert. 

Siehe auch 


Syntax 

string getProfile() 

Funktion 

Gibt den Namen des aktuellen Benutzerprofils zurück. 

string getProfile() 


TASKS 

Definition 

Eine Task ist ein Programm, das zu einem gegebenen Zeitpunkt ausgeführt wird. 

In einer Applikation befinden sich typischerweise Tasks für die Armbewegungen, eine Task Automat, eine Task für die 

Benutzerschnittstelle, eine Task für die Überwachung der Sicherheitssignale, Kommunikationstasks usw.. 

Eine Task ist durch folgende Elemente gekennzeichnet: 

• Namen: Bezeichnung der Task, die im System nur einmal vorkommt 

• Priorität: Parameter für Ablaufsteuerung der Tasks 

• Programm: Einsprungstelle (und Aussprungstelle) der Task 

• Status: aktiv oder beendet 

• die nächste auszuführende Anweisung (mit Kontext) 

Fortsetzen nach einer Fehlermeldung 

Wenn eine Anweisung zu einer Fehlermeldung geführt hat, wird die Task unterbrochen. Mit der Anweisung 

taskStatus() kann die Fehlerursache ermittelt werden. Anschließend wird die Task mit der Anweisung taskResume() 

fortgesetzt. Wenn die Störungsursache behoben werden konnte, macht das Programm in der Zeile weiter, in der die 

Task unterbrochen wurde. Andernfalls muss vor oder nach dieser Zeile begonnen werden. 

Starten und Beenden der Applikation 

Zum Starten einer Applikation wird ihr Programm start() in einer Task mit dem Namen der Applikation, dem 

nachgestellten Zeichen ’~’ und der Priorität 10 ausgeführt. 

Zum Beenden einer Applikation wird ihr Programm stop() in einer Task mit dem Namen der Applikation, dem ein ’~’ 

vorangestellt ist, und der Priorität 10 ausgeführt. 

Wird eine VAL3-Applikation von der Benutzerschnittstelle der CS8 aus unterbrochen, so wird die Start-Task, falls sie 

noch vorhanden ist, augenblicklich gelöscht. Dann wird das Programm stop() ausgeführt, worauf alle noch nicht 

ausgeführten Tasks der Applikation in der umgekehrten Reihenfolge ihrer Erstellung gelöscht werden. 



Sequentielles Ordnen 

Wenn in einer Applikation mehrere Tasks ausgeführt werden, hat es den Anschein, als ob dies gleichzeitig und 

unabhängig voneinander erfolgt. Das ist jedoch nur richtig, wenn man die Applikation global, d.h. über genügend lange 

Zeitintervalle von z.B. einer Sekunde betrachtet. Bei kurzen Zeitintervallen ist diese Aussage nicht mehr gültig. 

Da das System nur einen Prozessor besitzt, kann es auch nur jeweils eine Task ausführen. Die Gleichzeitigkeit der 

Ausführung wird durch ein rasches sequentielles Ordnen der einzelnen Tasks erreicht, die reihum einige Anweisungen 

abarbeiten, bevor das System auf die nächste Task weitergeht. 

Priorität 

T1 

Normale 

Ausführung 

T2 

Sequentielles Ordnen 

T1 führt die 

Funktion delay() 

aus. 

T1 

T2 

Zeit abgelaufen 

T2 T2 

T3 T3 T3 T3 

T1 

Normale 

Ausführung 

Unter VAL3 sind die Sequenzen der Tasks nach folgenden Regeln geordnet: 

1. Die Tasks werden in der Reihenfolge ihrer Erstellung sequentiell geordnet. 

2. In jeder Sequenz versucht das System, die Anzahl von VAL3-Programmzeilen auszuführen, die der 

Priorität der Task entspricht. 

3. Sobald eine Programmzeile nicht beendet werden kann (Ausführungsfehler, Warten auf ein Signal, Task 

unterbrochen...), fährt das System mit der nächsten Task fort. 

4. Jede Task wird mindestens alle 10 ms aufgerufen. 

Folgende Anweisungen in VAL3 bewirken ein sofortiges Weitergehen zur Sequenz der nächsten Task: 

• watch() (zeitlich begrenztes Warten auf eine Bedingung) 

• delay() (Wartezeit) 

• wait() (Warten auf eine Bedingung) 

• waitEndMove() (Warten auf Stillstand des Roboters) 

• open() und close() (Warten auf Stillstand des Roboters mit anschließender Wartezeit) 

• get() (Warten auf eine Tasteneingabe) 

• resume() (wartet, bis die Task zum Neustart bereit ist) 

• kill() (wartet, bis die Task tatsächlich gekillt ist) 

• disablePower() (wartet, bis die Leistung tatsächlich abgeschaltet wurde) 

• Die Anweisungen zum Zugriff auf den Inhalt der Festplatte (libLoad, libSave, libDelete, libList) 

• Die Anweisungen zum Lesen / Schreiben von sio (Bediener =, sioGet(), sioSet()) 

D28056202B - 06/2005 53 / 122 

T2 

T3 

Zeit

Synchronisierung 

Manchmal müssen mehrere Tasks miteinander synchronisiert werden, bevor ihre Ausführung fortgesetzt werden kann. 

Wenn die Ausführungszeiten der einzelnen Tasks bekannt sind, kann die Synchronisierung einfach durch Warten auf 

ein Signal des langsamsten Jobs erfolgen. Ist aber nicht bekannt, welche die langsamste Task ist, kommt ein etwas 

komplexeres Synchronisierungsverfahren zum Einsatz, von dem ein Programmierbeispiel in VAL3 nachstehend 

angegeben ist. 

Zum Beispiel 

// Globale Variablen zur Steuerung der Synchronisierung 

num n 

bool bSynch 

n=0 // Initialisierung der globalen Variablen 

bSynch=false 

program tache1() 

begin 

while(true) 

call synchro(n, bSynch, 2) // Synchronisierung mit Task 2 

 

endWhile 

end 


begin 

while(true) 

call synchro(n, bSynch, 2) // Synchronisierung mit Task 1 

 

endWhile 

end 

// Programm zur Synchronisierung von N Tasks 

program synchro(num& n, bool& bSynch, num N) 

begin 

n = n + 1 

wait((n==N) or (bSynch==true)) // Warten auf die Synchronisierung der Tasks 

bSynch = true 

n = n - 1 

wait((n==0) or (bSynch == false)) // Warten auf die Freigabe der Tasks 

bSynch = false 

end 



Gemeinsame Nutzung von Ressourcen 

Wenn mehrere Tasks gleiche Systemkomponenten oder Elemente der Roboterarbeitszelle (globale Variablen, 

Monitore, Tastatur, Roboter usw.) verwenden, muss darauf geachtet werden, dass sie sich nicht gegenseitig stören. 

Zum Schutz der Komponenten kann eine sogenannte "(’mutex’)"-Funktion (mutuel exclusion) verwendet werden, die 

sie nur für jeweils eine Task freigibt. Das nachstehende Programmierbeispiel verdeutlicht die Funktion Mutex in VAL3. 

Zum Beispiel 

bool bEcran 

bEcran = false 


begin 

while(true) 

call mutex(bEcran) // Anforderung der Komponente Bildschirm 

call fillScreen(1) 

bEcran = false // Freigabe der Komponente Bildschirm 

delay(0) // Weitergehen zur nächsten Task 

endWhile 

end 


begin 

while(true) 

call mutex(bEcran) // Anforderung der Komponente Bildschirm 

call fillScreen(2) 

bEcran = false // Freigabe der Komponente Bildschirm 

delay(0) // Weitergehen zur nächsten Task 

endWhile 

end 

// Programm zum Füllen des Bildschirms mit der Ziffer i 

program fillScreen(num i) 

num x 

num y 

begin 

i = i % 10 

for x = 0 to 39 

for y = 0 to 13 

gotoxy(x, y) 

put(i); 

endFor 

endFor 

end 

// Programm zur Verhinderung des gleichzeitigen Zugriffs auf eine 

Komponente 

program mutex(bool& bRessource) 

begin 

// Die Zuweisung der Komponente (bRessource) zu true muss in der gleichen Zeile wie die Prüfung erfolgen!!! 

wait((bRessource==false) and (bRessource = true)) 

end 


Anweisungen 

Syntax 

void taskSuspend() 

void taskSuspend(string Name) 

Funktion 

Unterbricht die Ausführung der Task Name. 

Wenn die Task bereits den Status STOPPED hat, ist die Anweisung wirkungslos. 

Wenn Name keiner Task in VAL3 entspricht, wird eine Fehlermeldung erzeugt. 

Parameter 

string Name Ausdruck des Typs Zeichenkette 

Siehe auch 

void taskResume(string Name, num Sprung) 

void taskKill(string Name) 

Syntax 


void taskResume (, ) 

Funktion 

Setzt die Task Name bei der Zeile fort, die Sprung Programmzeilen vor oder nach der aktuellen Zeile liegt. 

Wenn Sprung negativ ist, wird die Ausführung vor der aktuellen Zeile fortgesetzt. Wenn die Task nicht den Status 

STOPPED hat, ist die Anweisung wirkungslos. 

Eine Fehlermeldung wird erzeugt, wenn Name keiner Task in VAL3 entspricht, oder wenn es für den spezifizierten 

Sprung keine Programmzeile gibt. 

Parameter 


num Sprung Numerischer Ausdruck 

Siehe auch 





Syntax 

void taskKill () 


Funktion 

Unterbricht und löscht anschließend die Task Name. Nach Ausführung dieser Anweisung ist die Task Name im System 

nicht mehr vorhanden. 

Wenn es keine Task Name gibt, ist die Anweisung wirkungslos. 

Parameter 


Siehe auch 


void taskCreate string Name, num Priorität, Programm(...) 


Syntax 

num taskStatus () 

num taskStatus(string Name) 

Funktion 

Überträgt den aktuellen Status der Task Name oder den Code des bei der Ausführung der Task aufgetretenen Fehlers, 

wenn sich letztere in Fehlerzustand befindet: 

Code Beschreibung 

-1 Es gibt keine Task Name 

0 Die Task Name ist ohne Ausführungsfehler gestoppt 

1 Die Task Name befindet sich in Ausführung 

10 Ungültige numerische Berechnung (Division durch Null). 

11 Ungültige numerische Berechnung (zum Beispiel ln(-1)) 

20 Zugriff zu einer Tabelle mit höherem Index als die Tabellengröße. 

21 Zugriff zu einer Tabelle mit negativem Index. 

29 Ungültiger Name der Task. Siehe Anweisung taskCreate(). 

30 Der festgelegte Name entspricht keiner Task von VAL3. 

31 Es existiert bereits eine Task gleichen Namens. Siehe Anweisung taskCreate. 

40 Der Speicherplatz genügt nicht für die Daten. 

41 Der Ausführungsspeicher ist für die Task unzureichend. Siehe Größe des Ausführungsspeichers. 

60 Maximale Ausführungszeit der Anweisung ist abgelaufen. 

61 Interner Fehler des VAL3-Interpreters 

70 Ungültiger Wert des Parameters der Anweisung. Siehe entsprechende Anweisung. 

80 Verwendung von Daten oder Programmen einer nicht im Speicher geladenen Bibliothek. 

90 Die Task kann an der festgelegten Stelle nicht wieder aufgenommen werden. Siehe Anweisung taskResume(). 

100 Die im Bewegungsdeskriptor spezifizierte Geschwindigkeit ist ungültig (negativ oder zu groß). 

101 Die im Bewegungsdeskriptor spezifizierte Beschleunigung ist ungültig (negativ oder zu groß). 

102 

Die im Bewegungsdeskriptor spezifizierte Abbremsgeschwindigkeit ist ungültig (negativ, zu groß oder kleiner als die 

Geschwindigkeit). 

103 Die im Bewegungsdeskriptor spezifizierte Translationsgeschwindigkeit ist ungültig (negativ oder zu groß). 

104 Die im Bewegungsdeskriptor spezifizierte Rotationsgeschwindigkeit ist ungültig (negativ oder zu groß). 

105 Der im Bewegungsdeskriptor spezifizierte Parameter reach ist ungültig (negativ). 

106 Der im Bewegungsdeskriptor spezifizierte Parameter leave ist ungültig (negativ). 

122 Schreibversuch auf einem Eingang des Systems. 

123 Verwendung eines Ein-/Ausgangs dio, aio oder sio, der keinem Ein-/Ausgang des Systems zugeordnet ist. 

124 Versuch des Zugriffs auf einen geschützten Ein-/Ausgang des Systems 

125 Lese- oder Schreibfehler an einem dio, aio oder sio (Fehler auf Feldbus) 

150 

Diese Bewegungsanweisung lässt sich nicht ausführen: Eine vorher angeforderte Bewegung konnte nicht beendet 

werden (Punkt nicht erreichbar, singulärer Punkt, Konfigurationsproblem usw.) 

152 Verwendung eines point ohne Referenzsystem. Siehe Definition. 

153 Bewegungsbefehl nicht unterstützt 

154 Ungültige Bewegungsanweisung: Bewegungsdeskriptor überprüfen. 

160 Koordinaten des Tools flange nicht gültig 

161 Koordinaten des Koordinatensystems world nicht gültig 


163 Verwendung eines Koordinatensystems ohne Referenzsystem. Siehe Definition. 

164 Verwendung eines Tools ohne Referenztool. Siehe Definition. 

165 Referenzsystem oder Referenztool ungültig (globale Variable mit lokaler Variablen verbunden) 

Parameter 


Siehe auch 





Syntax 

void taskCreate string Name, num Priorität, Programm(...) 

void taskCreate , , Programm([p1] [,p2]) 

Funktion 

Erstellt und startet die Task Name. 

Name muss 1 bis 12 Zeichen zwischen "a..zA..Z0..9_" besitzen. Es darf keine andere Task mit dem gleichen Namen 

geben. 

Die Ausführung von Name beginnt mit dem Aufruf von Programm mit den spezifischen Parametern. Für 

Referenzparameter dürfen keine lokalen Variablen verwendet werden. 

Die Task endet vorprogrammiert mit der letzten Zeile von Programm bzw. vorher, wenn diese ausdrücklich gelöscht 

wurde. 

Priorität muss zwischen 1 und 100 liegen. Bei jedem sequentiellen Ordnen der Tasks führt das System die in Priorität 

angegebene Zahl von Programmzeilen aus, bzw. weniger, wenn eine sperrende Anweisung angetroffen wird (siehe 

Kapitel Sequentielles Ordnen). 

Wenn das System nicht genügend Speicherplatz zum Erstellen der Task vorfindet, Name ungültig oder bereits 

vergeben oder Priorität ungültig ist, wird eine Fehlermeldung erzeugt. 

Parameter 


num Priorität Numerischer Ausdruck 

Programm Name eines Programms der Applikation 

p1 Ausdruck des in Programm angegebenen Typs 

Zum Beispiel 

program affiche(string& sTexte) 

begin 

putln(sTexte) 

sTexte = "stop" 

end 

string sMessage 

program start() 

begin 

sMessage = "start" 

taskCreate "t1", 10, affiche(sMessage) // ergibt « start » 

wait(taskStatus("t1") == -1) // Wartet auf das Ende von t1 

putln(sMessage) // ergibt "stop" 

end 

Siehe auch 



num taskStatus(string Name) 


Syntax 

void wait() 

void wait(bool Bedingung) 

Funktion 

Stellt die aktuelle Task solange zurück, bis Bedingung true wird. 

Die Task bleibt RUNNING während der Wartezeit. Wenn condition bei der ersten Überprüfung true ist, wird die 

Ausführung sofort mit der gleichen Task fortgesetzt (kein sequentielles Ordnen der nächsten Task). 

Parameter 


Siehe auch 

void delay(num Sekunden) 

bool watch(bool Bedingung, num Sekunden) 

Syntax 

void delay() 


Funktion 

Schiebt die Ausführung der laufenden Task für Sekunden Sekunden auf. 

Die Task bleibt RUNNING während der Wartezeit. Wenn Sekunden kleiner oder gleich 0 ist, schiebt das System zuvor 

andere Tasks in VAL3 ein, bevor die aktuelle Task fortgesetzt wird. 

Parameter 

num Sekunden Numerischer Ausdruck 

Siehe auch 

num clock() 




Syntax 

num clock() 

num clock() 

Funktion 

Überträgt den aktuellen Wert des systeminternen Taktgebers in Sekunden. 

Die Genauigkeit des internen Taktgebers beträgt eine Millisekunde. Er wird beim Start der Steuerung auf 0 gesetzt und 

ist unabhängig von der Uhrzeit. 

Zum Beispiel 

num nDebut 

nDebut=clock() 

 

put("Dauer des Vorgangs= " ) 

putln(clock()-nDebut) 

Siehe auch 



Syntax 


bool watch (, ) 

Funktion 

Schiebt die aktuelle Task auf, bis Bedingung gleich true ist oder die Zeit von Sekunden Sekunden abgelaufen ist. 

Überträgt true, wenn die Wartezeit dadurch beendet wird, dass Bedingung gleich true wird. Wird die Wartezeit 

beendet, weil die Zeit abgelaufen ist, wird false übertragen. 

Die Task bleibt RUNNING während der Wartezeit. Wenn Bedingung bei der ersten Überprüfung true ist, wird die 

Ausführung sofort mit der gleichen Task fortgesetzt, andernfalls werden die anderen VAL3-Tasks vom System 

eingeschoben (auch wenn Sekunden kleiner oder gleich 0 ist). 

Parameter 


num Sekunden Numerischer Ausdruck 

Zum Beispiel 

while (watch (dCapteur, 20)) == false 

popUpMsg("Warten auf Teil") 

endWhile 

Siehe auch 


void wait(bool Bedingung) 

num clock() 


BIBLIOTHEKEN 

Definition 

Eine VAL3-Bibliothek ist eine Software, die von einer Applikation oder anderen VAL3-Bibliotheken verwendet werden 

kann. 

Wie eine Applikation besteht eine VAL3-Bibliothek aus folgenden Elementen: 

- einer Gruppe von Programmen: den auszuführenden VAL3-Anweisungen, 

- einer Gruppe von globalen Variablen: den Daten der Bibliothek 

- einer Gruppe von Bibliotheken: von der Bibliothek benutzte externe Anweisungen und Daten 

Eine in Ausführung befindliche Bibliothek kann zudem enthalten: 

- eine Gruppe von Tasks: eigene Programme der in Ausführung befindlichen Bibliothek 

Eine Bibliothek wird im gleichen Format gespeichert, wie eine VAL3-Applikation. Jede Applikation kann als Bibliothek 

und jede Bibliothek als Applikation verwendet werden, wenn in ihr die Programme start() und stop() definiert sind. 

Schnittstelle 

Die Programme und die globalen Variablen einer Bibliothek sind entweder exportiert oder privat. Nur exportierte 

Programme und globale Variablen sind außerhalb der Bibliothek zugänglich. Private Programme und globale Variablen 

können nur von den Programmen der Bibliothek verwendet werden. 

Die Gruppe der exportierten Programme und globalen Variablen einer Bibliothek wird als deren Schnittstelle 

bezeichnet: Verschiedene Bibliotheken können die gleiche Schnittstelle haben, wenn ihre exportierten Programme und 

Daten die gleichen Namen besitzen. 

Die vom Programm einer Bibliothek geschaffenen Tasks sind immer privat, das heißt, sie sind nur von dieser Bibliothek 

zugänglich. 

Kennung der Schnittstelle 

Um eine Bibliothek verwenden zu können, muss eine Applikation immer zunächst einen zugeordneten 

Verwendungsnamen festlegen und dann in einem Programm anfordern, die Bibliothek unter diesem Namen im 

Speicher zu laden. 

Der Verwendungsname ist der Schnittstelle der Bibliothek zugeordnet, nicht der Bibliothek selbst. Jede, die gleiche 

Schnittstelle aufweisende Bibliothek kann also unter diesem Namen geladen werden. Es ist deshalb zum Beispiel 

möglich, eine Bibliothek für jedes mögliche Teil einer Applikation zu definieren und dann nur das beim jeweiligen Zyklus 

bearbeitete Teil zu laden. 

Inhalt 

Der Inhalt einer Bibliothek ist nicht vorgeschrieben: Sie kann nur Programme, nur Daten oder beides gleichzeitig 

enthalten. 

Der Zugang zu einer Bibliothek erfolgt durch Aufschreiben des Namens der Kennung, gefolgt von ’:’ und dem Namen 

des Programms oder der Daten der Bibliothek, zum Beispiel: 

Teil:libLoad("Teil_7") // Lädt die Bibliothek "Teil_7" unter der Kennung ’Teil’ 

title(Teil:nom) // Zeigt als Titel den Namen des aktuellen Teils an 

call Teil:init() // Ruft das Programm init() des aktuellen Teils 

Wird der Zugriff zum Inhalt einer Bibliothek gefordert, die noch nicht in den Speicher geladen wurde, so bewirkt dies 

einen Ausführungsfehler. 

Im Speicher laden und aus dem Speicher entfernen 

Beim Öffnen einer VAL3-Applikation werden alle erklärten Bibliotheken untersucht, um die entsprechenden 

Schnittstellen aufzubauen. Bei diesem Schritt werden die Bibliotheken nicht in den Speicher geladen. 

Beim Laden einer Bibliothek werden deren globale Variablen initialisiert und ihre Programme auf eventuelle 

Syntaxfehler überprüft. 

Eine Bibliothek muss nicht aus dem Speicher entfernt werden. Dies erfolgt automatisch nach dem Beenden der 

Anwendung oder beim Laden einer neuen Anwendung an deren Stelle. 

Wird eine VAL3-Applikation von der CS8-Benutzerschnittstelle gestoppt, so wird zunächst das Programm stop() 

ausgeführt und anschließend werden alle Tasks der Applikation und ihrer Bibliotheken, falls solche verbleiben, 

gelöscht. 



Zugriffspfad 

Die Anweisungen libLoad(), libSave() und libDelete() verwenden einen Bibliotheks-Zugriffspfad, der in Form einer 

Zeichenkette festgelegt ist. Ein Zugriffspfad enthält einen Stamm (fakultativ), einen Pfad (fakultativ) und den Namen 

einer Bibliothek in folgendem Format: 

Stamm://Weg/Name 

Der Stamm legt den Datenträger der Datei fest: "Floppy" für Diskette, "Disk" für Speicherung in CS8 oder den Namen 

einer in CS8 für einen Netzzugang festgelegten Ftp-Verbindung. 

Im Standardfall ist der Stamm "Disk" und der Pfad leer. 

Beispiele 

Teil:libLoad("Teil_1") 

Teil:libSave("Floppy://Teil") 

Teil:libSave("Disk://Teil_x/Teil_1") 

Fehlercodes 

Die VAL3-Funktionen für den Umgang mit Bibliotheken erzeugen keine Ausführungsfehler, sondern übergeben einen 

Fehlercode, mit dessen Hilfe das Ergebnis einer Anweisung überprüft und der Ursprung eventueller Probleme 

untersucht werden kann. 


0 Kein Fehler 

10 Die Kennung der Bibliothek wurde nicht durch libLoad() initialisiert. 

11 

12 

13 

Laden der Bibliothek unmöglich: Ihre Schnittstelle entspricht nicht derjenigen der 

Kennung. 

Laden der Bibliothek unmöglich: Die Bibliothek enthält ungültige Daten oder 

Programme. 

Entfernen der Bibliothek nicht möglich: Die Bibliothek enthält ungültige Daten oder 

Programme. 

20 Datei-Zugriffsfehler: der Stamm des Pfads ist ungültig. 

21 Datei-Zugriffsfehler: der Pfad ist ungültig. 

22 Datei-Zugriffsfehler: der Name ist ungültig. 

30 Lese-/Schreibfehler auf Datei. 

31 

Schreibzugriff: Der angegebene Pfad enthält bereits eine Bibliothek. 

Lesezugriff: Diese Bibliothek wird schon von einer anderen Kennung genutzt. 


Anweisungen 

Syntax 

num identifiant:libLoad(string Weg) 

num identifiant:libLoad(string Weg) 

Funktion 

Initialisierung der Kennung einer Bibliothek durch Laden der Programme und Daten der Bibliothek auf den festgelegten 

Weg. 

Überträgt 0 nach erfolgreichem Laden und einen Bibliothek-Fehlercode, wenn noch von der zu entfernenden Bibliothek 

geschaffene Tasks verbleiben, wenn der Zugangspfad zur Bibliothek ungültig ist, wenn die Bibliothek Syntax-Fehler 

enthält oder wenn die genannte Bibliothek nicht der für die Kennung erklärten Schnittstelle entspricht. 

Siehe auch 

num identifiant:libSave(), num libSave() 


Syntax 

num identifiant:libSave() 

num identifiant:libSave(string Weg) 

Funktion 

Sichern der Programme und Daten, die einer Bibliothek-Kennung zugeordnet sind. Wenn libSave() ohne Kennung 

aufgerufen wird, wird die Anwendung der aufrufenden Bibliothek gespeichert. Bei Angabe eines Parameters erfolgt das 

Sichern über den genannten Weg. Andernfalls wird über den beim Laden festgelegten Pfad gesichert. 

Überträgt 0, wenn die Programme und Daten gesichert worden sind, und einen Bibliothek-Fehlercode, wenn die 

Kennung nicht initialisiert ist, wenn der Pfad ungültig ist, oder wenn ein Schreibfehler eingetreten ist bzw. der genannte 

Pfad bereits zu einer Bibliothek führt. 

Siehe auch 

num libDelete(string Weg) 

Syntax 



Funktion 

Löscht die durch den Weg angezeigte Bibliothek. 

Überträgt 0, wenn die genannte Bibliothek nicht existiert oder gelöscht worden ist, und einen Bibliothek-Fehlercode, 

wenn die Kennung nicht initialisiert ist, wenn der Pfad ungültig ist, oder wenn ein Schreibfehler eingetreten ist. 

Siehe auch 


string identifiant:libPath(), string libPath() 



Syntax 

string identifiant:libPath() 


Funktion 

Überträgt den Zugangspfad der mit der Kennung verknüpften Bibliothek, oder der aufrufenden Anwendung oder 

Bibliothek, falls keine Kennung angegeben ist. 

Siehe auch 

bool libList(string Weg, string& contenu) 

Syntax 



Funktion 

Liste des in Tabelle Inhalt spezifizierten Weg. Überträgt true, wenn Tabelle Inhalt das gesamte Ergebnis auflistet, 

false wenn die Tabelle zu klein ist, um die gesamte Liste zu speichern. 

Die Tabelle Inhalt wird vor der Aktualisierung bei "" gestartet. Um das Ergebnis von libList() zu lesen, muss gestoppt 

werden, sobald ein ""-Wert auftritt. 

Falls Inhalt eine globale Variable ist, wird sie automatisch vergrößert, wenn Platz zur Speicherung des vollständigen 

Ergebnisses benötigt wird. 

Siehe auch 



STEUERUNG DES ROBOTERS 

In diesem Kapitel sind die Anweisungen für die verschiedenen Komponenten des Roboters aufgeführt. 

Anweisungen 

Syntax 

void disablePower() 


Funktion 

Schaltet die Armleistung ab und wartet, bis die Leistung tatsächlich abgeschaltet wurde. 

Wenn der Arm zu diesem Zeitpunkt in Bewegung ist, erfolgt vor dem Abschalten ein sofortiger Stillstand auf der Bahn. 

Siehe auch 

void enablePower() 

bool isPowered() 

Syntax 



Funktion 

Schaltet den Arm im ferngesteuerten Betrieb ein. 

Diese Anweisung hat keinen Einfluss auf den lokalen, manuellen oder Testbetrieb oder wenn die Leistung gerade 

abgeschaltet wird. 

Zum Beispiel 

// Schaltet den Strom ein und wartet auf das volle Anliegen der Spannung 

enablePower() 

if(watch(isPowered(), 5) == false) 

putln("Die Leistung kann nicht angelegt werden") 

endIf 

Siehe auch 



Syntax 



Funktion 

Überträgt den Status der Leistungsversorgung des Arms: 

true: Arm mit Strom versorgt 

false: der Arm ist ausgeschaltet, wird gerade ein- oder ausgeschaltet 



Syntax 

bool isCalibrated() 

Funktion 

Überträgt den Kalibrierstatus des Roboters: 

true: Alle Roboterachsen sind kalibriert 

false: Mindestens eine Roboterachse ist nicht kalibriert 

bool isCalibrated() 

num workingMode(), num workingMode(num& Status) 

Syntax 

num workingMode (num& Status) 

num workingMode() 

Funktion 

Überträgt die aktuelle Betriebsart des Roboters: 

Modus Status Betriebsart Status 

0 0 Ungültig oder Transition - 

0 

Programmierte Bewegung 

1 Anschlussbewegung 

2 Drehbewegung (Joint) 

1 

3 Handbetrieb 

Translationsbewegung (World) 

4 Tool (Tool) 

5 zum Punkt (User) 

6 Hold 

0 

programmierte Bewegung (250 mm/s) 

2 

1 

2 

Test 

Anschlussbewegung (250 mm/s) 

programmierte schnelle Bewegung 

3 Hold 

0 

Move (programmierte Bewegung) 

3 

1 Local 

Move (Anschlussbewegung) 

2 Hold 

0 

Move (programmierte Bewegung) 

4 

1 Remote 

Move (Anschlussbewegung) 

2 Hold 

Parameter 

num& Status Variable numerischen Typs. 


Syntax 

num speedScale() 

Funktion 

Überträgt die aktuelle Geschwindigkeit des Monitors. 

Zum Beispiel 

num nCycle 

taskCreate "checkSpeed", 5, checkSpeed() 

num speedScale() 

program checkSpeed() 

begin 

while true 

if(nCycle < 2) 

if (speedScale()> 10) 

stopMotion() 

putln("Für den ersten Zyklus muss die Monitorgeschwindigkeit bei 10 % bleiben") 

wait(speedScale()


EINLEITUNG 

ARMPOSITION 

In diesem Kapitel sind die verschiedenen Typen von VAL3-Daten beschrieben, mit denen die in einer VAL3-Applikation 

verfügbaren Armpositionen programmiert werden können. 

Zwei Typen von Position sind in VAL3 definiert: Winkelpositionen (Typ joint), die die Stellung der Gelenkachsen 

beschreiben und kartesische Punkte (Typ point), mit denen die Position des am Arm montierten Werkzeugs in 

kartesischen Koordinaten angegeben wird. 

Der Typ tool beschreibt ein Werkzeug mit seiner Geometrie, das zur Positionierung und Geschwindigkeitssteuerung 

des Arms verwendet wird, sowie dessen Aktivierungsmodus. 

Der Typ frame beschreibt ein Koordinatensystem. Durch die Verwendung von Bezugssystemen wird insbesondere die 

Programmierung bewegter Punkte einfacher und intuitiver. 

Der Typ trsf beschreibt eine Koordinatentransformation. Sie wird implizit von den Typen tool, point und frame 

verwendet. 

Der Typ config beschreibt den komplexeren Begriff der Armkonfiguration. 

Die Beziehungen zwischen den verschiedenen Typen lassen sich wie folgt zusammenfassen: 

TYP JOINT 

tool t21 tool t22 

tool t1 

Trsf 

Trsf 

flange 

robot 

Beziehung zwischen: frame / point / tool / trsf 

tool t2 

Trsf 

Trsf 

point p1a 

frame f1 

world 

point p21a point p21b 

frame f21 frame f21 

frame f2 

Definition 

Ein Gelenkpunkt (Typ joint) definiert die Winkelposition jeder Roboterachse. 

Der Typ joint ist ein strukturierter Typ mit folgenden Feldern in der nachstehenden Reihenfolge: 

num j1 Winkelposition Achse 1 



Trsf 

Trsf 

Trsf 

point p2a 

Diese Felder werden für die Drehachsen in Grad angegeben sowie in Millimetern für die linearen Achsen. Der Nullpunkt 

jeder Achse ist durch den verwendeten Armtyp festgelegt. 

Standardmäßig wird der Wert für jedes Feld einer Variable des Typs joint mit dem Wert 0 initialisiert. 


Trsf 

Trsf 

Trsf 

Trsf 

Trsf

Operatoren 


joint = Weist Position2 nacheinander der Variablen 

Position1 zu und überträgt Position2. 

bool != Überträgt true, wenn ein Feld von Position1 im 

Rahmen der Robotergenauigkeit nicht gleich dem 

entsprechenden Feld von Position2 ist, ansonsten 

false. 

bool == Überträgt true, wenn jedes Feld von Position1 im 

Rahmen der Robotergenauigkeit gleich dem 

entsprechenden Feld von Position2 ist, ansonsten 

false. 

bool > Überträgt true, wenn jedes Feld von Position1 größer 

als das entsprechende Feld in Position2 ist, ansonsten 

false. 

bool < Überträgt true, wenn jedes Feld von Position1 kleiner 

als das entsprechende Feld in Position2 ist, ansonsten 

false. 

Achtung: Position1 > Position2 ist nicht 

vollständig identisch mit Position2 < Position1! 

joint - Überträgt die Differenz für jedes Feld von Position1 mit 

Position2. 

joint + Überträgt die Summe für jedes Feld von Position1 und 

Position2. 

Anweisungen 

Syntax 

joint abs() 

Funktion 

Überträgt den Absolutwert für jedes Feld von Position. 

Parameter 

joint abs(joint Position) 

num Position Ausdruck des Typs Gelenkpunkt 

Zum Beispiel 

joint jEcartMax 

joint j 

jEcartMax = {5, 5, 5, 5, 5, 5} 

j = herej 

// Prüft, ob alle Achsenpositionen weniger als 5 Grad von der Markierung abweichen 

if(!(abs(j) < jEcartMax)) 

popUpMsg("Nähern Sie sich den Markierungen) 

endIf 

Siehe auch 

Opérateur bool 



Syntax 

joint herej() 

joint herej() 

Funktion 

Überträgt die aktuelle Gelenkposition des Arms (empfohlene Position und nicht die gemessene Position). 

Siehe auch 

joint herej() 

bool isInRange(joint Position) 


Syntax 

bool isInRange() 

Funktion 

Überträgt true, wenn Position innerhalb der Softwarebegrenzungen des Roboters liegt. 

Parameter 

joint Position Ausdruck des Typs Gelenkpunkt 

Siehe auch 

joint herej() 

Opérateur bool 


TYP TRSF 

Definition 

Eine Transformation (Typ trsf) beschreibt die Position und die Orientierung eines kartesischen Koordinatensystems in 

Bezug auf ein anderes Koordinatensystem. 

Der Typ rsf ist ein strukturierter Typ mit folgenden Feldern in der nachstehenden Reihenfolge: 

num x Translationskomponente in Richtung der x-Achse 

num y Translationskomponente in Richtung der y-Achse 

num z Translationskomponente in Richtung der z-Achse 

num rx Rotationskomponente um die x-Achse 

num ry Rotationskomponente um die y-Achse 

num rz Rotationskomponente um die z-Achse 

Die Felder x, y und z sind in der Längeneinheit der Applikation (mm oder inch, siehe Kapitel Längeneinheit) angegeben. 

Die Felder rx, ry und rz sind in Grad angegeben. 

Die Koordinaten x, y und z sind die kartesischen Koordinaten des Koordinatenursprungs im Referenz- 

Koordinatensystem. Wenn rx, ry und rz null sind, haben beide Koordinatensysteme die gleiche Orientierung. 

Der vorprogrammierte Wert für eine Variable des Typs trsf ist immer {0,0,0,0,0,0}. 



Orientierung 

x1 

Orientierung 

z1 

Die Position des Koordinatensystems R2 (grau) in Bezug auf R1 (schwarz) ist Folgende: 

x = 250mm, y = 350 mm, z = 450mm, rx = 0°, ry = 0°, rz = 0° 

Die drei Koordinaten rx, ry und rz entsprechen den Winkeln, um welche die x, y und z-Achse nacheinander zu drehen 

sind, um die gewünschte Orientierung des Koordinatensystems zu erhalten. 

Die Orientierung rx = 20°, ry = 10°, rz = 30° wird zum Beispiel auf folgende Weise erhalten. Zuerst wird das 

Koordinatensystem (x,y,z) um 20° um die x-Achse gedreht. Damit erhält man das neue Koordinatensystem (x’,y’,z’). 

Die Achsen x und x’ sind deckungsgleich. 

Drehung des Koordinatensystems bezüglich folgender Achse: X 

x = x’ 

450 mm 

x2 y2 

250 mm 

350 mm 

z’ 

20° 

Anschließend wird das Koordinatensystem um 20° um die Achse y’ des im vorherigen Schritt erhaltenen 

Koordinatensystems gedreht. Damit erhält man das neue Koordinatensystem (x’’,y’’,z’’). Die Achsen y’ und y’’ sind 

deckungsgleich. 

z 


z2 

y’ 

y 

y1

Drehung des Koordinatensystems bezüglich folgender Achse: Y’ 

x = x’ 

x’’ 

Zum Schluss wird das Koordinatensystem um 20° um die Achse z’’ des im vorherigen Schritt erhaltenen 

Koordinatensystems gedreht. Das neue Koordinatensystem (x’’’,y’’’,z’’’) hat die durch rx, ry, rz definierte Orientierung. 

Die Achsen z’’ und z‘’’ sind deckungsgleich. 

Drehung des Koordinatensystems bezüglich folgender Achse: Z’’ 

x = x’ 

x’’ 

z’’ 

z’’ 

x’’’ 

30° 

z’ 

z’ 

z 

z 

Die Position des Koordinatensystems R2 (grau) in Bezug auf R1 (schwarz) ist Folgende: 

x = 250mm, y = 350 mm, z = 450mm, rx = 20°, ry = 10°, rz = 30° 

Die Werte rx, ry und rz sind Modulo 360 Grad definiert. Die vom System berechneten Werte für rx, ry und rz liegen 

damit immer zwischen -180 und +180. Damit bleiben noch mehrere Werte für rx, ry, und rz möglich: Das System sorgt 

dafür, dass mindestens zwei der Koordinaten zwischen -90 und 90 liegen. Wenn ry 90° (modulo 180) beträgt, wird rx = 

0 gewählt. 

74 / 122 D28056202B - 06/2005 

10° 

y’’’ 

y’ = y’’ 

y 

y’ = y’’ 

y


Operatoren 


trsf = Weist Position2 nacheinander der Variablen 

Position1 zu und überträgt Position2. 

bool != Überträgt true, wenn ein Feld von Position1 nicht 

gleich dem entsprechenden Feld in Position2 ist, 

ansonsten false. 

bool == Überträgt true, wenn jedes Feld von Position1 gleich 

dem entsprechenden Feld in Position2 ist, ansonsten 

false. 

trsf Überträgt die geometrischen Komponenten der 

Transformationen Position1 und Position2. Achtung! 

Im Allgemeinen ist ! Position1 Position2 ! = 

Position2 Position1! 

trsf ! Überträgt die Umkehrung der Transformation von 

Position. 

Anweisungen 

Syntax 

num distance(trsf Position1, trsf Position2) 

num distance(, ) 

Funktion 

Überträgt die Entfernung zwischen Position1 und Position2. 

ACHTUNG: 

Damit die Entfernung gültig ist, müssen Position1 und Position2 im gleichen Referenz- 

Koordinatensystem definiert sein. 

Parameter 

trsf Position1 Ausdruck des Typs Transformation 

trsf Position2 Ausdruck des Typs Transformation 

Zum Beispiel 

// Zeigt den Abstand zwischen zwei Punkten unabhängig von ihrem Referenz-Koordinatensystem an 

putln(distance(position(point1, world), position(point2, world))) 

Siehe auch 

point appro(point Position, trsf Umwandlung) 

point compose(point Position, frame Markierung, trsf Umwandlung) 

trsf position(point Position, frame Markierung) 

num distance(point Position1, point Position2) 


TYP FRAME 

Definition 

Der Typ frame dient zur Festlegung der Position der Referenz-Koordinatensysteme in der Arbeitszelle. 

Der Typ frame ist ein strukturierter Typ mit einem einzigen verfügbaren Feld: 

trsf trsf Position des Koordinatensystems in seinem Referenz-Koordinatensystem 

Das Referenz-Koordinatensystem einer Variable des Typs frame wird bei ihrer Initialisierung festgelegt (von der 

Benutzerschnittstelle aus oder mit dem Operator =). Das Referenz-Koordinatensystem world des Typs frame ist in 

einer VAL3-Applikation immer definiert: Alle Referenz-Koordinatensysteme sind direkt oder über andere 

Koordinatensysteme mit world verbunden. 

Wurden die Koordinaten des Bezugssystems world geändert, so wird bei jeder geometrischen Berechnung ein 


Zusammenhang zwischen den Referenz-Koordinatensystemen 

point1a 

point21a point21b 

frame 21 frame 21 

frame1 frame2 

world 

point2a 

Wenn nicht anders festgelegt, verwendet eine Variable des Typs frame world als Bezugssystem. 

Verwendung 

Die Verwendung von Referenz-Koordinatensystemen in einer Roboteranwendung wird ausdrücklich empfohlen: 

- Um die einzelnen Punkte der Applikation intuitiv erkennen zu können 

Die von der Arbeitszelle erlernten Punkte werden entsprechend der hierarchischen Ordnung der 

Koordinatensysteme in strukturierter Weise angezeigt. 

- Um die Position einer Gruppe von Punkten rasch zu ändern 

Sobald ein Punkt der Applikation an ein Objekt gebunden ist, sollten für dieses Objekt ein Koordinatensystem 

definiert und die VAL3-Punkte mit ihm verbunden werden. Wenn das Objekt verschoben wird, braucht nur das 

Koordinatensystem neu gelernt zu werden, und alle mit ihm verbundenen Punkte werden gleichzeitig korrigiert. 

- Zur Wiederholung einer Bahn an mehreren Stellen der Arbeitszelle 

Hierzu können die Bahnpunkte in Bezug auf ein Arbeitskoordinatensystem festgelegt werden, das dann an jeder 

Stelle, an der die Bahn wiederholt werden soll, gelernt wird. Durch Zuweisung des Wertes eines gelernten 

Koordinatensystems an das Arbeitskoordinatensystem wird die gesamte Bahn auf das gelernte 

Koordinatensystem "verschoben". 

- Um geometrische Verschiebungen leichter berechnen zu können 

Die Anweisung compose() erlaubt geometrische Verschiebungen an einen beliebigen Punkt, die in irgendeinem 

Referenz-Koordinatensystem ausgedrückt werden. Die Anweisung position() dient zur Berechnung der Position 

eines Punktes in einem beliebigen Referenz-Koordinatensystem. 



Operatoren 


frame = 

bool != 

bool == 

Anweisungen 

num setFrame(point Herkunft, point AchseOx, point PlanOxy, frame& 

Markierung) 

Syntax 

num setFrame(point Herkunft, point AchseOx, point PlanOxy, frame& Markierung) 

Funktion 

Berechnet die Koordinaten von Markierung anhand dessen Herkunft unter Verwendung eines Punktes AchseOx auf 

der (Ox)-Achse und eines Punktes PlanOxy der Ebene (Oxy). 

Der Punkt AchseOx muss auf der positiven x-Achse liegen. Der Punkt PlanOxy muss auf der positiven y-Achse liegen. 

Die Funktion liefert folgende Antwort: 

0 Kein Fehler. 

-1 Der Punkt AchseOx liegt zu dicht am Herkunft. 

-2 Der Punkt PlanOxy liegt zu dicht an der Achse (Ox). 

Wenn einer der Punkte kein Referenz-Koordinatensystem besitzt, wird eine Fehlermeldung erzeugt. 

TYP TOOL 

Weist die Position und das Referenz- 

Koordinatensystem von Markierung2 der Variable 

Markierung1 zu. 

Überträgt true, wenn Markierung1 und Markierung2 

nicht das gleiche Referenz-Koordinatensystem oder 

darin nicht die gleiche Position haben. 

Überträgt true, wenn Markierung1 und Markierung2 

die gleiche Position im gleichen Referenz- 

Koordinatensystem haben. 

Definition 

Der Typ tool dient zur Definition der Geometrie und der Bewegung eines Werkzeugs. 

Der Typ tool ist ein strukturierter Typ mit folgenden Feldern in der nachstehenden Reihenfolge: 

trsf trsf Position des Tools als Basiswerkzeug 

dio gripper Digitaler Ausgang zur Steuerung des Werkzeugs 

num otime Öffnungszeit des Werkzeugs (in Sekunden) 

num ctime Schließzeit des Werkzeugs (in Sekunden) 

Das Basiswerkzeug einer Variable des Typs tool wird bei ihrer Initialisierung festgelegt (von der Benutzerschnittstelle 

aus oder mit dem Operator =). Das Basiswerkzeug flange des Typs tool ist immer in einer VAL3-Applikation definiert: 

Jedes Tool ist direkt oder über andere Tools mit dem Tool flange verbunden. 

Wurden die Koordinaten des Werkzeugs flange geändert, so wird bei jeder geometrischen Berechnung ein 



Abhängigkeit der Tools 

Der Ausgang eines Tools ist vorprogrammiert auf Ausgang io:Ventil1 des Systems, die Öffnungs- und Schließzeit sind 

0 und das Basistool ist flange. 

Verwendung 

Die Verwendung von Werkzeugen in einer Roboteranwendung wird ausdrücklich empfohlen: 

Operatoren 


outil21 outil21 

outil1 outil2 

flange 

- Um die Bewegungsgeschwindigkeit zu steuern 

Bei manuellen oder programmierten Bewegungen steuert das System die kartesische Geschwindigkeit am 

Werkzeugende. 

- Um mit verschiedenen Werkzeugen die gleichen Punkte anzufahren 

Hierzu genügt es, das VAL3-Werkzeug zu wählen, das dem am Arm montierten realen Werkzeug entspricht. 

- Um einen Verschleiß oder einen Werkzeugwechsel zu verwalten 

Um die Armposition zu aktualisieren, brauchen nur die neuen Werkzeugkoordinaten eingegeben zu werden. 

tool = Weist der Variablen Werkzeug1 die Position und das 

Basiswerkzeug von Werkzeug2 zu. 

bool != Überträgt true, wenn Werkzeug1 und Werkzeug2 

nicht das gleiche Basiswerkzeug, die gleiche Position 

in ihrem Basiswerkzeug, den gleichen digitalen 

Ausgang oder die gleichen Öffnungs- und 

Schließzeiten haben. 

bool == Überträgt true, wenn Werkzeug1 und Werkzeug2 die 

gleiche Position im gleichen Basiswerkzeug, den 

gleichen digitalen Ausgang mit den gleichen Öffnungs- 

und Schließzeiten haben. 



Anweisungen 

Syntax 

void open (tool Werkzeug) 

void open(tool Werkzeug) 

Funktion 

Betätigung des Werkzeugs (öffnen). Hierfür wird der digitale Ausgang des Werkzeugs auf true gesetzt. 

Bevor das Tool bewegt werden kann, wartet open() bis der Roboter den Punkt erreicht hat, was mittels einer 

gleichwertigen Aktion wie waitEndMove() geschieht. Nach der Aktivierung wartet das System otime Sekunden, bevor 

die nächste Anweisung ausgeführt wird. 

Diese Anweisung stellt nicht die Stabilisierung des Roboters vor der Aktivierung des Werkzeugs an seiner Endposition 

sicher. Wenn die vollständige Stabilisierung nach der Bewegung abgewartet werden soll, so muss die Anweisung 

isSettled() verwendet werden. 

Wenn dio von Werkzeug nicht definiert oder kein Ausgang ist, wird ein Ausführungsfehler erzeugt, ebenso, wenn ein 

zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt werden kann (Endpunkt außer Reichweite). 

Parameter 

tool Werkzeug Ausdruck des Typs Werkzeug 

Zum Beispiel 

// Die Anweisung open() entspricht: 

waitEndMove() 

tOutil.gripper=true 

delay(tOutil.otime) 

Siehe auch 

void close(tool Werkzeug) 

void waitEndMove() 

Syntax 

void close (tool Werkzeug) 

void close(tool Werkzeug) 

Funktion 

Betätigt das Werkzeug (schließen). Hierfür wird der digitale Ausgang des Werkzeugs auf false gesetzt. 

Bevor das Tool bewegt werden kann, wartet open() bis der Roboter den Punkt erreicht hat, was mittels einer 

gleichwertigen Aktion wie waitEndMove() geschieht. Nach der Aktivierung wartet das System ctime Sekunden, bevor 

die nächste Anweisung ausgeführt wird. 

Diese Anweisung stellt nicht die Stabilisierung des Roboters vor der Aktivierung des Werkzeugs an seiner Endposition 

sicher. Wenn die vollständige Stabilisierung nach der Bewegung abgewartet werden soll, so muss die Anweisung 

isSettled() verwendet werden. 

Wenn dio von Werkzeug nicht definiert oder kein Ausgang ist, wird ein Ausführungsfehler erzeugt, ebenso, wenn ein 

zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt werden kann (Endpunkt außer Reichweite). 

Parameter 


Zum Beispiel 

// Ausdruck des Typs Werkzeug: 

waitEndMove() 

tOutil.gripper = false 

delay(tOutil.ctime) 

Siehe auch 

Type tool 

void open(tool Werkzeug) 



TYP POINT 

Definition 

Der Typ point dient zur Definition der Position und Orientierung des Roboterwerkzeugs in der Arbeitszelle. 

Der Typ point ist ein strukturierter Typ mit folgenden Feldern in der nachstehenden Reihenfolge: 

trsf trsf Position des Punktes in seinem Referenz-Koordinatensystem 

config config Konfiguration des Arms, um die Position anfahren zu können 

Das Referenz-Koordinatensystem eines point ist eine Variable des Typs frame, die bei ihrer Initialisierung definiert wird 

(von der Benutzerschnittstelle aus, mit dem Operator = und den Anweisungen here(), appro() und compose()). 

Punktdefinition 

Wenn man eine Variable des Typs point ohne definiertes Referenz-Koordinatensystem verwendet, wird eine 

Fehlermeldung erzeugt. 

Operatoren 


Frame world Frame f1 

Point p0 

Point p1 

ACHTUNG: 

Eine lokale Variable des Typs point hat standardmäßig kein vorprogrammiertes Referenz- 

Koordinatensystem. Um sie zu verwenden, muss sie von einem anderen Punkt aus oder mit 

einer der Anweisungen here(), appro() oder compose() initialisiert werden. 

point = Weist die Position, die Konfiguration und das 

Referenz-Koordinatensystem von Punkt1 der 

Variablen Punkt2 zu. 

bool ! = Überträgt true, wenn Punkt1 und Punkt2 nicht das 

gleiche Referenz-Koordinatensystem oder darin 

nicht die gleiche Position haben. 

bool == Überträgt true, wenn Punkt1 und Punkt2 die gleiche 

Position im gleichen Referenz-Koordinatensystem 

haben. 


Frame f2 

Point p2 

Point p3


Anweisungen 

Syntax 



Funktion 

Überträgt die Entfernung zwischen Position1 und Position2. 

Ein Ausführungsfehler wird erzeugt, wenn das Referenz-Koordinatensystem von Position1 oder Position2 nicht 

festgelegt ist. 

Parameter 

point Position1 Ausdruck des Typs point 

point Position2 Ausdruck des Typs point 

Zum Beispiel 


putln(distance(point1, point2)) 

Siehe auch 







Syntax 


Funktion 

Überträgt Position, auf welche die in Bezug auf Markierung definierte Koordinatentransformation Umwandlung 

angewandt wurde. 

ACHTUNG: 

Die Drehkomponente von Umwandlung ändert in der Regel nicht nur die Ausrichtung von 

Position, sondern auch seine kartesischen Koordinaten (außer wenn sich Position am 

Ursprung von Markierung befindet). 

Wenn Umwandlung nur die Ausrichtung von Position ändern soll, muss das Ergebnis mit den 

kartesischen Koordinaten von Position aktualisiert werden (siehe Beispiel). 

Das Referenz-Koordinatensystem und die Konfiguration des übertragenen Punktes sind die von Position. 

Wenn für Position kein Referenz-Koordinatensystem definiert ist, wird eine Fehlermeldung erzeugt. 

Parameter 

point Position Ausdruck des Typs point 

frame Markierung Ausdruck des Typs Referenz-Koordinatensystem 

trsf Umwandlung Ausdruck des Typs Transformation 

Zum Beispiel 

point pResultat 

// Änderung der Ausrichtung ohne Änderung von Position 

pResultat = compose (Position,Markierung,Umwandlung) 

pResultat.x = Position.x 

pResultat.y = Position.y 

pResultat.z = Position.z 

// Änderung von Position ohne Änderung der Ausrichtung 

Umwandlung.rx = Umwandlung.ry =Umwandlung.rz = 0 

pResultat = compose (pResultat,Markierung,Umwandlung) 

Siehe auch 

Opérateur trsf * 




Syntax 



Funktion 

Überträgt Position, auf welche die für das Referenz-Koordinatensystem von Position definierte 

Koordinatentransformation Umwandlung angewandt wurde. 

Das Referenz-Koordinatensystem und die Konfiguration des übertragenen Punktes sind die von Position. 


Parameter 


trsf Umwandlung Ausdruck des Typs Transformation 

Zum Beispiel 

// Annähern auf 100 mm oberhalb des Punktes (Z-Achse) 

point p 

movej(appro(p,{0,0,-100,0,0,0}), flange, mNomDesc) // Annäherung 

movel(p, flange, mNomDesc) // Bewegung zum Punkt 

Siehe auch 

Opérateur trsf * 


point here(tool Werkzeug, frame Markierung) 

Syntax 


Funktion 

Überträgt die aktuelle Position des Werkzeugs Werkzeug in Markierung (empfohlene Position und nicht die 

gemessene Position). 

Das Referenz-Koordinatensystem des übertragenen Punktes ist Markierung. Die Konfiguration des übertragenen 

Punktes ist die aktuelle Konfiguration des Arms. 

Siehe auch 

joint herej() 

config config(joint Position) 

point jointToPoint(tool Werkzeug, frame Markierung, joint Position) 



Syntax 

point jointToPoint (tool Werkzeug, frame Markierung, joint Position) 

Funktion 

Überträgt die Position Werkzeug in Markierung, wenn der Arm in der Gelenkposition Position ist. 

Das Referenz-Koordinatensystem des übertragenen Punktes ist Markierung. Die Konfiguration des übertragenen 

Punktes ist die des Arms in der Gelenkposition Position. 

Parameter 


frame Markierung Ausdruck des Typs Referenz-Koordinatensystem 

joint Position Ausdruck des Typs Gelenkposition 

Siehe auch 


bool pointToJoint(tool Werkzeug, joint anfänglich, point Position,joint& Angaben) 

bool pointToJoint(tool Werkzeug, joint anfänglich, point Position,joint& 

Angaben) 

Syntax 

bool pointToJoint(tool Werkzeug, joint anfänglich, point Position, joint& Angaben) 

Funktion 

Berechnet die Angaben, die der spezifizierten Position entsprechen. Überträgt true, wenn Gelenk-Angaben gefunden 

wurden, und false, wenn es keine Lösung gibt. 

Die gesuchte Gelenkposition ist mit der Konfiguration von Position kompatibel. Die Felder mit dem Wert free schreiben 

keine Konfiguration vor. Die Felder mit dem Wert same schreiben die gleiche Konfiguration wie anfänglich vor. 

Wenn die Achsen mehr als eine Umdrehung ausführen sollen, gibt es mehrere Lösungen, die genau die gleiche 

Konfiguration haben: Es wird die anfänglich am nächsten liegende Lösung genommen. 

Wenn Position außer Reichweite (Arm zu kurz) oder außerhalb der Softwaregrenzen liegt, kann es sein, dass es keine 

Lösung gibt. Wenn Position eine Konfiguration spezifiziert, kann sie für diese Konfiguration außerhalb, aber für eine 

andere Konfiguration innerhalb der Softwaregrenzen liegen. 


Parameter 


joint anfänglich Ausdruck des Typs Gelenkposition 


joint& Angaben Variable des Typs Gelenkposition 

Siehe auch 

joint herej() 




Syntax 



Funktion 

Überträgt die Koordinaten von Position in Markierung. 

Wenn Position kein Referenz-Koordinatensystem besitzt, wird eine Fehlermeldung erzeugt. 

Zum Beispiel 


putln(distance(position(point1, world), position(point2, world))) 

Siehe auch 



TYP CONFIG 

Die Konfiguration eines kartesischen Punktes gehört zu den komplexeren Funktionen und kann beim ersten Lesen 

übergangen werden. 

Einleitung 

Im Allgemeinen hat der Roboter mehrere Möglichkeiten, eine in kartesischen Koordinaten angegebene Position 

anzufahren. 

Diese verschiedenen Möglichkeiten werden "Konfigurationen" genannt. Die nachfolgende Zeichnung zeigt zwei 

verschiedene Konfigurationen: 

Zwei verschiedene Konfigurationen, um denselben Punkt zu erreichen: P 

In bestimmten Fällen ist es wichtig, anzugeben, welche der möglichen Konfigurationen zulässig sind und welche 

verboten werden sollen. Um dieses Problem zu lösen, können mit dem Typ point dank des nachstehend definierten 

Feldes des Typs config die zulässigen Roboterkonfigurationen spezifiziert werden. 

Definition 

Typ config ermöglicht die Definition der erlaubten Konfigurationen für eine bestimmte kartesische Position. 

Er hängt vom verwendeten Armtyp ab. 

Für einen Stäubli RX/TX-Arm ist der Typ config ein strukturierter Typ mit folgenden Feldern in der nachstehenden 

Reihenfolge: 

shoulder Konfiguration der Schulter 

elbow Konfiguration des Ellenbogens 

wrist Konfiguration des Handgelenks 

Für einen Stäubli RS-Arm ist der Typ config auf das Feld Shoulder begrenzt: 

shoulder Konfiguration der Schulter 

Die Felder shoulder, elbow und wrist können folgende Werte annehmen: 

shoulder 

righty Konfiguration der Schulter righty vorgeschrieben 

lefty Konfiguration der Schulter lefty vorgeschrieben 

ssame Andere Schulterkonfiguration verboten 

sfree Beliebige Konfiguration der Schulter 

P P 



elbow 

wrist 

Operatoren 


Konfiguration (Arm RX/TX) 

epositive Konfiguration des Ellenbogens epositive vorgeschrieben 

enegative Konfiguration des Ellenbogens enegative vorgeschrieben 

esame Andere Ellenbogenkonfiguration verboten 

efree Beliebige Konfiguration des Ellenbogens 

wpositive Konfiguration des Handgelenks wpositive vorgeschrieben 

wnegative Konfiguration des Handgelenks wnegative vorgeschrieben 

wsame Andere Handgelenkkonfiguration verboten 

wfree Beliebige Konfiguration des Handgelenks 

config = 

bool != 

bool == 

Weist die Felder shoulder, elbow und wrist von 

Konfiguration2 der Variablen Konfiguration1 zu. 

Überträgt true, wenn die Felder shoulder, elbow oder wrist 

in Konfiguration1 und Konfiguration2 nicht den gleichen 

Wert haben. 

Überträgt true, wenn die Felder shoulder, elbow oder wrist 

in Konfiguration1 und Konfiguration2 den gleichen Wert 

haben. 

Konfiguration der Schulter 

Um einen kartesischen Punkt zu erreichen kann sich der Roboterarm rechts oder links von diesem Punkt befinden: 

Diese beiden Konfigurationen werden righty und lefty genannt. 

Konfiguration: righty Konfiguration: lefty 

Die Konfiguration righty ist definiert durch ((d1.sin(j2) + d2.sin(j2+j3) + ) < 0, die Konfiguration lefty durch 

(d1.sin(j2) + d2.sin(j2+j3) + ) >= 0, mit d1 = Armlänge des Roboters, d2 = Unterarmlänge und = Abstand der 

Achsen 1 und 2 in Richtung x. 


Konfiguration des Ellenbogens 

Zusätzlich zur Konfiguration der Schulter gibt es zwei Möglichkeiten für das Ellenbogengelenk des Roboters: Die 

Ellenbogenkonfigurationen werden epositive und enegative genannt. 

Konfiguration: enegative Konfiguration: epositive 

Die Konfiguration epositive ist durch j3 >= 0 definiert. 

Die Konfiguration enegative ist durch j3 < 0 definiert. 

Konfiguration des Handgelenks 

Außer der Konfiguration der Schulter und des Ellenbogens gibt es zwei Möglichkeiten für das Handgelenk des 

Roboters. Die beiden Konfigurationen des Handgelenks werden wpositive und wnegative genannt. 

Konfiguration: wnegative Konfiguration: wpositive 

Die Konfiguration wpositive ist durch q5 >= 0 definiert. 

Die Konfiguration wnegative ist durch q5 < 0 definiert. 



Konfiguration (Arm RS) 

Um einen kartesischen Punkt zu erreichen kann sich der Roboterarm rechts oder links von diesem Punkt befinden: 

Diese beiden Konfigurationen werden righty und lefty genannt. 

Konfiguration: righty Konfiguration: lefty 

Die Konfiguration righty ist definiert durch sin(j2) > 0, die Konfiguration lefty durch sin(j2) < 0. 


Anweisungen 

Syntax 



Funktion 

Überträgt die Roboterkonfiguration für die Gelenkposition Position. 

Parameter 


Siehe auch 


joint herej() 



BEWEGUNGSSTEUERUNG 

BEWEGUNGSSTEUERUNG 

Um eine Roboterbahn zu definieren, genügt es nicht, nur eine Reihe von Punkten anzugeben. Es müssen außerdem 

die Art der zwischen diesen Punkten verwendeten Bahnen (Kurven- oder Geradenabschnitte) sowie die Art der 

Anschlüsse zwischen diesen Abschnitten und schließlich die Geschwindigkeitsparameter für diese Bewegung 

festgelegt werden. Dieses Kapitel gibt eine Einführung in Punkt-zu-Punkt-Bewegungen und geradlinige Bewegungen 

(Anweisungen movej und movel) und beschreibt, wie die Parameter des Bewegungsdeskriptors (Typ mdesc) zu 

verwenden sind. 

Bewegungstypen: Punkt-zu-Punkt, geradlinig, kreisförmig 

Roboterbewegungen werden vor allem mit den Anweisungen movej, movel und movec programmiert. Mit movej 

werden Punkt-zu-Punkt-Bewegungen, mit movel geradlinige Bewegungen und mit movec kreisförmige Bewegungen 

ausgeführt. 

Bei einer Punkt-zu-Punkt-Bewegung ist nur der Endpunkt (kartesischer Punkt oder Gelenkpunkt) von Bedeutung. 

Zwischen dem Anfangs- und dem Endpunkt folgt das Werkzeugzentrum einer vom System definierten Kurve, um die 

Bewegungsgeschwindigkeit zu optimieren. 

Anfans- und Endposition 

Dagegen bewegt sich der Werkzeugmittelpunkt bei einer geradlinigen Bewegung entlang der vorgegebenen Geraden. 

Die Orientierung wird zwischen der Ausgangs- und Endorientierung des Werkzeugs linear interpoliert. 

Z 

X 

Y 

Initial position 

Final position 

Geradlinige Bewegung 


X 

Z 

Y

Bei einer kreisförmigen Bewegung bewegt sich die Werkzeugmitte entlang eines durch 3 Punkte definierten 

Kreisbogens, und die Orientierung des Werkzeugs wird zwischen Ausgangs-, Mittel- und Endorientierung interpoliert. 

Z 

Vom Werkzeug während der 

kreisförmigen Bewegung beschriebene Bahn 

Kreisförmige Bewegung 

Zum Beispiel: 

Eine typische Handlingaufgabe besteht darin, Teile an einem Ort aufzunehmen und an einem anderen Ort abzulegen. 

Angenommen, die Teile sollen am Punkt PRISE aufgenommen und am Punkt DEPOSE abgelegt werden. Um vom 

Punkt PRISE zum Punkt DEPOSE zu gelangen, muss der Roboter über einen Zwischenpunkt DEGAGE und einen 

Annäherungspunkt APPRO fahren. 

DEGAGE 

Z 

PRISE 

Z 

X 

X 

Zyklus: U 

APPRO 

DEPOSE 

Nächste Bewegung 

Vorherige Bewegung 

Angenommen, der Roboter steht zu Beginn am Punkt PRISE. Dann kann das Programm für diese Bewegung wie folgt 

aussehen: 

movel(DEGAGE, tool, mDesc) 

movej(APPRO, tool, mDesc) 

movel(DEPOSE, tool, mDesc) 


Z 

Z 

X 

X


Zum Freifahren und zur Annäherung werden gerade Bahnabschnitte verwendet. Die Hauptbewegung ist dagegen eine 

Punkt-zu-Punkt-Bewegung, da dieser Teil der Bahn keine genaue geometrische Steuerung erfordert, sondern vielmehr 

möglichst rasch zurückgelegt werden soll. 

Hinweis: 

Bei beiden Bewegungstypen hängt die Geometrie der Bahn nicht von der Geschwindigkeit ab, 

mit der die Bewegungen ausgeführt werden. Der Roboter fährt immer den gleichen Punkt an. 

Dieser Umstand ist bei der Entwicklung von Applikationen besonders wichtig. Man kann mit 

langsamen Bewegungen beginnen und die Geschwindigkeit nach und nach erhöhen, ohne dabei 

die Bahn des Roboters zu ändern. 

Verkettung von Bewegungen 

Glättung 

Sehen wir uns das Beispiel des U-Zyklus im letzten Abschnitt an. Ohne besondere Maßnahmen zur Verkettung der 

Bewegungen würde der Roboter an den Punkten DEGAGE und DEPOSE anhalten, denn die Bahn hat an diesen 

Stellen einen Knick. Das würde unnötig Zeit kosten, außerdem ist das genaue Anfahren dieser Punkte gar nicht 

erforderlich. 

Durch Glättung der Bahn in der Umgebung der Punkte DEGAGE und APPRO lässt sich die Dauer der gesamten 

Bewegung erheblich verkürzen. Hierzu dient das Feld blend im Bewegungsdeskriptor. Wenn der Wert in diesem Feld 

auf off steht, hält der Roboter an jedem Punkt an. Wenn dieser Parameter jedoch auf joint gesetzt wird, wird die Bahn 

in der Umgebung dieser Punkte geglättet und der Roboter hält beim Überfahren der Punkte nicht mehr an. 

Wenn das Feld blend den Wert joint annimmt, müssen zwei weitere Parameter spezifiziert werden: leave und reach. 

Mit diesen Parametern wird festgelegt, in welcher Entfernung vom Zielpunkt die theoretische Bahn verlassen (Beginn 

der Glättung) und in welcher Entfernung vom Zielpunkt sie wieder eingenommen wird (Ende der Glättung). 

Definition der Entfernungen: ’leave’ / ’reach’ 

LEAVE 

REACH 

Zum Beispiel: 

Betrachten wir das Programm im Kapitel "Bewegungstypen:Punkt-zu-Punkt und geradlinig". Das vorhergehende 

Bewegungsprogramm kann geändert werden: 

mDesc.blend = joint 

mDesc.leave = 50 

mDesc.reach = 200 

movel(DEGAGE, tool, mDesc) 



movej(APPRO, tool, mDesc) 

mDesc.blend = OFF 

movel(DEPOSE, tool, mDesc) 


Damit erhält man folgende Bahn: 

DEGAGE 

50 

Geglätteter Zyklus 

Der Roboter hält an den Punkten DEGAGE und APPRO nicht mehr an. Die Bewegung wird daher schneller. Je größer 

die Entfernungen leave und reach gewählt werden, desto rascher wird die Bewegung. 

Aufheben der Glättung 

Die Anweisung waitEndMove() ermöglicht unter anderem, den Glättungseffekt zu annullieren. In diesem Fall führt der 

Roboter die zuletzt programmierte Bewegung bis zum Zielpunkt aus, als ob das Feld blend im Bewegungsdeskriptor 

auf off stehen würde. 

Betrachten wir zum Beispiel das folgende Programm: 

mDesc.blend = joint 



movej(A, tool, mDesc) 

movej(B, tool, mDesc) 

waitEndMove() 

movej(C, tool, mDesc) 

movej(D, tool, mDesc) 

etc... 

ergibt sich folgende Bahn des Roboters: 

Zyklus mit unterbrochener Glättung 

APPRO 

PRISE DEPOSE 

10 

200 

A 

10 

No smoothing at B 

(BREAK) 

10 

B 


10 

10 

C 

10 

200 

10 

D 

10 

50


Wiederaufnahme einer Bewegung 

Wird die Energieversorgung des Arms unterbrochen bevor der Roboter seine Bewegungen beendet hat, zum Beispiel 

nach einer Notabschaltung, so muss nach der Wiederherstellung der Energieversorgung eine Bewegungs- 

Wiederaufnahme durchgeführt werden. Wurde der Arm während der Abschaltung per Hand verschoben, so kann er von 

seiner Bahn weit entfernt sein. Es muss also sichergestellt werden, dass die Bewegung ohne Kollisionsgefahr 

wiederaufgenommen werden kann. Die CS8-Bahnkontrolle ermöglicht die Verwaltung der Bewegungs- 

Wiederaufnahme mittels einer "Anschlussbewegung". 

Bei der Wiederaufnahme der Bewegung stellt das System sicher, dass sich der Roboter auf der programmierten Bahn 

befindet: Bei Abweichungen (auch sehr kleinen Werts) zeichnet er automatisch einen Punkt-zu-Punkt- 

Bewegungsbefehl auf, der zur exakten Position, aus welcher der Roboter seine Bahn verlassen hat, zurückführt: Dies 

ist die sogenannte "Anschlussbewegung". Sie erfolgt mit reduzierter Geschwindigkeit. Sie muss vom Bediener bestätigt 

werden, außer bei Automatikbetrieb, wo sie ohne menschliche Eingriffe erfolgen kann. Das Verhalten bei 

Automatikbetrieb kann mittels der Anweisung autoConnectMove() festgelegt werden. 

Die Anweisung resetMotion() ermöglicht das Abbrechen der aktuellen Bewegung und das eventuelle Programmieren 

einer Anschlussbewegung, mit deren Hilfe eine Position bei reduzierter Geschwindigkeit unter der Kontrolle des 

Bedieners angefahren werden kann. 


Besonderheiten der kartesischen Bewegungen (geradlinig, kreisförmig) 

Interpolation der Ausrichtung 

Um die Ausrichtung zu ändern, minimiert der CS8-Bahnerzeuger stets die Amplitude der Werkzeugdrehungen. 

Dadurch kann als Sonderfall, für alle geradlinigen oder kreisförmigen Bewegungen, eine absolute, konstante 

Ausrichtung oder eine Ausrichtung bezüglich der Bahn programmiert werden. 

• Für eine konstante Ausrichtung müssen Ausgangs- und Endposition sowie die Mittelposition für einen Kreis 

dieselbe Ausrichung haben. 

Absolute, konstante Ausrichtung 

• Für eine konstante Ausrichtung bezüglich der Bahn (z. B. Richtung Y der Werkzeugmarkierung 

Bahntangente) müssen Ausgangs- und Endposition sowie die Mittelposition für einen Kreis dieselbe 

Ausrichtung haben. 


Y 


kreisförmigen Bewegung beschriebene 

Bahn 

(Ausrichtung bleibt konstant) 


Konstante Ausrichtung bezüglich der Bahn 

Vom Werkzeug während der kreisförmigen 

Bewegung beschriebene Bahn 

(Tangentenausrichtung) 





Daraus ergibt sich eine Beschränkung für die kreisförmigen Bewegungen: 

Wenn der mittlere Punkt mit dem Anfangs- oder mit dem Endpunkt einen Winkel von 180° oder mehr bildet, gibt es 

mehrere Interpolations- und Ausrichtungsmöglichkeiten und es wird ein Fehler erzeugt. 

Die Position des mittleren Punktes muss also geändert werden, um die Mehrdeutigkeit der mittleren Ausrichtungen zu 

beenden. 

Mehrdeutigkeit der mittleren Ausrichtung 

Fehler: kreisförmige Bewegungen 

Insbesondere verlangt die Programmierung eines vollständigen Kreises 2 movec-Anweisungen: 

movec (B, C, Werkzeug, mDesc) 

movec (D, A, Werkzeug, mDesc) 

Nächste 

Bewegung 

A 

Vollständiger Kreis 


kreisförmigen Bewegung 

beschriebene Bahn 


Y 

OK ! 

Vorherige 

Bewegung

Änderung der Konfiguration (Arm RX/TX) 

Wechsel: righty / lefty 

Bei einer Änderung der Schulterkonfiguration muss der Mittelpunkt des Handgelenks über die Achse 1 hinwegfahren 

(nicht unbedingt bei Robotern mit Ausleger). 

Positive / negative Konfiguration des Ellenbogens 

Bei Änderung der Konfiguration des Ellenbogens muss der Arm gestreckt (q3 = 0°) werden. 



Positive / negative Konfiguration des Handgelenks 

Bei einer Änderung der Konfiguration des Handgelenks muss der Arm kurzzeitig das Handgelenk (q5 = 0°) strecken. 

Das bedeutet, dass der Roboter auf seinem Weg bestimmte Positionen einnehmen muss, wenn die Konfiguration 

geändert wird. Man kann aber keine geradlinigen oder kreisförmigen Bewegungen über diese Positionen erzwingen, 

wenn sie nicht auf der gewünschten Bahn liegen! Daraus folgt, dass ein Konfigurationswechsel während einer 

geradlinigen oder kreisförmigen Bewegung nicht erzwungen werden kann. 

Wechseln der Ellenbogenkonfiguration nicht möglich 

Anders ausgedrückt kann man bei einer geradlinigen oder kreisförmigen Bewegung eine Konfiguration nur dann 

realisieren, wenn sie mit der Anfangsposition vereinbar ist: Eine freie oder mit der Ausgangsposition identische 

Konfiguration kann immer spezifiziert werden. 

Im Ausnahmefall kann die Gerade oder der Kreisbogen durch eine Position gehen, an der ein Konfigurationswechsel 

möglich ist. In diesem Fall kann das System, wenn die Konfiguration nicht vorher festgelegt wurde, die Konfiguration auf 

einer geradlinigen oder kreisförmigen Bewegung ändern. 

Bei einer kreisförmigen Bewegung wird die Konfiguration des mittleren Punktes nicht berücksichtigt. Es zählen nur die 

Konfigurationen von Anfangs- und Endposition. 


Andere Schulterkonfiguration möglich 

Singularitäten (Arm RX/TX) 

Singularitäten sind ein charakteristisches Merkmal aller 6-Achsen-Roboter. Sie können als Punkte definiert werden, an 

denen der Roboter die Konfiguration ändert. Bei einer Fluchtung zweier Achsen bilden diese eine einzige Achse: Der 6- 

Achsen-Roboter verhält sich lokal wie ein 5-Achsen-Roboter. Damit können bestimmte Bewegungen nicht mehr 

ausgeführt werden. Das stört bei einer Punktsteuerung nicht: Die vom System generierten Bewegungen sind immer 

noch möglich. Bei einer geradlinigen oder kreisförmigen Bewegung jedoch, wird die Bahn dieser Bewegung 

vorgeschrieben. Wenn die Bewegung nicht möglich ist, wird während der Bewegung eine Fehlermeldung erzeugt. 

ANTIZIPATION VON BEWEGUNGEN 

Prinzip 

Das System steuert die Bewegungen des Roboters etwa wie ein Autofahrer sein Auto. Es passt die Geschwindigkeit 

des Roboters an die Bahngeometrie an. Je früher die Bahn bekannt ist, desto optimaler kann das System die 

Geschwindigkeit steuern. Deshalb wartet das System zur Verarbeitung der nächsten Bewegungsanweisungen nicht 

darauf, dass die laufende Bewegung zu Ende geführt wird. 

Betrachten wir die folgenden Programmzeilen: 

movej (A, tool, mDesc) 

movej (B, tool, mDesc) 

movej (C, tool, mDesc) 

movej (D, tool, mDesc) 

Es wird vorausgesetzt, dass der Roboter bei Erreichen dieser Programmzeilen stillsteht. Wenn die erste Anweisung 

ausgeführt ist, beginnt der Roboter mit der Bewegung zum Punkt A. Das Programm setzt jedoch sofort mit der zweiten 

Linie fort, d. h. lange bevor der Roboter den Punkt A erreicht. 

Wenn das System die zweite Zeile ausführt, beginnt der Roboter erst mit seiner Bewegung nach A und die Information, 

dass der Roboter nach dem Punkt A zum Punkt B gehen soll, wird vom System gespeichert. Das Programm setzt mit 

der nächsten Zeile fort: Während der Roboter immer noch auf dem Weg nach A ist, speichert das System bereits die 

Bewegung von B nach C. Da das Programm sehr viel schneller läuft als sich der Roboter bewegt, ist dieser 

wahrscheinlich immer noch auf dem Weg zu A, wenn die nächste Zeile abgearbeitet wird. Auf diese Weise werden vom 

System mehrere der nächsten Punkte gespeichert. 

So weiß der Roboter bereits zu dem Zeitpunkt, wo er seine Bewegung zu A beginnt, dass er nach A zu B, dann zu C 

und schließlich zu D fahren muss. Wenn die Funktion Glättung aktiv ist, weiß das System, dass der Roboter erst am 

Punkt1 D anhalten muss. Es kann daher stärker beschleunigen, als wenn es sich darauf vorbereiten müsste, in B oder 

C anzuhalten. 



Das Ausführen der Programmzeilen führt nur zur Speicherung der aufeinanderfolgenden Bewegungsanweisungen. Der 

Roboter realisiert sie anschließend nach seinen Möglichkeiten. Damit das System eine möglichst optimale Bahn wählen 

kann, muss der Speicher, in dem die Bewegungen abgelegt werden, relativ groß sein. Die Speicherkapazität ist jedoch 

begrenzt. Wenn der Speicher voll ist, wird die Programmausführung bei der nächsten Bewegungsanweisung 

unterbrochen. Die Ausführung wird erst fortgesetzt, wenn der Roboter die laufende Bewegung beendet hat und der 

entsprechende Speicherplatz frei geworden ist. 

Antizipation und Glättung 

Wir sehen in diesem Kapitel, was im Einzelnen passiert, wenn die Bewegungen verkettet sind. Betrachten wir wieder 

das obige Beispiel: 

movej (A, tool, mDesc) 

movej (B, tool, mDesc) 

movej (C, tool, mDesc) 

movej (D, tool, mDesc) 

Angenommen, im Bewegungsdeskriptor desc ist die Glättung aktiviert. Wenn die erste Zeile ausgeführt wird, weiß das 

System noch nicht, welches die nächste Bewegung sein wird. Nur die Bewegung zwischen dem Startpunkt und dem 

Punkt Aleave ist vollständig bestimmt, da der Punkt Aleave vom System anhand des Datenelements leave des 

Bewegungsdeskriptors ermittelt wird (siehe nachstehendes Schema). 

A 

A leave A reach 

Geglätteter Zyklus 

B leave B reach 

B 

Solange die zweite Zeile nicht ausgeführt ist, kann der geglättete Bahnabschnitt um den Punkt A nicht vollständig 

bestimmt werden, da das System die nächste Bewegung noch nicht kennt. Im Schrittmodus würde der Roboter, wenn 

der Benutzer nicht auf die nächste Anweisung weitergeht, nur bis zum Punkt Aleave fahren. Wenn die nächste 

Anweisung ausgeführt wurde, können die geglättete Bahn um den Punkt A (zwischen Aleave und Areach) sowie die 

Bewegung zum Punkt Bleave definiert werden. Der Roboter kann sich damit bis Bleave bewegen. Er wird aber im 

Schrittmodus nicht über diesen Punkt hinausfahren können, wenn der Benutzer die dritte Anweisung noch nicht 

ausgeführt hat usw.. 

Der Vorteil dieser Betriebsart ist, dass der Roboter im Schrittmodus und bei normaler Programmausführung genau die 

gleiche Bewegung ausführt. 

Synchronisierung 

Das Antizipieren besteht also in einer zeitlichen Entkopplung der Ausführung der Programmzeilen unter VAL3 und den 

entsprechenden Bewegungen des Roboters: Das Programm VAL3 eilt dem Roboter voraus. 

Wenn an einer bestimmten Position des Roboters eine Aufgabe vorgesehen ist, muss das Programm warten, bis der 

Roboter seine Bewegungen beendet hat: Diese Synchronisierung wird mit der Anweisung waitEndMove() erreicht. 


C 

C leave C reach 

D

Deshalb wird im nachstehenden Programm: 

movej(A, tool, mDesc) 

movej(B, tool, mDesc) 

waitEndMove() 

movej(C, tool, mDesc) 

movej(D, tool, mDesc) 

etc... 

Die beiden ersten Zeilen werden ausgeführt, wenn der Roboter seinen Weg nach A beginnt. Dann wird die 

Programmausführung in der dritten Zeile unterbrochen, bis der Roboter im Punkt B steht. Nach der Stabilisierung in B 

setzt das Programm mit der Ausführung fort. 

Die Anweisungen open() und close() bewirken ebenfalls ein Warten auf das Ende der Roboterbewegung bevor das 

Werkzeug betätigt wird. 

GESCHWINDIGKEITSSTEUERUNG 

Prinzip 

Die Geschwindigkeitssteuerung auf einer Bahn arbeitet nach folgendem Prinzip: 

Zu jedem Zeitpunkt wird der Roboter mit voller Leistung bewegt und beschleunigt, wobei alle von der 

Bewegungssteuerung vorgegebenen Bedingungen für Geschwindigkeit und Beschleunigung einzuhalten sind. 

Die Bewegungsanweisungen enthalten zwei Arten von Randbedingungen für die Geschwindigkeit, die in einer 

Variablen des Typs mdesc definiert sind: 

1. Geschwindigkeiten, Beschleunigungen und Abbremsungen für Gelenkbewegungen 

2. Randbedingungen für die kartesischen Geschwindigkeiten des Werkzeugmittelpunkts 

Der Beschleunigungswert legt fest, wie rasch die Geschwindigkeit am Beginn der Bahn zunimmt. Umgekehrt wird durch 

den Wert der Abbremsung festgelegt, wie schnell die Geschwindigkeit am Ende der Bahn abnimmt. Wenn man hohe 

Beschleunigungs- und Abbremswerte verwendet, werden die Bewegungen zwar rascher, aber ruckartiger. Mit kleineren 

Werten nehmen die Bewegungen etwas mehr Zeit in Anspruch, werden jedoch sanfter. 

Einfache Einstellung 

Wenn das Werkzeug oder der vom Roboter transportierte Gegenstand keine besonders vorsichtige Handhabung 

erfordern, sind Randbedingungen für kartesische Geschwindigkeiten unnötig. Die Einstellung der Bahngeschwindigkeit 

erfolgt im Allgemeinen auf folgende Weise: 

1. Die Randbedingungen für kartesische Geschwindigkeit werden auf hohe Werte gesetzt, z.B. auf die 

vorprogrammierten Werte, damit sie keinen Einfluss auf die anschließende Einstellung haben. 

2. Die Geschwindigkeiten und Beschleunigungen der Gelenke werden auf ihre Nennwerte (100%) initialisiert. 

3. Dann wird die Bahngeschwindigkeit nur mit dem Parameter Gelenkgeschwindigkeit eingestellt. 

4. Wenn keine ausreichende Geschwindigkeit erreicht werden kann, müssen die Beschleunigungs- und 

Abbremswerte vergrößert werden 

Komplexere Einstellungen 

Wenn die kartesische Geschwindigkeit des Werkzeugs beherrscht werden muss, zum Beispiel um eine Bahn mit 

konstanter Geschwindigkeit auszuführen, sollte besser auf folgende Weise vorgegangen werden: 

1. Die Bedingungen für die kartesischen Geschwindigkeiten auf die zunächst gewünschten Werte einstellen. 

2. Die Geschwindigkeiten und Beschleunigungen der Gelenke werden auf ihre Nennwerte (100%) initialisiert. 

3. Dann die Bahngeschwindigkeit nur mit dem Parameter kartesische Geschwindigkeit einstellen. 

4. Wenn die gewünschte Geschwindigkeit nicht erreicht werden kann, müssen die Beschleunigungs- und 

Abbremswerte vergrößert werden. 

Wenn man in starken Kurven automatisch bremsen möchte, müssen die Beschleunigungs- und Abbremswerte 

verringert werden. 



Schleppfehler 

Die Nennwerte für die Geschwindigkeiten und Beschleunigungen der Drehachsen gelten für Roboter mit Nennlast 

unabhängig von der Bahn. 

In vielen Fällen kann der Roboter schnellere Bewegungen ausführen: Seine Höchstgeschwindigkeiten hängen jedoch 

von der Last und der Bahn ab. Unter günstigen Bedingungen (geringe Last, günstiger Einfluss der Schwerkraft) kann 

der Roboter seine Nennwerte ohne Schaden überschreiten. 

Wenn der Roboter hingegen eine schwerere Last bewegen muss, als die Nennlast, oder wenn zu hohe 

Geschwindigkeiten und Beschleunigungen der Drehachsen parametriert wurden, kann der Roboter unter Umständen 

den Bewegungsanweisungen nicht mehr folgen und bleibt mit einem Schleppfehler stehen. Durch Eingabe kleinerer 

Geschwindigkeits- und Beschleunigungswerte können derartige Fehler vermieden werden. 

ACHTUNG: 

Bei geradlinigen Bewegungen in der Nähe singulärer Punkte sind große Gelenkbewegungen 

für kleine Werkzeugbewegungen erforderlich. Wenn eine zu hohe Gelenkgeschwindigkeit 

eingegeben wurde, wird der Roboter der Anweisung nicht mehr folgen können und mit einem 

Schleppfehler stehen bleiben. 

ONLINE-BEWEGUNGSSTEUERUNG 

Die bis jetzt angesprochenen Bewegungssteuerungen haben keine sofortige Wirkung: Die Ausführung einer solchen 

Steueranweisung vom Programm führt zur Speicherung der Bewegungsanweisung durch das System. Sie werden erst 

anschließend vom Roboter ausgeführt. 

Es besteht jedoch die Möglichkeit, die Bewegungen des Roboters mit sofortiger Wirkung zu beeinflussen: 

• Die Monitorgeschwindigkeit ändert die Geschwindigkeiten aller Bewegungen. Sie kann nur auf dem 

Handbediengerät des Roboters und nicht in einem VAL3-Programm geändert werden. Mit der Anweisung 

speedScale() kann das Programm jedoch die aktuelle Monitorgeschwindigkeit lesen und den Benutzer 

gegebenenfalls auffordern, sie bei einem Wiederholzyklus zu verringern oder sie mit 100% in die Produktion 

zu geben. 

• Mit den Anweisungen stopMove() und restartMove() kann die Bewegung auf der Bahn unterbrochen und 

wieder aufgenommen werden. 

• Die Anweisung resetMotion() ermöglicht die Unterbrechung einer Bewegung und das Löschen der 

gespeicherten Bewegungsanweisungen. 


TYP MDESC 

Definition 

Mit dem Typ mdesc können die Parameter einer Bewegung festgelegt werden (Geschwindigkeit, Beschleunigung, 

Glättung). 

Der Typ mdesc ist ein strukturierter Typ mit folgenden Feldern in der nachstehenden Reihenfolge: 

num accel Maximal zulässige Winkelbeschleunigung, angegeben in % der Nennbeschleunigung des 

Roboters. 

num vel Maximal zulässige Winkelgeschwindigkeit, angegeben in % der Nenngeschwindigkeit des 

Roboters. 

num decel Maximal zulässige Abbremsung des Gelenks, angegeben in % der nominalen Abbremsung 

des Roboters. 

num tvel Maximal zulässige Lineargeschwindigkeit des Werkzeugmittelpunkts in mm/s oder inch/s je 

nach Längeneinheit des Programms. 

num rvel Maximal zulässige Winkelgeschwindigkeit des Werkzeugs in Grad/s. 

blend 

blend 

Ausführliche Beschreibung der verschiedenen Parameter, siehe Kapitel Bewegungssteuerung. 

Eine Variable des Typs mdesc wird vorprogrammiert auf {100,100,100,5000,1000,off,50,50} initialisiert, wenn die 

Längeneinheit des Projekts Millimeter ist und auf {100,100,100,2000, 1000, off, 20, 20}, wenn die Längeneinheit Inch 

ist. 

Operatoren 


Glättungsart: off (keine Glättung) oder joint (mit Glättung). 

num leave Bei Glättung (joint), die Entfernung vom Zielpunkt bei der die Glättung zum nächsten Punkt 

beginnt, angegeben in mm oder inch, je nach Längeneinheit des Programms. 

num reach Bei Glättung (joint), die Entfernung vom Zielpunkt bei der die Glättung zum nächsten Punkt 

endet, angegeben in mm oder inch, je nach Längeneinheit des Programms. 

mdesc = Weist jedes Feld desc2 dem entsprechenden Feld der 

Variablen desc1 zu. 

bool != Überträgt true, wenn sich desc1 und desc2 in 

mindestens einem Feld unterscheiden. 

bool == Überträgt true, wenn die Werte der Felder in desc1 

und desc2 gleich sind. 



BEWEGUNGSANWEISUNGEN 

void movej(joint joint, tool Werkzeug, mdesc desc) 

Syntax 

void movej(joint Position, tool Werkzeug, mdesc desc) 

void movej(point Punkt, tool Werkzeug, mdesc desc) 

Funktion 

Speichert einen Bewegungsbefehl für ein Gelenk zur Position Punkt oder Position mit dem Werkzeug Werkzeug und 

den Bewegungsparametern desc. 

ACHTUNG: 

Das System wartet nicht auf das Ende der Bewegung, um zur nächsten VAL3-Anweisung 

weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert werden. 

Wenn nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit der 

Ausführung gewartet, bis die Speicherung möglich ist. 

Zur ausführlichen Beschreibung der verschiedenen Bewegungsparameter, siehe Beginn des Kapitels 

Bewegungssteuerung. 

Wenn desc unzulässige Werte aufweist, position außerhalb der Softwaregrenzen liegt, point nicht erreichbar ist oder 

ein zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt werden kann, wird eine Fehlermeldung erzeugt 

(Endpunkt nicht erreichbar). 

Parameter 


mdesc desc Ausdruck des Typs Bewegungsdeskriptor 


point Punkt Ausdruck des Typs point 

Siehe auch 

void movel(point Punkt, tool Werkzeug, mdesc desc) 



void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, mdesc desc) 


Syntax 



Funktion 

Speichert einen linearen Bewegungsbefehl zur Position Punkt mit dem Werkzeug Werkzeug und den 

Bewegungsparametern desc. 

ACHTUNG: 





Zur ausführlichen Beschreibung der verschiedenen Bewegungsparameter, siehe Beginn des Kapitels 

Bewegungssteuerung. 

Wenn desc unzulässige Werte aufweist, Punkt nicht erreichbar oder eine geradlinige Bewegung zu Punkt nicht 

möglich ist oder ein zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt werden kann, wird eine Fehlermeldung 

erzeugt (Endpunkt nicht erreichbar). 

Parameter 

point Punkt Ausdruck des Typs point. 

tool Werkzeug Ausdruck des Typs Werkzeug. 

mdesc desc Ausdruck des Typs Bewegungsdeskriptor. 

Siehe auch 




106 / 122 D28056202B - 06/2005



Syntax 


Funktion 

Speichert die Anweisung für eine kreisförmige Bewegung, ausgehend vom Zielort der vorherigen Bewegung, über 

Mittlerer Punkt bis zu Endpunkt. 

Die Ausrichtung des Werkzeugs ist so interpoliert, dass eine absolute, konstante Ausrichtung oder eine Ausrichtung 

bezüglich der Bahn möglich ist. 

ACHTUNG: 





Zur ausführlichen Beschreibung der verschiedenen Bewegungsparameter und der Interpolation der 

Ausrichtung, siehe Beginn des Kapitels "Bewegungssteuerung". 

Bei ungültigen Werten von desc wird ein Ausführungsfehler erzeugt. Dies gilt auch, wenn die Positionen Mittlerer 

Punkt (oder Endpunkt) nicht erreichbar sind, wenn die kreisförmige Bewegung nicht möglich ist (siehe Kapitel 

"Bewegungssteuerung" - Interpolation der Ausrichtung) oder wenn ein zuvor aufgezeichneter Bewegungsbefehl nicht 

ausgeführt werden kann (Zielposition nicht erreichbar). 

Parameter 

Mittlerer Punkt Ausdruck des Typs point. 

Endpunkt Ausdruck des Typs point. 


mdesc desc Ausdruck des Typs Bewegungsdeskriptor. 

Siehe auch 





Syntax 

void stopMove() 


Funktion 

Hält den Arm während der Bewegung an und hebt die programmierte Freigabe der Bewegung vorübergehend auf. 

ACHTUNG: 

Diese Anweisung bewirkt sofortige Rückkehr, die VAL3-Task wartet zur Ausführung der 

folgenden Task nicht auf den Stillstand des Arms. 

Zum Anhalten des Roboters werden die kinematischen Parameter der laufenden Bewegung verwendet. 

Die Bewegung kann erst nach Ausführung der Anweisung restartMove() oder resetMotion() fortgesetzt werden. 

Nicht programmierte Bewegungen (manuelles Verfahren) bleiben weiterhin möglich. 

Zum Beispiel 

wait (dSignal==true) // Warten auf ein Signal 

stopMove() // Anhalten des Roboters während der Bewegung 

 

restartMove() // Erneutes Anfahren des Roboters auf der gleichen Bahn 

Siehe auch 

void restartMove() 

void resetMotion(), void resetMotion(joint Start) 


Syntax 

void resetMotion() 

void resetMotion(joint Start) 

Funktion 

Hält den Roboterarm während der Bewegung an und löscht alle gespeicherten Bewegungsanweisungen. 

ACHTUNG: 

Diese Anweisung bewirkt sofortige Rückkehr, die VAL3-Task wartet zur Ausführung der 

folgenden Task nicht auf den Stillstand des Arms. 

Wenn die programmierte Freigabe der Bewegung durch die Anweisung stopMove() aufgehoben worden war, wird sie 

wieder hergestellt. 

Wenn die Anfangs-Winkelposition Start festgelegt ist, so kann die nächste Bewegungsanweisung nur von dieser 

Position aus durchgeführt werden: Es ist zunächst eine Anschluss-Bewegung erforderlich, um zu Start 

zurückzukehren. 

Ist keine Winkelposition festgelegt, so wird die nächste Bewegungsanweisung von der aktuellen Position des Arms 

ausgeführt, egal, wo sich dieser befindet. 

Siehe auch 

bool isEmpty() 


void autoConnectMove(bool aktiv), bool autoConnectMove() 



Syntax 



Funktion 

Stellt die programmierte Freigabe der Bewegung wieder her und setzt die mit der Anweisung stopMove() 

unterbrochene Bewegung fort. 

Wenn die programmierte Bewegungsfreigabe nicht durch stopMove() unterbrochen war, hat diese Anweisung 

keinerlei Auswirkungen. 

Siehe auch 



Syntax 



Funktion 

Annulliert die Glättung der zuletzt gespeicherten Bewegungsanweisung und wartet auf die Ausführung dieser 

Anweisung. 

Diese Anweisung wartet nicht auf die Stabilisierung des Roboters an seiner Endposition, sondern nur dass die an die 

Getriebe gesendete Positionsanweisung mit der gewünschten Endposition übereinstimmt. Wenn die vollständige 

Stabilisierung nach der Bewegung abgewartet werden soll, so muss die Anweisung isSettled() verwendet werden. 

Ein Ausführungsfehler wird erzeugt, wenn ein zuvor aufgezeichneter Bewegungsbefehl nicht durchgeführt werden kann 

(Endpunkt außer Reichweite). 

Zum Beispiel 

waitEndMove() 

putln(sel(isEmpty(),1,-1)) // ergibt 1, wenn kein Befehl mehr ansteht 

putln(sel(isSettled(),1,-1)) // Kann -1 anzeigen, da der Roboter noch nicht unbedingt stabilisiert ist 

watch(isSettled(), 1) // Wartet während maximal 1 s auf die Stabilisierung des Roboters 

Siehe auch 

bool isSettled() 





Syntax 



Funktion 

Überträgt true, wenn alle Bewegungsanweisungen ausgeführt sind, und false, wenn noch mindestens eine Anweisung 

ansteht. 

Zum Beispiel 

// Wenn noch Anweisungen anstehen 

if ! isEmpty() 

// Roboter anhalten und Anweisungen löschen 

resetMotion() 

endIf 

Siehe auch 



Syntax 



Funktion 

Überträgt true, wenn der Roboter gestoppt ist, und false, wenn seine Position noch nicht stabilisiert ist. 

Die Position wird als stabilisiert betrachtet, wenn der Positionsfehler für jede Achse während 50 ms weniger als 1% der 

maximal zulässigen Position beträgt. 

Siehe auch 



Syntax 

void autoConnectMove(bool aktiv), bool autoConnectMove() 

void autoConnectMove(bool aktiv) 

bool autoConnectMove() 

Funktion 

Im ferngesteuerten Modus ist die Anschlussbewegung automatisch, wenn der Arm sich sehr nahe an seiner Bahn 

bewegt (Abstand kleiner als der maximal erlaubte Widerstandsfehler). Ist der Arm zu weit von seiner Bahn entfernt, 

findet die Anschlussbewegung automatisch oder unter manueller Kontrolle gemäß dem in der Anweisung 

autoConnectMove definierten Modus statt.: automatisch, wenn aktiv den Wert true hat, unter manueller Kontrolle, 

wenn der Wert aktiv gleich false ist. Bei Benutzung ohne Parameter, gibt autoConnectMove den üblichen Modus der 

Anschlussbewegung an. 

Standardmäßig erfolgt die Anschlussbewegung bei ferngesteuerten Betrieb manuell. 

ACHTUNG: 

Unter normalen Einsatzbedingungen stoppt der Arm bei einem Notaus auf seiner Bahn. 

Demzufolge kann der Arm im ferngesteuerten Modus unabhängig von dem in der Anweisung 

autoConnectMove definierten Modus der Anschlussbewegung automatisch neu starten. 

Siehe auch 




OPTIONEN 

AUSGEGLICHENE BEWEGUNGEN MIT KRAFTSTEUERUNG 

Prinzip 

Bei einer Standard-Bewegungssteuerung verschiebt sich der Roboter zur geforderten Position mit programmierten 

Beschleunigungs- und Geschwindigkeitswerten. Kann der Arm der Steuerung nicht folgen, so wird von den Motoren bei 

ihrem Versuch zur gewünschten Position zu gelangen eine steigende Kraft gefordert. Weicht die angesteuerte Position 

zu stark von der tatsächlichen Position ab, oder ist die nötige Kraft zu groß, so ergibt sich ein Systemfehler,welcher die 

Energieversorgung des Arms unterbricht. 

Der Roboter ist "ausgleichfähig" (compliant), wenn er gewisse Abweichungen der angesteuerten Position von der 

tatsächlichen Position erlaubt. Die Steuerung CS8 kann so programmiert werden, dass sie auf ihrer Bahn 

ausgleichfähig ist. Das heißt, sie kann einen Verzug oder eine Voreilung auf der programmierten Bahn durch Steuerung 

der auf den Arm ausgeübten Kraft ausgleichen. Hingegen wird keinerlei räumliche Abweichung von der Bahn toleriert. 

In der Praxis können ausgeglichene Bewegungen der CS8 dem Arm eine Verfolgung seiner Bahn ermöglichen, auch 

wenn er von äußeren Kräften geschoben oder gebremst wird. Gleichermaßen kann der Arm mit einem Objekt in 

Berührung treten, wobei die vom Arm auf dieses Objekt ausgeübte Kraft gesteuert wird. 

Programmierung 

Ausgeglichene Bewegungen werden wie Standardbewegungen mit den Anweisungen movelf() und movejf() 

programmiert, wobei ein zusätzlicher Parameter die vom Arm ausgeübte Kraft steuern kann. Während der 

ausgeglichenen Bewegung erfolgen Geschwindigkeits- und Beschleunigungsbegrenzungen wie bei 

Standardbewegungen mittels des Bewegungsdeskriptors. Die Bewegung kann auf der Bahn in beiden Richtungen 

erfolgen. 

Ausgeglichene Bewegungen können untereinander oder mit Standardbewegungen verkettet werden: Nach Erreichen 

der Zielposition fährt der Roboter mit dem folgenden Bewegungsbefehl fort. Die Anweisung waitEndMove() ermöglicht 

es, das Ende einer ausgeglichenen Bewegung abzuwarten. 

Die Anweisung resetMotion() bricht alle programmierten Bewegungen, sowohl standardmäßige als auch 

ausgeglichene, ab. Nach Ausführung von resetMotion() ist der Roboter nicht mehr ausgleichfähig (compliant). 

Die Anweisungen stopMove() und restartMove() können auch auf ausgeglichene Bewegungen zur Anwendung 

kommen: 

stopMove() erzwingt Geschwindigkeit 0 für die in Ausführung befindliche Bewegung. Handelt es sich um eine 

ausgeglichene Bewegung, so wird diese gestoppt und der Roboter ist bis zur nächsten Ausführung von restartMove() 

nicht mehr ausgleichfähig (compliant). 

Schließlich ermöglicht es die Anweisung isCompliant(), vor Zulassung der Einwirkung einer äußeren Kraft auf den 

Roboterarm sicherzustellen, dass der Roboter ausgleichfähig ist. 

Steuerung der Kraft 

Wurde für den Kraftparameter der Wert null festgelegt, so ist der Arm passiv, das heißt, er verschiebt sich nur unter 

Einwirkung einer äußeren Kraft. 

Bei positivem Wert des Kraftparameters ist die Bewegung für automatische Verschiebung des Arms zu seiner 

Endposition programmiert: Der Arm verschiebt sich selbst, kann jedoch durch eine äußere Einwirkung, die sich seinem 

Antrieb überlagert, gebremst oder beschleunigt werden. 

Bei negativem Wert des Kraftparameters wird der Arm durch eine äußere Kraft in seine Ausgangsposition überführt: In 

diesem Fall ist zur Verschiebung des Arms eine den angewiesenen Wert übertreffende äußere Kraft erforderlich. 

Der Kraftparameter wird in Prozent der maximalen Belastbarkeit des Arms ausgedrückt. Bei 100% übt der Arm eine der 

maximalen Belastbarkeit entsprechende Kraft in Richtung der angesteuerten Position aus. Bei Drehbewegungen 

entsprechen 100% dem für den Arm zulässigen maximalen Drehmoment. 

Wenn Geschwindigkeit oder Beschleunigung des Arms die im Bewegungsdeskriptor festgelegten Werte erreichen, so 

widersetzt sich der Roboter mit aller ihm zur Verfügung stehenden Leistung jeglichen Versuchen, diese Werte zu 

erhöhen. 


Begrenzungen 

Für ausgeglichene Bewegungen gelten folgende Begrenzungen: 

- Am Anfang oder Ende einer ausgeglichenen Bewegung kann kein Glätten erfolgen: der Arm muss am 

Anfang und am Ende einer ausgeglichenen Bewegung stoppen. 

- Der Arm kann bei einer ausgeglichenen Bewegung zu seinem Ausgangspunkt zurückkehren, jedoch nicht 

über diesen hinausfahren: Er stoppt in einem solchen Fall schlagartig am Ausgangspunkt. 

- Die auf den Arm ausgeübte Kraft (im Kraftparameter festgelegt) kann 1000% nicht überschreiten. Die für 

die Kraft geltende Präzision ist durch innere Reibungen begrenzt. Sie hängt stark von der Position des 

jeweiligen Roboterarms und der gesteuerten Bahn ab. 

- Lange ausgeglichene Bewegungen erfordern viel internen Speicherplatz. Reicht der Speicher des 

Systems nicht aus, um die Bewegung vollständig zu beenden, so wird ein Ausführungsfehler erzeugt. 

Anweisungen 

void movejf(joint Position, tool Werkzeug, mdesc desc, num Kraft) 

Syntax 


Funktion 

Speicherung einer ausgeglichenen Gelenkbewegung zu Position Position, mit dem Werkzeug Werkzeug, den 

Bewegungsparametern desc und einem gesteuerten Kraftwert Kraft. 

Der gesteuerte Kraftwert Kraft wird in Prozent der maximalen Belastbarkeit des Arms ausgedrückt. Er muss innerhalb 

±1000% liegen. 

ACHTUNG: 


weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert werden. Wenn 

nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit der 


Die verschiedenen Parameter der Bewegung sind zu Beginn des vorliegenden Kapitels genauer erklärt. 

Bei ungültigen Werten von desc oder Kraft wird ein Ausführungsfehler erzeugt, ebenfalls, wenn der Wert von Position 

außerhalb der Softwareanschläge liegt, wenn die vorangehende Bewegung eine Glättung fordert oder wenn ein zuvor 

aufgezeichneter Bewegungsbefehl nicht ausgeführt werden kann (Zielposition nicht erreichbar). 

Parameter 




num Kraft Ausdruck des Typs num 

Siehe auch 

void movelf(point Punkt, tool Werkzeug, mdesc desc, num Kraft) 

bool isCompliant() 



Syntax 



Funktion 

Speicherung einer ausgeglichenen Linearbewegung zur Position Punkt, mit dem Werkzeug Werkzeug, den 

Bewegungsparametern desc und einem gesteuerten Kraftwert Kraft. 

Der gesteuerte Kraftwert Kraft wird in Prozent der maximalen Belastbarkeit des Arms ausgedrückt. Er muss innerhalb 

±1000% liegen. 

ACHTUNG: 


weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert werden. Wenn 

nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit der 


Die verschiedenen Parameter der Bewegung sind zu Beginn des vorliegenden Kapitels genauer erklärt. 

Bei ungültigen Werten von desc oder Kraft wird ein Ausführungsfehler erzeugt. Dies gilt auch, wenn die Position Punkt 

nicht erreichbar ist, wenn die Position Punkt nicht auf einer geradlinigen Bewegung angefahren werden kann, wenn die 

vorangehende Bewegung eine Glättung fordert oder wenn ein zuvor aufgezeichneter Bewegungsbefehl nicht 

ausgeführt werden kann (Zielposition nicht erreichbar). 

Parameter 

point Punkt Ausdruck des Typs point. 



num Kraft Ausdruck des Typs num 

Siehe auch 




Syntax 



Funktion 

Liefert den Wert true, wenn der Roboter in ausgeglichenem Betrieb arbeitet, andernfalls den Wert false. 

Zum Beispiel 

movelf(position, outil, mDesc, 0) 

wait(isCompliant()) // Wartet bis der Roboter ausgleichfähig ist 

dEjection = true // Auswurfbefehl der Spritzgießmaschine 

waitEndMove() // Wartet auf das Ende der ausgeglichenen Bewegung 

movej(jDépart, outil, mDesc) // Schließt eine Standardbewegung an 

Siehe auch 





FEHLERCODES 

ANHANG 


-1 Es gibt keine Task Name 

0 Die Task Name ist ohne Ausführungsfehler gestoppt 

1 Die Task Name befindet sich in Ausführung 

10 Ungültige numerische Berechnung (Division durch Null). 

11 Ungültige numerische Berechnung (zum Beispiel ln(-1)) 

20 Zugriff zu einer Tabelle mit höherem Index als die Tabellengröße. 

21 Zugriff zu einer Tabelle mit negativem Index. 

29 Ungültiger Name der Task. Siehe Anweisung taskCreate(). 

30 Der festgelegte Name entspricht keiner Task von VAL3. 

31 Es existiert bereits eine Task gleichen Namens. Siehe Anweisung taskCreate. 

40 Der Speicherplatz genügt nicht für die Daten. 

41 Der Ausführungsspeicher ist für die Task unzureichend. Siehe Größe des Ausführungsspeichers. 

60 Maximale Ausführungszeit der Anweisung ist abgelaufen. 

61 Interner Fehler des VAL3-Interpreters 

70 Ungültiger Wert des Parameters der Anweisung. Siehe entsprechende Anweisung. 

80 Verwendung von Daten oder Programmen einer nicht im Speicher geladenen Bibliothek. 

90 Die Task kann an der festgelegten Stelle nicht wieder aufgenommen werden. Siehe Anweisung taskResume(). 

100 Die im Bewegungsdeskriptor spezifizierte Geschwindigkeit ist ungültig (negativ oder zu groß). 

101 Die im Bewegungsdeskriptor spezifizierte Beschleunigung ist ungültig (negativ oder zu groß). 

102 

Die im Bewegungsdeskriptor spezifizierte Abbremsgeschwindigkeit ist ungültig (negativ, zu groß oder kleiner als 

die Geschwindigkeit). 

103 Die im Bewegungsdeskriptor spezifizierte Translationsgeschwindigkeit ist ungültig (negativ oder zu groß). 

104 Die im Bewegungsdeskriptor spezifizierte Rotationsgeschwindigkeit ist ungültig (negativ oder zu groß). 

105 Der im Bewegungsdeskriptor spezifizierte Parameter reach ist ungültig (negativ). 

106 Der im Bewegungsdeskriptor spezifizierte Parameter leave ist ungültig (negativ). 

122 Schreibversuch auf einem Eingang des Systems. 

123 Verwendung eines Ein-/Ausgangs dio, aio oder sio, der keinem Ein-/Ausgang des Systems zugeordnet ist. 

124 Versuch des Zugriffs auf einen geschützten Ein-/Ausgang des Systems 

125 Lese- oder Schreibfehler an einem dio, aio oder sio (Fehler auf Feldbus) 

150 

Diese Bewegungsanweisung lässt sich nicht ausführen: Eine vorher angeforderte Bewegung konnte nicht beendet 

werden (Punkt nicht erreichbar, singulärer Punkt, Konfigurationsproblem usw.) 


153 Bewegungsbefehl nicht unterstützt 

154 Ungültige Bewegungsanweisung: Bewegungsdeskriptor überprüfen. 

160 Koordinaten des Tools flange nicht gültig 

161 Koordinaten des Koordinatensystems world nicht gültig 


163 Verwendung eines Koordinatensystems ohne Referenzsystem. Siehe Definition. 

164 Verwendung eines Tools ohne Referenztool. Siehe Definition. 

165 Referenzsystem oder Referenztool ungültig (globale Variable mit lokaler Variablen verbunden) 


TASTENCODES DER BEDIENKONSOLE 

Ohne Shift Mit Shift 

3 Caps Space 3 Caps Space 

283 - 32 Move 283 - 32 Move 

2 Shift Esc Help 

Ret. 

- 

Run 2 Shift Esc Help 

Ret. 

- 

Run 

282 - 255 - 270 - 282 - 255 - 270 - 

Menu Tab Up Bksp Stop Menu UnTab PgUp Bksp Stop 

- 259 261 263 - - 260 262 263 - 

1 User Left Down Right 1 User Home PgDn End 

281 - 264 266 268 281 - 265 267 269 

Menüs (mit und ohne Shift): 

F1 F2 F3 F4 F5 F6 F7 F8 

271 272 273 274 275 276 277 278 

Bei Standardtasten wird der ASCII-Code des betreffenden Zeichens zurückgesandt: 

Ohne Shift 

q w e r t y u i o p 

113 119 101 114 116 121 117 105 111 112 

a s d f g h j k l < 

97 115 100 102 103 104 106 107 108 60 

z x c v b n m . , = 

122 120 99 118 98 110 109 46 44 61 

Mit Shift 

7 8 9 + * ; ( ) [ ] 

55 56 57 43 42 59 40 41 91 93 

4 5 6 - / ? : ! { } 

52 53 54 45 47 63 58 33 123 125 

1 2 3 0 " % - . , > 

49 50 51 48 34 37 95 46 44 62 

Mit doppeltem Shift 

Q W E R T Y U I O P 

81 87 69 82 84 89 85 73 79 80 

A S D F G H J K L } 

65 83 68 70 71 72 74 75 76 125 

Z X C V B N M $ \ = 

90 88 67 86 66 78 77 36 92 61 



ADDILDUNG 

Abhängigkeit der Tools ................................................ 78 

Absolute, konstante Ausrichtung .......................................... 96 

Andere Schulterkonfiguration möglich ..................................... 100 

Anfans- und Endposition ............................................... 91 

Bedienerseite ...................................................... 46 

Beziehung zwischen: frame / point / tool / trsf ................................. 69 

Definition der Entfernungen: ’leave’ / ’reach’ .................................. 93 

Drehung des Koordinatensystems bezüglich folgender Achse: X .................... 73 

Drehung des Koordinatensystems bezüglich folgender Achse: Y’ .................... 74 

Drehung des Koordinatensystems bezüglich folgender Achse: Z’’ .................... 74 

Geglätteter Zyklus .................................................. 101 

Geglätteter Zyklus ................................................... 94 

Geradlinige Bewegung ................................................ 91 

Konfiguration: enegative ............................................... 88 

Konfiguration: epositive ................................................ 88 

Konfiguration: lefty ................................................... 87 

Konfiguration: lefty ................................................... 89 

Konfiguration: righty .................................................. 87 

Konfiguration: righty .................................................. 89 

Konfiguration: wnegative ............................................... 88 

Konfiguration: wpositive ............................................... 88 

Konstante Ausrichtung bezüglich der Bahn ................................... 96 

Kreisförmige Bewegung ............................................... 92 

Mehrdeutigkeit der mittleren Ausrichtung .................................... 97 

Orientierung ....................................................... 73 

Positive / negative Konfiguration des Ellenbogens .............................. 98 

Positive / negative Konfiguration des Handgelenks.............................. 99 

Punktdefinition...................................................... 80 

Sequentielles Ordnen ................................................. 53 

Vollständiger Kreis ................................................... 97 

Wechsel: righty / lefty ................................................. 98 

Wechseln der Ellenbogenkonfiguration nicht möglich ............................ 99 

Zusammenhang zwischen den Referenz-Koordinatensystemen ..................... 76 

Zwei verschiedene Konfigurationen, um denselben Punkt zu erreichen: P .............. 86 

Zyklus mit unterbrochener Glättung ........................................ 94 

Zyklus: U ......................................................... 92 




A 

abs (fonction) 24, 70 

accel 104 

acos (fonction) 23 

aio 12, 41 

aioGet (fonction) 41 

aioLink (fonction) 41 

aioSet (fonction) 42 

appro (fonction) 83 

asc (fonction) 33 

asin (fonction) 23 

atan (fonction) 24 

autoConnectMove 95 

autoConnectMove (fonction) 110 

B 

blend 93, 104 

bool 12 

C 

call 11, 16 

call (fonction) 15 

chr (fonction) 32 

clearBuffer (fonction) 44 

clock (fonction) 61 

close 53 

close (fonction) 79 

cls (fonction) 47 

codeAscii 32 

compose (fonction) 82 

config 12, 69, 86 

config (fonction) 90 

cos (fonction) 23 

D 

decel 104 

delay 53 

delay (fonction) 60 

delete (fonction) 35 

dio 12, 38 

dioGet (fonction) 39 

dioLink (fonction) 39 

dioSet (fonction) 40 

disablePower (fonction) 66 

distance (fonction) 75, 81 

do 17 

do ... until (fonction) 17 

INDEX 

E 

elbow 86 

else 16 

enablePower (fonction) 66 

endFor 18 

endIf 16 

endWhile 17 

enegative 88 

epositive 88 

esStatus (fonction) 68 

exp (fonction) 25 

F 

find (fonction) 36 

flange 10 

for 18 

for (fonction) 18 

frame 12, 69 

G 

get 53 

get (fonction) 48 

getKey (fonction) 50 

globale 13 

gotoxy (fonction) 47 

H 

here (fonction) 83 

herej (fonction) 71 

I 

if (fonction) 16 

insert (fonction) 35 

isCalibrated (fonction) 67 

isCompliant 111 

isCompliant (fonction) 114 

isEmpty (fonction) 110 

isInRange (fonction) 71 

isKeyPressed (fonction) 50 

isPowered (fonction) 66 

isSettled (fonction) 110 

J 

joint 12 

jointToPoint (fonction) 84 

L 

leave 93, 104 

left (fonction) 33 


lefty 87, 89 

len (fonction) 37 

libDelete (fonction) 64 

libLoad 63 

libLoad (fonction) 64 

libPath (fonction) 65 

libSave (fonction) 64 

limit (fonction) 28 

ln (fonction) 26 

locale 13 

log (fonction) 26 

logMsg (fonction) 51 

M 

max (fonction) 28 

mdesc 12, 91, 104 

mid (fonction) 34 

min (fonction) 28 

movec (fonction) 107 

movej 91 

movej (fonction) 105 

movejf 111 

movejf (fonction) 112 

movel 91 

movel (fonction) 106 

movelf 111 

movelf (fonction) 113 

N 

num 12, 33 

O 

open 53 

open (fonction) 79 

P 

point 12 

pointToJoint (fonction) 84 

popUpMsg (fonction) 50 

position (fonction) 85 

put (fonction) 47 

putln 47 

R 

reach 93, 104 

replace (fonction) 36 

resetMotion 95, 108, 111 

resetMotion (fonction) 108 

restartMove 108, 111 

restartMove (fonction) 109 

return (fonction) 16 

right (fonction) 34 

righty 87, 89 

round (fonction) 27 

roundDown (fonction) 27 

roundUp (fonction) 27 

RUNNING 60, 61 

rvel 104 

S 

sel (fonction) 29 

setFrame (fonction) 77 

shoulder 86 

sin (fonction) 22 

sio 12, 43 

sioGet (fonction) 44 

sioLink (fonction) 44 

sioSet (fonction) 45 

size (fonction) 20 

speedScale (fonction) 68 

sqrt (fonction) 25 

start 10 

stop 10 

stopMove 111 

stopMove (fonction) 108 

STOPPED 56 

string 12 

switch (fonction) 19 

T 

tan (fonction) 24 

taskCreate (fonction) 59 

taskKill (fonction) 57 

taskResume 52 

taskResume (fonction) 56 

taskStatus 52 

taskStatus (fonction) 58 

taskSuspend (fonction) 56 

title (fonction) 48 

toNum (fonction) 31 

tool 12, 69 

toString (fonction) 30 

trsf 12, 69 

tvel 104 

U 

until 17 



userPage (fonction) 46 

V 

vel 104 

W 

wait 53 

wait (fonction) 60 

waitEndMove 53, 94, 111 

waitEndMove (fonction) 109 

watch 53 

watch (fonction) 61 

while (fonction) 17 

wnegative 88 

workingMode (fonction) 67 

world 10 

wpositive 88 

wrist 86 


122

referenzanleitung val3 d28056202b - 06/2005 - eule-roboter.de

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?