referenzanleitung val3 d28056202b - 06/2005 - eule-roboter.de
referenzanleitung val3 d28056202b - 06/2005 - eule-roboter.de
referenzanleitung val3 d28056202b - 06/2005 - eule-roboter.de
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
© Stäubli Faverges <strong>2005</strong><br />
D28056202B - <strong>06</strong>/<strong>2005</strong><br />
REFERENZANLEITUNG VAL3<br />
Version 5.2
2 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
EINLEITUNG....................................................................................................................... 9<br />
ELEMENTE DER SPRACHE VAL3.................................................................................. 10<br />
APPLIKATIONEN ................................................................................................................. 10<br />
Definition........................................................................................................................................ 10<br />
Vorprogrammierte Inhalte .............................................................................................................. 10<br />
Starten und Been<strong>de</strong>n <strong>de</strong>r Applikation ............................................................................................ 10<br />
Parameter <strong>de</strong>r Applikation ............................................................................................................. 10<br />
Längeneinheit............................................................................................................................................ 11<br />
Größe <strong>de</strong>s Ausführungsspeichers............................................................................................................. 11<br />
PROGRAMME...................................................................................................................... 11<br />
Definition........................................................................................................................................ 11<br />
Wie<strong>de</strong>reinsprung............................................................................................................................ 11<br />
Programm start()........................................................................................................................... 11<br />
Programm stop() ........................................................................................................................... 11<br />
DATENTYP .......................................................................................................................... 12<br />
Definition........................................................................................................................................ 12<br />
Einfache Typen.............................................................................................................................. 12<br />
Strukturierte Typen ........................................................................................................................ 12<br />
KONSTANTEN ..................................................................................................................... 12<br />
Definition........................................................................................................................................ 12<br />
Konstanten einfachen Typs ........................................................................................................... 12<br />
Konstanten strukturierten Typs...................................................................................................... 12<br />
Konstantentabelle .......................................................................................................................... 13<br />
VARIABLEN ......................................................................................................................... 13<br />
Definition........................................................................................................................................ 13<br />
Gültigkeitsbereich einer Variablen ................................................................................................. 13<br />
Zugriff auf <strong>de</strong>n Wert einer Variablen.............................................................................................. 13<br />
"By value"-Parameter .................................................................................................................... 14<br />
"By Reference"-Parameter ............................................................................................................ 14<br />
ANWEISUNGEN ZUR ABLAUFSTEUERUNG..................................................................... 15<br />
Bemerkung // ...................................................................................................................................... 15<br />
Aufruf <strong>de</strong>s Unterprogramms call ......................................................................................................... 15<br />
Rückkehr aus <strong>de</strong>m Unterprogramm return......................................................................................... 16<br />
Anweisung if........................................................................................................................................ 16<br />
Anweisung while................................................................................................................................. 17<br />
Anweisung do ... until......................................................................................................................... 17<br />
Anweisung for ..................................................................................................................................... 18<br />
Anweisung switch............................................................................................................................... 19<br />
EINFACHE TYPEN ........................................................................................................... 20<br />
Anweisungen ................................................................................................................................. 20<br />
num size(Variable) .............................................................................................................................. 20<br />
TYP BOOL ........................................................................................................................... 21<br />
Definition........................................................................................................................................ 21<br />
Operatoren..................................................................................................................................... 21<br />
TYP NUM ............................................................................................................................. 21<br />
Definition........................................................................................................................................ 21<br />
Operatoren..................................................................................................................................... 22<br />
Anweisungen ................................................................................................................................. 22<br />
num sin(num Winkel) ......................................................................................................................... 22<br />
num asin(num Wert) .......................................................................................................................... 23<br />
num cos(num Winkel) ........................................................................................................................ 23<br />
num acos(num Wert) ......................................................................................................................... 23<br />
num tan(num Winkel) ......................................................................................................................... 24<br />
num atan(num Wert) .......................................................................................................................... 24<br />
num abs(num Wert) ........................................................................................................................... 24<br />
num sqrt(num Wert) ........................................................................................................................... 25<br />
num exp(num Wert) ........................................................................................................................... 25<br />
num ln(num Wert) .............................................................................................................................. 26<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 3 / 122
num log(num Wert) ............................................................................................................................ 26<br />
num roundUp(num Wert) .................................................................................................................. 27<br />
num roundDown(num Wert) ............................................................................................................. 27<br />
num round(num Wert) ....................................................................................................................... 27<br />
num min(num x, num y) ..................................................................................................................... 28<br />
num max(num x, num y) .................................................................................................................... 28<br />
num limit(num Wert, num Mini, num Maxi) ........................................................................................ 28<br />
num sel(bool Bedingung, num Wert1, num Wert2) ............................................................................ 29<br />
TYP STRING ........................................................................................................................ 30<br />
Definition........................................................................................................................................ 30<br />
Operatoren..................................................................................................................................... 30<br />
Anweisungen ................................................................................................................................. 30<br />
string toString(string Format, num Wert) ........................................................................................... 30<br />
string toNum(string Kette, num& Wert, bool& Bericht) ...................................................................... 31<br />
string chr(num ASCII-Co<strong>de</strong>) .............................................................................................................. 32<br />
num asc(string chaîne, num position) ................................................................................................ 33<br />
string left(string Kette, num Größe) ................................................................................................... 33<br />
string right(string Kette, num Größe) ................................................................................................. 34<br />
string mid(string Kette, num Größe, num Position) ............................................................................ 34<br />
string insert(string Kette, string Einfügen, num Position) .................................................................. 35<br />
string <strong>de</strong>lete(string Kette, num Größe, num Position) ........................................................................ 35<br />
num replace(string Kette, string Ersetzen, num Größe, num Position) ............................................. 36<br />
num find(string Kette1, string Kette2) ................................................................................................ 36<br />
num len(string Kette) .......................................................................................................................... 37<br />
TYP DIO ............................................................................................................................... 38<br />
Definition........................................................................................................................................ 38<br />
Operatoren..................................................................................................................................... 38<br />
Anweisungen ................................................................................................................................. 39<br />
void dioLink(dio& Variable, dio Quelle) ............................................................................................. 39<br />
num dioGet(dio dTabelle) .................................................................................................................. 39<br />
num dioSet(dio dTabelle, num Wert) ................................................................................................. 40<br />
TYP AIO ............................................................................................................................... 41<br />
Definition........................................................................................................................................ 41<br />
Anweisungen ................................................................................................................................. 41<br />
void aioLink(aio& Variable, aio Quelle) ............................................................................................. 41<br />
num aioGet(aio Eingang) ................................................................................................................... 41<br />
num aioSet(aio Ausgang, num Wert) ................................................................................................. 42<br />
TYP SIO ............................................................................................................................... 43<br />
Definition........................................................................................................................................ 43<br />
Operatoren..................................................................................................................................... 43<br />
Anweisungen ................................................................................................................................. 44<br />
void sioLink(sio& Variable, sio Quelle) .............................................................................................. 44<br />
num clearBuffer(sio Eingang) ........................................................................................................... 44<br />
num sioGet(sio Eingang, num& Daten) ............................................................................................. 44<br />
num sioSet(sio Ausgang, num& Daten) ............................................................................................ 45<br />
BENUTZERSCHNITTSTELLE.......................................................................................... 46<br />
Bedienerseite................................................................................................................................. 46<br />
Anweisungen ................................................................................................................................. 46<br />
void userPage(), void userPage(bool fix)........................................................................................... 46<br />
void gotoxy(num x, num y) ................................................................................................................. 47<br />
void cls() ............................................................................................................................................. 47<br />
void put() void putln() ......................................................................................................................... 47<br />
void title(string Kette).......................................................................................................................... 48<br />
num get()............................................................................................................................................. 48<br />
num getKey() ...................................................................................................................................... 50<br />
bool isKeyPressed(nom co<strong>de</strong>)........................................................................................................... 50<br />
void popUpMsg(string Kette).............................................................................................................. 50<br />
void logMsg(string Kette).................................................................................................................... 51<br />
string getProfile()................................................................................................................................ 51<br />
4 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
TASKS .............................................................................................................................. 52<br />
Definition........................................................................................................................................ 52<br />
Fortsetzen nach einer Fehlermeldung ........................................................................................... 52<br />
Starten und Been<strong>de</strong>n <strong>de</strong>r Applikation ............................................................................................ 52<br />
Sequentielles Ordnen .................................................................................................................... 53<br />
Synchronisierung ........................................................................................................................... 54<br />
Gemeinsame Nutzung von Ressourcen ........................................................................................ 55<br />
Anweisungen ................................................................................................................................. 56<br />
void taskSuspend(string Name)......................................................................................................... 56<br />
void taskResume(string Name, num Sprung) .................................................................................... 56<br />
void taskKill(string Name) .................................................................................................................. 57<br />
num taskStatus(string Name) ............................................................................................................ 58<br />
void taskCreate string Name, num Priorität, Programm(...) ............................................................... 59<br />
void wait(bool Bedingung) .................................................................................................................. 60<br />
void <strong>de</strong>lay(num Sekun<strong>de</strong>n) ................................................................................................................. 60<br />
num clock()......................................................................................................................................... 61<br />
bool watch(bool Bedingung, num Sekun<strong>de</strong>n)..................................................................................... 61<br />
BIBLIOTHEKEN................................................................................................................ 62<br />
Definition........................................................................................................................................ 62<br />
Schnittstelle ................................................................................................................................... 62<br />
Kennung <strong>de</strong>r Schnittstelle.............................................................................................................. 62<br />
Inhalt .............................................................................................................................................. 62<br />
Im Speicher la<strong>de</strong>n und aus <strong>de</strong>m Speicher entfernen..................................................................... 62<br />
Zugriffspfad.................................................................................................................................... 63<br />
Fehlerco<strong>de</strong>s ................................................................................................................................... 63<br />
Anweisungen ................................................................................................................................. 64<br />
num i<strong>de</strong>ntifiant:libLoad(string Weg).................................................................................................... 64<br />
num i<strong>de</strong>ntifiant:libSave(), num libSave() ............................................................................................ 64<br />
num libDelete(string Weg).................................................................................................................. 64<br />
string i<strong>de</strong>ntifiant:libPath(), string libPath().......................................................................................... 65<br />
bool libList(string Weg, string& contenu) ........................................................................................... 65<br />
STEUERUNG DES ROBOTERS ...................................................................................... 66<br />
Anweisungen ................................................................................................................................. 66<br />
void disablePower() ........................................................................................................................... 66<br />
void enablePower() ............................................................................................................................ 66<br />
bool isPowered() ................................................................................................................................ 66<br />
bool isCalibrated().............................................................................................................................. 67<br />
num workingMo<strong>de</strong>(), num workingMo<strong>de</strong>(num& Status)................................................................... 67<br />
num speedScale() .............................................................................................................................. 68<br />
num esStatus() ................................................................................................................................... 68<br />
ARMPOSITION ................................................................................................................. 69<br />
EINLEITUNG ........................................................................................................................ 69<br />
TYP JOINT ........................................................................................................................... 69<br />
Definition........................................................................................................................................ 69<br />
Operatoren..................................................................................................................................... 70<br />
Anweisungen ................................................................................................................................. 70<br />
joint abs(joint Position) ....................................................................................................................... 70<br />
joint herej() ......................................................................................................................................... 71<br />
bool isInRange(joint Position) ............................................................................................................ 71<br />
TYP TRSF ............................................................................................................................ 72<br />
Definition........................................................................................................................................ 72<br />
Orientierung ................................................................................................................................... 73<br />
Operatoren..................................................................................................................................... 75<br />
Anweisungen ................................................................................................................................. 75<br />
num distance(trsf Position1, trsf Position2) ....................................................................................... 75<br />
TYP FRAME......................................................................................................................... 76<br />
Definition........................................................................................................................................ 76<br />
Verwendung................................................................................................................................... 76<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 5 / 122
Operatoren..................................................................................................................................... 77<br />
Anweisungen ................................................................................................................................. 77<br />
num setFrame(point Herkunft, point AchseOx, point PlanOxy, frame& Markierung) ........................ 77<br />
TYP TOOL............................................................................................................................ 77<br />
Definition........................................................................................................................................ 77<br />
Verwendung................................................................................................................................... 78<br />
Operatoren..................................................................................................................................... 78<br />
Anweisungen ................................................................................................................................. 79<br />
void open(tool Werkzeug) .................................................................................................................. 79<br />
void close(tool Werkzeug) ................................................................................................................. 79<br />
TYP POINT........................................................................................................................... 80<br />
Definition........................................................................................................................................ 80<br />
Operatoren..................................................................................................................................... 80<br />
Anweisungen ................................................................................................................................. 81<br />
num distance(point Position1, point Position2) ................................................................................. 81<br />
point compose(point Position, frame Markierung, trsf Umwandlung) ................................................ 82<br />
point appro(point Position, trsf Umwandlung) .................................................................................... 83<br />
point here(tool Werkzeug, frame Markierung) ................................................................................... 83<br />
point jointToPoint(tool Werkzeug, frame Markierung, joint Position) ................................................ 84<br />
bool pointToJoint(tool Werkzeug, joint anfänglich, point Position,joint& Angaben) ......................... 84<br />
trsf position(point Position, frame Markierung) ................................................................................. 85<br />
TYP CONFIG........................................................................................................................ 86<br />
Einleitung ....................................................................................................................................... 86<br />
Definition........................................................................................................................................ 86<br />
Operatoren..................................................................................................................................... 87<br />
Konfiguration (Arm RX/TX) ............................................................................................................ 87<br />
Konfiguration <strong>de</strong>r Schulter......................................................................................................................... 87<br />
Konfiguration <strong>de</strong>s Ellenbogens ................................................................................................................. 88<br />
Konfiguration <strong>de</strong>s Handgelenks ................................................................................................................ 88<br />
Konfiguration (Arm RS).................................................................................................................. 89<br />
Anweisungen ................................................................................................................................. 90<br />
config config(joint Position) ............................................................................................................... 90<br />
BEWEGUNGSSTEUERUNG............................................................................................ 91<br />
BEWEGUNGSSTEUERUNG ............................................................................................... 91<br />
Bewegungstypen: Punkt-zu-Punkt, geradlinig, kreisförmig ........................................................... 91<br />
Verkettung von Bewegungen......................................................................................................... 93<br />
Glättung..................................................................................................................................................... 93<br />
Aufheben <strong>de</strong>r Glättung.............................................................................................................................. 94<br />
Wie<strong>de</strong>raufnahme einer Bewegung ................................................................................................ 95<br />
Beson<strong>de</strong>rheiten <strong>de</strong>r kartesischen Bewegungen (geradlinig, kreisförmig)...................................... 96<br />
Interpolation <strong>de</strong>r Ausrichtung .................................................................................................................... 96<br />
Än<strong>de</strong>rung <strong>de</strong>r Konfiguration (Arm RX/TX)................................................................................................. 98<br />
Singularitäten (Arm RX/TX).................................................................................................................... 100<br />
ANTIZIPATION VON BEWEGUNGEN............................................................................... 100<br />
Prinzip.......................................................................................................................................... 100<br />
Antizipation und Glättung............................................................................................................. 101<br />
Synchronisierung ......................................................................................................................... 101<br />
GESCHWINDIGKEITSSTEUERUNG ................................................................................ 102<br />
Prinzip.......................................................................................................................................... 102<br />
Einfache Einstellung .................................................................................................................... 102<br />
Komplexere Einstellungen ........................................................................................................... 102<br />
Schleppfehler............................................................................................................................... 103<br />
ONLINE-BEWEGUNGSSTEUERUNG............................................................................... 103<br />
TYP MDESC....................................................................................................................... 104<br />
Definition...................................................................................................................................... 104<br />
Operatoren................................................................................................................................... 104<br />
BEWEGUNGSANWEISUNGEN......................................................................................... 105<br />
void movej(joint joint, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)......................................................................... 105<br />
void movel(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)..................................................................... 1<strong>06</strong><br />
6 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc) ............................................. 107<br />
void stopMove()............................................................................................................................... 108<br />
void resetMotion(), void resetMotion(joint Start) ............................................................................. 108<br />
void restartMove() ........................................................................................................................... 109<br />
void waitEndMove() ........................................................................................................................ 109<br />
bool isEmpty() ................................................................................................................................. 110<br />
bool isSettled() ................................................................................................................................ 110<br />
void autoConnectMove(bool aktiv), bool autoConnectMove() ..................................................... 110<br />
OPTIONEN...................................................................................................................... 111<br />
AUSGEGLICHENE BEWEGUNGEN MIT KRAFTSTEUERUNG....................................... 111<br />
Prinzip.......................................................................................................................................... 111<br />
Programmierung .......................................................................................................................... 111<br />
Steuerung <strong>de</strong>r Kraft ..................................................................................................................... 111<br />
Begrenzungen ............................................................................................................................. 112<br />
Anweisungen ............................................................................................................................... 112<br />
void movejf(joint Position, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft) ............................................... 112<br />
void movelf(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft) ................................................. 113<br />
bool isCompliant() .......................................................................................................................... 114<br />
ANHANG......................................................................................................................... 115<br />
FEHLERCODES................................................................................................................. 115<br />
TASTENCODES DER BEDIENKONSOLE ........................................................................ 116<br />
ADDILDUNG................................................................................................................... 117<br />
INDEX.............................................................................................................................. 119<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 7 / 122
8 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
EINLEITUNG<br />
VAL3 ist eine höhere Programmiersprache für die Steuerung von Stäubli-Robotern bei <strong>de</strong>r Ausführung industrieller<br />
Handhabungs- und Montageaufgaben.<br />
VAL3 besitzt alle wichtigen Funktionen von gängigen Echtzeit-Programmiersprachen und zusätzlich die speziellen<br />
Steuerungsfunktionen für Industrie<strong>roboter</strong>:<br />
• Steuerungsprogramme <strong>de</strong>s Roboters<br />
• Programme zur Erstellung geometrischer Mo<strong>de</strong>lle<br />
• Tools zur Ansteuerung <strong>de</strong>r Ein-/Ausgänge<br />
In <strong>de</strong>m vorliegen<strong>de</strong>n Handbuch sind alle zur Programmierung notwendigen Begriffe und Anweisungen <strong>de</strong>r VAL3-<br />
Sprache eingehend erläutert. Es enthält die Kapitel:<br />
• Sprachelemente<br />
• Einfache Typen<br />
• Benutzerschnittstelle<br />
• Tasks<br />
• Bibliotheken<br />
• Steuerung <strong>de</strong>s Roboters<br />
• Position <strong>de</strong>s Roboterarms<br />
• Bewegungssteuerung<br />
Zum leichteren Auffin<strong>de</strong>n sind die Anweisungen mit ihrer Syntax im Inhaltsverzeichnis angegeben.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 9 / 122
Die Sprache VAL3 enthält folgen<strong>de</strong> Elemente:<br />
• Applikationen<br />
• Programme<br />
• Bibliotheken<br />
• Datentypen<br />
• Konstanten<br />
• Variablen (globale, lokale und Parameter)<br />
• Tasks<br />
APPLIKATIONEN<br />
ELEMENTE DER SPRACHE VAL3<br />
Definition<br />
Eine VAL3-Applikation ist ein eigenständiges Programm zur Programmierung <strong>de</strong>s Roboters einer CS8-Steuerung.<br />
Eine VAL3-Applikation besteht aus folgen<strong>de</strong>n Elementen:<br />
- einer Gruppe von Programmen: <strong>de</strong>n auszuführen<strong>de</strong>n VAL3-Anweisungen,<br />
- einer Gruppe von globalen Variablen: <strong>de</strong>n Daten <strong>de</strong>r Applikation<br />
- einer Gruppe von Bibliotheken: von <strong>de</strong>r Applikation benutzte externe Anweisungen und Daten<br />
Während ihrer Ausführung enthält eine Applikation außer<strong>de</strong>m:<br />
- eine Gruppe von Tasks: die zu diesem Zeitpunkt ausgeführten Programme<br />
Vorprogrammierte Inhalte<br />
Eine VAL3-Applikation enthält immer die Programme start() und stop(), das Koordinatensystem world (Typ frame)<br />
und das Tool flange (Typ tool).<br />
Bei <strong>de</strong>r Erstellung enthält eine VAL3-Applikation außer<strong>de</strong>m die speziellen Anweisungen und Daten <strong>de</strong>s gewählten<br />
Mo<strong>de</strong>lls.<br />
Diese Elemente wer<strong>de</strong>n in <strong>de</strong>n entsprechen<strong>de</strong>n Kapiteln <strong>de</strong>tailliert beschrieben.<br />
Starten und Been<strong>de</strong>n <strong>de</strong>r Applikation<br />
Applikationen können nicht mit VAL3-Anweisungen gehandhabt wer<strong>de</strong>n: Das La<strong>de</strong>n, Speichern, Starten und Been<strong>de</strong>n<br />
<strong>de</strong>r Applikationen erfolgt ausschließlich über die Benutzerschnittstelle <strong>de</strong>r CS8.<br />
Zum Starten einer VAL3-Applikation wird das Programm start() ausgeführt.<br />
Wenn die letzte Task been<strong>de</strong>t ist, schließt die VAL3-Applikation sich selbst: das Programm stop() wird dann<br />
ausgeführt. Alle eventuell verbleiben<strong>de</strong>n, von <strong>de</strong>n Bibliotheken erstellten Tasks wer<strong>de</strong>n in <strong>de</strong>r umgekehrten<br />
Reihenfolge ihrer Erstellung gelöscht.<br />
Wird eine VAL3-Applikation von <strong>de</strong>r Benutzerschnittstelle <strong>de</strong>r CS8 aus unterbrochen, so wird die Start-Task, falls sie<br />
noch vorhan<strong>de</strong>n ist, augenblicklich gelöscht. Dann wird das Programm stop() ausgeführt, worauf alle noch nicht<br />
ausgeführten Tasks <strong>de</strong>r Applikation in <strong>de</strong>r umgekehrten Reihenfolge ihrer Erstellung gelöscht wer<strong>de</strong>n.<br />
Parameter <strong>de</strong>r Applikation<br />
Eine VAL3-Applikation wird mit folgen<strong>de</strong>n Parametern konfiguriert:<br />
- Längeneinheit<br />
- Größe <strong>de</strong>s Ausführungsspeichers<br />
Diese Parameter sind mit einer VAL3-Anweisung nicht zugänglich und können nur über die Benutzerschnittstelle <strong>de</strong>r<br />
CS8 geän<strong>de</strong>rt wer<strong>de</strong>n.<br />
10 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Längeneinheit<br />
In <strong>de</strong>n VAL3-Applikationen wer<strong>de</strong>n Millimeter o<strong>de</strong>r Inch als Längeneinheit verwen<strong>de</strong>t. Sie dienen zur Beschreibung <strong>de</strong>r<br />
geometrischen Daten von VAL3: Koordinatensysteme, Punkte, Transformationen, Werkzeuge o<strong>de</strong>r Bahnglättungen.<br />
Die Längeneinheit wird bei Erstellung einer Applikation durch die im System gelten<strong>de</strong> Längeneinheit festgelegt und<br />
kann anschließend nicht mehr geän<strong>de</strong>rt wer<strong>de</strong>n.<br />
Größe <strong>de</strong>s Ausführungsspeichers<br />
Der Ausführungsspeicher einer VAL3-Applikation ist <strong>de</strong>r für die einzelnen Tasks verfügbare Speicher, in <strong>de</strong>m unter<br />
an<strong>de</strong>rem lokale Programmvariablen abgelegt wer<strong>de</strong>n. Der voreingestellte Wert beträgt 5000 Bytes.<br />
Dieser Wert kann jedoch für Applikationen mit beson<strong>de</strong>rs umfangreichen Tabellen lokaler Variablen o<strong>de</strong>r rekursiven<br />
Algorithmen nicht ausreichen: Er muss in diesem Fall über die Benutzerschnittstelle <strong>de</strong>r CS8 erhöht wer<strong>de</strong>n.<br />
PROGRAMME<br />
Definition<br />
Ein Programm enthält eine Reihe von VAL3-Anweisungen, die auszuführen sind.<br />
Es besteht aus folgen<strong>de</strong>n Elementen:<br />
- einer Sequenz von Anweisungen: <strong>de</strong>n auszuführen<strong>de</strong>n VAL3-Anweisungen,<br />
- einer Gruppe von lokalen Variablen: <strong>de</strong>n programminternen Daten,<br />
- einer Gruppe von Parametern: <strong>de</strong>n Daten, die <strong>de</strong>m Programm beim Aufrufen geliefert wer<strong>de</strong>n.<br />
Programme dienen zur Zusammenfassung von Anweisungssequenzen, um sie an verschie<strong>de</strong>nen Stellen in einer<br />
Applikation verwen<strong>de</strong>n zu können. Neben <strong>de</strong>m geringeren Programmierungsaufwand wer<strong>de</strong>n die Applikationen<br />
dadurch übersichtlicher, was die Programmierung und Wartung erleichtert und die Lesbarkeit verbessert.<br />
Die Anzahl <strong>de</strong>r Programmanweisungen ist nur durch <strong>de</strong>n im System verfügbaren Speicherplatz begrenzt.<br />
Die Anzahl <strong>de</strong>r lokalen Variablen und Parameter ist nur durch <strong>de</strong>n Ausführungsspeicher <strong>de</strong>r Applikation begrenzt.<br />
Wie<strong>de</strong>reinsprung<br />
Die Programme erlauben <strong>de</strong>n Wie<strong>de</strong>reinsprung (Reentrantprogramme), d.h. ein Programm kann sich selbst rekursiv<br />
aufrufen (Anweisung call) o<strong>de</strong>r von mehreren Tasks gleichzeitig aufgerufen wer<strong>de</strong>n. Je<strong>de</strong>r Programmaufruf besitzt<br />
seine eigenen lokalen Variablen und Parameter.<br />
Programm start()<br />
Um die VAL3-Applikation zu starten, wird das Programm start() aufgerufen. Es kann keine Parameter besitzen.<br />
In diesem Programm befin<strong>de</strong>n sich alle zum Start <strong>de</strong>r Applikation erfor<strong>de</strong>rlichen Vorgänge: Initialisierung <strong>de</strong>r globalen<br />
Variablen, <strong>de</strong>r Ein-/Ausgänge, Starten <strong>de</strong>r Tasks <strong>de</strong>r Applikation....<br />
Die Applikation ist am En<strong>de</strong> <strong>de</strong>s start()-Programms noch nicht unbedingt been<strong>de</strong>t, da noch an<strong>de</strong>re Tasks dieser<br />
Applikation in <strong>de</strong>r Ausführung sein können.<br />
Das start()-Programm kann, wie je<strong>de</strong>s an<strong>de</strong>re Programm, in einem an<strong>de</strong>ren Programm aufgerufen wer<strong>de</strong>n (Anweisung<br />
call).<br />
Programm stop()<br />
Das Programm stop() wird am En<strong>de</strong> <strong>de</strong>r Ausführung <strong>de</strong>r VAL3-Applikation aufgerufen. Es kann keine Parameter<br />
besitzen.<br />
In diesem Programm fin<strong>de</strong>n sich im Allgemeinen alle zum korrekten Been<strong>de</strong>n <strong>de</strong>r Applikation erfor<strong>de</strong>rlichen Vorgänge:<br />
Reinitialisierung <strong>de</strong>r Ein-/Ausgänge, Been<strong>de</strong>n <strong>de</strong>r Tasks <strong>de</strong>r Applikation in einer bestimmten Reihenfolge....<br />
Das stop()-Programm kann, wie je<strong>de</strong>s an<strong>de</strong>re Programm, in einem an<strong>de</strong>ren Programm aufgerufen wer<strong>de</strong>n (Anweisung<br />
call): Das Aufrufen <strong>de</strong>s stop()-Programms führt nicht zum Abbruch <strong>de</strong>r Applikation.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 11 / 122
DATENTYP<br />
Definition<br />
Der Typ einer VAL3-Konstanten o<strong>de</strong>r -Variablen ist ein Merkmal, mit <strong>de</strong>m das System die diese enthalten<strong>de</strong>n<br />
Anweisungen und Programme steuern kann.<br />
Alle VAL3-Konstanten und -Variablen besitzen einen Typ. Damit ist beim Editieren eines Programms eine erste<br />
Überprüfung durch das System und die sofortige Erkennung bestimmter Programmierfehler möglich.<br />
Einfache Typen<br />
Die Sprache VAL3 unterstützt folgen<strong>de</strong> einfache Typen:<br />
- Typ bool: für boolesche Werte (true/false)<br />
- Typ num: für digitale Werte<br />
- Typ string: für Zeichenketten<br />
- Typ dio: für digitale Ein-/Ausgänge<br />
- Typ aio: für numerische Ein-/Ausgänge (analog o<strong>de</strong>r digital)<br />
- Typ sio: für Ein-/Ausgänge serieller Verbindungen und Ethernet-Socket<br />
Strukturierte Typen<br />
Ein strukturierter Typ enthält mehrere Datentypen, so genannte strukturierte Datenfel<strong>de</strong>r. Strukturierte Datenfel<strong>de</strong>r<br />
können mit ihrem Namen einzeln aufgerufen wer<strong>de</strong>n.<br />
Die Sprache VAL3 unterstützt folgen<strong>de</strong> strukturierte Typen:<br />
- Typ trsf: für kartesische Koordinatentransformationen<br />
- Typ frame: für das kartesische Koordinatensystem<br />
- Typ tool: für die am Roboter montierten Tools<br />
- Typ point: für die kartesischen Toolpositionen<br />
- Typ joint: für die Winkelpositionen <strong>de</strong>r Robotergelenke<br />
- Typ config: für die Roboterkonfigurationen<br />
- Typ m<strong>de</strong>sc: für die Bewegungsparameter <strong>de</strong>s Roboters<br />
KONSTANTEN<br />
Definition<br />
Eine Konstante ist ein Datenelement, das direkt und ohne vorherige Deklaration in einem VAL3-Programm festgelegt<br />
ist. Der Typ einer Konstante ist implizit durch das System vorgegeben.<br />
Konstanten einfachen Typs<br />
Die genaue Syntax einer Konstante einfachen Typs ist im betreffen<strong>de</strong>n Kapitel <strong>de</strong>r einfachen Typen angegeben.<br />
Zum Beispiel<br />
bool bBool<br />
num nPi<br />
string sString<br />
bBool = true<br />
nPi = 3.141592653<br />
sString = "Dies ist eine konstante Kette"<br />
Konstanten strukturierten Typs<br />
Der Wert einer Konstante strukturierten Typs ist durch die aufeinan<strong>de</strong>rfolgen<strong>de</strong>n Werte ihrer Fel<strong>de</strong>r festgelegt. Die<br />
Reihenfolge ist im Kapitel über die strukturierte Typen angegeben.<br />
12 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Zum Beispiel<br />
procedure dummy(trsf t, dio d)<br />
point p<br />
p = {{100, -50, 200, 0, 0, 0}, {sfree, efree, wfree}}<br />
call dummy({a+b, 2* c, 120, limit(c, 0, 90), 0, 0}, io:Ventil1)<br />
Konstantentabelle<br />
Eine Konstantentabelle muss für je<strong>de</strong>n einzelnen Eingang initialisiert wer<strong>de</strong>n.<br />
Zum Beispiel<br />
joint j[5 ]<br />
j[0] = {0, 0, 0, 0, 0, 0}<br />
j[1] = {90, 0, 90, 0, 0, 0}<br />
j[2] = {-90, 0, 90, 0, 0, 0}<br />
j[3] = {90, 0, 0, -90, 0, 0}<br />
j[4] = {-90, 0, 0, -90, 0, 0}<br />
VARIABLEN<br />
Definition<br />
Eine Variable ist ein Datenelement in einem Programm, das durch seinen Namen gekennzeichnet ist.<br />
Eine Variable ist <strong>de</strong>finiert durch:<br />
- ihren Namen: eine Zeichenkette<br />
- ihren Typ: einen <strong>de</strong>r oben beschriebenen VAL3-Typen<br />
- ihre Größe: z.B. die Anzahl <strong>de</strong>r Datenelemente in einer Tabelle<br />
- ihren Gültigkeitsbereich: das (die) zur Verwendung dieser Variablen berechtigte(n) Programm(e)<br />
Der Name einer Variablen ist eine Zeichenkette mit 1 bis 12 Zeichen von "a..zA..Z0..9_".<br />
Alle Variablen können wie Tabellen verwen<strong>de</strong>t wer<strong>de</strong>n. Einfache Variablen haben die Größe 1. Die Größe einer<br />
Variablen kann mittels <strong>de</strong>r Anweisung size() in Erfahrung gebracht wer<strong>de</strong>n.<br />
Gültigkeitsbereich einer Variablen<br />
Eine Variable kann folgen<strong>de</strong> Gültigkeitsbereiche haben:<br />
• global: Diese Variable kann von allen Programmen verwen<strong>de</strong>t wer<strong>de</strong>n<br />
• lokal: Diese Variable kann nur in <strong>de</strong>m Programm verwen<strong>de</strong>t wer<strong>de</strong>n, in <strong>de</strong>m sie <strong>de</strong>klariert wur<strong>de</strong><br />
Haben eine globale und eine lokale Variable <strong>de</strong>n gleichen Namen, wird das Programm, in <strong>de</strong>m die lokale Variable<br />
<strong>de</strong>klariert ist, die lokale Variable verwen<strong>de</strong>n und nicht auf die globale Variable zugreifen.<br />
Die Parameter eines Programms sind lokale Variablen, die nur in <strong>de</strong>m Programm, in <strong>de</strong>m sie <strong>de</strong>klariert wur<strong>de</strong>n,<br />
verwen<strong>de</strong>t wer<strong>de</strong>n können.<br />
Zugriff auf <strong>de</strong>n Wert einer Variablen<br />
Auf die Datenelemente einer Tabelle kann mit <strong>de</strong>m in Klammern gesetzten In<strong>de</strong>x zugegriffen wer<strong>de</strong>n ‘[‘ und ‘]’. Der<br />
In<strong>de</strong>x muss einen Wert zwischen 0 und (Größe-1) besitzen, sonst wird bei <strong>de</strong>r Ausführung eine Fehlermeldung<br />
generiert.<br />
Wenn kein In<strong>de</strong>x spezifiziert wur<strong>de</strong>, wird <strong>de</strong>r In<strong>de</strong>x 0 verwen<strong>de</strong>t: var[0] entspricht var.<br />
Die Fel<strong>de</strong>r von strukturierten Variablen sind mit einem ‘.’ gefolgt vom Namen <strong>de</strong>s Fel<strong>de</strong>s zugänglich.<br />
Wenn das Feld selbst strukturierten Typs ist, kann nicht direkt auf <strong>de</strong>ssen Fel<strong>de</strong>r zugegriffen wer<strong>de</strong>n.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 13 / 122
Zum Beispiel<br />
num a // a ist eine Variable vom Typ num mit <strong>de</strong>r Größe 1<br />
num b[10] // b ist eine Variable vom Typ num mit <strong>de</strong>r Größe 10<br />
trsf t<br />
point p<br />
a = 0 // Initialisierung einer einfachen Variable<br />
a[0] = 0 // Korrekt: entsprechend a = 0<br />
b[0] = 0 // Initialisierung <strong>de</strong>s ersten Datenelements <strong>de</strong>r Tabelle b<br />
b = 0 // Korrekt: entsprechend b[0] = 0<br />
b[5] = 5 // Initialisierung <strong>de</strong>s sechsten Datenelements <strong>de</strong>r Tabelle b<br />
b[5.13] = 7 // Korrekt: entsprechend b[5] = 7 (nur <strong>de</strong>r ganzzahlige Teil wird verwen<strong>de</strong>t)<br />
b[-1] = 0 // Fehler: In<strong>de</strong>x kleiner 0<br />
b[10] = 0 // Fehler: In<strong>de</strong>x zu groß<br />
t = p.trsf // Initialisierung von t<br />
p.trsf.x = 100 // Fehler: x ist nicht direkt zugänglich<br />
t.x = 100 // Initialisierung <strong>de</strong>s Fel<strong>de</strong>s x einer Variable trsf<br />
p.trsf = t // Initialisierung <strong>de</strong>s Fel<strong>de</strong>s trsf einer Variablen point<br />
"By value"-Parameter<br />
Bei einer "By Value"-Parameter-Übergabe erstellt das System eine lokale Variable und initialisiert diese mit <strong>de</strong>m Wert<br />
<strong>de</strong>r Variablen o<strong>de</strong>r <strong>de</strong>s Ausdrucks, <strong>de</strong>r vom aufrufen<strong>de</strong>n Programm geliefert wird.<br />
Die Variablen <strong>de</strong>s aufrufen<strong>de</strong>n Programms, die als By Value-Parameter verwen<strong>de</strong>t wer<strong>de</strong>n, bleiben unverän<strong>de</strong>rt, auch<br />
wenn das aufgerufene Programm <strong>de</strong>n Wert <strong>de</strong>s Parameters geän<strong>de</strong>rt hat.<br />
Eine Datentabelle kann nicht "by value" übergeben wer<strong>de</strong>n.<br />
Zum Beispiel:<br />
procedure dummy(num x) // x per By Value-Übergabe<br />
begin<br />
x=0<br />
putln(x) // ergibt 0<br />
end<br />
num a<br />
a=10<br />
putln(a) // ergibt 10<br />
call dummy(a) // ergibt 0<br />
putln(a) // ergibt 10: a wird von dummy() nicht geän<strong>de</strong>rt<br />
"By Reference"-Parameter<br />
Bei einer "By Reference"-Parameter-Übergabe arbeitet das Programm nicht mehr mit einer Kopie <strong>de</strong>s vom aufrufen<strong>de</strong>n<br />
Programm übergebenen Datenelements, son<strong>de</strong>rn mit <strong>de</strong>m Datenelement selbst, das nur lokal umbenannt wur<strong>de</strong>.<br />
Die Variablen <strong>de</strong>s aufrufen<strong>de</strong>n Programms, die als By Reference-Parameter verwen<strong>de</strong>t wer<strong>de</strong>n, än<strong>de</strong>rn ihren Wert,<br />
wenn das aufgerufene Programm <strong>de</strong>n Wert <strong>de</strong>s Parameters än<strong>de</strong>rt.<br />
Alle Elemente einer "By Reference" übergebenen Tabelle können benutzt und geän<strong>de</strong>rt wer<strong>de</strong>n. Wird ein Element einer<br />
Tabelle "By Reference" übergeben, so können dieses Element und alle ihm folgen<strong>de</strong>n Elemente benutzt und geän<strong>de</strong>rt<br />
wer<strong>de</strong>n. Der Parameter wird dann wie eine Tabelle betrachtet, die bei <strong>de</strong>m beim Aufruf übergebenen Element beginnt.<br />
Die Anweisung size() ermöglicht es, die effektive Größe eines Parameters in Erfahrung zu bringen.<br />
Wenn eine Konstante o<strong>de</strong>r ein Ausdruck "By reference" übergeben wur<strong>de</strong>, hat eine Zuweisung <strong>de</strong>s entsprechen<strong>de</strong>n<br />
Parameters keinen Effekt: <strong>de</strong>r Parameter behält <strong>de</strong>n Wert <strong>de</strong>r Konstanten o<strong>de</strong>r <strong>de</strong>s Ausdrucks bei.<br />
14 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Zum Beispiel:<br />
procedure dummy(num& x) // x per By Reference-Übergabe<br />
begin<br />
x=0<br />
putln(x) // ergibt 0<br />
end<br />
procedure element(num& x)<br />
begin<br />
x[3] = 0<br />
putln(size(x))<br />
end<br />
num a<br />
num b[10]<br />
a=10<br />
putln(a) // ergibt 10<br />
call dummy(a) // ergibt 0<br />
putln(a) // ergibt 0: a wird von dummy() geän<strong>de</strong>rt.<br />
b[2] = 2<br />
b[5] = 5<br />
call element(b[2]) // ergibt 8, die Elemente 0 und 1 von b wur<strong>de</strong>n nicht übergeben<br />
putln(b[5]) // ergibt 0: b[5] wird von element() geän<strong>de</strong>rt.<br />
ANWEISUNGEN ZUR ABLAUFSTEUERUNG<br />
Syntax<br />
// <br />
Bemerkung //<br />
Funktion<br />
Eine Zeile, die mit « // » beginnt, wird nicht berücksichtigt, das Programm geht auf die nächste Zeile weiter.<br />
Zum Beispiel<br />
// Dies ist ein Beispiel für eine Bemerkung<br />
Syntax<br />
call Programm([Parameter1][,Parameter2])<br />
Aufruf <strong>de</strong>s Unterprogramms call<br />
Funktion<br />
Führt das aufgerufene Programm mit <strong>de</strong>n angegebenen Parametern aus.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 15 / 122
Zum Beispiel<br />
// Ruft die Programme pick() und place() für i,j zwischen 1 und 10 auf.<br />
for i = 1 to 10<br />
for j = 1 to 10<br />
call pick (i, j)<br />
call place (i, j)<br />
endFor<br />
endFor<br />
Syntax<br />
return<br />
Rückkehr aus <strong>de</strong>m Unterprogramm return<br />
Funktion<br />
Das laufen<strong>de</strong> Programm wird sofort verlassen. Wenn das Programm durch einen call aufgerufen wor<strong>de</strong>n war, wird die<br />
Programmausführung im aufrufen<strong>de</strong>n Programm nach <strong>de</strong>m call fortgesetzt. An<strong>de</strong>rnfalls (z. B. wenn das<br />
Unterprogramm das Programm start() o<strong>de</strong>r <strong>de</strong>r Startpunkt für eine Task ist) wird die laufen<strong>de</strong> Task been<strong>de</strong>t.<br />
Anweisung if<br />
Syntax<br />
if <br />
<br />
[else<br />
]<br />
endIf<br />
Funktion<br />
Wenn die Überprüfung <strong>de</strong>r booleschen Bedingung Bedingung wahr (true) ergibt, wer<strong>de</strong>n alle eventuell nachfolgen<strong>de</strong>n<br />
Anweisungen bis zur Bedingung else o<strong>de</strong>r endIf überprüft.<br />
Wenn <strong>de</strong>r Ausdruck falsch (false) ist, wer<strong>de</strong>n die zwischen else und endIf liegen<strong>de</strong>n Anweisungen überprüft, sofern<br />
else vorhan<strong>de</strong>n ist. In je<strong>de</strong>m Fall wird die Ausführung <strong>de</strong>s Programms nach <strong>de</strong>r Anweisung endIf fortgesetzt.<br />
Parameter<br />
bool Bedingung zu überprüfen<strong>de</strong>r boolescher Ausdruck<br />
Zum Beispiel<br />
string s<br />
num a<br />
// s = "a=0" wenn a=0, sonst "a = ? "<br />
s = "a = ? "<br />
if a==0<br />
s = "a=0"<br />
endIf<br />
// s = "a=0" wenn a=0, sonst "a 0"<br />
s = "a = ? "<br />
if a==0<br />
s = "a = 0"<br />
else<br />
s = "a 0"<br />
endIf<br />
16 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Anweisung while<br />
Syntax<br />
while <br />
<br />
endWhile<br />
Funktion<br />
Die Anweisungen zwischen while und endWhile wer<strong>de</strong>n solange ausgeführt, wie die boolesche Bedingung<br />
Bedingung wahr (true) ist.<br />
Wenn die boolesche Bedingung Bedingung bei <strong>de</strong>r ersten Überprüfung nicht wahr ist, wer<strong>de</strong>n die Anweisungen<br />
zwischen while und endWhile nicht ausgeführt.<br />
Parameter<br />
bool Bedingung zu überprüfen<strong>de</strong>r boolescher Ausdruck<br />
Zum Beispiel<br />
dio dLampe<br />
// Bewirkt das Blinken eines Signals solange <strong>de</strong>r Roboter nicht stillsteht<br />
dLampe = false<br />
while (isSettled()==false)<br />
dLampe = ! dLampe // Bil<strong>de</strong>t <strong>de</strong>n Kehrwert für die dLampe: true false<br />
<strong>de</strong>lay(0.5) // Wartet ½ s<br />
endWhile<br />
dLampe = false<br />
Anweisung do ... until<br />
Syntax<br />
do<br />
<br />
until <br />
Funktion<br />
Die Anweisungen zwischen do und until wer<strong>de</strong>n solange ausgeführt, bis die boolesche Bedingung Bedingung wahr<br />
(true) ist.<br />
Die Anweisungen zwischen do und until wer<strong>de</strong>n ausgeführt, wenn die boolesche Bedingung Bedingung bei <strong>de</strong>r<br />
erstmaligen Überprüfung wahr ist.<br />
Parameter<br />
bool Bedingung zu überprüfen<strong>de</strong>r boolescher Ausdruck<br />
Zum Beispiel<br />
num a<br />
// Warten auf Betätigung <strong>de</strong>r Enter-Taste<br />
do<br />
a = get() // Warten auf Betätigen einer Taste<br />
until (a == 270) // Testet <strong>de</strong>n Co<strong>de</strong> <strong>de</strong>r Enter-Taste<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 17 / 122
Anweisung for<br />
Syntax<br />
for = to [step ]<br />
<br />
endFor<br />
Funktion<br />
Die Anweisungen zwischen for und endFor wer<strong>de</strong>n solange ausgeführt, bis Zähler <strong>de</strong>n spezifizierte Wert En<strong>de</strong><br />
überschreitet.<br />
Der Zähler wird auf <strong>de</strong>n Wert Anfang initialisiert. Wenn Anfang En<strong>de</strong> überschreitet, wer<strong>de</strong>n die Anweisungen<br />
zwischen for und endFor nicht ausgeführt. Bei je<strong>de</strong>m Iterationsschritt wird Zähler um <strong>de</strong>n Wert Schritt und die<br />
Anweisungen zwischen for und endFor wer<strong>de</strong>n, solange <strong>de</strong>r Zähler <strong>de</strong>n Wert En<strong>de</strong> nicht überschreitet, wie<strong>de</strong>rholt.<br />
Wenn Schritt positiv ist, hat <strong>de</strong>r Zähler En<strong>de</strong> dann überschritten, wenn er größer ist als En<strong>de</strong>. Wenn Schritt negativ<br />
ist, hat <strong>de</strong>r Zähler En<strong>de</strong> überschritten, wenn er kleiner ist als En<strong>de</strong>.<br />
Parameter<br />
num Zähler Variable <strong>de</strong>s Typs num, die als Zähler verwen<strong>de</strong>t wird<br />
num Anfang Numerischer Ausdruck zur Initialisierung <strong>de</strong>s Zählers<br />
num En<strong>de</strong> Numerischer Ausdruck zum Test <strong>de</strong>s Schleifenen<strong>de</strong>s<br />
[num Schritt] Numerischer Ausdruck zur Erhöhung <strong>de</strong>s Zählers<br />
Zum Beispiel<br />
num i<br />
joint jDest<br />
jDest = {0,0,0,0,0,0}<br />
// Dreht die Achse 1 von 10° in Schritten von je 10 Grad<br />
for i = 90 to -90 step -10<br />
jDest.j1 = i<br />
movej(jDest, flange, mNomSpeed)<br />
waitEndMove()<br />
endFor<br />
18 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Anweisung switch<br />
Syntax<br />
switch <br />
case [, ]<br />
<br />
break<br />
[case [, ]<br />
<br />
break ]<br />
[<strong>de</strong>fault<br />
<br />
break ]<br />
endSwitch<br />
Funktion<br />
Führt die Anweisungen für die spezifizierte Auswahl aus.<br />
Wenn für Auswahl ein nicht ganzzahliger Wert spezifiziert wur<strong>de</strong> o<strong>de</strong>r für eine Fall (Fall Test), wird die nächstliegen<strong>de</strong><br />
ganze Zahl verwen<strong>de</strong>t.<br />
Wenn kein Fall auf die spezifizierte Auswahl zutrifft, wer<strong>de</strong>n die Standardanweisungen ausgeführt, sofern vorhan<strong>de</strong>n.<br />
Wenn <strong>de</strong>r gleiche Wert für Fall mehrmals auftritt, wird nur das letzte Auftreten berücksichtigt.<br />
Parameter<br />
num Auswahl Variable numerischen Typs num zur Auswahl<br />
num Fall1 Numerische Konstante für <strong>de</strong>n Testfall<br />
num Fall2 Numerische Konstante für <strong>de</strong>n Testfall<br />
num Fall3 Numerische Konstante für <strong>de</strong>n Testfall<br />
num Fall4 Numerische Konstante für <strong>de</strong>n Testfall<br />
Zum Beispiel<br />
num nMenü<br />
string s<br />
// Testet, ob die Menütaste gedrückt ist<br />
nMenü = get()<br />
switch nMenü<br />
case 271<br />
s = "Menü 1"<br />
break<br />
case 272<br />
s= "Menü 2"<br />
break<br />
case 273, 274, 275, 276, 277, 278<br />
s = "Menü 3 à 8"<br />
break<br />
<strong>de</strong>fault<br />
s = "Diese Schaltfläche ist kein Menü"<br />
break<br />
endSwitch<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 19 / 122
Anweisungen<br />
Syntax<br />
num size()<br />
EINFACHE TYPEN<br />
num size(Variable)<br />
Funktion<br />
Liefert die Größe <strong>de</strong>r Variable.<br />
Wenn es sich bei Variable um einen "By Reference" übergebenen Programmparameter han<strong>de</strong>lt, so hängt ihre Größe<br />
von <strong>de</strong>m beim Aufruf <strong>de</strong>s Programms festgelegten In<strong>de</strong>x ab.<br />
Parameter<br />
Variable Variable beliebigen Typs<br />
Zum Beispiel<br />
num nTabelle[10]<br />
program printSize(num& nParamètre)<br />
begin<br />
putln(size(nParamètre))<br />
end<br />
call printSize(nTabelle) // ergibt 10<br />
call printSize(nTabelle[6]) // ergibt 4<br />
20 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
TYP BOOL<br />
Definition<br />
Variablen o<strong>de</strong>r Konstanten <strong>de</strong>s Typs bool können folgen<strong>de</strong> Werte annehmen:<br />
- true: wahr<br />
- false: falsch<br />
Der vorprogrammierte Wert für eine Variable <strong>de</strong>s Typs bool ist immer false.<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
bool = <br />
bool or<br />
<br />
bool and<br />
<br />
bool xor<br />
bool <br />
bool !=<br />
<br />
bool ==<br />
<br />
TYP NUM<br />
Definition<br />
Der Typ num stellt einen numerischen Wert mit etwa 14 signifikanten Stellen dar.<br />
Numerische Berechnungen erfolgen daher mit einer durch die 14 Stellen beschränkten Genauigkeit.<br />
Dies ist bei <strong>de</strong>r Prüfung <strong>de</strong>r Gleichheit zweier numerischer Werte zu berücksichtigen: Deshalb muss in <strong>de</strong>r Regel in<br />
einem Intervall geprüft wer<strong>de</strong>n.<br />
Zum Beispiel<br />
putln(sel(cos(90)==0,1,-1)) // ergibt -1<br />
putln(sel(abs(cos(90))
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
num = Weist Wert <strong>de</strong>r Variable Variable zu und überträgt <strong>de</strong>n<br />
Wert.<br />
bool != Überträgt true, wenn Wert1 ungleich Wert2 ist,<br />
an<strong>de</strong>rnfalls false.<br />
bool == Überträgt true, wenn Wert1 gleich Wert2 ist,<br />
an<strong>de</strong>rnfalls false.<br />
bool >= Überträgt true, wenn Wert1 größer gleich Wert2 ist,<br />
an<strong>de</strong>rnfalls false.<br />
bool > Überträgt true, wenn Wert1 größer Wert2 ist,<br />
an<strong>de</strong>rnfalls false.<br />
bool
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num asin()<br />
num asin(num Wert)<br />
Funktion<br />
Liefert die Inverse <strong>de</strong>s Sinus von Wert in Grad. Das Ergebnis liegt zwischen -90 und +90 Grad.<br />
Ist Wert größer als 1 o<strong>de</strong>r kleiner als -1, wird eine Fehlermeldung generiert.<br />
Parameter<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(asin(0.5)) // ergibt 30<br />
Syntax<br />
num cos()<br />
Funktion<br />
Liefert <strong>de</strong>n Cosinus von Winkel.<br />
Parameter<br />
num Winkel Winkel in Grad<br />
Zum Beispiel<br />
putln(cos(60)) // ergibt 0.5<br />
Syntax<br />
num acos()<br />
num cos(num Winkel)<br />
num acos(num Wert)<br />
Funktion<br />
Liefert die Inverse <strong>de</strong>s Cosinus von Wert in Grad. Das Ergebnis liegt zwischen 0 und 180 Grad.<br />
Ist Wert größer als 1 o<strong>de</strong>r kleiner als -1, wird eine Fehlermeldung generiert.<br />
Parameter<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(acos(0.5)) // ergibt 60<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 23 / 122
Syntax<br />
num tan()<br />
num tan(num Winkel)<br />
Funktion<br />
Liefert die Tangente von Winkel.<br />
Ist <strong>de</strong>r Winkel zu groß o<strong>de</strong>r zu klein (ungenügen<strong>de</strong> Rechengenauigkeit), wird eine Fehlermeldung generiert.<br />
Parameter<br />
num Winkel Winkel in Grad<br />
Zum Beispiel<br />
putln(tan(45)) // ergibt 1.0<br />
Syntax<br />
num atan()<br />
num atan(num Wert)<br />
Funktion<br />
Liefert die Inverse <strong>de</strong>s Tangens von Wert in Grad. Das Ergebnis liegt zwischen -90 und +90 Grad.<br />
Parameter<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(atan(1)) // ergibt 45<br />
Syntax<br />
num abs()<br />
Funktion<br />
Liefert <strong>de</strong>n Absolutbetrag von Wert.<br />
Parameter<br />
Zum Beispiel<br />
num abs(num Wert)<br />
num Wert Numerischer Ausdruck<br />
putln(sel(abs(45)==abs(-45),1,-1)) // ergibt 1<br />
24 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num sqrt()<br />
Funktion<br />
Liefert die Quadratwurzel von Wert.<br />
Ist Wert negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
num sqrt(num Wert)<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(sqrt(9)) // ergibt 3<br />
Syntax<br />
num exp()<br />
Funktion<br />
Liefert <strong>de</strong>n Exponentialwert vonWert.<br />
Ist Wert zu groß, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
Zum Beispiel<br />
num exp(num Wert)<br />
num Wert Numerischer Ausdruck<br />
putln(exp(1)) // ergibt 2.718282<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 25 / 122
Syntax<br />
num ln()<br />
num ln(num Wert)<br />
Funktion<br />
Liefert <strong>de</strong>n natürlichen Logarithmus von Wert.<br />
Ist Wert negativ o<strong>de</strong>r null, wird eine Fehlermeldung generiert.<br />
Parameter<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(ln(2.718281828)) // ergibt 1<br />
Syntax<br />
num log()<br />
num log(num Wert)<br />
Funktion<br />
Liefert <strong>de</strong>n Zehnerlogarithmus von Wert.<br />
Ist Wert negativ o<strong>de</strong>r null, wird eine Fehlermeldung generiert.<br />
Parameter<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(log(10)) // ergibt 1<br />
26 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num roundUp()<br />
Funktion<br />
Liefert <strong>de</strong>n nächstgrößeren ganzzahligen Wert.<br />
Parameter<br />
num roundUp(num Wert)<br />
num Wert Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(roundUp(7.8)) // Ergibt <strong>de</strong>n Wert 8<br />
putln(roundUp(-7.8)) // Ergibt <strong>de</strong>n Wert -7<br />
Syntax<br />
num roundDown()<br />
Funktion<br />
Liefert <strong>de</strong>n nächstkleineren ganzzahligen Wert.<br />
Parameter<br />
Zum Beispiel<br />
Syntax<br />
num round()<br />
Funktion<br />
Liefert <strong>de</strong>n nächstliegen<strong>de</strong>n ganzzahligen Wert.<br />
Parameter<br />
Zum Beispiel<br />
num roundDown(num Wert)<br />
num Wert Numerischer Ausdruck<br />
putln(roundDown(7.8)) // Ergibt <strong>de</strong>n Wert 7<br />
putln(roundDown(-7.8)) // Ergibt <strong>de</strong>n Wert -8<br />
num round(num Wert)<br />
num Wert Numerischer Ausdruck<br />
putln(round(7.8)) // Ergibt <strong>de</strong>n Wert 8<br />
putln(round(-7.8)) // Ergibt <strong>de</strong>n Wert -8<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 27 / 122
Syntax<br />
num min(, )<br />
Funktion<br />
Liefert <strong>de</strong>n kleineren Wert von x und y.<br />
Parameter<br />
num min(num x, num y)<br />
num x Numerischer Ausdruck<br />
num y Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(min(-1,10)) // Ergibt <strong>de</strong>n Wert -1<br />
Syntax<br />
num max(, )<br />
Funktion<br />
Liefert <strong>de</strong>n größeren Wert von x und y.<br />
Parameter<br />
Zum Beispiel<br />
Syntax<br />
num max(num x, num y)<br />
num x Numerischer Ausdruck<br />
num y Numerischer Ausdruck<br />
putln(max(-1,10)) // Ergibt <strong>de</strong>n Wert -10<br />
num limit(num Wert, num Mini, num Maxi)<br />
num limit(, , )<br />
Funktion<br />
Liefert <strong>de</strong>n durch die Werte Mini und Maxi begrenzten Wert.<br />
Parameter<br />
num Wert Numerischer Ausdruck<br />
num Mini Numerischer Ausdruck<br />
num Maxi Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(limit(30,-90,90)) // ergibt 30<br />
putln(limit(100,90,-90)) // ergibt 90<br />
putln(limit(-100,-90,90)) // ergibt -90<br />
28 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num sel(bool Bedingung, num Wert1, num Wert2)<br />
num sel(, , )<br />
Funktion<br />
Liefert Wert1, wenn Bedingung gleich true ist, ansonsten Wert2.<br />
Parameter<br />
bool Bedingung Boolescher Ausdruck<br />
num Wert1 Numerischer Ausdruck<br />
num Wert2 Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(sel(bFlag,a,b))<br />
// ist äquivalent zu<br />
if bFlag==true<br />
putln(a)<br />
else<br />
putln(b)<br />
endIf<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 29 / 122
TYP STRING<br />
Definition<br />
Variablen <strong>de</strong>s Typs Zeichenkette (string) dienen zur Speicherung von Texten.<br />
Zeichenketten können eine maximale Länge von 128 Zeichen haben.<br />
Der Typ string akzeptiert editierbare Zeichen ohne Akzente (ASCII-Co<strong>de</strong>s 32 bis 126) mit Ausnahme <strong>de</strong>s Zeichens ".<br />
Variablen <strong>de</strong>s Typs string wer<strong>de</strong>n vorprogrammiert auf <strong>de</strong>n Wert "" initialisiert (Länge null).<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
string = Weist <strong>de</strong>r Variablen Variable die Zeichenkette zu und<br />
überträgt Kette.<br />
bool != Liefert true, wenn Kette1 und Kette2 nicht i<strong>de</strong>ntisch<br />
sind, ansonsten false.<br />
bool == Liefert true, wenn Kette1 und Kette2 i<strong>de</strong>ntisch sind,<br />
ansonsten false.<br />
string +
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
string toNum(string Kette, num& Wert, bool& Bericht)<br />
string toNum(, , bool& Bericht)<br />
Funktion<br />
Bestimmt <strong>de</strong>n numerischen Wert am Anfang <strong>de</strong>r genannten Kette, und übergibt Kette, in <strong>de</strong>r alle Zeichen bis zum<br />
nächsten numerischen Wert entfernt wor<strong>de</strong>n sind.<br />
Befin<strong>de</strong>t sich am Anfang von Kette kein numerischer Wert, so wird Bericht auf false gesetzt und Wert wird nicht<br />
geän<strong>de</strong>rt, an<strong>de</strong>rnfalls wird rapport auf true gesetzt.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num& Wert Variable <strong>de</strong>s Typs num<br />
bool& Bericht Variable <strong>de</strong>s Typs bool<br />
Zum Beispiel<br />
num nVal<br />
bool bOk<br />
putln(toNum("10 20 30", nVal, bOk)) // Zeigt «20 30» an, nVal nimmt <strong>de</strong>n Wert 10, bOk <strong>de</strong>n Wert true<br />
putln(toNum("a10 20 30", nVal, bOk)) // Zeigt «a10 20 30» an, nVal bleibt unverän<strong>de</strong>rt, bOk ist false<br />
putln(toNum("10 end", nVal, bOk)) // Zeigt «» an, nVal nimmt <strong>de</strong>n Wert 10, bOk <strong>de</strong>n Wert true<br />
buffer = "+90 0.0 -7.6 17.3"<br />
do<br />
buffer = toNum(buffer, nVal, bOk)<br />
putln(nVal) // Zeigt nacheinan<strong>de</strong>r an: 90, 0, -7.6, 17.3<br />
until (bOk ! = true)<br />
Siehe auch<br />
string toString(string Format, num Wert)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 31 / 122
Syntax<br />
string chr()<br />
string chr(num ASCII-Co<strong>de</strong>)<br />
Funktion<br />
Übergibt das <strong>de</strong>r Zahl ASCII Wert-Co<strong>de</strong> entsprechen<strong>de</strong> Zeichen, wenn dieses als Typ string erkannt wird, an<strong>de</strong>rnfalls<br />
eine leere Zeichenkette.<br />
In <strong>de</strong>r nachstehen<strong>de</strong>n Tabelle sind die ASCII-Co<strong>de</strong>-Zahlen kleiner 128 zusammengestellt. Die grau dargestellten<br />
Zeichen wer<strong>de</strong>n nicht als Typ string erkannt:<br />
Parameter<br />
num Wert Ausdruck <strong>de</strong>s Typs num<br />
Zum Beispiel<br />
putln(chr(65)) // ergibt «A»<br />
Siehe auch<br />
num asc(string chaîne, num position)<br />
32 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num asc(, )<br />
num asc(string chaîne, num position)<br />
Funktion<br />
Gibt <strong>de</strong>n ASCII-Co<strong>de</strong> <strong>de</strong>s In<strong>de</strong>xzeichens Position wie<strong>de</strong>r.<br />
Wird -1, wenn Position negativ o<strong>de</strong>r größer als Kette ist.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Position Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(asc("A",0)) // ergibt 65<br />
Siehe auch<br />
string chr(num ASCII-Co<strong>de</strong>)<br />
string left(string Kette, num Größe)<br />
Syntax<br />
string left(, )<br />
Funktion<br />
Liefert die Größe ersten Zeichen von Kette. Wenn Größe größer ist als die Länge von Kette, liefert diese Anweisung<br />
die Kette.<br />
Ist Größe negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Größe Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(left("hello world",5)) // ergibt «hello»<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 33 / 122
Syntax<br />
string right(, )<br />
string right(string Kette, num Größe)<br />
Funktion<br />
Liefert die Größe letzten Zeichen von Kette. Wenn die spezifizierte Anzahl größer ist, als die Länge von Kette, liefert<br />
diese Anweisung Kette.<br />
Ist Größe negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Größe Numerischer Ausdruck<br />
Zum Beispiel<br />
putln(right("hello world",5)) // ergibt «world»<br />
Syntax<br />
string mid(string Kette, num Größe, num Position)<br />
string mid(, , )<br />
Funktion<br />
Liefert Größe Zeichen von Kette ab <strong>de</strong>m Zeichen Position bis zum En<strong>de</strong> von Kette.<br />
Sind Größe o<strong>de</strong>r Position negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Größe Numerischer Ausdruck<br />
num Position Stelle in <strong>de</strong>r Zeichenkette (von 0 bis 127)<br />
Zum Beispiel<br />
putln(mid(«hello wild world»,4,6)) // ergibt «wild»<br />
34 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
string insert(string Kette, string Einfügen, num Position)<br />
string insert(, , )<br />
Funktion<br />
Überträgt die Kette, in die Einfügen nach <strong>de</strong>m Zeichen an <strong>de</strong>r Stelle Position eingefügt wur<strong>de</strong>. Ist Position größer als<br />
die Größe von Kette, so wird Einfügen am En<strong>de</strong> von Kette angefügt. Das Ergebnis wird nach 80 Zeichen<br />
abgeschnitten.<br />
Ist Position negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
string Einfügen Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Position Stelle in <strong>de</strong>r Zeichenkette (von 0 bis 127)<br />
Zum Beispiel<br />
putln(insert("hello world","wild ",6)) // ergibt «hello wild world»<br />
Syntax<br />
string <strong>de</strong>lete(string Kette, num Größe, num Position)<br />
string <strong>de</strong>lete(, , )<br />
Funktion<br />
Überträgt Kette, in <strong>de</strong>r die Größe Zeichen nach <strong>de</strong>m Zeichen an <strong>de</strong>r Stelle Position gelöscht wur<strong>de</strong>n. Wenn Position<br />
größer ist als die Länge von Kette, überträgt die Anweisung Kette.<br />
Sind Größe o<strong>de</strong>r Position negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Größe Numerischer Ausdruck<br />
num Position Stelle in <strong>de</strong>r Zeichenkette (von 0 bis 127)<br />
Zum Beispiel<br />
string source<br />
putln(<strong>de</strong>lete(source="hello wild world",5,6)) // ergibt «hello world»<br />
putln(source) // ergibt «hello wild world»<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 35 / 122
num replace(string Kette, string Ersetzen, num Größe, num Position)<br />
Syntax<br />
string replace(, , , )<br />
Funktion<br />
Überträgt Kette, in <strong>de</strong>r die Größe Zeichen nach <strong>de</strong>m Zeichen an <strong>de</strong>r Stelle Position durch Ersetzen ersetzt wur<strong>de</strong>n.<br />
Wenn Position größer ist als die Länge von Kette, überträgt die Anweisung Kette.<br />
Sind Größe o<strong>de</strong>r Position negativ, wird eine Fehlermeldung generiert.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
string Ersetzen Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Größe Numerischer Ausdruck<br />
num Position Stelle in <strong>de</strong>r Zeichenkette (von 0 bis 127)<br />
Zum Beispiel<br />
putln(replace("hello ? world","wild",1,6)) // ergibt «hello wild world»<br />
Syntax<br />
num find(, )<br />
num find(string Kette1, string Kette2)<br />
Funktion<br />
Überträgt die Stelle (zwischen 0 und 127) <strong>de</strong>s ersten Zeichens beim erstmaligen Auftreten von Kette2 in Kette1. Wenn<br />
Kette2 nicht in Kette1 enthalten ist, liefert die Anweisung -1.<br />
Parameter<br />
string Kette1 Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
string Kette2 Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
Zum Beispiel<br />
putln(find("hello wild world","wild")) // ergibt 6<br />
36 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num len()<br />
Funktion<br />
Überträgt die Länge von Kette.<br />
Parameter<br />
num len(string Kette)<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
Zum Beispiel<br />
putln(len("hello wild world")) // ergibt 16<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 37 / 122
TYP DIO<br />
Definition<br />
Mit <strong>de</strong>m Typ dio kann eine VAL3-Variable einem digitalen Ein-/Ausgang <strong>de</strong>s Systems zugewiesen wer<strong>de</strong>n.<br />
Die im System <strong>de</strong>klarierten Ein-/Ausgänge können direkt in einer VAL3-Applikation verwen<strong>de</strong>t wer<strong>de</strong>n, ohne dass sie<br />
vorher in <strong>de</strong>r Applikation als lokale o<strong>de</strong>r globale Variable <strong>de</strong>klariert wer<strong>de</strong>n müssen. Der Typ dio dient daher vor allem<br />
zum Parametrieren eines Programms, in <strong>de</strong>m Ein- o<strong>de</strong>r Ausgänge verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Anweisungen, in <strong>de</strong>nen eine Variable <strong>de</strong>s Typs dio verwen<strong>de</strong>t wird, die nicht einem im System <strong>de</strong>klarierten Ein-/<br />
Ausgang zugewiesen wur<strong>de</strong>, bewirken eine Fehlermeldung.<br />
Eine Variable <strong>de</strong>s Typs dio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung,<br />
wenn sie ohne Zuweisung verwen<strong>de</strong>t wird.<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
bool = <br />
bool = <br />
bool != <br />
bool != <br />
bool == <br />
Ordnet <strong>de</strong>n Status von Ein-/Ausgang <strong>de</strong>m Ausgang zu und<br />
überträgt diesen Status. Wenn Ausgang keinem digitalen<br />
Ausgang <strong>de</strong>s Systems zugewiesen ist, wird eine<br />
Fehlermeldung erzeugt.<br />
Weist Bedingung <strong>de</strong>m Status <strong>de</strong>s Ausgang zu und überträgt<br />
Bedingung. Wenn Ausgang keinem digitalen Ausgang <strong>de</strong>s<br />
Systems zugewiesen ist, wird eine Fehlermeldung erzeugt.<br />
Überträgt true, wenn Eingang1 und Eingang2 nicht <strong>de</strong>n<br />
gleichen Status haben, ansonsten false.<br />
Überträgt true, wenn <strong>de</strong>r Status <strong>de</strong>s Eingang nicht gleich<br />
Bedingung ist, ansonsten false.<br />
Überträgt true, wenn <strong>de</strong>r Status <strong>de</strong>s Eingang gleich<br />
Bedingung ist, ansonsten false.<br />
bool == Überträgt true, wenn Eingang1 und Eingang2 <strong>de</strong>n gleichen<br />
Status haben, ansonsten false.<br />
38 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Anweisungen<br />
Syntax<br />
void dioLink(, )<br />
void dioLink(dio& Variable, dio Quelle)<br />
Funktion<br />
Weist Variable <strong>de</strong>m Ein-/Ausgang <strong>de</strong>s Systems, an <strong>de</strong>m Quelle angeschlossen ist, zu.<br />
Wenn Quelle ein im System geschützter Ein-/Ausgang ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
dio& Variable Variable <strong>de</strong>s Typs digitaler Ein-/Ausgang<br />
dio Quelle Ausdruck <strong>de</strong>s Typs dio<br />
Zum Beispiel<br />
dio dZange1<br />
dio dZange2<br />
dioLink(dZange1, io:Ventil1) // Verbin<strong>de</strong>t dZange1 mit <strong>de</strong>m Ein-/Ausgang <strong>de</strong>s Systems Ventil1<br />
dioLink(dZange2, dZange1) // Verbin<strong>de</strong>t dZange2 mit <strong>de</strong>m Ein-/Ausgang von dZange1, und somit<br />
mit Ventil1<br />
dioLink(dZange1, io:Ventil2) // dZange2 ist nun mit Ventil2 und dZange1 immer noch mit<br />
Ventil1 verbun<strong>de</strong>n<br />
Syntax<br />
num dioGet()<br />
num dioGet(dio dTabelle)<br />
Funktion<br />
Übergibt <strong>de</strong>n Zahlenwert <strong>de</strong>r dTabelle von dio, welcher wie eine ganze Zahl in Binärschreibweise gelesen wird, das<br />
heißt: dTabelle[0]+2 dTabelle[1]+4 dTabelle[2]+...+2 k dTabelle[k], o<strong>de</strong>r dTabelle[i] = 1 wenn dTabelle[i]<br />
gleich true ist, an<strong>de</strong>renfalls 0.<br />
Ist ein Element <strong>de</strong>r dTabelle nicht an einem Ein-/Ausgang <strong>de</strong>s Systems angeschlossen, so wird ein Ausführungsfehler<br />
erzeugt.<br />
Parameter<br />
dio nTabelle Ausdruck <strong>de</strong>s Typs dio<br />
Zum Beispiel<br />
dio dCo<strong>de</strong>[4]<br />
dCo<strong>de</strong>[0] = false<br />
dCo<strong>de</strong>[1] = false<br />
dCo<strong>de</strong>[2] = false<br />
dCo<strong>de</strong>[3] = true<br />
putln(dioGet(dCo<strong>de</strong>)) // ergibt 10 = 0 + 2 1 + 4 0 + 8 1<br />
Siehe auch<br />
num dioSet(dio dTabelle, num Wert)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 39 / 122
Syntax<br />
num dioSet(, )<br />
num dioSet(dio dTabelle, num Wert)<br />
Funktion<br />
Ordnet <strong>de</strong>n binär geschriebenen ganzzahligen Teil von Wert <strong>de</strong>n digitalen Ein-/Ausgängen <strong>de</strong>r dTabelle zu und<br />
übergibt <strong>de</strong>n tatsächlich zugeordneten Wert, das heißt:<br />
dTabelle[0]+2 dTabelle[1]+4 dTabelle[2]+...+2 k dTabelle[k], o<strong>de</strong>r dTabelle[i] = 1 wenn dTabelle[i] gleich<br />
true ist, an<strong>de</strong>renfalls 0.<br />
Ist ein Element <strong>de</strong>r dTabelle keinem Ausgang <strong>de</strong>s Systems zugeordnet, wird ein Ausführungsfehler erzeugt.<br />
Parameter<br />
dio dTabelle Ausdruck <strong>de</strong>s Typs dio<br />
num Wert Ausdruck <strong>de</strong>s Typs num<br />
Zum Beispiel<br />
dio dCo<strong>de</strong>[4]<br />
? dioSet(dCo<strong>de</strong>, 10) // ergibt 10 = 0 + 2 1 + 4 0 + 8 1<br />
? dioSet(dCo<strong>de</strong>, 26) // ergibt 10, da co<strong>de</strong> nicht ausreicht, um 26 vollständig in binär<br />
aufzunehmen<br />
Siehe auch<br />
num dioGet(dio dTabelle)<br />
40 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
TYP AIO<br />
Definition<br />
Der Typ aio ermöglicht es, eine Variable VAL3 einem numerischen Ein-/Ausgang (digital o<strong>de</strong>r analog) <strong>de</strong>s Systems<br />
zuzuordnen.<br />
Die im System <strong>de</strong>klarierten Ein-/Ausgänge können direkt in einer VAL3-Applikation verwen<strong>de</strong>t wer<strong>de</strong>n, ohne dass sie<br />
vorher in <strong>de</strong>r Applikation als lokale o<strong>de</strong>r globale Variable <strong>de</strong>klariert wer<strong>de</strong>n müssen. Der Typ aio dient daher vor allem<br />
zum Parametrieren eines Programms, in <strong>de</strong>m Ein- o<strong>de</strong>r Ausgänge verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Anweisungen, in <strong>de</strong>nen eine Variable <strong>de</strong>s Typs aio verwen<strong>de</strong>t wird, die nicht einem im System <strong>de</strong>klarierten Ein-/<br />
Ausgang zugewiesen wur<strong>de</strong>, bewirken eine Fehlermeldung.<br />
Eine Variable <strong>de</strong>s Typs aio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung,<br />
wenn sie ohne Zuweisung verwen<strong>de</strong>t wird.<br />
Anweisungen<br />
Syntax<br />
void aioLink(, )<br />
void aioLink(aio& Variable, aio Quelle)<br />
Funktion<br />
Weist Variable <strong>de</strong>m Ein-/Ausgang <strong>de</strong>s Systems, an <strong>de</strong>m Quelle angeschlossen ist, zu.<br />
Wenn Quelle ein im System geschützter Ein-/Ausgang ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
aio& Variable Variable <strong>de</strong>s Typs aio<br />
aio Quelle Ausdruck <strong>de</strong>s Typs aio<br />
Zum Beispiel<br />
aio aCapteur1<br />
aio aCapteur2<br />
aioLink(aCapteur1, io:système1) // Verbin<strong>de</strong>t aCapteur1 mit <strong>de</strong>m Ein-/Ausgang <strong>de</strong>s Systems système1<br />
aioLink(aCapteur2, aCapteur1) // Verbin<strong>de</strong>t aCapteur2 mit <strong>de</strong>m Ein-/Ausgang von aCapteur1, und somit mit<br />
système1<br />
aioLink(aCapteur1, io:système2) // aCapteur2 ist nun mit système2 und aCapteur1 immer noch mit<br />
système1 verbun<strong>de</strong>n.<br />
Syntax<br />
num aioGet()<br />
num aioGet(aio Eingang)<br />
Funktion<br />
Übersen<strong>de</strong>t <strong>de</strong>n numerischen Wert von Eingang.<br />
Ist Eingang nicht mit einem Ein-/Ausgang <strong>de</strong>s Systems verbun<strong>de</strong>n, so wird ein Ausführungsfehler erzeugt.<br />
Parameter<br />
aio Tabelle Ausdruck <strong>de</strong>s Typs aio<br />
Zum Beispiel<br />
aio aCapteur<br />
putln(aioGet(aCapteur)) // zeigt <strong>de</strong>n aktuellen Wert <strong>de</strong>s Sensors an<br />
Siehe auch<br />
num aioSet(aio Ausgang, num Wert)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 41 / 122
Syntax<br />
num aioSet(, )<br />
num aioSet(aio Ausgang, num Wert)<br />
Funktion<br />
Ordnet Wert <strong>de</strong>n Wert von Ausgang zu und sen<strong>de</strong>t Wert zurück.<br />
Ist Ausgang mit keinem Ausgang <strong>de</strong>s Systems verbun<strong>de</strong>n, so wird ein Ausführungsfehler erzeugt.<br />
Parameter<br />
aio& Ausgang Ausdruck <strong>de</strong>s Typs aio<br />
num Wert Ausdruck <strong>de</strong>s Typs num<br />
Zum Beispiel<br />
aio aComman<strong>de</strong><br />
putln(aioSet(aComman<strong>de</strong>, -12.3)) // ergibt -12.3<br />
Siehe auch<br />
num aioGet(aio Eingang)<br />
42 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
TYP SIO<br />
Definition<br />
Der Typ sio ermöglicht es, eine VAL3-Variable einem seriellen Ein-/Ausgang <strong>de</strong>s Systems o<strong>de</strong>r einer Verbindung per<br />
Ethernet-Socket zuzuordnen. Ein sio-Ein-/Ausgang ist gekennzeichnet durch:<br />
• Im System <strong>de</strong>finierte, <strong>de</strong>m Typ <strong>de</strong>r Kommunikation eigene Parameter<br />
• Ein Zeichenketten-Endzeichen, um die Verwendung <strong>de</strong>s Typs string zu ermöglichen<br />
• Eine Kommunikations-Wartefrist<br />
Die seriellen Ein-/Ausgänge <strong>de</strong>s Systems sind ständig aktiviert. Die Verbindungen per Ethernet-Socket wer<strong>de</strong>n beim<br />
ersten Lese-/Schreibzugriff durch ein VAL3-Programm aktiviert. Bei Beendigung <strong>de</strong>r VAL3-Anwendung, wer<strong>de</strong>n die<br />
Verbindungen per Ethernet-Socket automatisch <strong>de</strong>aktiviert.<br />
Die im System erklärten Ein-/Ausgänge sind in einer Applikation <strong>de</strong>s Typs VAL3 direkt verwendbar, ohne dass sie in<br />
<strong>de</strong>r Applikation als globale o<strong>de</strong>r lokale Variable erklärt wer<strong>de</strong>n müssen. Der Typ sio dient daher vor allem zum<br />
Parametrieren eines Programms, in <strong>de</strong>m Ein- o<strong>de</strong>r Ausgänge verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Anweisungen, in <strong>de</strong>nen eine Variable <strong>de</strong>s Typs sio verwen<strong>de</strong>t wird, die nicht einem im System <strong>de</strong>klarierten Ein-/<br />
Ausgang zugewiesen wur<strong>de</strong>, bewirken eine Fehlermeldung.<br />
Eine Variable <strong>de</strong>s Typs sio ist nicht von vornherein einem Ein-/Ausgang zugewiesen und führt zu einer Fehlermeldung,<br />
wenn sie ohne Zuweisung verwen<strong>de</strong>t wird.<br />
Operatoren<br />
Wird die Kommunikations-Wartefrist beim Lesen o<strong>de</strong>r Schreiben eines seriellen Ein-/Ausgangs erreicht, so wird ein<br />
Ausführungsfehler erzeugt.<br />
string = Schreibt nacheinan<strong>de</strong>r in Ausgang die Zeichen von<br />
Angabe, gefolgt vom Zeichenketten-Endzeichen, und<br />
übergibt Angabe.<br />
num = Schreibt in Ausgang die Angabe nähestliegen<strong>de</strong><br />
ganze Zahl, Modulo 256, und übergibt <strong>de</strong>n tatsächlich<br />
übermittelten Wert.<br />
num = Liest ein Zeichen in Eingang und ordnet Angabe <strong>de</strong>n<br />
ASCII-Co<strong>de</strong> dieses Zeichens zu.<br />
string = Liest in Eingang eine Zeichenkette und ordnet dieser<br />
Angabe zu. Mit <strong>de</strong>m Typ string nicht kompatible<br />
Zeichen wer<strong>de</strong>n außer Acht gelassen. Die<br />
Zeichenkette en<strong>de</strong>t, wenn das Zeichenketten-<br />
Endzeichen gelesen wird, o<strong>de</strong>r wenn Angabe die<br />
maximale Größe <strong>de</strong>s Typs string (128 Zeichen)<br />
erreicht hat. Das Zeichenketten-Endzeichen wird<br />
nicht in Angabe übertragen.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 43 / 122
Anweisungen<br />
Syntax<br />
void sioLink(, )<br />
void sioLink(sio& Variable, sio Quelle)<br />
Funktion<br />
Verbin<strong>de</strong>t Variable mit <strong>de</strong>m seriellen Ein-/Ausgang <strong>de</strong>s Systems, an <strong>de</strong>m Quelle angeschlossen ist.<br />
Wenn Quelle ein im System geschützter Ein-/Ausgang ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
sio& Variable Variable <strong>de</strong>s Typs sio<br />
sio Quelle Ausdruck <strong>de</strong>s Typs sio<br />
Zum Beispiel<br />
sio sCapteur1<br />
sio sCapteur2<br />
sioLink(sCapteur1, io: serial1) // Verbin<strong>de</strong>t sCapteur1 mit <strong>de</strong>m Ein-/Ausgang <strong>de</strong>s Systems serial1<br />
sioLink(sCapteur2, sCapteur1) // Verbin<strong>de</strong>t sCapteur2 mit <strong>de</strong>m Ein-/Ausgang von sCapteur1, und<br />
somit mit serial1<br />
sioLink(sCapteur2, io: serial1) // Verbin<strong>de</strong>t sCapteur2 mit serial1, sCapteur1 ist weiterhin mit<br />
serial1 verbun<strong>de</strong>n<br />
Syntax<br />
num clearBuffer()<br />
num clearBuffer(sio Eingang)<br />
Funktion<br />
Leert <strong>de</strong>n Lesepuffer von Eingang und teilt die Anzahl <strong>de</strong>r so gelöschten Zeichen mit.<br />
Bei Verbindungen per Ethernet-Socket, übernimmt clearBuffer die Socket-Deaktivierung, falls diese schon<br />
stattgefun<strong>de</strong>n hat, mel<strong>de</strong>t clearBuffer -1.<br />
Wenn Eingang keiner seriellen Verbindung o<strong>de</strong>r Ethernet-Socket zugewiesen ist, wird ein Ausführungsfehler erzeugt.<br />
num sioGet(sio Eingang, num& Daten)<br />
Syntax<br />
num sioGet(,)<br />
Funktion<br />
Liest eine Zeichentabelle in Eingang und teilt die Anzahl <strong>de</strong>r gelesenen Zeichen mit. Der Lesevorgang wird<br />
been<strong>de</strong>t, wenn die Tabelle Angabe voll o<strong>de</strong>r <strong>de</strong>r Eingangs-Lesepuffer leer ist.<br />
Bei Verbindungen per Ethernet-Socket versucht sioGet zuerst die Verbindung herzustellen, wenn diese noch<br />
nicht aktiviert wur<strong>de</strong>. Nach <strong>de</strong>m Erreichen <strong>de</strong>r Kommunikations-Wartefrist eines Eingangs mel<strong>de</strong>t sioGet -1.<br />
Wenn die Verbindung aktiviert ist, aber keine Daten im Eingangs-Lesepuffer vorhan<strong>de</strong>n sind, wartet sioGet<br />
solange, bis Daten empfangen wer<strong>de</strong>n o<strong>de</strong>r die Kommunikations-Wartefrist abgelaufen ist.<br />
Wenn Eingang keiner seriellen Verbindung o<strong>de</strong>r Ethernet-Socket zugewiesen ist o<strong>de</strong>r Daten keine VAL3-<br />
Variable ist, wird ein Ausführungsfehler erzeugt.<br />
44 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num sioSet(,)<br />
num sioSet(sio Ausgang, num& Daten)<br />
Funktion<br />
Schreibt eine Zeichentabelle in Ausgang und teilt die Anzahl <strong>de</strong>r geschriebenen Zeichen mit. Die digitalen Werte<br />
wer<strong>de</strong>n vor <strong>de</strong>r Übertragung in ganze Zahlen zwischen 0 und 255 umgewan<strong>de</strong>lt, dabei wird jeweils die<br />
nähestliegen<strong>de</strong> ganze Zahl Modulo 256 verwen<strong>de</strong>t.<br />
Bei Verbindungen per Ethernet-Socket versucht sioSet zuerst die Verbindung herzustellen, wenn diese noch<br />
nicht aktiviert wur<strong>de</strong>. Nach <strong>de</strong>m Erreichen <strong>de</strong>r Kommunikations-Wartefrist eines Ausgangs mel<strong>de</strong>t sioSet -1. Die<br />
Anzahl <strong>de</strong>r geschriebenen Zeichen kann unter <strong>de</strong>r Größe von Daten liegen, wenn ein Kommunikationsfehler<br />
ent<strong>de</strong>ckt wur<strong>de</strong>.<br />
Wenn Ausgang keiner seriellen Verbindung o<strong>de</strong>r Ethernet-Socket zugewiesen ist, wird ein Ausführungsfehler<br />
erzeugt.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 45 / 122
BENUTZERSCHNITTSTELLE<br />
Bedienerseite<br />
Die über die Benutzerschnittstelle VAL3 eingegebenen Anweisungen erlauben:<br />
- die Anzeige von Meldungen auf <strong>de</strong>m Handbediengerät (MCP) für diese Applikation<br />
- die Erfassung <strong>de</strong>r Eingaben auf <strong>de</strong>r Tastatur <strong>de</strong>s MCP<br />
Bedienerseite<br />
Die Bedienerseite hat 14 Zeilen mit je 40 Zeichen. Die letzte Zeile kann zur Erstellung von Menüs mit zugeordneter<br />
Taste verwen<strong>de</strong>t wer<strong>de</strong>n. Eine weitere Zeile steht zur Anzeige eines Titels zur Verfügung.<br />
Anweisungen<br />
void userPage(), void userPage(bool fix)<br />
Syntax<br />
void userPage ()<br />
void userPage ()<br />
Funktion<br />
Bewirkt die Anzeige <strong>de</strong>r Bedienerseite auf <strong>de</strong>m Display <strong>de</strong>s MCP.<br />
Wenn <strong>de</strong>r Parameter fix true ist, kann <strong>de</strong>r Bediener nur auf die Bedienerseite zugreifen sowie über <strong>de</strong>n Shortcut "Shift<br />
User" auf die Seite Profilän<strong>de</strong>rung. Wenn diese Seite angezeigt wird, kann die Anwendung mit <strong>de</strong>r Taste "Stop"<br />
gestoppt wer<strong>de</strong>n, falls das aktuelle Benutzerprofil dies erlaubt.<br />
Hat <strong>de</strong>r Parameter <strong>de</strong>n Wert false, so sind auch die an<strong>de</strong>ren CS8-Seiten zugänglich.<br />
46 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
void gotoxy(, )<br />
void gotoxy(num x, num y)<br />
Funktion<br />
Bewegt <strong>de</strong>n Cursor <strong>de</strong>r Bedienerseite auf die Koordinaten (x, y). Die linke obere Ecke hat die Koordinaten (0,0), die<br />
rechte untere Ecke (39, 13).<br />
Auf die Abszisse x wird Modulo 40 angewandt. Für die Ordinate y gilt Modulo 14.<br />
Parameter<br />
num x Abszisse <strong>de</strong>s Cursors (von 0 bis 39)<br />
num y Ordinate <strong>de</strong>s Cursors (von 0 bis 13)<br />
Siehe auch<br />
void cls()<br />
Syntax<br />
void cls()<br />
Funktion<br />
Löscht die Bedienerseite und bewegt <strong>de</strong>n Cursor auf (0,0).<br />
Siehe auch<br />
void gotoxy(num x, num y)<br />
void cls()<br />
void put() void putln()<br />
Syntax<br />
void put()<br />
void put()<br />
void putln()<br />
void putln()<br />
Funktion<br />
Zeigt auf <strong>de</strong>r Bedienerseite an <strong>de</strong>r Stelle <strong>de</strong>s Cursors die Kette o<strong>de</strong>r <strong>de</strong>n spezifizierten Wert an (mit 3 Dezimalstellen).<br />
Der Cursor wird anschließend auf das <strong>de</strong>m letzten Zeichen <strong>de</strong>r angezeigten Meldung folgen<strong>de</strong> Zeichen weiterbewegt<br />
(Anweisung put), o<strong>de</strong>r auf das erste Zeichen <strong>de</strong>r nächsten Zeile (Anweisung putln).<br />
Beim Erreichen <strong>de</strong>s Zeilenen<strong>de</strong>s, wird die Anzeige auf <strong>de</strong>r nächsten Zeile fortgesetzt.<br />
Am Seitenen<strong>de</strong> verschiebt sich die Anzeige <strong>de</strong>r Benutzerseite eine Zeile nach oben.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Wert Numerischer Ausdruck<br />
Siehe auch<br />
void popUpMsg(string Kette)<br />
void logMsg(string Kette)<br />
void title(string Kette)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 47 / 122
Syntax<br />
void title()<br />
void title(string Kette)<br />
Funktion<br />
Än<strong>de</strong>rt <strong>de</strong>n Titel <strong>de</strong>r Bedienerseite.<br />
Die aktuelle Position <strong>de</strong>s Cursors wird durch die Anweisung title() nicht geän<strong>de</strong>rt.<br />
Parameter<br />
string Kette Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num get()<br />
Syntax<br />
num get()<br />
num get()<br />
num get()<br />
Funktion<br />
Erfasst eine in die Tastatur <strong>de</strong>r Konsole eingegebene Zeichenkette, eine Zahl o<strong>de</strong>r eine Taste.<br />
Kette o<strong>de</strong>r Wert wird an <strong>de</strong>r aktuellen Position <strong>de</strong>s Cursors angezeigt und kann vom Benutzer geän<strong>de</strong>rt wer<strong>de</strong>n. Die<br />
Eingabe wird mit einer Menütaste, mit Return o<strong>de</strong>r Esc been<strong>de</strong>t.<br />
Die Anweisung überträgt <strong>de</strong>n Co<strong>de</strong> <strong>de</strong>r Taste, mit <strong>de</strong>r die Eingabe been<strong>de</strong>t wur<strong>de</strong>.<br />
Mit <strong>de</strong>r Return- o<strong>de</strong>r einer Menütaste wird die Variable Kette o<strong>de</strong>r Wert aktualisiert. Mit <strong>de</strong>r Esc-Taste bleibt sie<br />
unverän<strong>de</strong>rt.<br />
Wenn kein Parameter übertragen wur<strong>de</strong>, wartet die Anweisung get() auf einen beliebigen Tastendruck und sen<strong>de</strong>t<br />
ihren Co<strong>de</strong> zurück. Die gedrückte Taste wird nicht angezeigt.<br />
Die aktuelle Position <strong>de</strong>s Cursors wird durch die Anweisung get() nicht geän<strong>de</strong>rt.<br />
Ohne Shift Mit Shift<br />
3 Caps Space 3 Caps Space<br />
283 - 32 Move 283 - 32 Move<br />
2 Shift Esc Help<br />
Ret.<br />
-<br />
Run 2 Shift Esc Help<br />
Ret.<br />
-<br />
Run<br />
282 - 255 - 270 - 282 - 255 - 270 -<br />
Menu Tab Up Bksp Stop Menu UnTab PgUp Bksp Stop<br />
- 259 261 263 - - 260 262 263 -<br />
1 User Left Down Right 1 User Home PgDn End<br />
281 - 264 266 268 281 - 265 267 269<br />
Menüs (mit und ohne Shift):<br />
F1 F2 F3 F4 F5 F6 F7 F8<br />
271 272 273 274 275 276 277 278<br />
48 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Parameter<br />
Zum Beispiel<br />
Siehe auch<br />
num getKey()<br />
Bei Standardtasten wird <strong>de</strong>r ASCII-Co<strong>de</strong> <strong>de</strong>s betreffen<strong>de</strong>n Zeichens zurückgesandt:<br />
Ohne Shift<br />
q w e r t y u i o p<br />
113 119 101 114 116 121 117 105 111 112<br />
a s d f g h j k l <<br />
97 115 100 102 103 104 1<strong>06</strong> 107 108 60<br />
z x c v b n m . , =<br />
122 120 99 118 98 110 109 46 44 61<br />
Mit Shift<br />
7 8 9 + * ; ( ) [ ]<br />
55 56 57 43 42 59 40 41 91 93<br />
4 5 6 - / ? : ! { }<br />
52 53 54 45 47 63 58 33 123 125<br />
1 2 3 0 " % - . , ><br />
49 50 51 48 34 37 95 46 44 62<br />
Mit doppeltem Shift<br />
Q W E R T Y U I O P<br />
81 87 69 82 84 89 85 73 79 80<br />
A S D F G H J K L }<br />
65 83 68 70 71 72 74 75 76 125<br />
Z X C V B N M $ \ =<br />
90 88 67 86 66 78 77 36 92 61<br />
string& Kette Variable <strong>de</strong>s Typs string<br />
num& Wert Variable <strong>de</strong>s Typs num<br />
num nValeur<br />
num nKey<br />
// Wartet auf die Return-Taste zum Validieren <strong>de</strong>r Eingabe<br />
do<br />
nKey = get (nValeur)<br />
until (nKey == 270)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 49 / 122
Syntax<br />
num getKey()<br />
num getKey()<br />
Funktion<br />
Erfasst <strong>de</strong>n Wert einer Taste <strong>de</strong>r Pult-Tastatur. Liefert <strong>de</strong>n Co<strong>de</strong> <strong>de</strong>r seit <strong>de</strong>m letzten Aufruf von getKey() zuletzt<br />
gedrückten Taste. Wur<strong>de</strong> seit<strong>de</strong>m keine Taste gedrückt, so wird <strong>de</strong>r Co<strong>de</strong> -1 übergeben.<br />
Im Gegensatz zur Anweisung get() übergibt die Anweisung getKey() <strong>de</strong>n Wert sofort.<br />
Die gedrückte Taste wird nicht angezeigt und die aktuelle Cursorposition wird nicht geän<strong>de</strong>rt.<br />
Zum Beispiel<br />
// Anzeige <strong>de</strong>r Systemuhr bis zum Drücken einer beliebigen Taste<br />
getKey() // Neuinitialisierung <strong>de</strong>s Co<strong>de</strong>s <strong>de</strong>r zuletzt gedrückten<br />
Taste<br />
while (getKey()== -1)<br />
gotoxy(0,0)<br />
put(toString(«», clock()* 10))<br />
endWhile<br />
Siehe auch<br />
num get()<br />
bool isKeyPressed(nom co<strong>de</strong>)<br />
Syntax<br />
bool isKeyPressed()<br />
bool isKeyPressed(nom co<strong>de</strong>)<br />
Funktion<br />
Liefert <strong>de</strong>n Zustand <strong>de</strong>r spezifizierten Taste durch ihren Co<strong>de</strong> (siehe get()), true bei gedrückter Taste, ansonsten false.<br />
Siehe auch<br />
num getKey()<br />
Syntax<br />
void popUpMsg()<br />
void popUpMsg(string Kette)<br />
Funktion<br />
Zeigt Kette in einem "popup"-Fenster über <strong>de</strong>m aktuellen MCP-Fenster an. Dieses Fenster bleibt so lange angezeigt,<br />
bis es im Menü mit Ok bestätigt o<strong>de</strong>r die Esc-Taste gedrückt wird.<br />
Siehe auch<br />
void userPage(), void userPage(bool fix)<br />
void put() void putln()<br />
50 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
void logMsg()<br />
void logMsg(string Kette)<br />
Funktion<br />
Schreibt Kette in die Protokollliste <strong>de</strong>s Systems. Die Meldung wird mit Datum und Uhrzeit registriert.<br />
Siehe auch<br />
void popUpMsg(string Kette)<br />
Syntax<br />
string getProfile()<br />
Funktion<br />
Gibt <strong>de</strong>n Namen <strong>de</strong>s aktuellen Benutzerprofils zurück.<br />
string getProfile()<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 51 / 122
TASKS<br />
Definition<br />
Eine Task ist ein Programm, das zu einem gegebenen Zeitpunkt ausgeführt wird.<br />
In einer Applikation befin<strong>de</strong>n sich typischerweise Tasks für die Armbewegungen, eine Task Automat, eine Task für die<br />
Benutzerschnittstelle, eine Task für die Überwachung <strong>de</strong>r Sicherheitssignale, Kommunikationstasks usw..<br />
Eine Task ist durch folgen<strong>de</strong> Elemente gekennzeichnet:<br />
• Namen: Bezeichnung <strong>de</strong>r Task, die im System nur einmal vorkommt<br />
• Priorität: Parameter für Ablaufsteuerung <strong>de</strong>r Tasks<br />
• Programm: Einsprungstelle (und Aussprungstelle) <strong>de</strong>r Task<br />
• Status: aktiv o<strong>de</strong>r been<strong>de</strong>t<br />
• die nächste auszuführen<strong>de</strong> Anweisung (mit Kontext)<br />
Fortsetzen nach einer Fehlermeldung<br />
Wenn eine Anweisung zu einer Fehlermeldung geführt hat, wird die Task unterbrochen. Mit <strong>de</strong>r Anweisung<br />
taskStatus() kann die Fehlerursache ermittelt wer<strong>de</strong>n. Anschließend wird die Task mit <strong>de</strong>r Anweisung taskResume()<br />
fortgesetzt. Wenn die Störungsursache behoben wer<strong>de</strong>n konnte, macht das Programm in <strong>de</strong>r Zeile weiter, in <strong>de</strong>r die<br />
Task unterbrochen wur<strong>de</strong>. An<strong>de</strong>rnfalls muss vor o<strong>de</strong>r nach dieser Zeile begonnen wer<strong>de</strong>n.<br />
Starten und Been<strong>de</strong>n <strong>de</strong>r Applikation<br />
Zum Starten einer Applikation wird ihr Programm start() in einer Task mit <strong>de</strong>m Namen <strong>de</strong>r Applikation, <strong>de</strong>m<br />
nachgestellten Zeichen ’~’ und <strong>de</strong>r Priorität 10 ausgeführt.<br />
Zum Been<strong>de</strong>n einer Applikation wird ihr Programm stop() in einer Task mit <strong>de</strong>m Namen <strong>de</strong>r Applikation, <strong>de</strong>m ein ’~’<br />
vorangestellt ist, und <strong>de</strong>r Priorität 10 ausgeführt.<br />
Wird eine VAL3-Applikation von <strong>de</strong>r Benutzerschnittstelle <strong>de</strong>r CS8 aus unterbrochen, so wird die Start-Task, falls sie<br />
noch vorhan<strong>de</strong>n ist, augenblicklich gelöscht. Dann wird das Programm stop() ausgeführt, worauf alle noch nicht<br />
ausgeführten Tasks <strong>de</strong>r Applikation in <strong>de</strong>r umgekehrten Reihenfolge ihrer Erstellung gelöscht wer<strong>de</strong>n.<br />
52 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Sequentielles Ordnen<br />
Wenn in einer Applikation mehrere Tasks ausgeführt wer<strong>de</strong>n, hat es <strong>de</strong>n Anschein, als ob dies gleichzeitig und<br />
unabhängig voneinan<strong>de</strong>r erfolgt. Das ist jedoch nur richtig, wenn man die Applikation global, d.h. über genügend lange<br />
Zeitintervalle von z.B. einer Sekun<strong>de</strong> betrachtet. Bei kurzen Zeitintervallen ist diese Aussage nicht mehr gültig.<br />
Da das System nur einen Prozessor besitzt, kann es auch nur jeweils eine Task ausführen. Die Gleichzeitigkeit <strong>de</strong>r<br />
Ausführung wird durch ein rasches sequentielles Ordnen <strong>de</strong>r einzelnen Tasks erreicht, die reihum einige Anweisungen<br />
abarbeiten, bevor das System auf die nächste Task weitergeht.<br />
Priorität<br />
T1<br />
Normale<br />
Ausführung<br />
T2<br />
Sequentielles Ordnen<br />
T1 führt die<br />
Funktion <strong>de</strong>lay()<br />
aus.<br />
T1<br />
T2<br />
Zeit abgelaufen<br />
T2 T2<br />
T3 T3 T3 T3<br />
T1<br />
Normale<br />
Ausführung<br />
Unter VAL3 sind die Sequenzen <strong>de</strong>r Tasks nach folgen<strong>de</strong>n Regeln geordnet:<br />
1. Die Tasks wer<strong>de</strong>n in <strong>de</strong>r Reihenfolge ihrer Erstellung sequentiell geordnet.<br />
2. In je<strong>de</strong>r Sequenz versucht das System, die Anzahl von VAL3-Programmzeilen auszuführen, die <strong>de</strong>r<br />
Priorität <strong>de</strong>r Task entspricht.<br />
3. Sobald eine Programmzeile nicht been<strong>de</strong>t wer<strong>de</strong>n kann (Ausführungsfehler, Warten auf ein Signal, Task<br />
unterbrochen...), fährt das System mit <strong>de</strong>r nächsten Task fort.<br />
4. Je<strong>de</strong> Task wird min<strong>de</strong>stens alle 10 ms aufgerufen.<br />
Folgen<strong>de</strong> Anweisungen in VAL3 bewirken ein sofortiges Weitergehen zur Sequenz <strong>de</strong>r nächsten Task:<br />
• watch() (zeitlich begrenztes Warten auf eine Bedingung)<br />
• <strong>de</strong>lay() (Wartezeit)<br />
• wait() (Warten auf eine Bedingung)<br />
• waitEndMove() (Warten auf Stillstand <strong>de</strong>s Roboters)<br />
• open() und close() (Warten auf Stillstand <strong>de</strong>s Roboters mit anschließen<strong>de</strong>r Wartezeit)<br />
• get() (Warten auf eine Tasteneingabe)<br />
• resume() (wartet, bis die Task zum Neustart bereit ist)<br />
• kill() (wartet, bis die Task tatsächlich gekillt ist)<br />
• disablePower() (wartet, bis die Leistung tatsächlich abgeschaltet wur<strong>de</strong>)<br />
• Die Anweisungen zum Zugriff auf <strong>de</strong>n Inhalt <strong>de</strong>r Festplatte (libLoad, libSave, libDelete, libList)<br />
• Die Anweisungen zum Lesen / Schreiben von sio (Bediener =, sioGet(), sioSet())<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 53 / 122<br />
T2<br />
T3<br />
Zeit
Synchronisierung<br />
Manchmal müssen mehrere Tasks miteinan<strong>de</strong>r synchronisiert wer<strong>de</strong>n, bevor ihre Ausführung fortgesetzt wer<strong>de</strong>n kann.<br />
Wenn die Ausführungszeiten <strong>de</strong>r einzelnen Tasks bekannt sind, kann die Synchronisierung einfach durch Warten auf<br />
ein Signal <strong>de</strong>s langsamsten Jobs erfolgen. Ist aber nicht bekannt, welche die langsamste Task ist, kommt ein etwas<br />
komplexeres Synchronisierungsverfahren zum Einsatz, von <strong>de</strong>m ein Programmierbeispiel in VAL3 nachstehend<br />
angegeben ist.<br />
Zum Beispiel<br />
// Globale Variablen zur Steuerung <strong>de</strong>r Synchronisierung<br />
num n<br />
bool bSynch<br />
n=0 // Initialisierung <strong>de</strong>r globalen Variablen<br />
bSynch=false<br />
program tache1()<br />
begin<br />
while(true)<br />
call synchro(n, bSynch, 2) // Synchronisierung mit Task 2<br />
<br />
endWhile<br />
end<br />
program tache2()<br />
begin<br />
while(true)<br />
call synchro(n, bSynch, 2) // Synchronisierung mit Task 1<br />
<br />
endWhile<br />
end<br />
// Programm zur Synchronisierung von N Tasks<br />
program synchro(num& n, bool& bSynch, num N)<br />
begin<br />
n = n + 1<br />
wait((n==N) or (bSynch==true)) // Warten auf die Synchronisierung <strong>de</strong>r Tasks<br />
bSynch = true<br />
n = n - 1<br />
wait((n==0) or (bSynch == false)) // Warten auf die Freigabe <strong>de</strong>r Tasks<br />
bSynch = false<br />
end<br />
54 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Gemeinsame Nutzung von Ressourcen<br />
Wenn mehrere Tasks gleiche Systemkomponenten o<strong>de</strong>r Elemente <strong>de</strong>r Roboterarbeitszelle (globale Variablen,<br />
Monitore, Tastatur, Roboter usw.) verwen<strong>de</strong>n, muss darauf geachtet wer<strong>de</strong>n, dass sie sich nicht gegenseitig stören.<br />
Zum Schutz <strong>de</strong>r Komponenten kann eine sogenannte "(’mutex’)"-Funktion (mutuel exclusion) verwen<strong>de</strong>t wer<strong>de</strong>n, die<br />
sie nur für jeweils eine Task freigibt. Das nachstehen<strong>de</strong> Programmierbeispiel ver<strong>de</strong>utlicht die Funktion Mutex in VAL3.<br />
Zum Beispiel<br />
bool bEcran<br />
bEcran = false<br />
program tache1()<br />
begin<br />
while(true)<br />
call mutex(bEcran) // Anfor<strong>de</strong>rung <strong>de</strong>r Komponente Bildschirm<br />
call fillScreen(1)<br />
bEcran = false // Freigabe <strong>de</strong>r Komponente Bildschirm<br />
<strong>de</strong>lay(0) // Weitergehen zur nächsten Task<br />
endWhile<br />
end<br />
program tache2()<br />
begin<br />
while(true)<br />
call mutex(bEcran) // Anfor<strong>de</strong>rung <strong>de</strong>r Komponente Bildschirm<br />
call fillScreen(2)<br />
bEcran = false // Freigabe <strong>de</strong>r Komponente Bildschirm<br />
<strong>de</strong>lay(0) // Weitergehen zur nächsten Task<br />
endWhile<br />
end<br />
// Programm zum Füllen <strong>de</strong>s Bildschirms mit <strong>de</strong>r Ziffer i<br />
program fillScreen(num i)<br />
num x<br />
num y<br />
begin<br />
i = i % 10<br />
for x = 0 to 39<br />
for y = 0 to 13<br />
gotoxy(x, y)<br />
put(i);<br />
endFor<br />
endFor<br />
end<br />
// Programm zur Verhin<strong>de</strong>rung <strong>de</strong>s gleichzeitigen Zugriffs auf eine<br />
Komponente<br />
program mutex(bool& bRessource)<br />
begin<br />
// Die Zuweisung <strong>de</strong>r Komponente (bRessource) zu true muss in <strong>de</strong>r gleichen Zeile wie die Prüfung erfolgen!!!<br />
wait((bRessource==false) and (bRessource = true))<br />
end<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 55 / 122
Anweisungen<br />
Syntax<br />
void taskSuspend()<br />
void taskSuspend(string Name)<br />
Funktion<br />
Unterbricht die Ausführung <strong>de</strong>r Task Name.<br />
Wenn die Task bereits <strong>de</strong>n Status STOPPED hat, ist die Anweisung wirkungslos.<br />
Wenn Name keiner Task in VAL3 entspricht, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
string Name Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
Siehe auch<br />
void taskResume(string Name, num Sprung)<br />
void taskKill(string Name)<br />
Syntax<br />
void taskResume(string Name, num Sprung)<br />
void taskResume (, )<br />
Funktion<br />
Setzt die Task Name bei <strong>de</strong>r Zeile fort, die Sprung Programmzeilen vor o<strong>de</strong>r nach <strong>de</strong>r aktuellen Zeile liegt.<br />
Wenn Sprung negativ ist, wird die Ausführung vor <strong>de</strong>r aktuellen Zeile fortgesetzt. Wenn die Task nicht <strong>de</strong>n Status<br />
STOPPED hat, ist die Anweisung wirkungslos.<br />
Eine Fehlermeldung wird erzeugt, wenn Name keiner Task in VAL3 entspricht, o<strong>de</strong>r wenn es für <strong>de</strong>n spezifizierten<br />
Sprung keine Programmzeile gibt.<br />
Parameter<br />
string Name Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Sprung Numerischer Ausdruck<br />
Siehe auch<br />
void taskSuspend(string Name)<br />
void taskKill(string Name)<br />
56 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
void taskKill ()<br />
void taskKill(string Name)<br />
Funktion<br />
Unterbricht und löscht anschließend die Task Name. Nach Ausführung dieser Anweisung ist die Task Name im System<br />
nicht mehr vorhan<strong>de</strong>n.<br />
Wenn es keine Task Name gibt, ist die Anweisung wirkungslos.<br />
Parameter<br />
string Name Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
Siehe auch<br />
void taskSuspend(string Name)<br />
void taskCreate string Name, num Priorität, Programm(...)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 57 / 122
Syntax<br />
num taskStatus ()<br />
num taskStatus(string Name)<br />
Funktion<br />
Überträgt <strong>de</strong>n aktuellen Status <strong>de</strong>r Task Name o<strong>de</strong>r <strong>de</strong>n Co<strong>de</strong> <strong>de</strong>s bei <strong>de</strong>r Ausführung <strong>de</strong>r Task aufgetretenen Fehlers,<br />
wenn sich letztere in Fehlerzustand befin<strong>de</strong>t:<br />
Co<strong>de</strong> Beschreibung<br />
-1 Es gibt keine Task Name<br />
0 Die Task Name ist ohne Ausführungsfehler gestoppt<br />
1 Die Task Name befin<strong>de</strong>t sich in Ausführung<br />
10 Ungültige numerische Berechnung (Division durch Null).<br />
11 Ungültige numerische Berechnung (zum Beispiel ln(-1))<br />
20 Zugriff zu einer Tabelle mit höherem In<strong>de</strong>x als die Tabellengröße.<br />
21 Zugriff zu einer Tabelle mit negativem In<strong>de</strong>x.<br />
29 Ungültiger Name <strong>de</strong>r Task. Siehe Anweisung taskCreate().<br />
30 Der festgelegte Name entspricht keiner Task von VAL3.<br />
31 Es existiert bereits eine Task gleichen Namens. Siehe Anweisung taskCreate.<br />
40 Der Speicherplatz genügt nicht für die Daten.<br />
41 Der Ausführungsspeicher ist für die Task unzureichend. Siehe Größe <strong>de</strong>s Ausführungsspeichers.<br />
60 Maximale Ausführungszeit <strong>de</strong>r Anweisung ist abgelaufen.<br />
61 Interner Fehler <strong>de</strong>s VAL3-Interpreters<br />
70 Ungültiger Wert <strong>de</strong>s Parameters <strong>de</strong>r Anweisung. Siehe entsprechen<strong>de</strong> Anweisung.<br />
80 Verwendung von Daten o<strong>de</strong>r Programmen einer nicht im Speicher gela<strong>de</strong>nen Bibliothek.<br />
90 Die Task kann an <strong>de</strong>r festgelegten Stelle nicht wie<strong>de</strong>r aufgenommen wer<strong>de</strong>n. Siehe Anweisung taskResume().<br />
100 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Geschwindigkeit ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
101 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Beschleunigung ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
102<br />
Die im Bewegungs<strong>de</strong>skriptor spezifizierte Abbremsgeschwindigkeit ist ungültig (negativ, zu groß o<strong>de</strong>r kleiner als die<br />
Geschwindigkeit).<br />
103 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Translationsgeschwindigkeit ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
104 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Rotationsgeschwindigkeit ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
105 Der im Bewegungs<strong>de</strong>skriptor spezifizierte Parameter reach ist ungültig (negativ).<br />
1<strong>06</strong> Der im Bewegungs<strong>de</strong>skriptor spezifizierte Parameter leave ist ungültig (negativ).<br />
122 Schreibversuch auf einem Eingang <strong>de</strong>s Systems.<br />
123 Verwendung eines Ein-/Ausgangs dio, aio o<strong>de</strong>r sio, <strong>de</strong>r keinem Ein-/Ausgang <strong>de</strong>s Systems zugeordnet ist.<br />
124 Versuch <strong>de</strong>s Zugriffs auf einen geschützten Ein-/Ausgang <strong>de</strong>s Systems<br />
125 Lese- o<strong>de</strong>r Schreibfehler an einem dio, aio o<strong>de</strong>r sio (Fehler auf Feldbus)<br />
150<br />
Diese Bewegungsanweisung lässt sich nicht ausführen: Eine vorher angefor<strong>de</strong>rte Bewegung konnte nicht been<strong>de</strong>t<br />
wer<strong>de</strong>n (Punkt nicht erreichbar, singulärer Punkt, Konfigurationsproblem usw.)<br />
152 Verwendung eines point ohne Referenzsystem. Siehe Definition.<br />
153 Bewegungsbefehl nicht unterstützt<br />
154 Ungültige Bewegungsanweisung: Bewegungs<strong>de</strong>skriptor überprüfen.<br />
160 Koordinaten <strong>de</strong>s Tools flange nicht gültig<br />
161 Koordinaten <strong>de</strong>s Koordinatensystems world nicht gültig<br />
162 Verwendung eines point ohne Referenzsystem. Siehe Definition.<br />
163 Verwendung eines Koordinatensystems ohne Referenzsystem. Siehe Definition.<br />
164 Verwendung eines Tools ohne Referenztool. Siehe Definition.<br />
165 Referenzsystem o<strong>de</strong>r Referenztool ungültig (globale Variable mit lokaler Variablen verbun<strong>de</strong>n)<br />
Parameter<br />
string Name Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
Siehe auch<br />
void taskResume(string Name, num Sprung)<br />
void taskKill(string Name)<br />
58 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
void taskCreate string Name, num Priorität, Programm(...)<br />
void taskCreate , , Programm([p1] [,p2])<br />
Funktion<br />
Erstellt und startet die Task Name.<br />
Name muss 1 bis 12 Zeichen zwischen "a..zA..Z0..9_" besitzen. Es darf keine an<strong>de</strong>re Task mit <strong>de</strong>m gleichen Namen<br />
geben.<br />
Die Ausführung von Name beginnt mit <strong>de</strong>m Aufruf von Programm mit <strong>de</strong>n spezifischen Parametern. Für<br />
Referenzparameter dürfen keine lokalen Variablen verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Die Task en<strong>de</strong>t vorprogrammiert mit <strong>de</strong>r letzten Zeile von Programm bzw. vorher, wenn diese ausdrücklich gelöscht<br />
wur<strong>de</strong>.<br />
Priorität muss zwischen 1 und 100 liegen. Bei je<strong>de</strong>m sequentiellen Ordnen <strong>de</strong>r Tasks führt das System die in Priorität<br />
angegebene Zahl von Programmzeilen aus, bzw. weniger, wenn eine sperren<strong>de</strong> Anweisung angetroffen wird (siehe<br />
Kapitel Sequentielles Ordnen).<br />
Wenn das System nicht genügend Speicherplatz zum Erstellen <strong>de</strong>r Task vorfin<strong>de</strong>t, Name ungültig o<strong>de</strong>r bereits<br />
vergeben o<strong>de</strong>r Priorität ungültig ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
string Name Ausdruck <strong>de</strong>s Typs Zeichenkette<br />
num Priorität Numerischer Ausdruck<br />
Programm Name eines Programms <strong>de</strong>r Applikation<br />
p1 Ausdruck <strong>de</strong>s in Programm angegebenen Typs<br />
Zum Beispiel<br />
program affiche(string& sTexte)<br />
begin<br />
putln(sTexte)<br />
sTexte = "stop"<br />
end<br />
string sMessage<br />
program start()<br />
begin<br />
sMessage = "start"<br />
taskCreate "t1", 10, affiche(sMessage) // ergibt « start »<br />
wait(taskStatus("t1") == -1) // Wartet auf das En<strong>de</strong> von t1<br />
putln(sMessage) // ergibt "stop"<br />
end<br />
Siehe auch<br />
void taskSuspend(string Name)<br />
void taskKill(string Name)<br />
num taskStatus(string Name)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 59 / 122
Syntax<br />
void wait()<br />
void wait(bool Bedingung)<br />
Funktion<br />
Stellt die aktuelle Task solange zurück, bis Bedingung true wird.<br />
Die Task bleibt RUNNING während <strong>de</strong>r Wartezeit. Wenn condition bei <strong>de</strong>r ersten Überprüfung true ist, wird die<br />
Ausführung sofort mit <strong>de</strong>r gleichen Task fortgesetzt (kein sequentielles Ordnen <strong>de</strong>r nächsten Task).<br />
Parameter<br />
bool Bedingung Boolescher Ausdruck<br />
Siehe auch<br />
void <strong>de</strong>lay(num Sekun<strong>de</strong>n)<br />
bool watch(bool Bedingung, num Sekun<strong>de</strong>n)<br />
Syntax<br />
void <strong>de</strong>lay()<br />
void <strong>de</strong>lay(num Sekun<strong>de</strong>n)<br />
Funktion<br />
Schiebt die Ausführung <strong>de</strong>r laufen<strong>de</strong>n Task für Sekun<strong>de</strong>n Sekun<strong>de</strong>n auf.<br />
Die Task bleibt RUNNING während <strong>de</strong>r Wartezeit. Wenn Sekun<strong>de</strong>n kleiner o<strong>de</strong>r gleich 0 ist, schiebt das System zuvor<br />
an<strong>de</strong>re Tasks in VAL3 ein, bevor die aktuelle Task fortgesetzt wird.<br />
Parameter<br />
num Sekun<strong>de</strong>n Numerischer Ausdruck<br />
Siehe auch<br />
num clock()<br />
bool watch(bool Bedingung, num Sekun<strong>de</strong>n)<br />
60 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
num clock()<br />
num clock()<br />
Funktion<br />
Überträgt <strong>de</strong>n aktuellen Wert <strong>de</strong>s systeminternen Taktgebers in Sekun<strong>de</strong>n.<br />
Die Genauigkeit <strong>de</strong>s internen Taktgebers beträgt eine Millisekun<strong>de</strong>. Er wird beim Start <strong>de</strong>r Steuerung auf 0 gesetzt und<br />
ist unabhängig von <strong>de</strong>r Uhrzeit.<br />
Zum Beispiel<br />
num nDebut<br />
nDebut=clock()<br />
<br />
put("Dauer <strong>de</strong>s Vorgangs= " )<br />
putln(clock()-nDebut)<br />
Siehe auch<br />
void <strong>de</strong>lay(num Sekun<strong>de</strong>n)<br />
bool watch(bool Bedingung, num Sekun<strong>de</strong>n)<br />
Syntax<br />
bool watch(bool Bedingung, num Sekun<strong>de</strong>n)<br />
bool watch (, )<br />
Funktion<br />
Schiebt die aktuelle Task auf, bis Bedingung gleich true ist o<strong>de</strong>r die Zeit von Sekun<strong>de</strong>n Sekun<strong>de</strong>n abgelaufen ist.<br />
Überträgt true, wenn die Wartezeit dadurch been<strong>de</strong>t wird, dass Bedingung gleich true wird. Wird die Wartezeit<br />
been<strong>de</strong>t, weil die Zeit abgelaufen ist, wird false übertragen.<br />
Die Task bleibt RUNNING während <strong>de</strong>r Wartezeit. Wenn Bedingung bei <strong>de</strong>r ersten Überprüfung true ist, wird die<br />
Ausführung sofort mit <strong>de</strong>r gleichen Task fortgesetzt, an<strong>de</strong>rnfalls wer<strong>de</strong>n die an<strong>de</strong>ren VAL3-Tasks vom System<br />
eingeschoben (auch wenn Sekun<strong>de</strong>n kleiner o<strong>de</strong>r gleich 0 ist).<br />
Parameter<br />
bool Bedingung Boolescher Ausdruck<br />
num Sekun<strong>de</strong>n Numerischer Ausdruck<br />
Zum Beispiel<br />
while (watch (dCapteur, 20)) == false<br />
popUpMsg("Warten auf Teil")<br />
endWhile<br />
Siehe auch<br />
void <strong>de</strong>lay(num Sekun<strong>de</strong>n)<br />
void wait(bool Bedingung)<br />
num clock()<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 61 / 122
BIBLIOTHEKEN<br />
Definition<br />
Eine VAL3-Bibliothek ist eine Software, die von einer Applikation o<strong>de</strong>r an<strong>de</strong>ren VAL3-Bibliotheken verwen<strong>de</strong>t wer<strong>de</strong>n<br />
kann.<br />
Wie eine Applikation besteht eine VAL3-Bibliothek aus folgen<strong>de</strong>n Elementen:<br />
- einer Gruppe von Programmen: <strong>de</strong>n auszuführen<strong>de</strong>n VAL3-Anweisungen,<br />
- einer Gruppe von globalen Variablen: <strong>de</strong>n Daten <strong>de</strong>r Bibliothek<br />
- einer Gruppe von Bibliotheken: von <strong>de</strong>r Bibliothek benutzte externe Anweisungen und Daten<br />
Eine in Ausführung befindliche Bibliothek kann zu<strong>de</strong>m enthalten:<br />
- eine Gruppe von Tasks: eigene Programme <strong>de</strong>r in Ausführung befindlichen Bibliothek<br />
Eine Bibliothek wird im gleichen Format gespeichert, wie eine VAL3-Applikation. Je<strong>de</strong> Applikation kann als Bibliothek<br />
und je<strong>de</strong> Bibliothek als Applikation verwen<strong>de</strong>t wer<strong>de</strong>n, wenn in ihr die Programme start() und stop() <strong>de</strong>finiert sind.<br />
Schnittstelle<br />
Die Programme und die globalen Variablen einer Bibliothek sind entwe<strong>de</strong>r exportiert o<strong>de</strong>r privat. Nur exportierte<br />
Programme und globale Variablen sind außerhalb <strong>de</strong>r Bibliothek zugänglich. Private Programme und globale Variablen<br />
können nur von <strong>de</strong>n Programmen <strong>de</strong>r Bibliothek verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Die Gruppe <strong>de</strong>r exportierten Programme und globalen Variablen einer Bibliothek wird als <strong>de</strong>ren Schnittstelle<br />
bezeichnet: Verschie<strong>de</strong>ne Bibliotheken können die gleiche Schnittstelle haben, wenn ihre exportierten Programme und<br />
Daten die gleichen Namen besitzen.<br />
Die vom Programm einer Bibliothek geschaffenen Tasks sind immer privat, das heißt, sie sind nur von dieser Bibliothek<br />
zugänglich.<br />
Kennung <strong>de</strong>r Schnittstelle<br />
Um eine Bibliothek verwen<strong>de</strong>n zu können, muss eine Applikation immer zunächst einen zugeordneten<br />
Verwendungsnamen festlegen und dann in einem Programm anfor<strong>de</strong>rn, die Bibliothek unter diesem Namen im<br />
Speicher zu la<strong>de</strong>n.<br />
Der Verwendungsname ist <strong>de</strong>r Schnittstelle <strong>de</strong>r Bibliothek zugeordnet, nicht <strong>de</strong>r Bibliothek selbst. Je<strong>de</strong>, die gleiche<br />
Schnittstelle aufweisen<strong>de</strong> Bibliothek kann also unter diesem Namen gela<strong>de</strong>n wer<strong>de</strong>n. Es ist <strong>de</strong>shalb zum Beispiel<br />
möglich, eine Bibliothek für je<strong>de</strong>s mögliche Teil einer Applikation zu <strong>de</strong>finieren und dann nur das beim jeweiligen Zyklus<br />
bearbeitete Teil zu la<strong>de</strong>n.<br />
Inhalt<br />
Der Inhalt einer Bibliothek ist nicht vorgeschrieben: Sie kann nur Programme, nur Daten o<strong>de</strong>r bei<strong>de</strong>s gleichzeitig<br />
enthalten.<br />
Der Zugang zu einer Bibliothek erfolgt durch Aufschreiben <strong>de</strong>s Namens <strong>de</strong>r Kennung, gefolgt von ’:’ und <strong>de</strong>m Namen<br />
<strong>de</strong>s Programms o<strong>de</strong>r <strong>de</strong>r Daten <strong>de</strong>r Bibliothek, zum Beispiel:<br />
Teil:libLoad("Teil_7") // Lädt die Bibliothek "Teil_7" unter <strong>de</strong>r Kennung ’Teil’<br />
title(Teil:nom) // Zeigt als Titel <strong>de</strong>n Namen <strong>de</strong>s aktuellen Teils an<br />
call Teil:init() // Ruft das Programm init() <strong>de</strong>s aktuellen Teils<br />
Wird <strong>de</strong>r Zugriff zum Inhalt einer Bibliothek gefor<strong>de</strong>rt, die noch nicht in <strong>de</strong>n Speicher gela<strong>de</strong>n wur<strong>de</strong>, so bewirkt dies<br />
einen Ausführungsfehler.<br />
Im Speicher la<strong>de</strong>n und aus <strong>de</strong>m Speicher entfernen<br />
Beim Öffnen einer VAL3-Applikation wer<strong>de</strong>n alle erklärten Bibliotheken untersucht, um die entsprechen<strong>de</strong>n<br />
Schnittstellen aufzubauen. Bei diesem Schritt wer<strong>de</strong>n die Bibliotheken nicht in <strong>de</strong>n Speicher gela<strong>de</strong>n.<br />
Beim La<strong>de</strong>n einer Bibliothek wer<strong>de</strong>n <strong>de</strong>ren globale Variablen initialisiert und ihre Programme auf eventuelle<br />
Syntaxfehler überprüft.<br />
Eine Bibliothek muss nicht aus <strong>de</strong>m Speicher entfernt wer<strong>de</strong>n. Dies erfolgt automatisch nach <strong>de</strong>m Been<strong>de</strong>n <strong>de</strong>r<br />
Anwendung o<strong>de</strong>r beim La<strong>de</strong>n einer neuen Anwendung an <strong>de</strong>ren Stelle.<br />
Wird eine VAL3-Applikation von <strong>de</strong>r CS8-Benutzerschnittstelle gestoppt, so wird zunächst das Programm stop()<br />
ausgeführt und anschließend wer<strong>de</strong>n alle Tasks <strong>de</strong>r Applikation und ihrer Bibliotheken, falls solche verbleiben,<br />
gelöscht.<br />
62 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Zugriffspfad<br />
Die Anweisungen libLoad(), libSave() und libDelete() verwen<strong>de</strong>n einen Bibliotheks-Zugriffspfad, <strong>de</strong>r in Form einer<br />
Zeichenkette festgelegt ist. Ein Zugriffspfad enthält einen Stamm (fakultativ), einen Pfad (fakultativ) und <strong>de</strong>n Namen<br />
einer Bibliothek in folgen<strong>de</strong>m Format:<br />
Stamm://Weg/Name<br />
Der Stamm legt <strong>de</strong>n Datenträger <strong>de</strong>r Datei fest: "Floppy" für Diskette, "Disk" für Speicherung in CS8 o<strong>de</strong>r <strong>de</strong>n Namen<br />
einer in CS8 für einen Netzzugang festgelegten Ftp-Verbindung.<br />
Im Standardfall ist <strong>de</strong>r Stamm "Disk" und <strong>de</strong>r Pfad leer.<br />
Beispiele<br />
Teil:libLoad("Teil_1")<br />
Teil:libSave("Floppy://Teil")<br />
Teil:libSave("Disk://Teil_x/Teil_1")<br />
Fehlerco<strong>de</strong>s<br />
Die VAL3-Funktionen für <strong>de</strong>n Umgang mit Bibliotheken erzeugen keine Ausführungsfehler, son<strong>de</strong>rn übergeben einen<br />
Fehlerco<strong>de</strong>, mit <strong>de</strong>ssen Hilfe das Ergebnis einer Anweisung überprüft und <strong>de</strong>r Ursprung eventueller Probleme<br />
untersucht wer<strong>de</strong>n kann.<br />
Co<strong>de</strong> Beschreibung<br />
0 Kein Fehler<br />
10 Die Kennung <strong>de</strong>r Bibliothek wur<strong>de</strong> nicht durch libLoad() initialisiert.<br />
11<br />
12<br />
13<br />
La<strong>de</strong>n <strong>de</strong>r Bibliothek unmöglich: Ihre Schnittstelle entspricht nicht <strong>de</strong>rjenigen <strong>de</strong>r<br />
Kennung.<br />
La<strong>de</strong>n <strong>de</strong>r Bibliothek unmöglich: Die Bibliothek enthält ungültige Daten o<strong>de</strong>r<br />
Programme.<br />
Entfernen <strong>de</strong>r Bibliothek nicht möglich: Die Bibliothek enthält ungültige Daten o<strong>de</strong>r<br />
Programme.<br />
20 Datei-Zugriffsfehler: <strong>de</strong>r Stamm <strong>de</strong>s Pfads ist ungültig.<br />
21 Datei-Zugriffsfehler: <strong>de</strong>r Pfad ist ungültig.<br />
22 Datei-Zugriffsfehler: <strong>de</strong>r Name ist ungültig.<br />
30 Lese-/Schreibfehler auf Datei.<br />
31<br />
Schreibzugriff: Der angegebene Pfad enthält bereits eine Bibliothek.<br />
Lesezugriff: Diese Bibliothek wird schon von einer an<strong>de</strong>ren Kennung genutzt.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 63 / 122
Anweisungen<br />
Syntax<br />
num i<strong>de</strong>ntifiant:libLoad(string Weg)<br />
num i<strong>de</strong>ntifiant:libLoad(string Weg)<br />
Funktion<br />
Initialisierung <strong>de</strong>r Kennung einer Bibliothek durch La<strong>de</strong>n <strong>de</strong>r Programme und Daten <strong>de</strong>r Bibliothek auf <strong>de</strong>n festgelegten<br />
Weg.<br />
Überträgt 0 nach erfolgreichem La<strong>de</strong>n und einen Bibliothek-Fehlerco<strong>de</strong>, wenn noch von <strong>de</strong>r zu entfernen<strong>de</strong>n Bibliothek<br />
geschaffene Tasks verbleiben, wenn <strong>de</strong>r Zugangspfad zur Bibliothek ungültig ist, wenn die Bibliothek Syntax-Fehler<br />
enthält o<strong>de</strong>r wenn die genannte Bibliothek nicht <strong>de</strong>r für die Kennung erklärten Schnittstelle entspricht.<br />
Siehe auch<br />
num i<strong>de</strong>ntifiant:libSave(), num libSave()<br />
num i<strong>de</strong>ntifiant:libSave(), num libSave()<br />
Syntax<br />
num i<strong>de</strong>ntifiant:libSave()<br />
num i<strong>de</strong>ntifiant:libSave(string Weg)<br />
Funktion<br />
Sichern <strong>de</strong>r Programme und Daten, die einer Bibliothek-Kennung zugeordnet sind. Wenn libSave() ohne Kennung<br />
aufgerufen wird, wird die Anwendung <strong>de</strong>r aufrufen<strong>de</strong>n Bibliothek gespeichert. Bei Angabe eines Parameters erfolgt das<br />
Sichern über <strong>de</strong>n genannten Weg. An<strong>de</strong>rnfalls wird über <strong>de</strong>n beim La<strong>de</strong>n festgelegten Pfad gesichert.<br />
Überträgt 0, wenn die Programme und Daten gesichert wor<strong>de</strong>n sind, und einen Bibliothek-Fehlerco<strong>de</strong>, wenn die<br />
Kennung nicht initialisiert ist, wenn <strong>de</strong>r Pfad ungültig ist, o<strong>de</strong>r wenn ein Schreibfehler eingetreten ist bzw. <strong>de</strong>r genannte<br />
Pfad bereits zu einer Bibliothek führt.<br />
Siehe auch<br />
num libDelete(string Weg)<br />
Syntax<br />
num libDelete(string Weg)<br />
num libDelete(string Weg)<br />
Funktion<br />
Löscht die durch <strong>de</strong>n Weg angezeigte Bibliothek.<br />
Überträgt 0, wenn die genannte Bibliothek nicht existiert o<strong>de</strong>r gelöscht wor<strong>de</strong>n ist, und einen Bibliothek-Fehlerco<strong>de</strong>,<br />
wenn die Kennung nicht initialisiert ist, wenn <strong>de</strong>r Pfad ungültig ist, o<strong>de</strong>r wenn ein Schreibfehler eingetreten ist.<br />
Siehe auch<br />
num i<strong>de</strong>ntifiant:libSave(), num libSave()<br />
string i<strong>de</strong>ntifiant:libPath(), string libPath()<br />
64 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
string i<strong>de</strong>ntifiant:libPath()<br />
string i<strong>de</strong>ntifiant:libPath(), string libPath()<br />
Funktion<br />
Überträgt <strong>de</strong>n Zugangspfad <strong>de</strong>r mit <strong>de</strong>r Kennung verknüpften Bibliothek, o<strong>de</strong>r <strong>de</strong>r aufrufen<strong>de</strong>n Anwendung o<strong>de</strong>r<br />
Bibliothek, falls keine Kennung angegeben ist.<br />
Siehe auch<br />
bool libList(string Weg, string& contenu)<br />
Syntax<br />
bool libList(string Weg, string& contenu)<br />
bool libList(string Weg, string& contenu)<br />
Funktion<br />
Liste <strong>de</strong>s in Tabelle Inhalt spezifizierten Weg. Überträgt true, wenn Tabelle Inhalt das gesamte Ergebnis auflistet,<br />
false wenn die Tabelle zu klein ist, um die gesamte Liste zu speichern.<br />
Die Tabelle Inhalt wird vor <strong>de</strong>r Aktualisierung bei "" gestartet. Um das Ergebnis von libList() zu lesen, muss gestoppt<br />
wer<strong>de</strong>n, sobald ein ""-Wert auftritt.<br />
Falls Inhalt eine globale Variable ist, wird sie automatisch vergrößert, wenn Platz zur Speicherung <strong>de</strong>s vollständigen<br />
Ergebnisses benötigt wird.<br />
Siehe auch<br />
string i<strong>de</strong>ntifiant:libPath(), string libPath()<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 65 / 122
STEUERUNG DES ROBOTERS<br />
In diesem Kapitel sind die Anweisungen für die verschie<strong>de</strong>nen Komponenten <strong>de</strong>s Roboters aufgeführt.<br />
Anweisungen<br />
Syntax<br />
void disablePower()<br />
void disablePower()<br />
Funktion<br />
Schaltet die Armleistung ab und wartet, bis die Leistung tatsächlich abgeschaltet wur<strong>de</strong>.<br />
Wenn <strong>de</strong>r Arm zu diesem Zeitpunkt in Bewegung ist, erfolgt vor <strong>de</strong>m Abschalten ein sofortiger Stillstand auf <strong>de</strong>r Bahn.<br />
Siehe auch<br />
void enablePower()<br />
bool isPowered()<br />
Syntax<br />
void enablePower()<br />
void enablePower()<br />
Funktion<br />
Schaltet <strong>de</strong>n Arm im ferngesteuerten Betrieb ein.<br />
Diese Anweisung hat keinen Einfluss auf <strong>de</strong>n lokalen, manuellen o<strong>de</strong>r Testbetrieb o<strong>de</strong>r wenn die Leistung gera<strong>de</strong><br />
abgeschaltet wird.<br />
Zum Beispiel<br />
// Schaltet <strong>de</strong>n Strom ein und wartet auf das volle Anliegen <strong>de</strong>r Spannung<br />
enablePower()<br />
if(watch(isPowered(), 5) == false)<br />
putln("Die Leistung kann nicht angelegt wer<strong>de</strong>n")<br />
endIf<br />
Siehe auch<br />
void disablePower()<br />
bool isPowered()<br />
Syntax<br />
bool isPowered()<br />
bool isPowered()<br />
Funktion<br />
Überträgt <strong>de</strong>n Status <strong>de</strong>r Leistungsversorgung <strong>de</strong>s Arms:<br />
true: Arm mit Strom versorgt<br />
false: <strong>de</strong>r Arm ist ausgeschaltet, wird gera<strong>de</strong> ein- o<strong>de</strong>r ausgeschaltet<br />
66 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
bool isCalibrated()<br />
Funktion<br />
Überträgt <strong>de</strong>n Kalibrierstatus <strong>de</strong>s Roboters:<br />
true: Alle Roboterachsen sind kalibriert<br />
false: Min<strong>de</strong>stens eine Roboterachse ist nicht kalibriert<br />
bool isCalibrated()<br />
num workingMo<strong>de</strong>(), num workingMo<strong>de</strong>(num& Status)<br />
Syntax<br />
num workingMo<strong>de</strong> (num& Status)<br />
num workingMo<strong>de</strong>()<br />
Funktion<br />
Überträgt die aktuelle Betriebsart <strong>de</strong>s Roboters:<br />
Modus Status Betriebsart Status<br />
0 0 Ungültig o<strong>de</strong>r Transition -<br />
0<br />
Programmierte Bewegung<br />
1 Anschlussbewegung<br />
2 Drehbewegung (Joint)<br />
1<br />
3 Handbetrieb<br />
Translationsbewegung (World)<br />
4 Tool (Tool)<br />
5 zum Punkt (User)<br />
6 Hold<br />
0<br />
programmierte Bewegung (250 mm/s)<br />
2<br />
1<br />
2<br />
Test<br />
Anschlussbewegung (250 mm/s)<br />
programmierte schnelle Bewegung<br />
3 Hold<br />
0<br />
Move (programmierte Bewegung)<br />
3<br />
1 Local<br />
Move (Anschlussbewegung)<br />
2 Hold<br />
0<br />
Move (programmierte Bewegung)<br />
4<br />
1 Remote<br />
Move (Anschlussbewegung)<br />
2 Hold<br />
Parameter<br />
num& Status Variable numerischen Typs.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 67 / 122
Syntax<br />
num speedScale()<br />
Funktion<br />
Überträgt die aktuelle Geschwindigkeit <strong>de</strong>s Monitors.<br />
Zum Beispiel<br />
num nCycle<br />
taskCreate "checkSpeed", 5, checkSpeed()<br />
num speedScale()<br />
program checkSpeed()<br />
begin<br />
while true<br />
if(nCycle < 2)<br />
if (speedScale()> 10)<br />
stopMotion()<br />
putln("Für <strong>de</strong>n ersten Zyklus muss die Monitorgeschwindigkeit bei 10 % bleiben")<br />
wait(speedScale()
REFERENZANLEITUNG VAL3 - Version 5.2<br />
EINLEITUNG<br />
ARMPOSITION<br />
In diesem Kapitel sind die verschie<strong>de</strong>nen Typen von VAL3-Daten beschrieben, mit <strong>de</strong>nen die in einer VAL3-Applikation<br />
verfügbaren Armpositionen programmiert wer<strong>de</strong>n können.<br />
Zwei Typen von Position sind in VAL3 <strong>de</strong>finiert: Winkelpositionen (Typ joint), die die Stellung <strong>de</strong>r Gelenkachsen<br />
beschreiben und kartesische Punkte (Typ point), mit <strong>de</strong>nen die Position <strong>de</strong>s am Arm montierten Werkzeugs in<br />
kartesischen Koordinaten angegeben wird.<br />
Der Typ tool beschreibt ein Werkzeug mit seiner Geometrie, das zur Positionierung und Geschwindigkeitssteuerung<br />
<strong>de</strong>s Arms verwen<strong>de</strong>t wird, sowie <strong>de</strong>ssen Aktivierungsmodus.<br />
Der Typ frame beschreibt ein Koordinatensystem. Durch die Verwendung von Bezugssystemen wird insbeson<strong>de</strong>re die<br />
Programmierung bewegter Punkte einfacher und intuitiver.<br />
Der Typ trsf beschreibt eine Koordinatentransformation. Sie wird implizit von <strong>de</strong>n Typen tool, point und frame<br />
verwen<strong>de</strong>t.<br />
Der Typ config beschreibt <strong>de</strong>n komplexeren Begriff <strong>de</strong>r Armkonfiguration.<br />
Die Beziehungen zwischen <strong>de</strong>n verschie<strong>de</strong>nen Typen lassen sich wie folgt zusammenfassen:<br />
TYP JOINT<br />
tool t21 tool t22<br />
tool t1<br />
Trsf<br />
Trsf<br />
flange<br />
robot<br />
Beziehung zwischen: frame / point / tool / trsf<br />
tool t2<br />
Trsf<br />
Trsf<br />
point p1a<br />
frame f1<br />
world<br />
point p21a point p21b<br />
frame f21 frame f21<br />
frame f2<br />
Definition<br />
Ein Gelenkpunkt (Typ joint) <strong>de</strong>finiert die Winkelposition je<strong>de</strong>r Roboterachse.<br />
Der Typ joint ist ein strukturierter Typ mit folgen<strong>de</strong>n Fel<strong>de</strong>rn in <strong>de</strong>r nachstehen<strong>de</strong>n Reihenfolge:<br />
num j1 Winkelposition Achse 1<br />
num j2 Winkelposition Achse 2<br />
num j3 Winkelposition Achse 3<br />
Trsf<br />
Trsf<br />
Trsf<br />
point p2a<br />
Diese Fel<strong>de</strong>r wer<strong>de</strong>n für die Drehachsen in Grad angegeben sowie in Millimetern für die linearen Achsen. Der Nullpunkt<br />
je<strong>de</strong>r Achse ist durch <strong>de</strong>n verwen<strong>de</strong>ten Armtyp festgelegt.<br />
Standardmäßig wird <strong>de</strong>r Wert für je<strong>de</strong>s Feld einer Variable <strong>de</strong>s Typs joint mit <strong>de</strong>m Wert 0 initialisiert.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 69 / 122<br />
Trsf<br />
Trsf<br />
Trsf<br />
Trsf<br />
Trsf
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
joint = Weist Position2 nacheinan<strong>de</strong>r <strong>de</strong>r Variablen<br />
Position1 zu und überträgt Position2.<br />
bool != Überträgt true, wenn ein Feld von Position1 im<br />
Rahmen <strong>de</strong>r Robotergenauigkeit nicht gleich <strong>de</strong>m<br />
entsprechen<strong>de</strong>n Feld von Position2 ist, ansonsten<br />
false.<br />
bool == Überträgt true, wenn je<strong>de</strong>s Feld von Position1 im<br />
Rahmen <strong>de</strong>r Robotergenauigkeit gleich <strong>de</strong>m<br />
entsprechen<strong>de</strong>n Feld von Position2 ist, ansonsten<br />
false.<br />
bool > Überträgt true, wenn je<strong>de</strong>s Feld von Position1 größer<br />
als das entsprechen<strong>de</strong> Feld in Position2 ist, ansonsten<br />
false.<br />
bool < Überträgt true, wenn je<strong>de</strong>s Feld von Position1 kleiner<br />
als das entsprechen<strong>de</strong> Feld in Position2 ist, ansonsten<br />
false.<br />
Achtung: Position1 > Position2 ist nicht<br />
vollständig i<strong>de</strong>ntisch mit Position2 < Position1!<br />
joint - Überträgt die Differenz für je<strong>de</strong>s Feld von Position1 mit<br />
Position2.<br />
joint + Überträgt die Summe für je<strong>de</strong>s Feld von Position1 und<br />
Position2.<br />
Anweisungen<br />
Syntax<br />
joint abs()<br />
Funktion<br />
Überträgt <strong>de</strong>n Absolutwert für je<strong>de</strong>s Feld von Position.<br />
Parameter<br />
joint abs(joint Position)<br />
num Position Ausdruck <strong>de</strong>s Typs Gelenkpunkt<br />
Zum Beispiel<br />
joint jEcartMax<br />
joint j<br />
jEcartMax = {5, 5, 5, 5, 5, 5}<br />
j = herej<br />
// Prüft, ob alle Achsenpositionen weniger als 5 Grad von <strong>de</strong>r Markierung abweichen<br />
if(!(abs(j) < jEcartMax))<br />
popUpMsg("Nähern Sie sich <strong>de</strong>n Markierungen)<br />
endIf<br />
Siehe auch<br />
Opérateur bool <br />
70 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
joint herej()<br />
joint herej()<br />
Funktion<br />
Überträgt die aktuelle Gelenkposition <strong>de</strong>s Arms (empfohlene Position und nicht die gemessene Position).<br />
Siehe auch<br />
joint herej()<br />
bool isInRange(joint Position)<br />
bool isInRange(joint Position)<br />
Syntax<br />
bool isInRange()<br />
Funktion<br />
Überträgt true, wenn Position innerhalb <strong>de</strong>r Softwarebegrenzungen <strong>de</strong>s Roboters liegt.<br />
Parameter<br />
joint Position Ausdruck <strong>de</strong>s Typs Gelenkpunkt<br />
Siehe auch<br />
joint herej()<br />
Opérateur bool <br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 71 / 122
TYP TRSF<br />
Definition<br />
Eine Transformation (Typ trsf) beschreibt die Position und die Orientierung eines kartesischen Koordinatensystems in<br />
Bezug auf ein an<strong>de</strong>res Koordinatensystem.<br />
Der Typ rsf ist ein strukturierter Typ mit folgen<strong>de</strong>n Fel<strong>de</strong>rn in <strong>de</strong>r nachstehen<strong>de</strong>n Reihenfolge:<br />
num x Translationskomponente in Richtung <strong>de</strong>r x-Achse<br />
num y Translationskomponente in Richtung <strong>de</strong>r y-Achse<br />
num z Translationskomponente in Richtung <strong>de</strong>r z-Achse<br />
num rx Rotationskomponente um die x-Achse<br />
num ry Rotationskomponente um die y-Achse<br />
num rz Rotationskomponente um die z-Achse<br />
Die Fel<strong>de</strong>r x, y und z sind in <strong>de</strong>r Längeneinheit <strong>de</strong>r Applikation (mm o<strong>de</strong>r inch, siehe Kapitel Längeneinheit) angegeben.<br />
Die Fel<strong>de</strong>r rx, ry und rz sind in Grad angegeben.<br />
Die Koordinaten x, y und z sind die kartesischen Koordinaten <strong>de</strong>s Koordinatenursprungs im Referenz-<br />
Koordinatensystem. Wenn rx, ry und rz null sind, haben bei<strong>de</strong> Koordinatensysteme die gleiche Orientierung.<br />
Der vorprogrammierte Wert für eine Variable <strong>de</strong>s Typs trsf ist immer {0,0,0,0,0,0}.<br />
72 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Orientierung<br />
x1<br />
Orientierung<br />
z1<br />
Die Position <strong>de</strong>s Koordinatensystems R2 (grau) in Bezug auf R1 (schwarz) ist Folgen<strong>de</strong>:<br />
x = 250mm, y = 350 mm, z = 450mm, rx = 0°, ry = 0°, rz = 0°<br />
Die drei Koordinaten rx, ry und rz entsprechen <strong>de</strong>n Winkeln, um welche die x, y und z-Achse nacheinan<strong>de</strong>r zu drehen<br />
sind, um die gewünschte Orientierung <strong>de</strong>s Koordinatensystems zu erhalten.<br />
Die Orientierung rx = 20°, ry = 10°, rz = 30° wird zum Beispiel auf folgen<strong>de</strong> Weise erhalten. Zuerst wird das<br />
Koordinatensystem (x,y,z) um 20° um die x-Achse gedreht. Damit erhält man das neue Koordinatensystem (x’,y’,z’).<br />
Die Achsen x und x’ sind <strong>de</strong>ckungsgleich.<br />
Drehung <strong>de</strong>s Koordinatensystems bezüglich folgen<strong>de</strong>r Achse: X<br />
x = x’<br />
450 mm<br />
x2 y2<br />
250 mm<br />
350 mm<br />
z’<br />
20°<br />
Anschließend wird das Koordinatensystem um 20° um die Achse y’ <strong>de</strong>s im vorherigen Schritt erhaltenen<br />
Koordinatensystems gedreht. Damit erhält man das neue Koordinatensystem (x’’,y’’,z’’). Die Achsen y’ und y’’ sind<br />
<strong>de</strong>ckungsgleich.<br />
z<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 73 / 122<br />
z2<br />
y’<br />
y<br />
y1
Drehung <strong>de</strong>s Koordinatensystems bezüglich folgen<strong>de</strong>r Achse: Y’<br />
x = x’<br />
x’’<br />
Zum Schluss wird das Koordinatensystem um 20° um die Achse z’’ <strong>de</strong>s im vorherigen Schritt erhaltenen<br />
Koordinatensystems gedreht. Das neue Koordinatensystem (x’’’,y’’’,z’’’) hat die durch rx, ry, rz <strong>de</strong>finierte Orientierung.<br />
Die Achsen z’’ und z‘’’ sind <strong>de</strong>ckungsgleich.<br />
Drehung <strong>de</strong>s Koordinatensystems bezüglich folgen<strong>de</strong>r Achse: Z’’<br />
x = x’<br />
x’’<br />
z’’<br />
z’’<br />
x’’’<br />
30°<br />
z’<br />
z’<br />
z<br />
z<br />
Die Position <strong>de</strong>s Koordinatensystems R2 (grau) in Bezug auf R1 (schwarz) ist Folgen<strong>de</strong>:<br />
x = 250mm, y = 350 mm, z = 450mm, rx = 20°, ry = 10°, rz = 30°<br />
Die Werte rx, ry und rz sind Modulo 360 Grad <strong>de</strong>finiert. Die vom System berechneten Werte für rx, ry und rz liegen<br />
damit immer zwischen -180 und +180. Damit bleiben noch mehrere Werte für rx, ry, und rz möglich: Das System sorgt<br />
dafür, dass min<strong>de</strong>stens zwei <strong>de</strong>r Koordinaten zwischen -90 und 90 liegen. Wenn ry 90° (modulo 180) beträgt, wird rx =<br />
0 gewählt.<br />
74 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong><br />
10°<br />
y’’’<br />
y’ = y’’<br />
y<br />
y’ = y’’<br />
y
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
trsf = Weist Position2 nacheinan<strong>de</strong>r <strong>de</strong>r Variablen<br />
Position1 zu und überträgt Position2.<br />
bool != Überträgt true, wenn ein Feld von Position1 nicht<br />
gleich <strong>de</strong>m entsprechen<strong>de</strong>n Feld in Position2 ist,<br />
ansonsten false.<br />
bool == Überträgt true, wenn je<strong>de</strong>s Feld von Position1 gleich<br />
<strong>de</strong>m entsprechen<strong>de</strong>n Feld in Position2 ist, ansonsten<br />
false.<br />
trsf Überträgt die geometrischen Komponenten <strong>de</strong>r<br />
Transformationen Position1 und Position2. Achtung!<br />
Im Allgemeinen ist ! Position1 Position2 ! =<br />
Position2 Position1!<br />
trsf ! Überträgt die Umkehrung <strong>de</strong>r Transformation von<br />
Position.<br />
Anweisungen<br />
Syntax<br />
num distance(trsf Position1, trsf Position2)<br />
num distance(, )<br />
Funktion<br />
Überträgt die Entfernung zwischen Position1 und Position2.<br />
ACHTUNG:<br />
Damit die Entfernung gültig ist, müssen Position1 und Position2 im gleichen Referenz-<br />
Koordinatensystem <strong>de</strong>finiert sein.<br />
Parameter<br />
trsf Position1 Ausdruck <strong>de</strong>s Typs Transformation<br />
trsf Position2 Ausdruck <strong>de</strong>s Typs Transformation<br />
Zum Beispiel<br />
// Zeigt <strong>de</strong>n Abstand zwischen zwei Punkten unabhängig von ihrem Referenz-Koordinatensystem an<br />
putln(distance(position(point1, world), position(point2, world)))<br />
Siehe auch<br />
point appro(point Position, trsf Umwandlung)<br />
point compose(point Position, frame Markierung, trsf Umwandlung)<br />
trsf position(point Position, frame Markierung)<br />
num distance(point Position1, point Position2)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 75 / 122
TYP FRAME<br />
Definition<br />
Der Typ frame dient zur Festlegung <strong>de</strong>r Position <strong>de</strong>r Referenz-Koordinatensysteme in <strong>de</strong>r Arbeitszelle.<br />
Der Typ frame ist ein strukturierter Typ mit einem einzigen verfügbaren Feld:<br />
trsf trsf Position <strong>de</strong>s Koordinatensystems in seinem Referenz-Koordinatensystem<br />
Das Referenz-Koordinatensystem einer Variable <strong>de</strong>s Typs frame wird bei ihrer Initialisierung festgelegt (von <strong>de</strong>r<br />
Benutzerschnittstelle aus o<strong>de</strong>r mit <strong>de</strong>m Operator =). Das Referenz-Koordinatensystem world <strong>de</strong>s Typs frame ist in<br />
einer VAL3-Applikation immer <strong>de</strong>finiert: Alle Referenz-Koordinatensysteme sind direkt o<strong>de</strong>r über an<strong>de</strong>re<br />
Koordinatensysteme mit world verbun<strong>de</strong>n.<br />
Wur<strong>de</strong>n die Koordinaten <strong>de</strong>s Bezugssystems world geän<strong>de</strong>rt, so wird bei je<strong>de</strong>r geometrischen Berechnung ein<br />
Ausführungsfehler erzeugt.<br />
Zusammenhang zwischen <strong>de</strong>n Referenz-Koordinatensystemen<br />
point1a<br />
point21a point21b<br />
frame 21 frame 21<br />
frame1 frame2<br />
world<br />
point2a<br />
Wenn nicht an<strong>de</strong>rs festgelegt, verwen<strong>de</strong>t eine Variable <strong>de</strong>s Typs frame world als Bezugssystem.<br />
Verwendung<br />
Die Verwendung von Referenz-Koordinatensystemen in einer Roboteranwendung wird ausdrücklich empfohlen:<br />
- Um die einzelnen Punkte <strong>de</strong>r Applikation intuitiv erkennen zu können<br />
Die von <strong>de</strong>r Arbeitszelle erlernten Punkte wer<strong>de</strong>n entsprechend <strong>de</strong>r hierarchischen Ordnung <strong>de</strong>r<br />
Koordinatensysteme in strukturierter Weise angezeigt.<br />
- Um die Position einer Gruppe von Punkten rasch zu än<strong>de</strong>rn<br />
Sobald ein Punkt <strong>de</strong>r Applikation an ein Objekt gebun<strong>de</strong>n ist, sollten für dieses Objekt ein Koordinatensystem<br />
<strong>de</strong>finiert und die VAL3-Punkte mit ihm verbun<strong>de</strong>n wer<strong>de</strong>n. Wenn das Objekt verschoben wird, braucht nur das<br />
Koordinatensystem neu gelernt zu wer<strong>de</strong>n, und alle mit ihm verbun<strong>de</strong>nen Punkte wer<strong>de</strong>n gleichzeitig korrigiert.<br />
- Zur Wie<strong>de</strong>rholung einer Bahn an mehreren Stellen <strong>de</strong>r Arbeitszelle<br />
Hierzu können die Bahnpunkte in Bezug auf ein Arbeitskoordinatensystem festgelegt wer<strong>de</strong>n, das dann an je<strong>de</strong>r<br />
Stelle, an <strong>de</strong>r die Bahn wie<strong>de</strong>rholt wer<strong>de</strong>n soll, gelernt wird. Durch Zuweisung <strong>de</strong>s Wertes eines gelernten<br />
Koordinatensystems an das Arbeitskoordinatensystem wird die gesamte Bahn auf das gelernte<br />
Koordinatensystem "verschoben".<br />
- Um geometrische Verschiebungen leichter berechnen zu können<br />
Die Anweisung compose() erlaubt geometrische Verschiebungen an einen beliebigen Punkt, die in irgen<strong>de</strong>inem<br />
Referenz-Koordinatensystem ausgedrückt wer<strong>de</strong>n. Die Anweisung position() dient zur Berechnung <strong>de</strong>r Position<br />
eines Punktes in einem beliebigen Referenz-Koordinatensystem.<br />
76 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
frame = <br />
bool != <br />
bool == <br />
Anweisungen<br />
num setFrame(point Herkunft, point AchseOx, point PlanOxy, frame&<br />
Markierung)<br />
Syntax<br />
num setFrame(point Herkunft, point AchseOx, point PlanOxy, frame& Markierung)<br />
Funktion<br />
Berechnet die Koordinaten von Markierung anhand <strong>de</strong>ssen Herkunft unter Verwendung eines Punktes AchseOx auf<br />
<strong>de</strong>r (Ox)-Achse und eines Punktes PlanOxy <strong>de</strong>r Ebene (Oxy).<br />
Der Punkt AchseOx muss auf <strong>de</strong>r positiven x-Achse liegen. Der Punkt PlanOxy muss auf <strong>de</strong>r positiven y-Achse liegen.<br />
Die Funktion liefert folgen<strong>de</strong> Antwort:<br />
0 Kein Fehler.<br />
-1 Der Punkt AchseOx liegt zu dicht am Herkunft.<br />
-2 Der Punkt PlanOxy liegt zu dicht an <strong>de</strong>r Achse (Ox).<br />
Wenn einer <strong>de</strong>r Punkte kein Referenz-Koordinatensystem besitzt, wird eine Fehlermeldung erzeugt.<br />
TYP TOOL<br />
Weist die Position und das Referenz-<br />
Koordinatensystem von Markierung2 <strong>de</strong>r Variable<br />
Markierung1 zu.<br />
Überträgt true, wenn Markierung1 und Markierung2<br />
nicht das gleiche Referenz-Koordinatensystem o<strong>de</strong>r<br />
darin nicht die gleiche Position haben.<br />
Überträgt true, wenn Markierung1 und Markierung2<br />
die gleiche Position im gleichen Referenz-<br />
Koordinatensystem haben.<br />
Definition<br />
Der Typ tool dient zur Definition <strong>de</strong>r Geometrie und <strong>de</strong>r Bewegung eines Werkzeugs.<br />
Der Typ tool ist ein strukturierter Typ mit folgen<strong>de</strong>n Fel<strong>de</strong>rn in <strong>de</strong>r nachstehen<strong>de</strong>n Reihenfolge:<br />
trsf trsf Position <strong>de</strong>s Tools als Basiswerkzeug<br />
dio gripper Digitaler Ausgang zur Steuerung <strong>de</strong>s Werkzeugs<br />
num otime Öffnungszeit <strong>de</strong>s Werkzeugs (in Sekun<strong>de</strong>n)<br />
num ctime Schließzeit <strong>de</strong>s Werkzeugs (in Sekun<strong>de</strong>n)<br />
Das Basiswerkzeug einer Variable <strong>de</strong>s Typs tool wird bei ihrer Initialisierung festgelegt (von <strong>de</strong>r Benutzerschnittstelle<br />
aus o<strong>de</strong>r mit <strong>de</strong>m Operator =). Das Basiswerkzeug flange <strong>de</strong>s Typs tool ist immer in einer VAL3-Applikation <strong>de</strong>finiert:<br />
Je<strong>de</strong>s Tool ist direkt o<strong>de</strong>r über an<strong>de</strong>re Tools mit <strong>de</strong>m Tool flange verbun<strong>de</strong>n.<br />
Wur<strong>de</strong>n die Koordinaten <strong>de</strong>s Werkzeugs flange geän<strong>de</strong>rt, so wird bei je<strong>de</strong>r geometrischen Berechnung ein<br />
Ausführungsfehler erzeugt.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 77 / 122
Abhängigkeit <strong>de</strong>r Tools<br />
Der Ausgang eines Tools ist vorprogrammiert auf Ausgang io:Ventil1 <strong>de</strong>s Systems, die Öffnungs- und Schließzeit sind<br />
0 und das Basistool ist flange.<br />
Verwendung<br />
Die Verwendung von Werkzeugen in einer Roboteranwendung wird ausdrücklich empfohlen:<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
outil21 outil21<br />
outil1 outil2<br />
flange<br />
- Um die Bewegungsgeschwindigkeit zu steuern<br />
Bei manuellen o<strong>de</strong>r programmierten Bewegungen steuert das System die kartesische Geschwindigkeit am<br />
Werkzeugen<strong>de</strong>.<br />
- Um mit verschie<strong>de</strong>nen Werkzeugen die gleichen Punkte anzufahren<br />
Hierzu genügt es, das VAL3-Werkzeug zu wählen, das <strong>de</strong>m am Arm montierten realen Werkzeug entspricht.<br />
- Um einen Verschleiß o<strong>de</strong>r einen Werkzeugwechsel zu verwalten<br />
Um die Armposition zu aktualisieren, brauchen nur die neuen Werkzeugkoordinaten eingegeben zu wer<strong>de</strong>n.<br />
tool = Weist <strong>de</strong>r Variablen Werkzeug1 die Position und das<br />
Basiswerkzeug von Werkzeug2 zu.<br />
bool != Überträgt true, wenn Werkzeug1 und Werkzeug2<br />
nicht das gleiche Basiswerkzeug, die gleiche Position<br />
in ihrem Basiswerkzeug, <strong>de</strong>n gleichen digitalen<br />
Ausgang o<strong>de</strong>r die gleichen Öffnungs- und<br />
Schließzeiten haben.<br />
bool == Überträgt true, wenn Werkzeug1 und Werkzeug2 die<br />
gleiche Position im gleichen Basiswerkzeug, <strong>de</strong>n<br />
gleichen digitalen Ausgang mit <strong>de</strong>n gleichen Öffnungs-<br />
und Schließzeiten haben.<br />
78 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Anweisungen<br />
Syntax<br />
void open (tool Werkzeug)<br />
void open(tool Werkzeug)<br />
Funktion<br />
Betätigung <strong>de</strong>s Werkzeugs (öffnen). Hierfür wird <strong>de</strong>r digitale Ausgang <strong>de</strong>s Werkzeugs auf true gesetzt.<br />
Bevor das Tool bewegt wer<strong>de</strong>n kann, wartet open() bis <strong>de</strong>r Roboter <strong>de</strong>n Punkt erreicht hat, was mittels einer<br />
gleichwertigen Aktion wie waitEndMove() geschieht. Nach <strong>de</strong>r Aktivierung wartet das System otime Sekun<strong>de</strong>n, bevor<br />
die nächste Anweisung ausgeführt wird.<br />
Diese Anweisung stellt nicht die Stabilisierung <strong>de</strong>s Roboters vor <strong>de</strong>r Aktivierung <strong>de</strong>s Werkzeugs an seiner Endposition<br />
sicher. Wenn die vollständige Stabilisierung nach <strong>de</strong>r Bewegung abgewartet wer<strong>de</strong>n soll, so muss die Anweisung<br />
isSettled() verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Wenn dio von Werkzeug nicht <strong>de</strong>finiert o<strong>de</strong>r kein Ausgang ist, wird ein Ausführungsfehler erzeugt, ebenso, wenn ein<br />
zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt wer<strong>de</strong>n kann (Endpunkt außer Reichweite).<br />
Parameter<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug<br />
Zum Beispiel<br />
// Die Anweisung open() entspricht:<br />
waitEndMove()<br />
tOutil.gripper=true<br />
<strong>de</strong>lay(tOutil.otime)<br />
Siehe auch<br />
void close(tool Werkzeug)<br />
void waitEndMove()<br />
Syntax<br />
void close (tool Werkzeug)<br />
void close(tool Werkzeug)<br />
Funktion<br />
Betätigt das Werkzeug (schließen). Hierfür wird <strong>de</strong>r digitale Ausgang <strong>de</strong>s Werkzeugs auf false gesetzt.<br />
Bevor das Tool bewegt wer<strong>de</strong>n kann, wartet open() bis <strong>de</strong>r Roboter <strong>de</strong>n Punkt erreicht hat, was mittels einer<br />
gleichwertigen Aktion wie waitEndMove() geschieht. Nach <strong>de</strong>r Aktivierung wartet das System ctime Sekun<strong>de</strong>n, bevor<br />
die nächste Anweisung ausgeführt wird.<br />
Diese Anweisung stellt nicht die Stabilisierung <strong>de</strong>s Roboters vor <strong>de</strong>r Aktivierung <strong>de</strong>s Werkzeugs an seiner Endposition<br />
sicher. Wenn die vollständige Stabilisierung nach <strong>de</strong>r Bewegung abgewartet wer<strong>de</strong>n soll, so muss die Anweisung<br />
isSettled() verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Wenn dio von Werkzeug nicht <strong>de</strong>finiert o<strong>de</strong>r kein Ausgang ist, wird ein Ausführungsfehler erzeugt, ebenso, wenn ein<br />
zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt wer<strong>de</strong>n kann (Endpunkt außer Reichweite).<br />
Parameter<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug<br />
Zum Beispiel<br />
// Ausdruck <strong>de</strong>s Typs Werkzeug:<br />
waitEndMove()<br />
tOutil.gripper = false<br />
<strong>de</strong>lay(tOutil.ctime)<br />
Siehe auch<br />
Type tool<br />
void open(tool Werkzeug)<br />
void waitEndMove()<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 79 / 122
TYP POINT<br />
Definition<br />
Der Typ point dient zur Definition <strong>de</strong>r Position und Orientierung <strong>de</strong>s Roboterwerkzeugs in <strong>de</strong>r Arbeitszelle.<br />
Der Typ point ist ein strukturierter Typ mit folgen<strong>de</strong>n Fel<strong>de</strong>rn in <strong>de</strong>r nachstehen<strong>de</strong>n Reihenfolge:<br />
trsf trsf Position <strong>de</strong>s Punktes in seinem Referenz-Koordinatensystem<br />
config config Konfiguration <strong>de</strong>s Arms, um die Position anfahren zu können<br />
Das Referenz-Koordinatensystem eines point ist eine Variable <strong>de</strong>s Typs frame, die bei ihrer Initialisierung <strong>de</strong>finiert wird<br />
(von <strong>de</strong>r Benutzerschnittstelle aus, mit <strong>de</strong>m Operator = und <strong>de</strong>n Anweisungen here(), appro() und compose()).<br />
Punkt<strong>de</strong>finition<br />
Wenn man eine Variable <strong>de</strong>s Typs point ohne <strong>de</strong>finiertes Referenz-Koordinatensystem verwen<strong>de</strong>t, wird eine<br />
Fehlermeldung erzeugt.<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
Frame world Frame f1<br />
Point p0<br />
Point p1<br />
ACHTUNG:<br />
Eine lokale Variable <strong>de</strong>s Typs point hat standardmäßig kein vorprogrammiertes Referenz-<br />
Koordinatensystem. Um sie zu verwen<strong>de</strong>n, muss sie von einem an<strong>de</strong>ren Punkt aus o<strong>de</strong>r mit<br />
einer <strong>de</strong>r Anweisungen here(), appro() o<strong>de</strong>r compose() initialisiert wer<strong>de</strong>n.<br />
point = Weist die Position, die Konfiguration und das<br />
Referenz-Koordinatensystem von Punkt1 <strong>de</strong>r<br />
Variablen Punkt2 zu.<br />
bool ! = Überträgt true, wenn Punkt1 und Punkt2 nicht das<br />
gleiche Referenz-Koordinatensystem o<strong>de</strong>r darin<br />
nicht die gleiche Position haben.<br />
bool == Überträgt true, wenn Punkt1 und Punkt2 die gleiche<br />
Position im gleichen Referenz-Koordinatensystem<br />
haben.<br />
80 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong><br />
Frame f2<br />
Point p2<br />
Point p3
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Anweisungen<br />
Syntax<br />
num distance(point Position1, point Position2)<br />
num distance(point Position1, point Position2)<br />
Funktion<br />
Überträgt die Entfernung zwischen Position1 und Position2.<br />
Ein Ausführungsfehler wird erzeugt, wenn das Referenz-Koordinatensystem von Position1 o<strong>de</strong>r Position2 nicht<br />
festgelegt ist.<br />
Parameter<br />
point Position1 Ausdruck <strong>de</strong>s Typs point<br />
point Position2 Ausdruck <strong>de</strong>s Typs point<br />
Zum Beispiel<br />
// Zeigt <strong>de</strong>n Abstand zwischen zwei Punkten unabhängig von ihrem Referenz-Koordinatensystem an<br />
putln(distance(point1, point2))<br />
Siehe auch<br />
point appro(point Position, trsf Umwandlung)<br />
point compose(point Position, frame Markierung, trsf Umwandlung)<br />
trsf position(point Position, frame Markierung)<br />
num distance(point Position1, point Position2)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 81 / 122
point compose(point Position, frame Markierung, trsf Umwandlung)<br />
Syntax<br />
point compose(point Position, frame Markierung, trsf Umwandlung)<br />
Funktion<br />
Überträgt Position, auf welche die in Bezug auf Markierung <strong>de</strong>finierte Koordinatentransformation Umwandlung<br />
angewandt wur<strong>de</strong>.<br />
ACHTUNG:<br />
Die Drehkomponente von Umwandlung än<strong>de</strong>rt in <strong>de</strong>r Regel nicht nur die Ausrichtung von<br />
Position, son<strong>de</strong>rn auch seine kartesischen Koordinaten (außer wenn sich Position am<br />
Ursprung von Markierung befin<strong>de</strong>t).<br />
Wenn Umwandlung nur die Ausrichtung von Position än<strong>de</strong>rn soll, muss das Ergebnis mit <strong>de</strong>n<br />
kartesischen Koordinaten von Position aktualisiert wer<strong>de</strong>n (siehe Beispiel).<br />
Das Referenz-Koordinatensystem und die Konfiguration <strong>de</strong>s übertragenen Punktes sind die von Position.<br />
Wenn für Position kein Referenz-Koordinatensystem <strong>de</strong>finiert ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
point Position Ausdruck <strong>de</strong>s Typs point<br />
frame Markierung Ausdruck <strong>de</strong>s Typs Referenz-Koordinatensystem<br />
trsf Umwandlung Ausdruck <strong>de</strong>s Typs Transformation<br />
Zum Beispiel<br />
point pResultat<br />
// Än<strong>de</strong>rung <strong>de</strong>r Ausrichtung ohne Än<strong>de</strong>rung von Position<br />
pResultat = compose (Position,Markierung,Umwandlung)<br />
pResultat.x = Position.x<br />
pResultat.y = Position.y<br />
pResultat.z = Position.z<br />
// Än<strong>de</strong>rung von Position ohne Än<strong>de</strong>rung <strong>de</strong>r Ausrichtung<br />
Umwandlung.rx = Umwandlung.ry =Umwandlung.rz = 0<br />
pResultat = compose (pResultat,Markierung,Umwandlung)<br />
Siehe auch<br />
Opérateur trsf * <br />
point appro(point Position, trsf Umwandlung)<br />
82 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
point appro(point Position, trsf Umwandlung)<br />
point appro(point Position, trsf Umwandlung)<br />
Funktion<br />
Überträgt Position, auf welche die für das Referenz-Koordinatensystem von Position <strong>de</strong>finierte<br />
Koordinatentransformation Umwandlung angewandt wur<strong>de</strong>.<br />
Das Referenz-Koordinatensystem und die Konfiguration <strong>de</strong>s übertragenen Punktes sind die von Position.<br />
Wenn für Position kein Referenz-Koordinatensystem <strong>de</strong>finiert ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
point Position Ausdruck <strong>de</strong>s Typs point<br />
trsf Umwandlung Ausdruck <strong>de</strong>s Typs Transformation<br />
Zum Beispiel<br />
// Annähern auf 100 mm oberhalb <strong>de</strong>s Punktes (Z-Achse)<br />
point p<br />
movej(appro(p,{0,0,-100,0,0,0}), flange, mNomDesc) // Annäherung<br />
movel(p, flange, mNomDesc) // Bewegung zum Punkt<br />
Siehe auch<br />
Opérateur trsf * <br />
point compose(point Position, frame Markierung, trsf Umwandlung)<br />
point here(tool Werkzeug, frame Markierung)<br />
Syntax<br />
point here(tool Werkzeug, frame Markierung)<br />
Funktion<br />
Überträgt die aktuelle Position <strong>de</strong>s Werkzeugs Werkzeug in Markierung (empfohlene Position und nicht die<br />
gemessene Position).<br />
Das Referenz-Koordinatensystem <strong>de</strong>s übertragenen Punktes ist Markierung. Die Konfiguration <strong>de</strong>s übertragenen<br />
Punktes ist die aktuelle Konfiguration <strong>de</strong>s Arms.<br />
Siehe auch<br />
joint herej()<br />
config config(joint Position)<br />
point jointToPoint(tool Werkzeug, frame Markierung, joint Position)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 83 / 122
point jointToPoint(tool Werkzeug, frame Markierung, joint Position)<br />
Syntax<br />
point jointToPoint (tool Werkzeug, frame Markierung, joint Position)<br />
Funktion<br />
Überträgt die Position Werkzeug in Markierung, wenn <strong>de</strong>r Arm in <strong>de</strong>r Gelenkposition Position ist.<br />
Das Referenz-Koordinatensystem <strong>de</strong>s übertragenen Punktes ist Markierung. Die Konfiguration <strong>de</strong>s übertragenen<br />
Punktes ist die <strong>de</strong>s Arms in <strong>de</strong>r Gelenkposition Position.<br />
Parameter<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug<br />
frame Markierung Ausdruck <strong>de</strong>s Typs Referenz-Koordinatensystem<br />
joint Position Ausdruck <strong>de</strong>s Typs Gelenkposition<br />
Siehe auch<br />
point here(tool Werkzeug, frame Markierung)<br />
bool pointToJoint(tool Werkzeug, joint anfänglich, point Position,joint& Angaben)<br />
bool pointToJoint(tool Werkzeug, joint anfänglich, point Position,joint&<br />
Angaben)<br />
Syntax<br />
bool pointToJoint(tool Werkzeug, joint anfänglich, point Position, joint& Angaben)<br />
Funktion<br />
Berechnet die Angaben, die <strong>de</strong>r spezifizierten Position entsprechen. Überträgt true, wenn Gelenk-Angaben gefun<strong>de</strong>n<br />
wur<strong>de</strong>n, und false, wenn es keine Lösung gibt.<br />
Die gesuchte Gelenkposition ist mit <strong>de</strong>r Konfiguration von Position kompatibel. Die Fel<strong>de</strong>r mit <strong>de</strong>m Wert free schreiben<br />
keine Konfiguration vor. Die Fel<strong>de</strong>r mit <strong>de</strong>m Wert same schreiben die gleiche Konfiguration wie anfänglich vor.<br />
Wenn die Achsen mehr als eine Umdrehung ausführen sollen, gibt es mehrere Lösungen, die genau die gleiche<br />
Konfiguration haben: Es wird die anfänglich am nächsten liegen<strong>de</strong> Lösung genommen.<br />
Wenn Position außer Reichweite (Arm zu kurz) o<strong>de</strong>r außerhalb <strong>de</strong>r Softwaregrenzen liegt, kann es sein, dass es keine<br />
Lösung gibt. Wenn Position eine Konfiguration spezifiziert, kann sie für diese Konfiguration außerhalb, aber für eine<br />
an<strong>de</strong>re Konfiguration innerhalb <strong>de</strong>r Softwaregrenzen liegen.<br />
Wenn für Position kein Referenz-Koordinatensystem <strong>de</strong>finiert ist, wird eine Fehlermeldung erzeugt.<br />
Parameter<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug<br />
joint anfänglich Ausdruck <strong>de</strong>s Typs Gelenkposition<br />
point Position Ausdruck <strong>de</strong>s Typs point<br />
joint& Angaben Variable <strong>de</strong>s Typs Gelenkposition<br />
Siehe auch<br />
joint herej()<br />
point jointToPoint(tool Werkzeug, frame Markierung, joint Position)<br />
84 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
trsf position(point Position, frame Markierung)<br />
trsf position(point Position, frame Markierung)<br />
Funktion<br />
Überträgt die Koordinaten von Position in Markierung.<br />
Wenn Position kein Referenz-Koordinatensystem besitzt, wird eine Fehlermeldung erzeugt.<br />
Zum Beispiel<br />
// Zeigt <strong>de</strong>n Abstand zwischen zwei Punkten unabhängig von ihrem Referenz-Koordinatensystem an<br />
putln(distance(position(point1, world), position(point2, world)))<br />
Siehe auch<br />
num distance(point Position1, point Position2)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 85 / 122
TYP CONFIG<br />
Die Konfiguration eines kartesischen Punktes gehört zu <strong>de</strong>n komplexeren Funktionen und kann beim ersten Lesen<br />
übergangen wer<strong>de</strong>n.<br />
Einleitung<br />
Im Allgemeinen hat <strong>de</strong>r Roboter mehrere Möglichkeiten, eine in kartesischen Koordinaten angegebene Position<br />
anzufahren.<br />
Diese verschie<strong>de</strong>nen Möglichkeiten wer<strong>de</strong>n "Konfigurationen" genannt. Die nachfolgen<strong>de</strong> Zeichnung zeigt zwei<br />
verschie<strong>de</strong>ne Konfigurationen:<br />
Zwei verschie<strong>de</strong>ne Konfigurationen, um <strong>de</strong>nselben Punkt zu erreichen: P<br />
In bestimmten Fällen ist es wichtig, anzugeben, welche <strong>de</strong>r möglichen Konfigurationen zulässig sind und welche<br />
verboten wer<strong>de</strong>n sollen. Um dieses Problem zu lösen, können mit <strong>de</strong>m Typ point dank <strong>de</strong>s nachstehend <strong>de</strong>finierten<br />
Fel<strong>de</strong>s <strong>de</strong>s Typs config die zulässigen Roboterkonfigurationen spezifiziert wer<strong>de</strong>n.<br />
Definition<br />
Typ config ermöglicht die Definition <strong>de</strong>r erlaubten Konfigurationen für eine bestimmte kartesische Position.<br />
Er hängt vom verwen<strong>de</strong>ten Armtyp ab.<br />
Für einen Stäubli RX/TX-Arm ist <strong>de</strong>r Typ config ein strukturierter Typ mit folgen<strong>de</strong>n Fel<strong>de</strong>rn in <strong>de</strong>r nachstehen<strong>de</strong>n<br />
Reihenfolge:<br />
shoul<strong>de</strong>r Konfiguration <strong>de</strong>r Schulter<br />
elbow Konfiguration <strong>de</strong>s Ellenbogens<br />
wrist Konfiguration <strong>de</strong>s Handgelenks<br />
Für einen Stäubli RS-Arm ist <strong>de</strong>r Typ config auf das Feld Shoul<strong>de</strong>r begrenzt:<br />
shoul<strong>de</strong>r Konfiguration <strong>de</strong>r Schulter<br />
Die Fel<strong>de</strong>r shoul<strong>de</strong>r, elbow und wrist können folgen<strong>de</strong> Werte annehmen:<br />
shoul<strong>de</strong>r<br />
righty Konfiguration <strong>de</strong>r Schulter righty vorgeschrieben<br />
lefty Konfiguration <strong>de</strong>r Schulter lefty vorgeschrieben<br />
ssame An<strong>de</strong>re Schulterkonfiguration verboten<br />
sfree Beliebige Konfiguration <strong>de</strong>r Schulter<br />
P P<br />
86 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
elbow<br />
wrist<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
Konfiguration (Arm RX/TX)<br />
epositive Konfiguration <strong>de</strong>s Ellenbogens epositive vorgeschrieben<br />
enegative Konfiguration <strong>de</strong>s Ellenbogens enegative vorgeschrieben<br />
esame An<strong>de</strong>re Ellenbogenkonfiguration verboten<br />
efree Beliebige Konfiguration <strong>de</strong>s Ellenbogens<br />
wpositive Konfiguration <strong>de</strong>s Handgelenks wpositive vorgeschrieben<br />
wnegative Konfiguration <strong>de</strong>s Handgelenks wnegative vorgeschrieben<br />
wsame An<strong>de</strong>re Handgelenkkonfiguration verboten<br />
wfree Beliebige Konfiguration <strong>de</strong>s Handgelenks<br />
config = <br />
bool != <br />
bool == <br />
Weist die Fel<strong>de</strong>r shoul<strong>de</strong>r, elbow und wrist von<br />
Konfiguration2 <strong>de</strong>r Variablen Konfiguration1 zu.<br />
Überträgt true, wenn die Fel<strong>de</strong>r shoul<strong>de</strong>r, elbow o<strong>de</strong>r wrist<br />
in Konfiguration1 und Konfiguration2 nicht <strong>de</strong>n gleichen<br />
Wert haben.<br />
Überträgt true, wenn die Fel<strong>de</strong>r shoul<strong>de</strong>r, elbow o<strong>de</strong>r wrist<br />
in Konfiguration1 und Konfiguration2 <strong>de</strong>n gleichen Wert<br />
haben.<br />
Konfiguration <strong>de</strong>r Schulter<br />
Um einen kartesischen Punkt zu erreichen kann sich <strong>de</strong>r Roboterarm rechts o<strong>de</strong>r links von diesem Punkt befin<strong>de</strong>n:<br />
Diese bei<strong>de</strong>n Konfigurationen wer<strong>de</strong>n righty und lefty genannt.<br />
Konfiguration: righty Konfiguration: lefty<br />
Die Konfiguration righty ist <strong>de</strong>finiert durch ((d1.sin(j2) + d2.sin(j2+j3) + ) < 0, die Konfiguration lefty durch<br />
(d1.sin(j2) + d2.sin(j2+j3) + ) >= 0, mit d1 = Armlänge <strong>de</strong>s Roboters, d2 = Unterarmlänge und = Abstand <strong>de</strong>r<br />
Achsen 1 und 2 in Richtung x.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 87 / 122
Konfiguration <strong>de</strong>s Ellenbogens<br />
Zusätzlich zur Konfiguration <strong>de</strong>r Schulter gibt es zwei Möglichkeiten für das Ellenbogengelenk <strong>de</strong>s Roboters: Die<br />
Ellenbogenkonfigurationen wer<strong>de</strong>n epositive und enegative genannt.<br />
Konfiguration: enegative Konfiguration: epositive<br />
Die Konfiguration epositive ist durch j3 >= 0 <strong>de</strong>finiert.<br />
Die Konfiguration enegative ist durch j3 < 0 <strong>de</strong>finiert.<br />
Konfiguration <strong>de</strong>s Handgelenks<br />
Außer <strong>de</strong>r Konfiguration <strong>de</strong>r Schulter und <strong>de</strong>s Ellenbogens gibt es zwei Möglichkeiten für das Handgelenk <strong>de</strong>s<br />
Roboters. Die bei<strong>de</strong>n Konfigurationen <strong>de</strong>s Handgelenks wer<strong>de</strong>n wpositive und wnegative genannt.<br />
Konfiguration: wnegative Konfiguration: wpositive<br />
Die Konfiguration wpositive ist durch q5 >= 0 <strong>de</strong>finiert.<br />
Die Konfiguration wnegative ist durch q5 < 0 <strong>de</strong>finiert.<br />
88 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Konfiguration (Arm RS)<br />
Um einen kartesischen Punkt zu erreichen kann sich <strong>de</strong>r Roboterarm rechts o<strong>de</strong>r links von diesem Punkt befin<strong>de</strong>n:<br />
Diese bei<strong>de</strong>n Konfigurationen wer<strong>de</strong>n righty und lefty genannt.<br />
Konfiguration: righty Konfiguration: lefty<br />
Die Konfiguration righty ist <strong>de</strong>finiert durch sin(j2) > 0, die Konfiguration lefty durch sin(j2) < 0.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 89 / 122
Anweisungen<br />
Syntax<br />
config config(joint Position)<br />
config config(joint Position)<br />
Funktion<br />
Überträgt die Roboterkonfiguration für die Gelenkposition Position.<br />
Parameter<br />
joint Position Ausdruck <strong>de</strong>s Typs Gelenkposition<br />
Siehe auch<br />
point here(tool Werkzeug, frame Markierung)<br />
joint herej()<br />
90 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
BEWEGUNGSSTEUERUNG<br />
BEWEGUNGSSTEUERUNG<br />
Um eine Roboterbahn zu <strong>de</strong>finieren, genügt es nicht, nur eine Reihe von Punkten anzugeben. Es müssen außer<strong>de</strong>m<br />
die Art <strong>de</strong>r zwischen diesen Punkten verwen<strong>de</strong>ten Bahnen (Kurven- o<strong>de</strong>r Gera<strong>de</strong>nabschnitte) sowie die Art <strong>de</strong>r<br />
Anschlüsse zwischen diesen Abschnitten und schließlich die Geschwindigkeitsparameter für diese Bewegung<br />
festgelegt wer<strong>de</strong>n. Dieses Kapitel gibt eine Einführung in Punkt-zu-Punkt-Bewegungen und geradlinige Bewegungen<br />
(Anweisungen movej und movel) und beschreibt, wie die Parameter <strong>de</strong>s Bewegungs<strong>de</strong>skriptors (Typ m<strong>de</strong>sc) zu<br />
verwen<strong>de</strong>n sind.<br />
Bewegungstypen: Punkt-zu-Punkt, geradlinig, kreisförmig<br />
Roboterbewegungen wer<strong>de</strong>n vor allem mit <strong>de</strong>n Anweisungen movej, movel und movec programmiert. Mit movej<br />
wer<strong>de</strong>n Punkt-zu-Punkt-Bewegungen, mit movel geradlinige Bewegungen und mit movec kreisförmige Bewegungen<br />
ausgeführt.<br />
Bei einer Punkt-zu-Punkt-Bewegung ist nur <strong>de</strong>r Endpunkt (kartesischer Punkt o<strong>de</strong>r Gelenkpunkt) von Be<strong>de</strong>utung.<br />
Zwischen <strong>de</strong>m Anfangs- und <strong>de</strong>m Endpunkt folgt das Werkzeugzentrum einer vom System <strong>de</strong>finierten Kurve, um die<br />
Bewegungsgeschwindigkeit zu optimieren.<br />
Anfans- und Endposition<br />
Dagegen bewegt sich <strong>de</strong>r Werkzeugmittelpunkt bei einer geradlinigen Bewegung entlang <strong>de</strong>r vorgegebenen Gera<strong>de</strong>n.<br />
Die Orientierung wird zwischen <strong>de</strong>r Ausgangs- und Endorientierung <strong>de</strong>s Werkzeugs linear interpoliert.<br />
Z<br />
X<br />
Y<br />
Initial position<br />
Final position<br />
Geradlinige Bewegung<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 91 / 122<br />
X<br />
Z<br />
Y
Bei einer kreisförmigen Bewegung bewegt sich die Werkzeugmitte entlang eines durch 3 Punkte <strong>de</strong>finierten<br />
Kreisbogens, und die Orientierung <strong>de</strong>s Werkzeugs wird zwischen Ausgangs-, Mittel- und Endorientierung interpoliert.<br />
Z<br />
Vom Werkzeug während <strong>de</strong>r<br />
kreisförmigen Bewegung beschriebene Bahn<br />
Kreisförmige Bewegung<br />
Zum Beispiel:<br />
Eine typische Handlingaufgabe besteht darin, Teile an einem Ort aufzunehmen und an einem an<strong>de</strong>ren Ort abzulegen.<br />
Angenommen, die Teile sollen am Punkt PRISE aufgenommen und am Punkt DEPOSE abgelegt wer<strong>de</strong>n. Um vom<br />
Punkt PRISE zum Punkt DEPOSE zu gelangen, muss <strong>de</strong>r Roboter über einen Zwischenpunkt DEGAGE und einen<br />
Annäherungspunkt APPRO fahren.<br />
DEGAGE<br />
Z<br />
PRISE<br />
Z<br />
X<br />
X<br />
Zyklus: U<br />
APPRO<br />
DEPOSE<br />
Nächste Bewegung<br />
Vorherige Bewegung<br />
Angenommen, <strong>de</strong>r Roboter steht zu Beginn am Punkt PRISE. Dann kann das Programm für diese Bewegung wie folgt<br />
aussehen:<br />
movel(DEGAGE, tool, mDesc)<br />
movej(APPRO, tool, mDesc)<br />
movel(DEPOSE, tool, mDesc)<br />
92 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong><br />
Z<br />
Z<br />
X<br />
X
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Zum Freifahren und zur Annäherung wer<strong>de</strong>n gera<strong>de</strong> Bahnabschnitte verwen<strong>de</strong>t. Die Hauptbewegung ist dagegen eine<br />
Punkt-zu-Punkt-Bewegung, da dieser Teil <strong>de</strong>r Bahn keine genaue geometrische Steuerung erfor<strong>de</strong>rt, son<strong>de</strong>rn vielmehr<br />
möglichst rasch zurückgelegt wer<strong>de</strong>n soll.<br />
Hinweis:<br />
Bei bei<strong>de</strong>n Bewegungstypen hängt die Geometrie <strong>de</strong>r Bahn nicht von <strong>de</strong>r Geschwindigkeit ab,<br />
mit <strong>de</strong>r die Bewegungen ausgeführt wer<strong>de</strong>n. Der Roboter fährt immer <strong>de</strong>n gleichen Punkt an.<br />
Dieser Umstand ist bei <strong>de</strong>r Entwicklung von Applikationen beson<strong>de</strong>rs wichtig. Man kann mit<br />
langsamen Bewegungen beginnen und die Geschwindigkeit nach und nach erhöhen, ohne dabei<br />
die Bahn <strong>de</strong>s Roboters zu än<strong>de</strong>rn.<br />
Verkettung von Bewegungen<br />
Glättung<br />
Sehen wir uns das Beispiel <strong>de</strong>s U-Zyklus im letzten Abschnitt an. Ohne beson<strong>de</strong>re Maßnahmen zur Verkettung <strong>de</strong>r<br />
Bewegungen wür<strong>de</strong> <strong>de</strong>r Roboter an <strong>de</strong>n Punkten DEGAGE und DEPOSE anhalten, <strong>de</strong>nn die Bahn hat an diesen<br />
Stellen einen Knick. Das wür<strong>de</strong> unnötig Zeit kosten, außer<strong>de</strong>m ist das genaue Anfahren dieser Punkte gar nicht<br />
erfor<strong>de</strong>rlich.<br />
Durch Glättung <strong>de</strong>r Bahn in <strong>de</strong>r Umgebung <strong>de</strong>r Punkte DEGAGE und APPRO lässt sich die Dauer <strong>de</strong>r gesamten<br />
Bewegung erheblich verkürzen. Hierzu dient das Feld blend im Bewegungs<strong>de</strong>skriptor. Wenn <strong>de</strong>r Wert in diesem Feld<br />
auf off steht, hält <strong>de</strong>r Roboter an je<strong>de</strong>m Punkt an. Wenn dieser Parameter jedoch auf joint gesetzt wird, wird die Bahn<br />
in <strong>de</strong>r Umgebung dieser Punkte geglättet und <strong>de</strong>r Roboter hält beim Überfahren <strong>de</strong>r Punkte nicht mehr an.<br />
Wenn das Feld blend <strong>de</strong>n Wert joint annimmt, müssen zwei weitere Parameter spezifiziert wer<strong>de</strong>n: leave und reach.<br />
Mit diesen Parametern wird festgelegt, in welcher Entfernung vom Zielpunkt die theoretische Bahn verlassen (Beginn<br />
<strong>de</strong>r Glättung) und in welcher Entfernung vom Zielpunkt sie wie<strong>de</strong>r eingenommen wird (En<strong>de</strong> <strong>de</strong>r Glättung).<br />
Definition <strong>de</strong>r Entfernungen: ’leave’ / ’reach’<br />
LEAVE<br />
REACH<br />
Zum Beispiel:<br />
Betrachten wir das Programm im Kapitel "Bewegungstypen:Punkt-zu-Punkt und geradlinig". Das vorhergehen<strong>de</strong><br />
Bewegungsprogramm kann geän<strong>de</strong>rt wer<strong>de</strong>n:<br />
mDesc.blend = joint<br />
mDesc.leave = 50<br />
mDesc.reach = 200<br />
movel(DEGAGE, tool, mDesc)<br />
mDesc.leave = 200<br />
mDesc.reach = 50<br />
movej(APPRO, tool, mDesc)<br />
mDesc.blend = OFF<br />
movel(DEPOSE, tool, mDesc)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 93 / 122
Damit erhält man folgen<strong>de</strong> Bahn:<br />
DEGAGE<br />
50<br />
Geglätteter Zyklus<br />
Der Roboter hält an <strong>de</strong>n Punkten DEGAGE und APPRO nicht mehr an. Die Bewegung wird daher schneller. Je größer<br />
die Entfernungen leave und reach gewählt wer<strong>de</strong>n, <strong>de</strong>sto rascher wird die Bewegung.<br />
Aufheben <strong>de</strong>r Glättung<br />
Die Anweisung waitEndMove() ermöglicht unter an<strong>de</strong>rem, <strong>de</strong>n Glättungseffekt zu annullieren. In diesem Fall führt <strong>de</strong>r<br />
Roboter die zuletzt programmierte Bewegung bis zum Zielpunkt aus, als ob das Feld blend im Bewegungs<strong>de</strong>skriptor<br />
auf off stehen wür<strong>de</strong>.<br />
Betrachten wir zum Beispiel das folgen<strong>de</strong> Programm:<br />
mDesc.blend = joint<br />
mDesc.leave = 10<br />
mDesc.reach = 10<br />
movej(A, tool, mDesc)<br />
movej(B, tool, mDesc)<br />
waitEndMove()<br />
movej(C, tool, mDesc)<br />
movej(D, tool, mDesc)<br />
etc...<br />
ergibt sich folgen<strong>de</strong> Bahn <strong>de</strong>s Roboters:<br />
Zyklus mit unterbrochener Glättung<br />
APPRO<br />
PRISE DEPOSE<br />
10<br />
200<br />
A<br />
10<br />
No smoothing at B<br />
(BREAK)<br />
10<br />
B<br />
94 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong><br />
10<br />
10<br />
C<br />
10<br />
200<br />
10<br />
D<br />
10<br />
50
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Wie<strong>de</strong>raufnahme einer Bewegung<br />
Wird die Energieversorgung <strong>de</strong>s Arms unterbrochen bevor <strong>de</strong>r Roboter seine Bewegungen been<strong>de</strong>t hat, zum Beispiel<br />
nach einer Notabschaltung, so muss nach <strong>de</strong>r Wie<strong>de</strong>rherstellung <strong>de</strong>r Energieversorgung eine Bewegungs-<br />
Wie<strong>de</strong>raufnahme durchgeführt wer<strong>de</strong>n. Wur<strong>de</strong> <strong>de</strong>r Arm während <strong>de</strong>r Abschaltung per Hand verschoben, so kann er von<br />
seiner Bahn weit entfernt sein. Es muss also sichergestellt wer<strong>de</strong>n, dass die Bewegung ohne Kollisionsgefahr<br />
wie<strong>de</strong>raufgenommen wer<strong>de</strong>n kann. Die CS8-Bahnkontrolle ermöglicht die Verwaltung <strong>de</strong>r Bewegungs-<br />
Wie<strong>de</strong>raufnahme mittels einer "Anschlussbewegung".<br />
Bei <strong>de</strong>r Wie<strong>de</strong>raufnahme <strong>de</strong>r Bewegung stellt das System sicher, dass sich <strong>de</strong>r Roboter auf <strong>de</strong>r programmierten Bahn<br />
befin<strong>de</strong>t: Bei Abweichungen (auch sehr kleinen Werts) zeichnet er automatisch einen Punkt-zu-Punkt-<br />
Bewegungsbefehl auf, <strong>de</strong>r zur exakten Position, aus welcher <strong>de</strong>r Roboter seine Bahn verlassen hat, zurückführt: Dies<br />
ist die sogenannte "Anschlussbewegung". Sie erfolgt mit reduzierter Geschwindigkeit. Sie muss vom Bediener bestätigt<br />
wer<strong>de</strong>n, außer bei Automatikbetrieb, wo sie ohne menschliche Eingriffe erfolgen kann. Das Verhalten bei<br />
Automatikbetrieb kann mittels <strong>de</strong>r Anweisung autoConnectMove() festgelegt wer<strong>de</strong>n.<br />
Die Anweisung resetMotion() ermöglicht das Abbrechen <strong>de</strong>r aktuellen Bewegung und das eventuelle Programmieren<br />
einer Anschlussbewegung, mit <strong>de</strong>ren Hilfe eine Position bei reduzierter Geschwindigkeit unter <strong>de</strong>r Kontrolle <strong>de</strong>s<br />
Bedieners angefahren wer<strong>de</strong>n kann.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 95 / 122
Beson<strong>de</strong>rheiten <strong>de</strong>r kartesischen Bewegungen (geradlinig, kreisförmig)<br />
Interpolation <strong>de</strong>r Ausrichtung<br />
Um die Ausrichtung zu än<strong>de</strong>rn, minimiert <strong>de</strong>r CS8-Bahnerzeuger stets die Amplitu<strong>de</strong> <strong>de</strong>r Werkzeugdrehungen.<br />
Dadurch kann als Son<strong>de</strong>rfall, für alle geradlinigen o<strong>de</strong>r kreisförmigen Bewegungen, eine absolute, konstante<br />
Ausrichtung o<strong>de</strong>r eine Ausrichtung bezüglich <strong>de</strong>r Bahn programmiert wer<strong>de</strong>n.<br />
• Für eine konstante Ausrichtung müssen Ausgangs- und Endposition sowie die Mittelposition für einen Kreis<br />
dieselbe Ausrichung haben.<br />
Absolute, konstante Ausrichtung<br />
• Für eine konstante Ausrichtung bezüglich <strong>de</strong>r Bahn (z. B. Richtung Y <strong>de</strong>r Werkzeugmarkierung<br />
Bahntangente) müssen Ausgangs- und Endposition sowie die Mittelposition für einen Kreis dieselbe<br />
Ausrichtung haben.<br />
Vorherige Bewegung<br />
Y<br />
Vom Werkzeug während <strong>de</strong>r<br />
kreisförmigen Bewegung beschriebene<br />
Bahn<br />
(Ausrichtung bleibt konstant)<br />
Vorherige Bewegung<br />
Konstante Ausrichtung bezüglich <strong>de</strong>r Bahn<br />
Vom Werkzeug während <strong>de</strong>r kreisförmigen<br />
Bewegung beschriebene Bahn<br />
(Tangentenausrichtung)<br />
Nächste Bewegung<br />
Nächste Bewegung<br />
96 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Daraus ergibt sich eine Beschränkung für die kreisförmigen Bewegungen:<br />
Wenn <strong>de</strong>r mittlere Punkt mit <strong>de</strong>m Anfangs- o<strong>de</strong>r mit <strong>de</strong>m Endpunkt einen Winkel von 180° o<strong>de</strong>r mehr bil<strong>de</strong>t, gibt es<br />
mehrere Interpolations- und Ausrichtungsmöglichkeiten und es wird ein Fehler erzeugt.<br />
Die Position <strong>de</strong>s mittleren Punktes muss also geän<strong>de</strong>rt wer<strong>de</strong>n, um die Mehr<strong>de</strong>utigkeit <strong>de</strong>r mittleren Ausrichtungen zu<br />
been<strong>de</strong>n.<br />
Mehr<strong>de</strong>utigkeit <strong>de</strong>r mittleren Ausrichtung<br />
Fehler: kreisförmige Bewegungen<br />
Insbeson<strong>de</strong>re verlangt die Programmierung eines vollständigen Kreises 2 movec-Anweisungen:<br />
movec (B, C, Werkzeug, mDesc)<br />
movec (D, A, Werkzeug, mDesc)<br />
Nächste<br />
Bewegung<br />
A<br />
Vollständiger Kreis<br />
Vom Werkzeug während <strong>de</strong>r<br />
kreisförmigen Bewegung<br />
beschriebene Bahn<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 97 / 122<br />
Y<br />
OK !<br />
Vorherige<br />
Bewegung
Än<strong>de</strong>rung <strong>de</strong>r Konfiguration (Arm RX/TX)<br />
Wechsel: righty / lefty<br />
Bei einer Än<strong>de</strong>rung <strong>de</strong>r Schulterkonfiguration muss <strong>de</strong>r Mittelpunkt <strong>de</strong>s Handgelenks über die Achse 1 hinwegfahren<br />
(nicht unbedingt bei Robotern mit Ausleger).<br />
Positive / negative Konfiguration <strong>de</strong>s Ellenbogens<br />
Bei Än<strong>de</strong>rung <strong>de</strong>r Konfiguration <strong>de</strong>s Ellenbogens muss <strong>de</strong>r Arm gestreckt (q3 = 0°) wer<strong>de</strong>n.<br />
98 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Positive / negative Konfiguration <strong>de</strong>s Handgelenks<br />
Bei einer Än<strong>de</strong>rung <strong>de</strong>r Konfiguration <strong>de</strong>s Handgelenks muss <strong>de</strong>r Arm kurzzeitig das Handgelenk (q5 = 0°) strecken.<br />
Das be<strong>de</strong>utet, dass <strong>de</strong>r Roboter auf seinem Weg bestimmte Positionen einnehmen muss, wenn die Konfiguration<br />
geän<strong>de</strong>rt wird. Man kann aber keine geradlinigen o<strong>de</strong>r kreisförmigen Bewegungen über diese Positionen erzwingen,<br />
wenn sie nicht auf <strong>de</strong>r gewünschten Bahn liegen! Daraus folgt, dass ein Konfigurationswechsel während einer<br />
geradlinigen o<strong>de</strong>r kreisförmigen Bewegung nicht erzwungen wer<strong>de</strong>n kann.<br />
Wechseln <strong>de</strong>r Ellenbogenkonfiguration nicht möglich<br />
An<strong>de</strong>rs ausgedrückt kann man bei einer geradlinigen o<strong>de</strong>r kreisförmigen Bewegung eine Konfiguration nur dann<br />
realisieren, wenn sie mit <strong>de</strong>r Anfangsposition vereinbar ist: Eine freie o<strong>de</strong>r mit <strong>de</strong>r Ausgangsposition i<strong>de</strong>ntische<br />
Konfiguration kann immer spezifiziert wer<strong>de</strong>n.<br />
Im Ausnahmefall kann die Gera<strong>de</strong> o<strong>de</strong>r <strong>de</strong>r Kreisbogen durch eine Position gehen, an <strong>de</strong>r ein Konfigurationswechsel<br />
möglich ist. In diesem Fall kann das System, wenn die Konfiguration nicht vorher festgelegt wur<strong>de</strong>, die Konfiguration auf<br />
einer geradlinigen o<strong>de</strong>r kreisförmigen Bewegung än<strong>de</strong>rn.<br />
Bei einer kreisförmigen Bewegung wird die Konfiguration <strong>de</strong>s mittleren Punktes nicht berücksichtigt. Es zählen nur die<br />
Konfigurationen von Anfangs- und Endposition.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 99 / 122
An<strong>de</strong>re Schulterkonfiguration möglich<br />
Singularitäten (Arm RX/TX)<br />
Singularitäten sind ein charakteristisches Merkmal aller 6-Achsen-Roboter. Sie können als Punkte <strong>de</strong>finiert wer<strong>de</strong>n, an<br />
<strong>de</strong>nen <strong>de</strong>r Roboter die Konfiguration än<strong>de</strong>rt. Bei einer Fluchtung zweier Achsen bil<strong>de</strong>n diese eine einzige Achse: Der 6-<br />
Achsen-Roboter verhält sich lokal wie ein 5-Achsen-Roboter. Damit können bestimmte Bewegungen nicht mehr<br />
ausgeführt wer<strong>de</strong>n. Das stört bei einer Punktsteuerung nicht: Die vom System generierten Bewegungen sind immer<br />
noch möglich. Bei einer geradlinigen o<strong>de</strong>r kreisförmigen Bewegung jedoch, wird die Bahn dieser Bewegung<br />
vorgeschrieben. Wenn die Bewegung nicht möglich ist, wird während <strong>de</strong>r Bewegung eine Fehlermeldung erzeugt.<br />
ANTIZIPATION VON BEWEGUNGEN<br />
Prinzip<br />
Das System steuert die Bewegungen <strong>de</strong>s Roboters etwa wie ein Autofahrer sein Auto. Es passt die Geschwindigkeit<br />
<strong>de</strong>s Roboters an die Bahngeometrie an. Je früher die Bahn bekannt ist, <strong>de</strong>sto optimaler kann das System die<br />
Geschwindigkeit steuern. Deshalb wartet das System zur Verarbeitung <strong>de</strong>r nächsten Bewegungsanweisungen nicht<br />
darauf, dass die laufen<strong>de</strong> Bewegung zu En<strong>de</strong> geführt wird.<br />
Betrachten wir die folgen<strong>de</strong>n Programmzeilen:<br />
movej (A, tool, mDesc)<br />
movej (B, tool, mDesc)<br />
movej (C, tool, mDesc)<br />
movej (D, tool, mDesc)<br />
Es wird vorausgesetzt, dass <strong>de</strong>r Roboter bei Erreichen dieser Programmzeilen stillsteht. Wenn die erste Anweisung<br />
ausgeführt ist, beginnt <strong>de</strong>r Roboter mit <strong>de</strong>r Bewegung zum Punkt A. Das Programm setzt jedoch sofort mit <strong>de</strong>r zweiten<br />
Linie fort, d. h. lange bevor <strong>de</strong>r Roboter <strong>de</strong>n Punkt A erreicht.<br />
Wenn das System die zweite Zeile ausführt, beginnt <strong>de</strong>r Roboter erst mit seiner Bewegung nach A und die Information,<br />
dass <strong>de</strong>r Roboter nach <strong>de</strong>m Punkt A zum Punkt B gehen soll, wird vom System gespeichert. Das Programm setzt mit<br />
<strong>de</strong>r nächsten Zeile fort: Während <strong>de</strong>r Roboter immer noch auf <strong>de</strong>m Weg nach A ist, speichert das System bereits die<br />
Bewegung von B nach C. Da das Programm sehr viel schneller läuft als sich <strong>de</strong>r Roboter bewegt, ist dieser<br />
wahrscheinlich immer noch auf <strong>de</strong>m Weg zu A, wenn die nächste Zeile abgearbeitet wird. Auf diese Weise wer<strong>de</strong>n vom<br />
System mehrere <strong>de</strong>r nächsten Punkte gespeichert.<br />
So weiß <strong>de</strong>r Roboter bereits zu <strong>de</strong>m Zeitpunkt, wo er seine Bewegung zu A beginnt, dass er nach A zu B, dann zu C<br />
und schließlich zu D fahren muss. Wenn die Funktion Glättung aktiv ist, weiß das System, dass <strong>de</strong>r Roboter erst am<br />
Punkt1 D anhalten muss. Es kann daher stärker beschleunigen, als wenn es sich darauf vorbereiten müsste, in B o<strong>de</strong>r<br />
C anzuhalten.<br />
100 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Das Ausführen <strong>de</strong>r Programmzeilen führt nur zur Speicherung <strong>de</strong>r aufeinan<strong>de</strong>rfolgen<strong>de</strong>n Bewegungsanweisungen. Der<br />
Roboter realisiert sie anschließend nach seinen Möglichkeiten. Damit das System eine möglichst optimale Bahn wählen<br />
kann, muss <strong>de</strong>r Speicher, in <strong>de</strong>m die Bewegungen abgelegt wer<strong>de</strong>n, relativ groß sein. Die Speicherkapazität ist jedoch<br />
begrenzt. Wenn <strong>de</strong>r Speicher voll ist, wird die Programmausführung bei <strong>de</strong>r nächsten Bewegungsanweisung<br />
unterbrochen. Die Ausführung wird erst fortgesetzt, wenn <strong>de</strong>r Roboter die laufen<strong>de</strong> Bewegung been<strong>de</strong>t hat und <strong>de</strong>r<br />
entsprechen<strong>de</strong> Speicherplatz frei gewor<strong>de</strong>n ist.<br />
Antizipation und Glättung<br />
Wir sehen in diesem Kapitel, was im Einzelnen passiert, wenn die Bewegungen verkettet sind. Betrachten wir wie<strong>de</strong>r<br />
das obige Beispiel:<br />
movej (A, tool, mDesc)<br />
movej (B, tool, mDesc)<br />
movej (C, tool, mDesc)<br />
movej (D, tool, mDesc)<br />
Angenommen, im Bewegungs<strong>de</strong>skriptor <strong>de</strong>sc ist die Glättung aktiviert. Wenn die erste Zeile ausgeführt wird, weiß das<br />
System noch nicht, welches die nächste Bewegung sein wird. Nur die Bewegung zwischen <strong>de</strong>m Startpunkt und <strong>de</strong>m<br />
Punkt Aleave ist vollständig bestimmt, da <strong>de</strong>r Punkt Aleave vom System anhand <strong>de</strong>s Datenelements leave <strong>de</strong>s<br />
Bewegungs<strong>de</strong>skriptors ermittelt wird (siehe nachstehen<strong>de</strong>s Schema).<br />
A<br />
A leave A reach<br />
Geglätteter Zyklus<br />
B leave B reach<br />
B<br />
Solange die zweite Zeile nicht ausgeführt ist, kann <strong>de</strong>r geglättete Bahnabschnitt um <strong>de</strong>n Punkt A nicht vollständig<br />
bestimmt wer<strong>de</strong>n, da das System die nächste Bewegung noch nicht kennt. Im Schrittmodus wür<strong>de</strong> <strong>de</strong>r Roboter, wenn<br />
<strong>de</strong>r Benutzer nicht auf die nächste Anweisung weitergeht, nur bis zum Punkt Aleave fahren. Wenn die nächste<br />
Anweisung ausgeführt wur<strong>de</strong>, können die geglättete Bahn um <strong>de</strong>n Punkt A (zwischen Aleave und Areach) sowie die<br />
Bewegung zum Punkt Bleave <strong>de</strong>finiert wer<strong>de</strong>n. Der Roboter kann sich damit bis Bleave bewegen. Er wird aber im<br />
Schrittmodus nicht über diesen Punkt hinausfahren können, wenn <strong>de</strong>r Benutzer die dritte Anweisung noch nicht<br />
ausgeführt hat usw..<br />
Der Vorteil dieser Betriebsart ist, dass <strong>de</strong>r Roboter im Schrittmodus und bei normaler Programmausführung genau die<br />
gleiche Bewegung ausführt.<br />
Synchronisierung<br />
Das Antizipieren besteht also in einer zeitlichen Entkopplung <strong>de</strong>r Ausführung <strong>de</strong>r Programmzeilen unter VAL3 und <strong>de</strong>n<br />
entsprechen<strong>de</strong>n Bewegungen <strong>de</strong>s Roboters: Das Programm VAL3 eilt <strong>de</strong>m Roboter voraus.<br />
Wenn an einer bestimmten Position <strong>de</strong>s Roboters eine Aufgabe vorgesehen ist, muss das Programm warten, bis <strong>de</strong>r<br />
Roboter seine Bewegungen been<strong>de</strong>t hat: Diese Synchronisierung wird mit <strong>de</strong>r Anweisung waitEndMove() erreicht.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 101 / 122<br />
C<br />
C leave C reach<br />
D
Deshalb wird im nachstehen<strong>de</strong>n Programm:<br />
movej(A, tool, mDesc)<br />
movej(B, tool, mDesc)<br />
waitEndMove()<br />
movej(C, tool, mDesc)<br />
movej(D, tool, mDesc)<br />
etc...<br />
Die bei<strong>de</strong>n ersten Zeilen wer<strong>de</strong>n ausgeführt, wenn <strong>de</strong>r Roboter seinen Weg nach A beginnt. Dann wird die<br />
Programmausführung in <strong>de</strong>r dritten Zeile unterbrochen, bis <strong>de</strong>r Roboter im Punkt B steht. Nach <strong>de</strong>r Stabilisierung in B<br />
setzt das Programm mit <strong>de</strong>r Ausführung fort.<br />
Die Anweisungen open() und close() bewirken ebenfalls ein Warten auf das En<strong>de</strong> <strong>de</strong>r Roboterbewegung bevor das<br />
Werkzeug betätigt wird.<br />
GESCHWINDIGKEITSSTEUERUNG<br />
Prinzip<br />
Die Geschwindigkeitssteuerung auf einer Bahn arbeitet nach folgen<strong>de</strong>m Prinzip:<br />
Zu je<strong>de</strong>m Zeitpunkt wird <strong>de</strong>r Roboter mit voller Leistung bewegt und beschleunigt, wobei alle von <strong>de</strong>r<br />
Bewegungssteuerung vorgegebenen Bedingungen für Geschwindigkeit und Beschleunigung einzuhalten sind.<br />
Die Bewegungsanweisungen enthalten zwei Arten von Randbedingungen für die Geschwindigkeit, die in einer<br />
Variablen <strong>de</strong>s Typs m<strong>de</strong>sc <strong>de</strong>finiert sind:<br />
1. Geschwindigkeiten, Beschleunigungen und Abbremsungen für Gelenkbewegungen<br />
2. Randbedingungen für die kartesischen Geschwindigkeiten <strong>de</strong>s Werkzeugmittelpunkts<br />
Der Beschleunigungswert legt fest, wie rasch die Geschwindigkeit am Beginn <strong>de</strong>r Bahn zunimmt. Umgekehrt wird durch<br />
<strong>de</strong>n Wert <strong>de</strong>r Abbremsung festgelegt, wie schnell die Geschwindigkeit am En<strong>de</strong> <strong>de</strong>r Bahn abnimmt. Wenn man hohe<br />
Beschleunigungs- und Abbremswerte verwen<strong>de</strong>t, wer<strong>de</strong>n die Bewegungen zwar rascher, aber ruckartiger. Mit kleineren<br />
Werten nehmen die Bewegungen etwas mehr Zeit in Anspruch, wer<strong>de</strong>n jedoch sanfter.<br />
Einfache Einstellung<br />
Wenn das Werkzeug o<strong>de</strong>r <strong>de</strong>r vom Roboter transportierte Gegenstand keine beson<strong>de</strong>rs vorsichtige Handhabung<br />
erfor<strong>de</strong>rn, sind Randbedingungen für kartesische Geschwindigkeiten unnötig. Die Einstellung <strong>de</strong>r Bahngeschwindigkeit<br />
erfolgt im Allgemeinen auf folgen<strong>de</strong> Weise:<br />
1. Die Randbedingungen für kartesische Geschwindigkeit wer<strong>de</strong>n auf hohe Werte gesetzt, z.B. auf die<br />
vorprogrammierten Werte, damit sie keinen Einfluss auf die anschließen<strong>de</strong> Einstellung haben.<br />
2. Die Geschwindigkeiten und Beschleunigungen <strong>de</strong>r Gelenke wer<strong>de</strong>n auf ihre Nennwerte (100%) initialisiert.<br />
3. Dann wird die Bahngeschwindigkeit nur mit <strong>de</strong>m Parameter Gelenkgeschwindigkeit eingestellt.<br />
4. Wenn keine ausreichen<strong>de</strong> Geschwindigkeit erreicht wer<strong>de</strong>n kann, müssen die Beschleunigungs- und<br />
Abbremswerte vergrößert wer<strong>de</strong>n<br />
Komplexere Einstellungen<br />
Wenn die kartesische Geschwindigkeit <strong>de</strong>s Werkzeugs beherrscht wer<strong>de</strong>n muss, zum Beispiel um eine Bahn mit<br />
konstanter Geschwindigkeit auszuführen, sollte besser auf folgen<strong>de</strong> Weise vorgegangen wer<strong>de</strong>n:<br />
1. Die Bedingungen für die kartesischen Geschwindigkeiten auf die zunächst gewünschten Werte einstellen.<br />
2. Die Geschwindigkeiten und Beschleunigungen <strong>de</strong>r Gelenke wer<strong>de</strong>n auf ihre Nennwerte (100%) initialisiert.<br />
3. Dann die Bahngeschwindigkeit nur mit <strong>de</strong>m Parameter kartesische Geschwindigkeit einstellen.<br />
4. Wenn die gewünschte Geschwindigkeit nicht erreicht wer<strong>de</strong>n kann, müssen die Beschleunigungs- und<br />
Abbremswerte vergrößert wer<strong>de</strong>n.<br />
Wenn man in starken Kurven automatisch bremsen möchte, müssen die Beschleunigungs- und Abbremswerte<br />
verringert wer<strong>de</strong>n.<br />
102 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Schleppfehler<br />
Die Nennwerte für die Geschwindigkeiten und Beschleunigungen <strong>de</strong>r Drehachsen gelten für Roboter mit Nennlast<br />
unabhängig von <strong>de</strong>r Bahn.<br />
In vielen Fällen kann <strong>de</strong>r Roboter schnellere Bewegungen ausführen: Seine Höchstgeschwindigkeiten hängen jedoch<br />
von <strong>de</strong>r Last und <strong>de</strong>r Bahn ab. Unter günstigen Bedingungen (geringe Last, günstiger Einfluss <strong>de</strong>r Schwerkraft) kann<br />
<strong>de</strong>r Roboter seine Nennwerte ohne Scha<strong>de</strong>n überschreiten.<br />
Wenn <strong>de</strong>r Roboter hingegen eine schwerere Last bewegen muss, als die Nennlast, o<strong>de</strong>r wenn zu hohe<br />
Geschwindigkeiten und Beschleunigungen <strong>de</strong>r Drehachsen parametriert wur<strong>de</strong>n, kann <strong>de</strong>r Roboter unter Umstän<strong>de</strong>n<br />
<strong>de</strong>n Bewegungsanweisungen nicht mehr folgen und bleibt mit einem Schleppfehler stehen. Durch Eingabe kleinerer<br />
Geschwindigkeits- und Beschleunigungswerte können <strong>de</strong>rartige Fehler vermie<strong>de</strong>n wer<strong>de</strong>n.<br />
ACHTUNG:<br />
Bei geradlinigen Bewegungen in <strong>de</strong>r Nähe singulärer Punkte sind große Gelenkbewegungen<br />
für kleine Werkzeugbewegungen erfor<strong>de</strong>rlich. Wenn eine zu hohe Gelenkgeschwindigkeit<br />
eingegeben wur<strong>de</strong>, wird <strong>de</strong>r Roboter <strong>de</strong>r Anweisung nicht mehr folgen können und mit einem<br />
Schleppfehler stehen bleiben.<br />
ONLINE-BEWEGUNGSSTEUERUNG<br />
Die bis jetzt angesprochenen Bewegungssteuerungen haben keine sofortige Wirkung: Die Ausführung einer solchen<br />
Steueranweisung vom Programm führt zur Speicherung <strong>de</strong>r Bewegungsanweisung durch das System. Sie wer<strong>de</strong>n erst<br />
anschließend vom Roboter ausgeführt.<br />
Es besteht jedoch die Möglichkeit, die Bewegungen <strong>de</strong>s Roboters mit sofortiger Wirkung zu beeinflussen:<br />
• Die Monitorgeschwindigkeit än<strong>de</strong>rt die Geschwindigkeiten aller Bewegungen. Sie kann nur auf <strong>de</strong>m<br />
Handbediengerät <strong>de</strong>s Roboters und nicht in einem VAL3-Programm geän<strong>de</strong>rt wer<strong>de</strong>n. Mit <strong>de</strong>r Anweisung<br />
speedScale() kann das Programm jedoch die aktuelle Monitorgeschwindigkeit lesen und <strong>de</strong>n Benutzer<br />
gegebenenfalls auffor<strong>de</strong>rn, sie bei einem Wie<strong>de</strong>rholzyklus zu verringern o<strong>de</strong>r sie mit 100% in die Produktion<br />
zu geben.<br />
• Mit <strong>de</strong>n Anweisungen stopMove() und restartMove() kann die Bewegung auf <strong>de</strong>r Bahn unterbrochen und<br />
wie<strong>de</strong>r aufgenommen wer<strong>de</strong>n.<br />
• Die Anweisung resetMotion() ermöglicht die Unterbrechung einer Bewegung und das Löschen <strong>de</strong>r<br />
gespeicherten Bewegungsanweisungen.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 103 / 122
TYP MDESC<br />
Definition<br />
Mit <strong>de</strong>m Typ m<strong>de</strong>sc können die Parameter einer Bewegung festgelegt wer<strong>de</strong>n (Geschwindigkeit, Beschleunigung,<br />
Glättung).<br />
Der Typ m<strong>de</strong>sc ist ein strukturierter Typ mit folgen<strong>de</strong>n Fel<strong>de</strong>rn in <strong>de</strong>r nachstehen<strong>de</strong>n Reihenfolge:<br />
num accel Maximal zulässige Winkelbeschleunigung, angegeben in % <strong>de</strong>r Nennbeschleunigung <strong>de</strong>s<br />
Roboters.<br />
num vel Maximal zulässige Winkelgeschwindigkeit, angegeben in % <strong>de</strong>r Nenngeschwindigkeit <strong>de</strong>s<br />
Roboters.<br />
num <strong>de</strong>cel Maximal zulässige Abbremsung <strong>de</strong>s Gelenks, angegeben in % <strong>de</strong>r nominalen Abbremsung<br />
<strong>de</strong>s Roboters.<br />
num tvel Maximal zulässige Lineargeschwindigkeit <strong>de</strong>s Werkzeugmittelpunkts in mm/s o<strong>de</strong>r inch/s je<br />
nach Längeneinheit <strong>de</strong>s Programms.<br />
num rvel Maximal zulässige Winkelgeschwindigkeit <strong>de</strong>s Werkzeugs in Grad/s.<br />
blend<br />
blend<br />
Ausführliche Beschreibung <strong>de</strong>r verschie<strong>de</strong>nen Parameter, siehe Kapitel Bewegungssteuerung.<br />
Eine Variable <strong>de</strong>s Typs m<strong>de</strong>sc wird vorprogrammiert auf {100,100,100,5000,1000,off,50,50} initialisiert, wenn die<br />
Längeneinheit <strong>de</strong>s Projekts Millimeter ist und auf {100,100,100,2000, 1000, off, 20, 20}, wenn die Längeneinheit Inch<br />
ist.<br />
Operatoren<br />
Mit zunehmen<strong>de</strong>r Priorität:<br />
Glättungsart: off (keine Glättung) o<strong>de</strong>r joint (mit Glättung).<br />
num leave Bei Glättung (joint), die Entfernung vom Zielpunkt bei <strong>de</strong>r die Glättung zum nächsten Punkt<br />
beginnt, angegeben in mm o<strong>de</strong>r inch, je nach Längeneinheit <strong>de</strong>s Programms.<br />
num reach Bei Glättung (joint), die Entfernung vom Zielpunkt bei <strong>de</strong>r die Glättung zum nächsten Punkt<br />
en<strong>de</strong>t, angegeben in mm o<strong>de</strong>r inch, je nach Längeneinheit <strong>de</strong>s Programms.<br />
m<strong>de</strong>sc = Weist je<strong>de</strong>s Feld <strong>de</strong>sc2 <strong>de</strong>m entsprechen<strong>de</strong>n Feld <strong>de</strong>r<br />
Variablen <strong>de</strong>sc1 zu.<br />
bool != Überträgt true, wenn sich <strong>de</strong>sc1 und <strong>de</strong>sc2 in<br />
min<strong>de</strong>stens einem Feld unterschei<strong>de</strong>n.<br />
bool == Überträgt true, wenn die Werte <strong>de</strong>r Fel<strong>de</strong>r in <strong>de</strong>sc1<br />
und <strong>de</strong>sc2 gleich sind.<br />
104 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
BEWEGUNGSANWEISUNGEN<br />
void movej(joint joint, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
Syntax<br />
void movej(joint Position, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
void movej(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
Funktion<br />
Speichert einen Bewegungsbefehl für ein Gelenk zur Position Punkt o<strong>de</strong>r Position mit <strong>de</strong>m Werkzeug Werkzeug und<br />
<strong>de</strong>n Bewegungsparametern <strong>de</strong>sc.<br />
ACHTUNG:<br />
Das System wartet nicht auf das En<strong>de</strong> <strong>de</strong>r Bewegung, um zur nächsten VAL3-Anweisung<br />
weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert wer<strong>de</strong>n.<br />
Wenn nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit <strong>de</strong>r<br />
Ausführung gewartet, bis die Speicherung möglich ist.<br />
Zur ausführlichen Beschreibung <strong>de</strong>r verschie<strong>de</strong>nen Bewegungsparameter, siehe Beginn <strong>de</strong>s Kapitels<br />
Bewegungssteuerung.<br />
Wenn <strong>de</strong>sc unzulässige Werte aufweist, position außerhalb <strong>de</strong>r Softwaregrenzen liegt, point nicht erreichbar ist o<strong>de</strong>r<br />
ein zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt wer<strong>de</strong>n kann, wird eine Fehlermeldung erzeugt<br />
(Endpunkt nicht erreichbar).<br />
Parameter<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug<br />
m<strong>de</strong>sc <strong>de</strong>sc Ausdruck <strong>de</strong>s Typs Bewegungs<strong>de</strong>skriptor<br />
joint Position Ausdruck <strong>de</strong>s Typs Gelenkposition<br />
point Punkt Ausdruck <strong>de</strong>s Typs point<br />
Siehe auch<br />
void movel(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
bool isInRange(joint Position)<br />
void waitEndMove()<br />
void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 105 / 122
Syntax<br />
void movel(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
void movel(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
Funktion<br />
Speichert einen linearen Bewegungsbefehl zur Position Punkt mit <strong>de</strong>m Werkzeug Werkzeug und <strong>de</strong>n<br />
Bewegungsparametern <strong>de</strong>sc.<br />
ACHTUNG:<br />
Das System wartet nicht auf das En<strong>de</strong> <strong>de</strong>r Bewegung, um zur nächsten VAL3-Anweisung<br />
weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert wer<strong>de</strong>n.<br />
Wenn nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit <strong>de</strong>r<br />
Ausführung gewartet, bis die Speicherung möglich ist.<br />
Zur ausführlichen Beschreibung <strong>de</strong>r verschie<strong>de</strong>nen Bewegungsparameter, siehe Beginn <strong>de</strong>s Kapitels<br />
Bewegungssteuerung.<br />
Wenn <strong>de</strong>sc unzulässige Werte aufweist, Punkt nicht erreichbar o<strong>de</strong>r eine geradlinige Bewegung zu Punkt nicht<br />
möglich ist o<strong>de</strong>r ein zuvor aufgezeichneter Bewegungsbefehl nicht ausgeführt wer<strong>de</strong>n kann, wird eine Fehlermeldung<br />
erzeugt (Endpunkt nicht erreichbar).<br />
Parameter<br />
point Punkt Ausdruck <strong>de</strong>s Typs point.<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug.<br />
m<strong>de</strong>sc <strong>de</strong>sc Ausdruck <strong>de</strong>s Typs Bewegungs<strong>de</strong>skriptor.<br />
Siehe auch<br />
void movej(joint joint, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
void waitEndMove()<br />
void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
1<strong>06</strong> / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
Syntax<br />
void movec(Mittlerer Punkt, Endpunkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
Funktion<br />
Speichert die Anweisung für eine kreisförmige Bewegung, ausgehend vom Zielort <strong>de</strong>r vorherigen Bewegung, über<br />
Mittlerer Punkt bis zu Endpunkt.<br />
Die Ausrichtung <strong>de</strong>s Werkzeugs ist so interpoliert, dass eine absolute, konstante Ausrichtung o<strong>de</strong>r eine Ausrichtung<br />
bezüglich <strong>de</strong>r Bahn möglich ist.<br />
ACHTUNG:<br />
Das System wartet nicht auf das En<strong>de</strong> <strong>de</strong>r Bewegung, um zur nächsten VAL3-Anweisung<br />
weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert wer<strong>de</strong>n.<br />
Wenn nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit <strong>de</strong>r<br />
Ausführung gewartet, bis die Speicherung möglich ist.<br />
Zur ausführlichen Beschreibung <strong>de</strong>r verschie<strong>de</strong>nen Bewegungsparameter und <strong>de</strong>r Interpolation <strong>de</strong>r<br />
Ausrichtung, siehe Beginn <strong>de</strong>s Kapitels "Bewegungssteuerung".<br />
Bei ungültigen Werten von <strong>de</strong>sc wird ein Ausführungsfehler erzeugt. Dies gilt auch, wenn die Positionen Mittlerer<br />
Punkt (o<strong>de</strong>r Endpunkt) nicht erreichbar sind, wenn die kreisförmige Bewegung nicht möglich ist (siehe Kapitel<br />
"Bewegungssteuerung" - Interpolation <strong>de</strong>r Ausrichtung) o<strong>de</strong>r wenn ein zuvor aufgezeichneter Bewegungsbefehl nicht<br />
ausgeführt wer<strong>de</strong>n kann (Zielposition nicht erreichbar).<br />
Parameter<br />
Mittlerer Punkt Ausdruck <strong>de</strong>s Typs point.<br />
Endpunkt Ausdruck <strong>de</strong>s Typs point.<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug.<br />
m<strong>de</strong>sc <strong>de</strong>sc Ausdruck <strong>de</strong>s Typs Bewegungs<strong>de</strong>skriptor.<br />
Siehe auch<br />
void movej(joint joint, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
void movel(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc)<br />
void waitEndMove()<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 107 / 122
Syntax<br />
void stopMove()<br />
void stopMove()<br />
Funktion<br />
Hält <strong>de</strong>n Arm während <strong>de</strong>r Bewegung an und hebt die programmierte Freigabe <strong>de</strong>r Bewegung vorübergehend auf.<br />
ACHTUNG:<br />
Diese Anweisung bewirkt sofortige Rückkehr, die VAL3-Task wartet zur Ausführung <strong>de</strong>r<br />
folgen<strong>de</strong>n Task nicht auf <strong>de</strong>n Stillstand <strong>de</strong>s Arms.<br />
Zum Anhalten <strong>de</strong>s Roboters wer<strong>de</strong>n die kinematischen Parameter <strong>de</strong>r laufen<strong>de</strong>n Bewegung verwen<strong>de</strong>t.<br />
Die Bewegung kann erst nach Ausführung <strong>de</strong>r Anweisung restartMove() o<strong>de</strong>r resetMotion() fortgesetzt wer<strong>de</strong>n.<br />
Nicht programmierte Bewegungen (manuelles Verfahren) bleiben weiterhin möglich.<br />
Zum Beispiel<br />
wait (dSignal==true) // Warten auf ein Signal<br />
stopMove() // Anhalten <strong>de</strong>s Roboters während <strong>de</strong>r Bewegung<br />
<br />
restartMove() // Erneutes Anfahren <strong>de</strong>s Roboters auf <strong>de</strong>r gleichen Bahn<br />
Siehe auch<br />
void restartMove()<br />
void resetMotion(), void resetMotion(joint Start)<br />
void resetMotion(), void resetMotion(joint Start)<br />
Syntax<br />
void resetMotion()<br />
void resetMotion(joint Start)<br />
Funktion<br />
Hält <strong>de</strong>n Roboterarm während <strong>de</strong>r Bewegung an und löscht alle gespeicherten Bewegungsanweisungen.<br />
ACHTUNG:<br />
Diese Anweisung bewirkt sofortige Rückkehr, die VAL3-Task wartet zur Ausführung <strong>de</strong>r<br />
folgen<strong>de</strong>n Task nicht auf <strong>de</strong>n Stillstand <strong>de</strong>s Arms.<br />
Wenn die programmierte Freigabe <strong>de</strong>r Bewegung durch die Anweisung stopMove() aufgehoben wor<strong>de</strong>n war, wird sie<br />
wie<strong>de</strong>r hergestellt.<br />
Wenn die Anfangs-Winkelposition Start festgelegt ist, so kann die nächste Bewegungsanweisung nur von dieser<br />
Position aus durchgeführt wer<strong>de</strong>n: Es ist zunächst eine Anschluss-Bewegung erfor<strong>de</strong>rlich, um zu Start<br />
zurückzukehren.<br />
Ist keine Winkelposition festgelegt, so wird die nächste Bewegungsanweisung von <strong>de</strong>r aktuellen Position <strong>de</strong>s Arms<br />
ausgeführt, egal, wo sich dieser befin<strong>de</strong>t.<br />
Siehe auch<br />
bool isEmpty()<br />
void stopMove()<br />
void autoConnectMove(bool aktiv), bool autoConnectMove()<br />
108 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
void restartMove()<br />
void restartMove()<br />
Funktion<br />
Stellt die programmierte Freigabe <strong>de</strong>r Bewegung wie<strong>de</strong>r her und setzt die mit <strong>de</strong>r Anweisung stopMove()<br />
unterbrochene Bewegung fort.<br />
Wenn die programmierte Bewegungsfreigabe nicht durch stopMove() unterbrochen war, hat diese Anweisung<br />
keinerlei Auswirkungen.<br />
Siehe auch<br />
void stopMove()<br />
void resetMotion(), void resetMotion(joint Start)<br />
Syntax<br />
void waitEndMove()<br />
void waitEndMove()<br />
Funktion<br />
Annulliert die Glättung <strong>de</strong>r zuletzt gespeicherten Bewegungsanweisung und wartet auf die Ausführung dieser<br />
Anweisung.<br />
Diese Anweisung wartet nicht auf die Stabilisierung <strong>de</strong>s Roboters an seiner Endposition, son<strong>de</strong>rn nur dass die an die<br />
Getriebe gesen<strong>de</strong>te Positionsanweisung mit <strong>de</strong>r gewünschten Endposition übereinstimmt. Wenn die vollständige<br />
Stabilisierung nach <strong>de</strong>r Bewegung abgewartet wer<strong>de</strong>n soll, so muss die Anweisung isSettled() verwen<strong>de</strong>t wer<strong>de</strong>n.<br />
Ein Ausführungsfehler wird erzeugt, wenn ein zuvor aufgezeichneter Bewegungsbefehl nicht durchgeführt wer<strong>de</strong>n kann<br />
(Endpunkt außer Reichweite).<br />
Zum Beispiel<br />
waitEndMove()<br />
putln(sel(isEmpty(),1,-1)) // ergibt 1, wenn kein Befehl mehr ansteht<br />
putln(sel(isSettled(),1,-1)) // Kann -1 anzeigen, da <strong>de</strong>r Roboter noch nicht unbedingt stabilisiert ist<br />
watch(isSettled(), 1) // Wartet während maximal 1 s auf die Stabilisierung <strong>de</strong>s Roboters<br />
Siehe auch<br />
bool isSettled()<br />
bool isEmpty()<br />
void stopMove()<br />
void resetMotion(), void resetMotion(joint Start)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 109 / 122
Syntax<br />
bool isEmpty()<br />
bool isEmpty()<br />
Funktion<br />
Überträgt true, wenn alle Bewegungsanweisungen ausgeführt sind, und false, wenn noch min<strong>de</strong>stens eine Anweisung<br />
ansteht.<br />
Zum Beispiel<br />
// Wenn noch Anweisungen anstehen<br />
if ! isEmpty()<br />
// Roboter anhalten und Anweisungen löschen<br />
resetMotion()<br />
endIf<br />
Siehe auch<br />
void waitEndMove()<br />
void resetMotion(), void resetMotion(joint Start)<br />
Syntax<br />
bool isSettled()<br />
bool isSettled()<br />
Funktion<br />
Überträgt true, wenn <strong>de</strong>r Roboter gestoppt ist, und false, wenn seine Position noch nicht stabilisiert ist.<br />
Die Position wird als stabilisiert betrachtet, wenn <strong>de</strong>r Positionsfehler für je<strong>de</strong> Achse während 50 ms weniger als 1% <strong>de</strong>r<br />
maximal zulässigen Position beträgt.<br />
Siehe auch<br />
bool isEmpty()<br />
void waitEndMove()<br />
Syntax<br />
void autoConnectMove(bool aktiv), bool autoConnectMove()<br />
void autoConnectMove(bool aktiv)<br />
bool autoConnectMove()<br />
Funktion<br />
Im ferngesteuerten Modus ist die Anschlussbewegung automatisch, wenn <strong>de</strong>r Arm sich sehr nahe an seiner Bahn<br />
bewegt (Abstand kleiner als <strong>de</strong>r maximal erlaubte Wi<strong>de</strong>rstandsfehler). Ist <strong>de</strong>r Arm zu weit von seiner Bahn entfernt,<br />
fin<strong>de</strong>t die Anschlussbewegung automatisch o<strong>de</strong>r unter manueller Kontrolle gemäß <strong>de</strong>m in <strong>de</strong>r Anweisung<br />
autoConnectMove <strong>de</strong>finierten Modus statt.: automatisch, wenn aktiv <strong>de</strong>n Wert true hat, unter manueller Kontrolle,<br />
wenn <strong>de</strong>r Wert aktiv gleich false ist. Bei Benutzung ohne Parameter, gibt autoConnectMove <strong>de</strong>n üblichen Modus <strong>de</strong>r<br />
Anschlussbewegung an.<br />
Standardmäßig erfolgt die Anschlussbewegung bei ferngesteuerten Betrieb manuell.<br />
ACHTUNG:<br />
Unter normalen Einsatzbedingungen stoppt <strong>de</strong>r Arm bei einem Notaus auf seiner Bahn.<br />
Demzufolge kann <strong>de</strong>r Arm im ferngesteuerten Modus unabhängig von <strong>de</strong>m in <strong>de</strong>r Anweisung<br />
autoConnectMove <strong>de</strong>finierten Modus <strong>de</strong>r Anschlussbewegung automatisch neu starten.<br />
Siehe auch<br />
void resetMotion(), void resetMotion(joint Start)<br />
110 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
OPTIONEN<br />
AUSGEGLICHENE BEWEGUNGEN MIT KRAFTSTEUERUNG<br />
Prinzip<br />
Bei einer Standard-Bewegungssteuerung verschiebt sich <strong>de</strong>r Roboter zur gefor<strong>de</strong>rten Position mit programmierten<br />
Beschleunigungs- und Geschwindigkeitswerten. Kann <strong>de</strong>r Arm <strong>de</strong>r Steuerung nicht folgen, so wird von <strong>de</strong>n Motoren bei<br />
ihrem Versuch zur gewünschten Position zu gelangen eine steigen<strong>de</strong> Kraft gefor<strong>de</strong>rt. Weicht die angesteuerte Position<br />
zu stark von <strong>de</strong>r tatsächlichen Position ab, o<strong>de</strong>r ist die nötige Kraft zu groß, so ergibt sich ein Systemfehler,welcher die<br />
Energieversorgung <strong>de</strong>s Arms unterbricht.<br />
Der Roboter ist "ausgleichfähig" (compliant), wenn er gewisse Abweichungen <strong>de</strong>r angesteuerten Position von <strong>de</strong>r<br />
tatsächlichen Position erlaubt. Die Steuerung CS8 kann so programmiert wer<strong>de</strong>n, dass sie auf ihrer Bahn<br />
ausgleichfähig ist. Das heißt, sie kann einen Verzug o<strong>de</strong>r eine Voreilung auf <strong>de</strong>r programmierten Bahn durch Steuerung<br />
<strong>de</strong>r auf <strong>de</strong>n Arm ausgeübten Kraft ausgleichen. Hingegen wird keinerlei räumliche Abweichung von <strong>de</strong>r Bahn toleriert.<br />
In <strong>de</strong>r Praxis können ausgeglichene Bewegungen <strong>de</strong>r CS8 <strong>de</strong>m Arm eine Verfolgung seiner Bahn ermöglichen, auch<br />
wenn er von äußeren Kräften geschoben o<strong>de</strong>r gebremst wird. Gleichermaßen kann <strong>de</strong>r Arm mit einem Objekt in<br />
Berührung treten, wobei die vom Arm auf dieses Objekt ausgeübte Kraft gesteuert wird.<br />
Programmierung<br />
Ausgeglichene Bewegungen wer<strong>de</strong>n wie Standardbewegungen mit <strong>de</strong>n Anweisungen movelf() und movejf()<br />
programmiert, wobei ein zusätzlicher Parameter die vom Arm ausgeübte Kraft steuern kann. Während <strong>de</strong>r<br />
ausgeglichenen Bewegung erfolgen Geschwindigkeits- und Beschleunigungsbegrenzungen wie bei<br />
Standardbewegungen mittels <strong>de</strong>s Bewegungs<strong>de</strong>skriptors. Die Bewegung kann auf <strong>de</strong>r Bahn in bei<strong>de</strong>n Richtungen<br />
erfolgen.<br />
Ausgeglichene Bewegungen können untereinan<strong>de</strong>r o<strong>de</strong>r mit Standardbewegungen verkettet wer<strong>de</strong>n: Nach Erreichen<br />
<strong>de</strong>r Zielposition fährt <strong>de</strong>r Roboter mit <strong>de</strong>m folgen<strong>de</strong>n Bewegungsbefehl fort. Die Anweisung waitEndMove() ermöglicht<br />
es, das En<strong>de</strong> einer ausgeglichenen Bewegung abzuwarten.<br />
Die Anweisung resetMotion() bricht alle programmierten Bewegungen, sowohl standardmäßige als auch<br />
ausgeglichene, ab. Nach Ausführung von resetMotion() ist <strong>de</strong>r Roboter nicht mehr ausgleichfähig (compliant).<br />
Die Anweisungen stopMove() und restartMove() können auch auf ausgeglichene Bewegungen zur Anwendung<br />
kommen:<br />
stopMove() erzwingt Geschwindigkeit 0 für die in Ausführung befindliche Bewegung. Han<strong>de</strong>lt es sich um eine<br />
ausgeglichene Bewegung, so wird diese gestoppt und <strong>de</strong>r Roboter ist bis zur nächsten Ausführung von restartMove()<br />
nicht mehr ausgleichfähig (compliant).<br />
Schließlich ermöglicht es die Anweisung isCompliant(), vor Zulassung <strong>de</strong>r Einwirkung einer äußeren Kraft auf <strong>de</strong>n<br />
Roboterarm sicherzustellen, dass <strong>de</strong>r Roboter ausgleichfähig ist.<br />
Steuerung <strong>de</strong>r Kraft<br />
Wur<strong>de</strong> für <strong>de</strong>n Kraftparameter <strong>de</strong>r Wert null festgelegt, so ist <strong>de</strong>r Arm passiv, das heißt, er verschiebt sich nur unter<br />
Einwirkung einer äußeren Kraft.<br />
Bei positivem Wert <strong>de</strong>s Kraftparameters ist die Bewegung für automatische Verschiebung <strong>de</strong>s Arms zu seiner<br />
Endposition programmiert: Der Arm verschiebt sich selbst, kann jedoch durch eine äußere Einwirkung, die sich seinem<br />
Antrieb überlagert, gebremst o<strong>de</strong>r beschleunigt wer<strong>de</strong>n.<br />
Bei negativem Wert <strong>de</strong>s Kraftparameters wird <strong>de</strong>r Arm durch eine äußere Kraft in seine Ausgangsposition überführt: In<br />
diesem Fall ist zur Verschiebung <strong>de</strong>s Arms eine <strong>de</strong>n angewiesenen Wert übertreffen<strong>de</strong> äußere Kraft erfor<strong>de</strong>rlich.<br />
Der Kraftparameter wird in Prozent <strong>de</strong>r maximalen Belastbarkeit <strong>de</strong>s Arms ausgedrückt. Bei 100% übt <strong>de</strong>r Arm eine <strong>de</strong>r<br />
maximalen Belastbarkeit entsprechen<strong>de</strong> Kraft in Richtung <strong>de</strong>r angesteuerten Position aus. Bei Drehbewegungen<br />
entsprechen 100% <strong>de</strong>m für <strong>de</strong>n Arm zulässigen maximalen Drehmoment.<br />
Wenn Geschwindigkeit o<strong>de</strong>r Beschleunigung <strong>de</strong>s Arms die im Bewegungs<strong>de</strong>skriptor festgelegten Werte erreichen, so<br />
wi<strong>de</strong>rsetzt sich <strong>de</strong>r Roboter mit aller ihm zur Verfügung stehen<strong>de</strong>n Leistung jeglichen Versuchen, diese Werte zu<br />
erhöhen.<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 111 / 122
Begrenzungen<br />
Für ausgeglichene Bewegungen gelten folgen<strong>de</strong> Begrenzungen:<br />
- Am Anfang o<strong>de</strong>r En<strong>de</strong> einer ausgeglichenen Bewegung kann kein Glätten erfolgen: <strong>de</strong>r Arm muss am<br />
Anfang und am En<strong>de</strong> einer ausgeglichenen Bewegung stoppen.<br />
- Der Arm kann bei einer ausgeglichenen Bewegung zu seinem Ausgangspunkt zurückkehren, jedoch nicht<br />
über diesen hinausfahren: Er stoppt in einem solchen Fall schlagartig am Ausgangspunkt.<br />
- Die auf <strong>de</strong>n Arm ausgeübte Kraft (im Kraftparameter festgelegt) kann 1000% nicht überschreiten. Die für<br />
die Kraft gelten<strong>de</strong> Präzision ist durch innere Reibungen begrenzt. Sie hängt stark von <strong>de</strong>r Position <strong>de</strong>s<br />
jeweiligen Roboterarms und <strong>de</strong>r gesteuerten Bahn ab.<br />
- Lange ausgeglichene Bewegungen erfor<strong>de</strong>rn viel internen Speicherplatz. Reicht <strong>de</strong>r Speicher <strong>de</strong>s<br />
Systems nicht aus, um die Bewegung vollständig zu been<strong>de</strong>n, so wird ein Ausführungsfehler erzeugt.<br />
Anweisungen<br />
void movejf(joint Position, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
Syntax<br />
void movejf(joint Position, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
Funktion<br />
Speicherung einer ausgeglichenen Gelenkbewegung zu Position Position, mit <strong>de</strong>m Werkzeug Werkzeug, <strong>de</strong>n<br />
Bewegungsparametern <strong>de</strong>sc und einem gesteuerten Kraftwert Kraft.<br />
Der gesteuerte Kraftwert Kraft wird in Prozent <strong>de</strong>r maximalen Belastbarkeit <strong>de</strong>s Arms ausgedrückt. Er muss innerhalb<br />
±1000% liegen.<br />
ACHTUNG:<br />
Das System wartet nicht auf das En<strong>de</strong> <strong>de</strong>r Bewegung, um zur nächsten VAL3-Anweisung<br />
weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert wer<strong>de</strong>n. Wenn<br />
nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit <strong>de</strong>r<br />
Ausführung gewartet, bis die Speicherung möglich ist.<br />
Die verschie<strong>de</strong>nen Parameter <strong>de</strong>r Bewegung sind zu Beginn <strong>de</strong>s vorliegen<strong>de</strong>n Kapitels genauer erklärt.<br />
Bei ungültigen Werten von <strong>de</strong>sc o<strong>de</strong>r Kraft wird ein Ausführungsfehler erzeugt, ebenfalls, wenn <strong>de</strong>r Wert von Position<br />
außerhalb <strong>de</strong>r Softwareanschläge liegt, wenn die vorangehen<strong>de</strong> Bewegung eine Glättung for<strong>de</strong>rt o<strong>de</strong>r wenn ein zuvor<br />
aufgezeichneter Bewegungsbefehl nicht ausgeführt wer<strong>de</strong>n kann (Zielposition nicht erreichbar).<br />
Parameter<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug.<br />
m<strong>de</strong>sc <strong>de</strong>sc Ausdruck <strong>de</strong>s Typs Bewegungs<strong>de</strong>skriptor<br />
joint Position Ausdruck <strong>de</strong>s Typs Gelenkposition<br />
num Kraft Ausdruck <strong>de</strong>s Typs num<br />
Siehe auch<br />
void movelf(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
bool isCompliant()<br />
112 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
Syntax<br />
void movelf(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
void movelf(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
Funktion<br />
Speicherung einer ausgeglichenen Linearbewegung zur Position Punkt, mit <strong>de</strong>m Werkzeug Werkzeug, <strong>de</strong>n<br />
Bewegungsparametern <strong>de</strong>sc und einem gesteuerten Kraftwert Kraft.<br />
Der gesteuerte Kraftwert Kraft wird in Prozent <strong>de</strong>r maximalen Belastbarkeit <strong>de</strong>s Arms ausgedrückt. Er muss innerhalb<br />
±1000% liegen.<br />
ACHTUNG:<br />
Das System wartet nicht auf das En<strong>de</strong> <strong>de</strong>r Bewegung, um zur nächsten VAL3-Anweisung<br />
weiterzugehen: Es können mehrere Bewegungsanweisungen vorab gespeichert wer<strong>de</strong>n. Wenn<br />
nicht mehr genügend Speicherplatz für eine neue Anweisung verfügbar ist, wird mit <strong>de</strong>r<br />
Ausführung gewartet, bis die Speicherung möglich ist.<br />
Die verschie<strong>de</strong>nen Parameter <strong>de</strong>r Bewegung sind zu Beginn <strong>de</strong>s vorliegen<strong>de</strong>n Kapitels genauer erklärt.<br />
Bei ungültigen Werten von <strong>de</strong>sc o<strong>de</strong>r Kraft wird ein Ausführungsfehler erzeugt. Dies gilt auch, wenn die Position Punkt<br />
nicht erreichbar ist, wenn die Position Punkt nicht auf einer geradlinigen Bewegung angefahren wer<strong>de</strong>n kann, wenn die<br />
vorangehen<strong>de</strong> Bewegung eine Glättung for<strong>de</strong>rt o<strong>de</strong>r wenn ein zuvor aufgezeichneter Bewegungsbefehl nicht<br />
ausgeführt wer<strong>de</strong>n kann (Zielposition nicht erreichbar).<br />
Parameter<br />
point Punkt Ausdruck <strong>de</strong>s Typs point.<br />
tool Werkzeug Ausdruck <strong>de</strong>s Typs Werkzeug<br />
m<strong>de</strong>sc <strong>de</strong>sc Ausdruck <strong>de</strong>s Typs Bewegungs<strong>de</strong>skriptor<br />
num Kraft Ausdruck <strong>de</strong>s Typs num<br />
Siehe auch<br />
void movejf(joint Position, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
bool isCompliant()<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 113 / 122
Syntax<br />
bool isCompliant()<br />
bool isCompliant()<br />
Funktion<br />
Liefert <strong>de</strong>n Wert true, wenn <strong>de</strong>r Roboter in ausgeglichenem Betrieb arbeitet, an<strong>de</strong>rnfalls <strong>de</strong>n Wert false.<br />
Zum Beispiel<br />
movelf(position, outil, mDesc, 0)<br />
wait(isCompliant()) // Wartet bis <strong>de</strong>r Roboter ausgleichfähig ist<br />
dEjection = true // Auswurfbefehl <strong>de</strong>r Spritzgießmaschine<br />
waitEndMove() // Wartet auf das En<strong>de</strong> <strong>de</strong>r ausgeglichenen Bewegung<br />
movej(jDépart, outil, mDesc) // Schließt eine Standardbewegung an<br />
Siehe auch<br />
void movelf(point Punkt, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
void movejf(joint Position, tool Werkzeug, m<strong>de</strong>sc <strong>de</strong>sc, num Kraft)<br />
114 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
FEHLERCODES<br />
ANHANG<br />
Co<strong>de</strong> Beschreibung<br />
-1 Es gibt keine Task Name<br />
0 Die Task Name ist ohne Ausführungsfehler gestoppt<br />
1 Die Task Name befin<strong>de</strong>t sich in Ausführung<br />
10 Ungültige numerische Berechnung (Division durch Null).<br />
11 Ungültige numerische Berechnung (zum Beispiel ln(-1))<br />
20 Zugriff zu einer Tabelle mit höherem In<strong>de</strong>x als die Tabellengröße.<br />
21 Zugriff zu einer Tabelle mit negativem In<strong>de</strong>x.<br />
29 Ungültiger Name <strong>de</strong>r Task. Siehe Anweisung taskCreate().<br />
30 Der festgelegte Name entspricht keiner Task von VAL3.<br />
31 Es existiert bereits eine Task gleichen Namens. Siehe Anweisung taskCreate.<br />
40 Der Speicherplatz genügt nicht für die Daten.<br />
41 Der Ausführungsspeicher ist für die Task unzureichend. Siehe Größe <strong>de</strong>s Ausführungsspeichers.<br />
60 Maximale Ausführungszeit <strong>de</strong>r Anweisung ist abgelaufen.<br />
61 Interner Fehler <strong>de</strong>s VAL3-Interpreters<br />
70 Ungültiger Wert <strong>de</strong>s Parameters <strong>de</strong>r Anweisung. Siehe entsprechen<strong>de</strong> Anweisung.<br />
80 Verwendung von Daten o<strong>de</strong>r Programmen einer nicht im Speicher gela<strong>de</strong>nen Bibliothek.<br />
90 Die Task kann an <strong>de</strong>r festgelegten Stelle nicht wie<strong>de</strong>r aufgenommen wer<strong>de</strong>n. Siehe Anweisung taskResume().<br />
100 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Geschwindigkeit ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
101 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Beschleunigung ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
102<br />
Die im Bewegungs<strong>de</strong>skriptor spezifizierte Abbremsgeschwindigkeit ist ungültig (negativ, zu groß o<strong>de</strong>r kleiner als<br />
die Geschwindigkeit).<br />
103 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Translationsgeschwindigkeit ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
104 Die im Bewegungs<strong>de</strong>skriptor spezifizierte Rotationsgeschwindigkeit ist ungültig (negativ o<strong>de</strong>r zu groß).<br />
105 Der im Bewegungs<strong>de</strong>skriptor spezifizierte Parameter reach ist ungültig (negativ).<br />
1<strong>06</strong> Der im Bewegungs<strong>de</strong>skriptor spezifizierte Parameter leave ist ungültig (negativ).<br />
122 Schreibversuch auf einem Eingang <strong>de</strong>s Systems.<br />
123 Verwendung eines Ein-/Ausgangs dio, aio o<strong>de</strong>r sio, <strong>de</strong>r keinem Ein-/Ausgang <strong>de</strong>s Systems zugeordnet ist.<br />
124 Versuch <strong>de</strong>s Zugriffs auf einen geschützten Ein-/Ausgang <strong>de</strong>s Systems<br />
125 Lese- o<strong>de</strong>r Schreibfehler an einem dio, aio o<strong>de</strong>r sio (Fehler auf Feldbus)<br />
150<br />
Diese Bewegungsanweisung lässt sich nicht ausführen: Eine vorher angefor<strong>de</strong>rte Bewegung konnte nicht been<strong>de</strong>t<br />
wer<strong>de</strong>n (Punkt nicht erreichbar, singulärer Punkt, Konfigurationsproblem usw.)<br />
152 Verwendung eines point ohne Referenzsystem. Siehe Definition.<br />
153 Bewegungsbefehl nicht unterstützt<br />
154 Ungültige Bewegungsanweisung: Bewegungs<strong>de</strong>skriptor überprüfen.<br />
160 Koordinaten <strong>de</strong>s Tools flange nicht gültig<br />
161 Koordinaten <strong>de</strong>s Koordinatensystems world nicht gültig<br />
162 Verwendung eines point ohne Referenzsystem. Siehe Definition.<br />
163 Verwendung eines Koordinatensystems ohne Referenzsystem. Siehe Definition.<br />
164 Verwendung eines Tools ohne Referenztool. Siehe Definition.<br />
165 Referenzsystem o<strong>de</strong>r Referenztool ungültig (globale Variable mit lokaler Variablen verbun<strong>de</strong>n)<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 115 / 122
TASTENCODES DER BEDIENKONSOLE<br />
Ohne Shift Mit Shift<br />
3 Caps Space 3 Caps Space<br />
283 - 32 Move 283 - 32 Move<br />
2 Shift Esc Help<br />
Ret.<br />
-<br />
Run 2 Shift Esc Help<br />
Ret.<br />
-<br />
Run<br />
282 - 255 - 270 - 282 - 255 - 270 -<br />
Menu Tab Up Bksp Stop Menu UnTab PgUp Bksp Stop<br />
- 259 261 263 - - 260 262 263 -<br />
1 User Left Down Right 1 User Home PgDn End<br />
281 - 264 266 268 281 - 265 267 269<br />
Menüs (mit und ohne Shift):<br />
F1 F2 F3 F4 F5 F6 F7 F8<br />
271 272 273 274 275 276 277 278<br />
Bei Standardtasten wird <strong>de</strong>r ASCII-Co<strong>de</strong> <strong>de</strong>s betreffen<strong>de</strong>n Zeichens zurückgesandt:<br />
Ohne Shift<br />
q w e r t y u i o p<br />
113 119 101 114 116 121 117 105 111 112<br />
a s d f g h j k l <<br />
97 115 100 102 103 104 1<strong>06</strong> 107 108 60<br />
z x c v b n m . , =<br />
122 120 99 118 98 110 109 46 44 61<br />
Mit Shift<br />
7 8 9 + * ; ( ) [ ]<br />
55 56 57 43 42 59 40 41 91 93<br />
4 5 6 - / ? : ! { }<br />
52 53 54 45 47 63 58 33 123 125<br />
1 2 3 0 " % - . , ><br />
49 50 51 48 34 37 95 46 44 62<br />
Mit doppeltem Shift<br />
Q W E R T Y U I O P<br />
81 87 69 82 84 89 85 73 79 80<br />
A S D F G H J K L }<br />
65 83 68 70 71 72 74 75 76 125<br />
Z X C V B N M $ \ =<br />
90 88 67 86 66 78 77 36 92 61<br />
116 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
ADDILDUNG<br />
Abhängigkeit <strong>de</strong>r Tools ................................................ 78<br />
Absolute, konstante Ausrichtung .......................................... 96<br />
An<strong>de</strong>re Schulterkonfiguration möglich ..................................... 100<br />
Anfans- und Endposition ............................................... 91<br />
Bedienerseite ...................................................... 46<br />
Beziehung zwischen: frame / point / tool / trsf ................................. 69<br />
Definition <strong>de</strong>r Entfernungen: ’leave’ / ’reach’ .................................. 93<br />
Drehung <strong>de</strong>s Koordinatensystems bezüglich folgen<strong>de</strong>r Achse: X .................... 73<br />
Drehung <strong>de</strong>s Koordinatensystems bezüglich folgen<strong>de</strong>r Achse: Y’ .................... 74<br />
Drehung <strong>de</strong>s Koordinatensystems bezüglich folgen<strong>de</strong>r Achse: Z’’ .................... 74<br />
Geglätteter Zyklus .................................................. 101<br />
Geglätteter Zyklus ................................................... 94<br />
Geradlinige Bewegung ................................................ 91<br />
Konfiguration: enegative ............................................... 88<br />
Konfiguration: epositive ................................................ 88<br />
Konfiguration: lefty ................................................... 87<br />
Konfiguration: lefty ................................................... 89<br />
Konfiguration: righty .................................................. 87<br />
Konfiguration: righty .................................................. 89<br />
Konfiguration: wnegative ............................................... 88<br />
Konfiguration: wpositive ............................................... 88<br />
Konstante Ausrichtung bezüglich <strong>de</strong>r Bahn ................................... 96<br />
Kreisförmige Bewegung ............................................... 92<br />
Mehr<strong>de</strong>utigkeit <strong>de</strong>r mittleren Ausrichtung .................................... 97<br />
Orientierung ....................................................... 73<br />
Positive / negative Konfiguration <strong>de</strong>s Ellenbogens .............................. 98<br />
Positive / negative Konfiguration <strong>de</strong>s Handgelenks.............................. 99<br />
Punkt<strong>de</strong>finition...................................................... 80<br />
Sequentielles Ordnen ................................................. 53<br />
Vollständiger Kreis ................................................... 97<br />
Wechsel: righty / lefty ................................................. 98<br />
Wechseln <strong>de</strong>r Ellenbogenkonfiguration nicht möglich ............................ 99<br />
Zusammenhang zwischen <strong>de</strong>n Referenz-Koordinatensystemen ..................... 76<br />
Zwei verschie<strong>de</strong>ne Konfigurationen, um <strong>de</strong>nselben Punkt zu erreichen: P .............. 86<br />
Zyklus mit unterbrochener Glättung ........................................ 94<br />
Zyklus: U ......................................................... 92<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 117 / 122
118 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
A<br />
abs (fonction) 24, 70<br />
accel 104<br />
acos (fonction) 23<br />
aio 12, 41<br />
aioGet (fonction) 41<br />
aioLink (fonction) 41<br />
aioSet (fonction) 42<br />
appro (fonction) 83<br />
asc (fonction) 33<br />
asin (fonction) 23<br />
atan (fonction) 24<br />
autoConnectMove 95<br />
autoConnectMove (fonction) 110<br />
B<br />
blend 93, 104<br />
bool 12<br />
C<br />
call 11, 16<br />
call (fonction) 15<br />
chr (fonction) 32<br />
clearBuffer (fonction) 44<br />
clock (fonction) 61<br />
close 53<br />
close (fonction) 79<br />
cls (fonction) 47<br />
co<strong>de</strong>Ascii 32<br />
compose (fonction) 82<br />
config 12, 69, 86<br />
config (fonction) 90<br />
cos (fonction) 23<br />
D<br />
<strong>de</strong>cel 104<br />
<strong>de</strong>lay 53<br />
<strong>de</strong>lay (fonction) 60<br />
<strong>de</strong>lete (fonction) 35<br />
dio 12, 38<br />
dioGet (fonction) 39<br />
dioLink (fonction) 39<br />
dioSet (fonction) 40<br />
disablePower (fonction) 66<br />
distance (fonction) 75, 81<br />
do 17<br />
do ... until (fonction) 17<br />
INDEX<br />
E<br />
elbow 86<br />
else 16<br />
enablePower (fonction) 66<br />
endFor 18<br />
endIf 16<br />
endWhile 17<br />
enegative 88<br />
epositive 88<br />
esStatus (fonction) 68<br />
exp (fonction) 25<br />
F<br />
find (fonction) 36<br />
flange 10<br />
for 18<br />
for (fonction) 18<br />
frame 12, 69<br />
G<br />
get 53<br />
get (fonction) 48<br />
getKey (fonction) 50<br />
globale 13<br />
gotoxy (fonction) 47<br />
H<br />
here (fonction) 83<br />
herej (fonction) 71<br />
I<br />
if (fonction) 16<br />
insert (fonction) 35<br />
isCalibrated (fonction) 67<br />
isCompliant 111<br />
isCompliant (fonction) 114<br />
isEmpty (fonction) 110<br />
isInRange (fonction) 71<br />
isKeyPressed (fonction) 50<br />
isPowered (fonction) 66<br />
isSettled (fonction) 110<br />
J<br />
joint 12<br />
jointToPoint (fonction) 84<br />
L<br />
leave 93, 104<br />
left (fonction) 33<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 119 / 122
lefty 87, 89<br />
len (fonction) 37<br />
libDelete (fonction) 64<br />
libLoad 63<br />
libLoad (fonction) 64<br />
libPath (fonction) 65<br />
libSave (fonction) 64<br />
limit (fonction) 28<br />
ln (fonction) 26<br />
locale 13<br />
log (fonction) 26<br />
logMsg (fonction) 51<br />
M<br />
max (fonction) 28<br />
m<strong>de</strong>sc 12, 91, 104<br />
mid (fonction) 34<br />
min (fonction) 28<br />
movec (fonction) 107<br />
movej 91<br />
movej (fonction) 105<br />
movejf 111<br />
movejf (fonction) 112<br />
movel 91<br />
movel (fonction) 1<strong>06</strong><br />
movelf 111<br />
movelf (fonction) 113<br />
N<br />
num 12, 33<br />
O<br />
open 53<br />
open (fonction) 79<br />
P<br />
point 12<br />
pointToJoint (fonction) 84<br />
popUpMsg (fonction) 50<br />
position (fonction) 85<br />
put (fonction) 47<br />
putln 47<br />
R<br />
reach 93, 104<br />
replace (fonction) 36<br />
resetMotion 95, 108, 111<br />
resetMotion (fonction) 108<br />
restartMove 108, 111<br />
restartMove (fonction) 109<br />
return (fonction) 16<br />
right (fonction) 34<br />
righty 87, 89<br />
round (fonction) 27<br />
roundDown (fonction) 27<br />
roundUp (fonction) 27<br />
RUNNING 60, 61<br />
rvel 104<br />
S<br />
sel (fonction) 29<br />
setFrame (fonction) 77<br />
shoul<strong>de</strong>r 86<br />
sin (fonction) 22<br />
sio 12, 43<br />
sioGet (fonction) 44<br />
sioLink (fonction) 44<br />
sioSet (fonction) 45<br />
size (fonction) 20<br />
speedScale (fonction) 68<br />
sqrt (fonction) 25<br />
start 10<br />
stop 10<br />
stopMove 111<br />
stopMove (fonction) 108<br />
STOPPED 56<br />
string 12<br />
switch (fonction) 19<br />
T<br />
tan (fonction) 24<br />
taskCreate (fonction) 59<br />
taskKill (fonction) 57<br />
taskResume 52<br />
taskResume (fonction) 56<br />
taskStatus 52<br />
taskStatus (fonction) 58<br />
taskSuspend (fonction) 56<br />
title (fonction) 48<br />
toNum (fonction) 31<br />
tool 12, 69<br />
toString (fonction) 30<br />
trsf 12, 69<br />
tvel 104<br />
U<br />
until 17<br />
120 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>
REFERENZANLEITUNG VAL3 - Version 5.2<br />
userPage (fonction) 46<br />
V<br />
vel 104<br />
W<br />
wait 53<br />
wait (fonction) 60<br />
waitEndMove 53, 94, 111<br />
waitEndMove (fonction) 109<br />
watch 53<br />
watch (fonction) 61<br />
while (fonction) 17<br />
wnegative 88<br />
workingMo<strong>de</strong> (fonction) 67<br />
world 10<br />
wpositive 88<br />
wrist 86<br />
D28056202B - <strong>06</strong>/<strong>2005</strong> 121 / 122
122<br />
122 / 122 D28056202B - <strong>06</strong>/<strong>2005</strong>