Referenzanleitung Val3 d28056202b - 06 - 2005 - Eule-Roboter - de

REFERENZANLEITUNG VAL3
Version 5.2
© Stäubli Faverges 2005
D28056202B - 06/2005
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
4 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 5 / 122

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
6 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 7 / 122

8 / 122 D28056202B - 06/2005
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.
D28056202B - 06/2005 9 / 122

ELEMENTE DER SPRACHE VAL3
Die Sprache VAL3 enthält folgende Elemente:

• Applikationen
• Programme
• Bibliotheken
• Datentypen
• Konstanten
• Variablen (globale, lokale und Parameter)
• Tasks
APPLIKATIONEN
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.
10 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 11 / 122

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.
12 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 13 / 122

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.
14 / 122 D28056202B - 06/2005

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

Bemerkung //
Syntax
// <Kette>
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
Aufruf des Unterprogramms call
Syntax
call Programm([Parameter1][,Parameter2])
Funktion
Führt das aufgerufene Programm mit den angegebenen Parametern aus.
D28056202B - 06/2005 15 / 122

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
Rückkehr aus dem Unterprogramm return
Syntax
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 <bool Bedingung>
<Anweisungen>
[else
<Anweisungen>]
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
16 / 122 D28056202B - 06/2005

Anweisung while
Syntax
while <bool Bedingung>
<Anweisungen>
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
<Anweisungen>
until <bool Bedingung>
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
D28056202B - 06/2005 17 / 122

Anweisung for
Syntax
for <num Zähler> = <num Anfang> to <num Ende> [step <num Schritt>]
<Anweisungen>
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
18 / 122 D28056202B - 06/2005

Anweisung switch
Syntax
switch <num Auswahl>
case <num Fall1> [, <num Fall2>]
<Anweisungen1-2>
break
[case <num Fall3> [, <num Fall4>]
<Anweisungen3-4>
break ]
[default
<Standardanweisungen>
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
D28056202B - 06/2005 19 / 122

EINFACHE TYPEN
Anweisungen
num size(Variable)
Syntax
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
20 / 122 D28056202B - 06/2005

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& Variable> = <bool Weist den Wert von Bedingung der Variable Variable zu und überträgt
Bedingung> den Wert von Bedingung.
bool <bool Bedingung1> or Überträgt den Wert des logischen OR zwischen Bedingung1 und
<bool Bedingung2> Bedingung2.. Bedingung2 wird nur zur Bewertung herangezogen, wenn
Bedingung1 false ist.
bool <bool Bedingung1> and Überträgt den Wert des logischen AND für Bedingung1 und Bedingung2..
<bool Bedingung2> Bedingung2 wird nur zur Bewertung herangezogen, wenn Bedingung1
true ist.
bool <bool Bedingung1> xor Überträgt den Wert des ausschließenden logischen OR für Bedingung1
bool <Bedingung2> und Bedingung2.
bool <bool Bedingung1> != Testet die Ungleichheit der Werte für Bedingung1 und Bedingung2.
<bool Bedingung2> Überträgt true, wenn die Werte verschieden sind, andernfalls false.
bool <bool Bedingung1> == Testet die Ungleichheit der Werte für Bedingung1 und Bedingung2.
<bool Bedingung2> Überträgt true, wenn die Werte identisch sind, andernfalls false.
bool ! <bool Bedingung> Überträgt das Gegenteil des Wertes für Bedingung
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))<0.000000000000001,1,-1)) // ergibt 1
Konstanten numerischen Typs haben folgendes Format:
[-] <Zahlen>[.<Zahlen>]
Zum Beispiel
1
0.2
-3.141592653
Variablen des Typs num werden vorprogrammiert auf den Wert 0 initialisiert.
D28056202B - 06/2005 21 / 122

Operatoren
num <num& Variable> = <num Wert> Weist Wert der Variable Variable zu und überträgt den
Wert.
bool <num Wert1> != <num Wert2> Überträgt true, wenn Wert1 ungleich Wert2 ist,
andernfalls false.
bool <num Wert1> == <num Wert2> Überträgt true, wenn Wert1 gleich Wert2 ist,
andernfalls false.
bool <num Wert1> >= <num Wert2> Überträgt true, wenn Wert1 größer gleich Wert2 ist,
andernfalls false.
bool <num Wert1> > <num Wert2> Überträgt true, wenn Wert1 größer Wert2 ist,
andernfalls false.
bool <num Wert1> <= <num Wert2> Überträgt true, wenn Wert1 kleiner gleich Wert2 ist,
andernfalls false.
bool <num Wert1> < <num Wert2> Überträgt true, wenn Wert1 kleiner Wert2 ist,
andernfalls false.
num <num Wert1> - <num Wert2> Überträgt den Unterschied zwischen Wert1 und Wert2.
num <num Wert1> + <num Wert2> Überträgt die Summe von Wert1 und Wert2.
num <num Wert1> % <num Wert2> Überträgt den Rest der Division von Wert1 durch
Wert2. Ist Wert2 gleich 0, wird eine Fehlermeldung
generiert. Das Zeichen für den Rest ist das Zeichen von
Wert1.
num <num Wert1> / <num Wert2> Überträgt den Quotienten von Wert1 durch Wert2. Ist
Wert2 gleich 0, wird eine Fehlermeldung generiert.
num <num Wert1> * <num Wert2> Überträgt das Produkt von Wert1 und Wert2.
num - <num Wert> Überträgt das Gegenteil von Wert.
Anweisungen
num sin(num Winkel)
Syntax
num sin(<num Winkel>)
Funktion
Liefert den Sinus von Winkel.
Parameter
num Winkel Winkel in Grad
Zum Beispiel
putln(sin(30)) // ergibt 0.5
22 / 122 D28056202B - 06/2005

num asin(num Wert)
Syntax
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
num cos(num Winkel)
Syntax
num cos(<num Winkel>)
Funktion
Liefert den Cosinus von Winkel.
Parameter
Zum Beispiel
putln(cos(60)) // ergibt 0.5
num acos(num Wert)
Syntax
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
D28056202B - 06/2005 23 / 122

num tan(num Winkel)
Syntax
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
Zum Beispiel
putln(tan(45)) // ergibt 1.0
num atan(num Wert)
Syntax
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
num abs(num Wert)
Syntax
num abs(<num Wert>)
Funktion
Liefert den Absolutbetrag von Wert.
Parameter
Zum Beispiel
putln(sel(abs(45)==abs(-45),1,-1)) // ergibt 1
24 / 122 D28056202B - 06/2005

num sqrt(num Wert)
Syntax
num sqrt(<num Wert>)
Funktion
Liefert die Quadratwurzel von Wert.
Ist Wert negativ, wird eine Fehlermeldung generiert.
Parameter
Zum Beispiel
putln(sqrt(9)) // ergibt 3
num exp(num Wert)
Syntax
num exp(<num Wert>)
Funktion
Liefert den Exponentialwert vonWert.
Ist Wert zu groß, wird eine Fehlermeldung erzeugt.
Parameter
Zum Beispiel
putln(exp(1)) // ergibt 2.718282
D28056202B - 06/2005 25 / 122

num ln(num Wert)
Syntax
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
num log(num Wert)
Syntax
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
26 / 122 D28056202B - 06/2005

num roundUp(num Wert)
Syntax
num roundUp(<num Wert>)
Funktion
Liefert den nächstgrößeren ganzzahligen Wert.
Parameter
Zum Beispiel
putln(roundUp(7.8)) // Ergibt den Wert 8
putln(roundUp(-7.8)) // Ergibt den Wert -7
num roundDown(num Wert)
Syntax
num roundDown(<num Wert>)
Funktion
Liefert den nächstkleineren ganzzahligen Wert.
Parameter
Zum Beispiel
putln(roundDown(7.8)) // Ergibt den Wert 7
putln(roundDown(-7.8)) // Ergibt den Wert -8
num round(num Wert)
Syntax
num round(<num Wert>)
Funktion
Liefert den nächstliegenden ganzzahligen Wert.
Parameter
Zum Beispiel
putln(round(7.8)) // Ergibt den Wert 8
putln(round(-7.8)) // Ergibt den Wert -8
D28056202B - 06/2005 27 / 122

num min(num x, num y)
Syntax
num min(<num x>, <num y>)
Funktion
Liefert den kleineren Wert von x und y.
Parameter
num x Numerischer Ausdruck
num y Numerischer Ausdruck
Zum Beispiel
putln(min(-1,10)) // Ergibt den Wert -1
num max(num x, num y)
Syntax
num max(<num x>, <num y>)
Funktion
Liefert den größeren Wert von x und y.
Parameter
num x Numerischer Ausdruck
num y Numerischer Ausdruck
Zum Beispiel
putln(max(-1,10)) // Ergibt den Wert -10
num limit(num Wert, num Mini, num Maxi)
Syntax
num limit(<num Wert>, <num Mini>, <num Maxi>)
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
28 / 122 D28056202B - 06/2005

num sel(bool Bedingung, num Wert1, num Wert2)
Syntax
num sel(<bool Bedingung>, <num Wert1>, <num Wert2>)
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
D28056202B - 06/2005 29 / 122

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 <string& Variable> = <string Kette> Weist der Variablen Variable die Zeichenkette zu und
überträgt Kette.
bool <string Kette1> != <string Kette2> Liefert true, wenn Kette1 und Kette2 nicht identisch
sind, ansonsten false.
bool <string Kette1> == <string Kette2> Liefert true, wenn Kette1 und Kette2 identisch sind,
ansonsten false.
string <string Kette1> + <string <Kette2> Liefert die 128 ersten Zeichen von Kette1 verknüpft
mit Kette2.
Anweisungen
string toString(string Format, num Wert)
Syntax
string toString(<string Format>, <num Wert>)
Funktion
Liefert eine Zeichenkette, die Wert im Anzeigeformat Format darstellt.
Das Format hat die Form "Größe.Präzision", wobei Größe für die Mindestgröße des Ergebnisses (gegebenenfalls
werden am Anfang der Zeichenkette Leerstellen hinzugefügt) und Präzision für die Anzahl bedeutungstragender
Ziffern nach dem Dezimalkomma steht (die 0 am Ende der Kette werden durch Leerstellen ersetzt). Größe und
Präzision haben den Standardwert 0. Der ganzzahlige Teil des Werts wird niemals verkürzt, auch wenn seine
Anzeigelänge den Wert von Größe übertrifft.
Parameter
string Format Ausdruck des Typs Zeichenkette
Zum Beispiel
num nPi
nPi = 3.141592654
putln(toString(".4", nPi)) // ergibt «3.1416»
putln(toString("8", nPi)) // ergibt « 3»
putln(toString("8.4", nPi)) // ergibt « 3.1416»
putln(toString("8.4", 2.70001)) // ergibt « 2.7 »
putln(toString("", nPi)) // ergibt «3»
putln(toString("1.2", 1234.1234)) // ergibt «1234.12»
Siehe auch
string chr(num ASCII-Code)
string toNum(string Kette, num& Wert, bool& Bericht)
30 / 122 D28056202B - 06/2005

string toNum(string Kette, num& Wert, bool& Bericht)
Syntax
string toNum(<string Kette>, <num& Wert>, 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)
D28056202B - 06/2005 31 / 122

Syntax
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)
32 / 122 D28056202B - 06/2005

num asc(string chaîne, num position)
Syntax
num asc(<string Kette>, <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 left(string Kette, num Größe)
Syntax
string left(<string Kette>, <num Größe>)
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»
D28056202B - 06/2005 33 / 122

string right(string Kette, num Größe)
Syntax
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»
string mid(string Kette, num Größe, num Position)
Syntax
string mid(<string Kette>, <num Größe>, <num Position>)
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»
34 / 122 D28056202B - 06/2005

string insert(string Kette, string Einfügen, num Position)
Syntax
string insert(<string Kette>, <string Einfügen>, <num Position>)
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»
string delete(string Kette, num Größe, num Position)
Syntax
string delete(<string Kette>, <num Größe>, <num Position>)
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»
D28056202B - 06/2005 35 / 122

num replace(string Kette, string Ersetzen, num Größe, num Position)
Syntax
string replace(<string Kette>, <string Ersetzen>, <num Größe>, <num Position>)
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»
num find(string Kette1, string Kette2)
Syntax
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
36 / 122 D28056202B - 06/2005

num len(string Kette)
Syntax
num len(<string Kette>)
Funktion
Überträgt die Länge von Kette.
Parameter
Zum Beispiel
putln(len("hello wild world")) // ergibt 16
D28056202B - 06/2005 37 / 122

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 <dio Ausgang> = <dio Ein-/ Ordnet den Status von Ein-/Ausgang dem Ausgang zu und
Ausgang> überträgt diesen Status. Wenn Ausgang keinem digitalen
Ausgang des Systems zugewiesen ist, wird eine
Fehlermeldung erzeugt.
bool <dio Ausgang> = <bool Weist Bedingung dem Status des Ausgang zu und überträgt
Bedingung> Bedingung. Wenn Ausgang keinem digitalen Ausgang des
Systems zugewiesen ist, wird eine Fehlermeldung erzeugt.
bool <dio Eingang1> != <bool Überträgt true, wenn Eingang1 und Eingang2 nicht den
Eingang2> gleichen Status haben, ansonsten false.
bool <dio Eingang> != <bool Überträgt true, wenn der Status des Eingang nicht gleich
Bedingung> Bedingung ist, ansonsten false.
bool <dio Eingang> == <bool Überträgt true, wenn der Status des Eingang gleich
Bedingung> Bedingung ist, ansonsten false.
bool <dio Eingang1> == <dio Eingang2> Überträgt true, wenn Eingang1 und Eingang2 den gleichen
Status haben, ansonsten false.
38 / 122 D28056202B - 06/2005

Anweisungen
void dioLink(dio& Variable, dio Quelle)
Syntax
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
num dioGet(dio dTabelle)
Syntax
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[1] = false
dCode[2] = false
dCode[3] = true
putln(dioGet(dCode)) // ergibt 10 = 0 + 2 1 + 4 0 + 8 1
Siehe auch
num dioSet(dio dTabelle, num Wert)
D28056202B - 06/2005 39 / 122

num dioSet(dio dTabelle, num Wert)
Syntax
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)
40 / 122 D28056202B - 06/2005

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
void aioLink(aio& Variable, aio Quelle)
Syntax
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.
num aioGet(aio Eingang)
Syntax
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)
D28056202B - 06/2005 41 / 122

num aioSet(aio Ausgang, num Wert)
Syntax
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)
42 / 122 D28056202B - 06/2005

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 <sio Ausgang> = <string Angabe> Schreibt nacheinander in Ausgang die Zeichen von
Angabe, gefolgt vom Zeichenketten-Endzeichen, und
übergibt Angabe.
num <sio Ausgang> = <num Angabe> Schreibt in Ausgang die Angabe nähestliegende
ganze Zahl, Modulo 256, und übergibt den tatsächlich
übermittelten Wert.
num <num Angabe> = <sio Eingang> Liest ein Zeichen in Eingang und ordnet Angabe den
ASCII-Code dieses Zeichens zu.
string <string Angabe> = <sio Eingang> 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.
D28056202B - 06/2005 43 / 122

Anweisungen
void sioLink(sio& Variable, sio Quelle)
Syntax
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
num clearBuffer(sio Eingang)
Syntax
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(<sio Eingang>,<num& Daten>)
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.
44 / 122 D28056202B - 06/2005

num sioSet(sio Ausgang, num& Daten)
Syntax
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.
D28056202B - 06/2005 45 / 122

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 (<bool fix>)
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.
46 / 122 D28056202B - 06/2005

void gotoxy(num x, num y)
Syntax
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()
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 put() void putln()
Syntax
void put(<string Kette>)
void put(<num Wert>)
void putln(<string Kette>)
void putln(<num Wert>)
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)
D28056202B - 06/2005 47 / 122

void title(string Kette)
Syntax
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(<string& Kette>)
num get(<num& Wert>)
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
- -
Ret. Ret.
2 Shift Esc Help Run 2 Shift Esc Help 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
48 / 122 D28056202B - 06/2005

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
Parameter
string& Kette Variable des Typs string
num& Wert Variable des Typs num
Zum Beispiel
num nValeur
num nKey
// Wartet auf die Return-Taste zum Validieren der Eingabe
do
nKey = get (nValeur)
until (nKey == 270)
Siehe auch
num getKey()
D28056202B - 06/2005 49 / 122

num getKey()
Syntax
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)
bool isKeyPressed(nom code)
Syntax
bool isKeyPressed(<num 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(<string Kette>)
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()
50 / 122 D28056202B - 06/2005

void logMsg(string Kette)
Syntax
void logMsg(<string Kette>)
Funktion
Schreibt Kette in die Protokollliste des Systems. Die Meldung wird mit Datum und Uhrzeit registriert.
Siehe auch
string getProfile()
Syntax
string getProfile()
Funktion
Gibt den Namen des aktuellen Benutzerprofils zurück.
D28056202B - 06/2005 51 / 122

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.
52 / 122 D28056202B - 06/2005

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.
Sequentielles Ordnen
Priorität
T1 führt die
Funktion delay() Zeit abgelaufen
aus.
T1 T1
Normale T1 Normale
Ausführung Ausführung
T2 T2 T2 T2 T2
T3 T3 T3 T3 T3
Zeit
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

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
<instructionsTache1>
endWhile
end
program tache2()
begin
while(true)
call synchro(n, bSynch, 2) // Synchronisierung mit Task 1
<instructionsTache2>
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
54 / 122 D28056202B - 06/2005

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
program tache1()
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
program tache2()
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
D28056202B - 06/2005 55 / 122

Anweisungen
void taskSuspend(string Name)
Syntax
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 (<string Name>, <num Sprung>)
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
56 / 122 D28056202B - 06/2005

Syntax
void taskKill (<string Name>)
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(...)
D28056202B - 06/2005 57 / 122

num taskStatus(string Name)
Syntax
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ß).
Die im Bewegungsdeskriptor spezifizierte Abbremsgeschwindigkeit ist ungültig (negativ, zu groß oder kleiner als die
102
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)
Diese Bewegungsanweisung lässt sich nicht ausführen: Eine vorher angeforderte Bewegung konnte nicht beendet
150
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
58 / 122 D28056202B - 06/2005

void taskCreate string Name, num Priorität, Programm(...)
Syntax
void taskCreate <string Name>, <num Priorität>, 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)
D28056202B - 06/2005 59 / 122

void wait(bool Bedingung)
Syntax
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(<num Sekunden>)
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()
60 / 122 D28056202B - 06/2005

num clock()
Syntax
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()
<instructions>
put("Dauer des Vorgangs= " )
putln(clock()-nDebut)
Siehe auch
Syntax
bool watch (<bool Bedingung>, <num Sekunden>)
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()
D28056202B - 06/2005 61 / 122

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.
62 / 122 D28056202B - 06/2005

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.
Code Beschreibung
0 Kein Fehler
10 Die Kennung der Bibliothek wurde nicht durch libLoad() initialisiert.
11
Laden der Bibliothek unmöglich: Ihre Schnittstelle entspricht nicht derjenigen der
Kennung.
12
Laden der Bibliothek unmöglich: Die Bibliothek enthält ungültige Daten oder
Programme.
13
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.
D28056202B - 06/2005 63 / 122

Anweisungen
num identifiant:libLoad(string Weg)
Syntax
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()
64 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 65 / 122

STEUERUNG DES ROBOTERS
In diesem Kapitel sind die Anweisungen für die verschiedenen Komponenten des Roboters aufgeführt.
Anweisungen
void disablePower()
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()
void enablePower()
Syntax
void enablePower()
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
void disablePower()
bool isPowered()
bool isPowered()
Syntax
bool isPowered()
Funktion
Überträgt den Status der Leistungsversorgung des Arms:
true: Arm mit Strom versorgt
false: der Arm ist ausgeschaltet, wird gerade ein- oder ausgeschaltet
66 / 122 D28056202B - 06/2005

bool isCalibrated()
Syntax
bool isCalibrated()
Funktion
Überträgt den Kalibrierstatus des Roboters:
true: Alle Roboterachsen sind kalibriert
false: Mindestens eine Roboterachse ist nicht kalibriert
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)
1 Anschlussbewegung (250 mm/s)
2 2
Test 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.
D28056202B - 06/2005 67 / 122

num speedScale()
Syntax
num speedScale()
Funktion
Überträgt die aktuelle Geschwindigkeit des Monitors.
Zum Beispiel
num nCycle
taskCreate "checkSpeed", 5, checkSpeed()
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()<= 10)
restartMotion()
endIf
endIf
endWhile
end
num esStatus()
Syntax
num esStatus()
Funktion
Überträgt den Status der Sicherheitsschaltungen:
Code Status
0 Alle Sicherheitssignale sind inaktiv.
1 Warten auf Freigabe nach Notausschaltung.
2 Sicherheitssignal aktiviert.
Siehe auch
num workingMode(), num workingMode(num& Status)
68 / 122 D28056202B - 06/2005

ARMPOSITION
EINLEITUNG
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:
Beziehung zwischen: frame / point / tool / trsf
tool t21 tool t22

point p21a point p21b
Trsf Trsf
Trsf Trsf
tool t2
frame f21 frame f21
tool t1 point p1a
Trsf point p2a
Trsf
Trsf Trsf
Trsf
Trsf
frame f2
frame f1
flange Trsf
Trsf
robot
world
TYP JOINT
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
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.
D28056202B - 06/2005 69 / 122

Operatoren
joint <joint& Position1> = <joint Position2> Weist Position2 nacheinander der Variablen
Position1 zu und überträgt Position2.
bool <joint Position1> != <joint Position2> Überträgt true, wenn ein Feld von Position1 im
Rahmen der Robotergenauigkeit nicht gleich dem
entsprechenden Feld von Position2 ist, ansonsten
false.
bool <joint Position1> == <joint Position2> Überträgt true, wenn jedes Feld von Position1 im
Rahmen der Robotergenauigkeit gleich dem
entsprechenden Feld von Position2 ist, ansonsten
false.
bool <joint Position1> > <joint Position2> Überträgt true, wenn jedes Feld von Position1 größer
als das entsprechende Feld in Position2 ist, ansonsten
false.
bool <joint Position1> < <joint Position2> Ü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 <joint Position1> - <joint Position2> Überträgt die Differenz für jedes Feld von Position1 mit
Position2.
joint <joint Position1> + <joint Position2> Überträgt die Summe für jedes Feld von Position1 und
Position2.
Anweisungen
joint abs(joint Position)
Syntax
joint abs(<joint Position>)
Funktion
Überträgt den Absolutwert für jedes Feld von Position.
Parameter
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 <Joint Position1> <Joint Position2>
70 / 122 D28056202B - 06/2005

joint herej()
Syntax
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(<joint Position>)
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 <Joint Position1> <Joint Position2>
D28056202B - 06/2005 71 / 122

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}.
72 / 122 D28056202B - 06/2005

Orientierung
Orientierung
z1
z2
450 mm
x2 y2
250 mm
350 mm
x1 y1
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

z
z’
y’
20°
x = x’
y
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.
D28056202B - 06/2005 73 / 122

Drehung des Koordinatensystems bezüglich folgender Achse: Y’
z
z’
z’’
10°
y’ = y’’
x = x’
y
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’’

z
z’
z’’
30°
y’’’
y’ = y’’
x = x’
y
x’’
x’’’
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

Operatoren
trsf <trsf& Position1> = <trsf Position2> Weist Position2 nacheinander der Variablen
Position1 zu und überträgt Position2.
bool <trsf Position1> != <trsf Position2> Überträgt true, wenn ein Feld von Position1 nicht
gleich dem entsprechenden Feld in Position2 ist,
ansonsten false.
bool <trsf Position1> == <trsf Position2> Überträgt true, wenn jedes Feld von Position1 gleich
dem entsprechenden Feld in Position2 ist, ansonsten
false.
trsf <trsf Position1> <trsf Position2> Überträgt die geometrischen Komponenten der
Transformationen Position1 und Position2. Achtung!
Im Allgemeinen ist ! Position1 Position2 ! =
Position2 Position1!
trsf ! <trsf Position> Überträgt die Umkehrung der Transformation von

Position.
Anweisungen
num distance(trsf Position1, trsf Position2)
Syntax
num distance(<trsf Position1>, <trsf Position2>)
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)
D28056202B - 06/2005 75 / 122

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
point21a point21b
frame 21 frame 21
point1a
point2a
frame1 frame2
world
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.
76 / 122 D28056202B - 06/2005

Operatoren
frame <frame& Markierung1> = <frame Weist die Position und das Referenz-
Markierung2> Koordinatensystem von Markierung2 der Variable
Markierung1 zu.
bool <frame Markierung1> != <frame Überträgt true, wenn Markierung1 und Markierung2
Markierung2> nicht das gleiche Referenz-Koordinatensystem oder
darin nicht die gleiche Position haben.
bool <frame Markierung1> == <frame Überträgt true, wenn Markierung1 und Markierung2
Markierung2> die gleiche Position im gleichen Referenz-
Koordinatensystem haben.
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
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
D28056202B - 06/2005 77 / 122

Abhängigkeit der Tools
outil21 outil21
outil1 outil2
flange
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:
- 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.
Operatoren
tool <tool& Werkzeug1> = <tool Werkzeug2> Weist der Variablen Werkzeug1 die Position und das
Basiswerkzeug von Werkzeug2 zu.
bool <tool Werkzeug1> != <tool Werkzeug2> Ü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 <tool Werkzeug1> == <tool Werkzeug2> Ü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.
78 / 122 D28056202B - 06/2005

Anweisungen
void open(tool Werkzeug)
Syntax
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()
void close(tool Werkzeug)
Syntax
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)
void waitEndMove()
D28056202B - 06/2005 79 / 122

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
Frame world Frame f1 Frame f2
Point p0 Point p1 Point p2
Point p3
Wenn man eine Variable des Typs point ohne definiertes Referenz-Koordinatensystem verwendet, wird eine
Fehlermeldung erzeugt.
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.
Operatoren
point <point& Punkt1> = <point Punkt2> Weist die Position, die Konfiguration und das
Referenz-Koordinatensystem von Punkt1 der
Variablen Punkt2 zu.
bool <point Punkt1> ! = <point Punkt2> Überträgt true, wenn Punkt1 und Punkt2 nicht das
gleiche Referenz-Koordinatensystem oder darin
nicht die gleiche Position haben.
bool <point Punkt1> == <point Punkt2> Überträgt true, wenn Punkt1 und Punkt2 die gleiche
Position im gleichen Referenz-Koordinatensystem
haben.
80 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 81 / 122

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 <trsf Position1> * <trsf Position2>
82 / 122 D28056202B - 06/2005

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 <trsf Position1> * <trsf Position2>
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)
D28056202B - 06/2005 83 / 122

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()
84 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 85 / 122

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
P 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:
righty Konfiguration der Schulter righty vorgeschrieben
lefty Konfiguration der Schulter lefty vorgeschrieben

shoulder
ssame Andere Schulterkonfiguration verboten
sfree Beliebige Konfiguration der Schulter
86 / 122 D28056202B - 06/2005

epositive Konfiguration des Ellenbogens epositive vorgeschrieben
enegative Konfiguration des Ellenbogens enegative vorgeschrieben

elbow
esame Andere Ellenbogenkonfiguration verboten
efree Beliebige Konfiguration des Ellenbogens
wpositive Konfiguration des Handgelenks wpositive vorgeschrieben
wnegative Konfiguration des Handgelenks wnegative vorgeschrieben

wrist
wsame Andere Handgelenkkonfiguration verboten
wfree Beliebige Konfiguration des Handgelenks
Operatoren
config <config& Konfiguration1> = <config Weist die Felder shoulder, elbow und wrist von
Konfiguration2> Konfiguration2 der Variablen Konfiguration1 zu.
bool <config Konfiguration1> != <config Überträgt true, wenn die Felder shoulder, elbow oder wrist
Konfiguration2> in Konfiguration1 und Konfiguration2 nicht den gleichen
Wert haben.
bool <config Konfiguration1> == <config Überträgt true, wenn die Felder shoulder, elbow oder wrist
Konfiguration2> in Konfiguration1 und Konfiguration2 den gleichen Wert
haben.
Konfiguration (Arm RX/TX)

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.
D28056202B - 06/2005 87 / 122

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.
88 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 89 / 122

Anweisungen
Syntax
Funktion
Überträgt die Roboterkonfiguration für die Gelenkposition Position.
Parameter
Siehe auch
joint herej()
90 / 122 D28056202B - 06/2005

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

Initial position
Final position
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.
Geradlinige Bewegung
Z
Y
Z
X
X Y
D28056202B - 06/2005 91 / 122

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.
Kreisförmige Bewegung
Nächste Bewegung
Vorherige Bewegung
Vom Werkzeug während der

kreisförmigen Bewegung beschriebene Bahn
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.
Zyklus: U
DEGAGE APPRO
X X
Z Z
PRISE DEPOSE
X X
Z Z
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)
92 / 122 D28056202B - 06/2005

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’
R
VE EA
LEA C
H
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)
mDesc.leave = 200
mDesc.reach = 50
movej(APPRO, tool, mDesc)
mDesc.blend = OFF
movel(DEPOSE, tool, mDesc)
D28056202B - 06/2005 93 / 122

Damit erhält man folgende Bahn:
Geglätteter Zyklus
200
200
DEGAGE APPRO
50
50
PRISE DEPOSE
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
mDesc.leave = 10
mDesc.reach = 10
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

A C
10 10 10
10
No smoothing at B
(BREAK)
10 10 10
D 10
B
94 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 95 / 122

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
Vom Werkzeug während der Nächste Bewegung

kreisförmigen Bewegung beschriebene
Bahn
(Ausrichtung bleibt konstant)
Vorherige Bewegung
• 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.
Konstante Ausrichtung bezüglich der Bahn

Vorherige Bewegung
Vom Werkzeug während der kreisförmigen

Bewegung beschriebene Bahn
(Tangentenausrichtung)
Nächste Bewegung
96 / 122 D28056202B - 06/2005

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 OK !
• •
Insbesondere verlangt die Programmierung eines vollständigen Kreises 2 movec-Anweisungen:

movec (B, C, Werkzeug, mDesc)
movec (D, A, Werkzeug, mDesc)
Vollständiger Kreis
Vom Werkzeug während der

kreisförmigen Bewegung
beschriebene Bahn
Vorherige
Bewegung
Nächste
Bewegung
Y
D28056202B - 06/2005 97 / 122

Ä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.
98 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 99 / 122

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.
100 / 122 D28056202B - 06/2005

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).
Geglätteter Zyklus
A C
A leave A reach C leave C reach
B leave B reach
B D
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.
D28056202B - 06/2005 101 / 122

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.
102 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 103 / 122

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
Glättungsart: off (keine Glättung) oder joint (mit Glättung).
blend
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.
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
mdesc <mdesc& desc1> = <mdesc desc2> Weist jedes Feld desc2 dem entsprechenden Feld der
Variablen desc1 zu.
bool <mdesc desc1> != <mdesc desc2> Überträgt true, wenn sich desc1 und desc2 in
mindestens einem Feld unterscheiden.
bool <mdesc desc1> == <mdesc desc2> Überträgt true, wenn die Werte der Felder in desc1
und desc2 gleich sind.
104 / 122 D28056202B - 06/2005

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 waitEndMove()
void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, mdesc desc)
D28056202B - 06/2005 105 / 122

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
void waitEndMove()
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
void waitEndMove()
D28056202B - 06/2005 107 / 122

void stopMove()
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
<instructions>
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 stopMove()
void autoConnectMove(bool aktiv), bool autoConnectMove()
108 / 122 D28056202B - 06/2005

void restartMove()
Syntax
void restartMove()
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
void stopMove()
void waitEndMove()
Syntax
void waitEndMove()
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()
bool isEmpty()
void stopMove()
D28056202B - 06/2005 109 / 122

bool isEmpty()
Syntax
bool isEmpty()
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
void waitEndMove()
bool isSettled()
Syntax
bool isSettled()
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
bool isEmpty()
void waitEndMove()
void autoConnectMove(bool aktiv), bool autoConnectMove()

Syntax
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
110 / 122 D28056202B - 06/2005

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.
D28056202B - 06/2005 111 / 122

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()
112 / 122 D28056202B - 06/2005

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
bool isCompliant()
D28056202B - 06/2005 113 / 122

bool isCompliant()
Syntax
bool isCompliant()
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
114 / 122 D28056202B - 06/2005

ANHANG
FEHLERCODES
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ß).
Die im Bewegungsdeskriptor spezifizierte Abbremsgeschwindigkeit ist ungültig (negativ, zu groß oder kleiner als
102
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)
Diese Bewegungsanweisung lässt sich nicht ausführen: Eine vorher angeforderte Bewegung konnte nicht beendet
150
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)
D28056202B - 06/2005 115 / 122

TASTENCODES DER BEDIENKONSOLE
Ohne Shift Mit Shift
3 Caps Space 3 Caps Space
283 - 32 Move 283 - 32 Move
- -
Ret. Ret.
2 Shift Esc Help Run 2 Shift Esc Help 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
116 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 117 / 122

118 / 122 D28056202B - 06/2005
INDEX
A E
abs (fonction) 24, 70 elbow 86
accel 104 else 16
acos (fonction) 23 enablePower (fonction) 66
aio 12, 41 endFor 18
aioGet (fonction) 41 endIf 16
aioLink (fonction) 41 endWhile 17
aioSet (fonction) 42 enegative 88
appro (fonction) 83 epositive 88
asc (fonction) 33 esStatus (fonction) 68
asin (fonction) 23 exp (fonction) 25
atan (fonction) 24
autoConnectMove 95 F
autoConnectMove (fonction) 110 find (fonction) 36
flange 10
B for 18
blend 93, 104 for (fonction) 18
bool 12 frame 12, 69
C G
call 11, 16 get 53
call (fonction) 15 get (fonction) 48
chr (fonction) 32 getKey (fonction) 50
clearBuffer (fonction) 44 globale 13
clock (fonction) 61 gotoxy (fonction) 47
close 53
close (fonction) 79 H
cls (fonction) 47 here (fonction) 83
codeAscii 32 herej (fonction) 71
compose (fonction) 82 I
config 12, 69, 86 if (fonction) 16
config (fonction) 90 insert (fonction) 35
cos (fonction) 23 isCalibrated (fonction) 67
D isCompliant 111
decel 104 isCompliant (fonction) 114
delay 53 isEmpty (fonction) 110
delay (fonction) 60 isInRange (fonction) 71
delete (fonction) 35 isKeyPressed (fonction) 50
dio 12, 38 isPowered (fonction) 66
dioGet (fonction) 39 isSettled (fonction) 110
dioLink (fonction) 39 J
dioSet (fonction) 40 joint 12
disablePower (fonction) 66 jointToPoint (fonction) 84
distance (fonction) 75, 81
do 17 L
do ... until (fonction) 17 leave 93, 104
left (fonction) 33
D28056202B - 06/2005 119 / 122

lefty 87, 89 restartMove (fonction) 109
len (fonction) 37 return (fonction) 16
libDelete (fonction) 64 right (fonction) 34
libLoad 63 righty 87, 89
libLoad (fonction) 64 round (fonction) 27
libPath (fonction) 65 roundDown (fonction) 27
libSave (fonction) 64 roundUp (fonction) 27
limit (fonction) 28 RUNNING 60, 61
ln (fonction) 26 rvel 104
locale 13
log (fonction) 26 S
logMsg (fonction) 51 sel (fonction) 29
setFrame (fonction) 77
M shoulder 86
max (fonction) 28 sin (fonction) 22
mdesc 12, 91, 104 sio 12, 43
mid (fonction) 34 sioGet (fonction) 44
min (fonction) 28 sioLink (fonction) 44
movec (fonction) 107 sioSet (fonction) 45
movej 91 size (fonction) 20
movej (fonction) 105 speedScale (fonction) 68
movejf 111 sqrt (fonction) 25
movejf (fonction) 112 start 10
movel 91 stop 10
movel (fonction) 106 stopMove 111
movelf 111 stopMove (fonction) 108
movelf (fonction) 113 STOPPED 56
string 12
N switch (fonction) 19
num 12, 33
T
O tan (fonction) 24
open 53 taskCreate (fonction) 59
open (fonction) 79 taskKill (fonction) 57
P taskResume 52
point 12 taskResume (fonction) 56
pointToJoint (fonction) 84 taskStatus 52
popUpMsg (fonction) 50 taskStatus (fonction) 58
position (fonction) 85 taskSuspend (fonction) 56
put (fonction) 47 title (fonction) 48
putln 47 toNum (fonction) 31
tool 12, 69
R toString (fonction) 30
reach 93, 104 trsf 12, 69
replace (fonction) 36 tvel 104
resetMotion 95, 108, 111
resetMotion (fonction) 108 U
restartMove 108, 111 until 17
120 / 122 D28056202B - 06/2005

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
D28056202B - 06/2005 121 / 122

122
122 / 122 D28056202B - 06/2005

Referenzanleitung Val3 d28056202b - 06 - 2005 - Eule-Roboter - de

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Referenzanleitung Val3 d28056202b - 06 - 2005 - Eule-Roboter - de

Hochgeladen von

Copyright:

Verfügbare Formate

REFERENZANLEITUNG VAL3

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

D28056202B - 06/2005 3 / 122

4 / 122 D28056202B - 06/2005

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

D28056202B - 06/2005 5 / 122

6 / 122 D28056202B - 06/2005

D28056202B - 06/2005 7 / 122

D28056202B - 06/2005 9 / 122

Die Sprache VAL3 enthält folgende Elemente:

Starten und Beenden der Applikation

Parameter der Applikation

10 / 122 D28056202B - 06/2005

D28056202B - 06/2005 11 / 122

Konstanten einfachen Typs

Konstanten strukturierten Typs

12 / 122 D28056202B - 06/2005

Gültigkeitsbereich einer Variablen

Zugriff auf den Wert einer Variablen

D28056202B - 06/2005 13 / 122

a = 0 // Initialisierung einer einfachen Variable

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

t = p.trsf // Initialisierung von t

14 / 122 D28056202B - 06/2005

ANWEISUNGEN ZUR ABLAUFSTEUERUNG

Aufruf des Unterprogramms call

D28056202B - 06/2005 15 / 122

Rückkehr aus dem Unterprogramm return

16 / 122 D28056202B - 06/2005

Anweisung do ... until

D28056202B - 06/2005 17 / 122

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

18 / 122 D28056202B - 06/2005

num Fall1 Numerische Konstante für den Testfall

num Fall2 Numerische Konstante für den Testfall

num Fall3 Numerische Konstante für den Testfall

num Fall4 Numerische Konstante für den Testfall

D28056202B - 06/2005 19 / 122

20 / 122 D28056202B - 06/2005

D28056202B - 06/2005 21 / 122

num - <num Wert> Überträgt das Gegenteil von Wert.

22 / 122 D28056202B - 06/2005

num asin(num Wert)

num cos(num Winkel)

num acos(num Wert)

D28056202B - 06/2005 23 / 122

num atan(num Wert)

num abs(num Wert)

24 / 122 D28056202B - 06/2005

num sqrt(num Wert)

num exp(num Wert)

D28056202B - 06/2005 25 / 122

num log(num Wert)

26 / 122 D28056202B - 06/2005

num roundUp(num Wert)

num roundDown(num Wert)

num round(num Wert)

D28056202B - 06/2005 27 / 122

num y Numerischer Ausdruck

num max(num x, num y)

num y Numerischer Ausdruck