Bedienanleitung Einführung in RAPID - ABB Robotics
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
ABB Robotics Bedienanleitung Einführung in RAPID
Trace back information: Workspace R12-2 version a9 Checked in 2012-09-29 Skribenta version 1184
Bedienanleitung
Einführung in RAPID
RobotWare 5
Dokumentnr: 3HAC029364-003
Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Die Informationen in diesem Handbuch können ohne vorherige Ankündigung geändert
werden und stellen keine Verpflichtung von ABB dar. ABB übernimmt keinerlei
Verantwortung für etwaige Fehler, die dieses Handbuch enthalten kann.
Wenn nicht ausdrücklich in vorliegendem Handbuch angegeben, gibt ABB für keine
hierin enthaltenen Informationen Garantie oder Gewährleistung für Verluste, Personen-
oder Sachschäden, Verwendbarkeit für einen bestimmten Zweck oder Ähnliches.
In keinem Fall kann ABB haftbar gemacht werden für Schäden oder Folgeschäden,
die sich aus der Anwendung dieses Dokuments oder der darin beschriebenen
Produkte ergeben.
Dieses Handbuch darf weder ganz noch teilweise ohne vorherige schriftliche
Genehmigung von ABB vervielfältigt oder kopiert werden.
Zusätzliche Kopien dieses Handbuchs können von ABB bezogen werden.
Die ursprüngliche Sprache diese Veröffentlichung ist Englisch. Alle anderen
angebotenen Sprachen wurden aus dem Englischen übersetzt.
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.
ABB AB
Robotics Products
SE-721 68 Västerås
SchwedenInhaltsverzeichnis
Inhaltsverzeichnis
Überblick über dieses Handbuch ..................................................................................................... 7
Produktdokumentation, M2004 ........................................................................................................ 9
Sicherheit .......................................................................................................................................... 11
Terminologie ..................................................................................................................................... 12
1 Grundlagen von RAPID 13
1.1 Über RAPID ..................................................................................................... 13
1.2 RAPID-Daten .................................................................................................... 14
1.2.1 Variablen ............................................................................................... 14
1.2.2 Persistente Variablen ............................................................................... 16
1.2.3 Konstanten ............................................................................................ 17
1.2.4 Operatoren ............................................................................................ 18
1.3 Steuern des Programmablaufs ............................................................................. 20
1.3.1 IF THEN ................................................................................................ 20
1.3.2 Beispiele für logische Bedingungen und IF-Anweisungen ............................... 22
1.3.3 FOR-Schleife .......................................................................................... 23
1.3.4 WHILE-Schleife ....................................................................................... 24
1.4 Regeln und Empfehlungen für RAPID-Syntax ......................................................... 25
1.4.1 Allgemeine Regeln für die RAPID-Syntax ..................................................... 25
1.4.2 Empfehlungen für RAPID-Code .................................................................. 26
2 RAPID-Roboterfunktionalität 27
2.1 Bewegungsinstruktionen .................................................................................... 27
2.1.1 MoveL-Instruktion ................................................................................... 27
2.1.2 Koordinatensysteme ................................................................................ 30
2.1.3 Beispiele für MoveL ................................................................................. 31
2.1.4 Weitere Bewegungsinstruktionen ............................................................... 33
2.1.5 Abarbeitungsverhalten in Verschleifzonen ................................................... 34
2.2 E/A-Signale ...................................................................................................... 36
2.2.1 E/A-Signale ............................................................................................ 36
2.3 Benutzerinteraktion ........................................................................................... 38
2.3.1 Kommunikation mit dem FlexPendant ......................................................... 38
3 Struktur 41
3.1 RAPID-Prozedur ............................................................................................... 41
3.2 Module ............................................................................................................ 43
3.3 Strukturierter Entwurf ......................................................................................... 45
4 Daten mit mehreren Werten 49
4.1 Datenfelder ...................................................................................................... 49
4.2 Zusammengesetzte Datentypen ........................................................................... 50
5 RAPID-Instruktionen und -Funktionen 53
5.1 Instruktionen .................................................................................................... 53
5.2 Funktionen ....................................................................................................... 54
6 Weiterführende Literatur 55
6.1 Weitere Informationen ........................................................................................ 55
Index 57
3HAC029364-003 Revision: A 5
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Diese Seite wurde absichtlich leer gelassen
Überblick über dieses Handbuch
Überblick über dieses Handbuch
Über dieses Handbuch
Dieses Handbuch bietet eine Einführung in RAPID. Viele Funktionen in RAPID
werden nicht behandelt, jedoch werden die wichtigsten Komponenten beschrieben,
so dass eine gut verständliche Beschreibung der Programmiersprache geboten
wird. Dieses Handbuch macht Sie nicht zu einem versierten RAPID-Programmierer,
Sie lernen jedoch das Konzept der Programmierung mit RAPID kennen. Details
finden Sie immer in den Referenzhandbüchern.
Verwendung
Dieses Handbuch sollte gelesen werden, bevor mit der Programmierung begonnen
wird. Es enthält nicht alle Informationen, die Sie benötigen, jedoch müssen Sie mit
den meisten Informationen in diesem Handbuch vertraut sein, bevor Sie mit dem
Schreiben eines RAPID-Programms beginnen.
Das Handbuch ersetzt nicht die Schulungskurse für RAPID, kann sie jedoch
ergänzen.
An welche Personen richtet sich dieses Handbuch?
Das Handbuch ist für Personen vorgesehen, die noch keine Programmiererfahrung
besitzen, z. B. für einen Roboterbediener, der das Programmieren des Roboters
erlernen möchte.
Voraussetzungen
Zum Lesen dieses Handbuchs sind keine Voraussetzungen erforderlich.
Kapiteleinteilung
Dieses Handbuch setzt sich aus den folgenden Kapiteln zusammen:
Kapitel Inhalt
1 RAPID-Grundlagen Die Grundlagen des Programmierens. Diese Funktiona-
lität ist in den meisten höheren Programmiersprachen
ähnlich.
2 RAPID-Roboterfunktionalität Beschreibt die Funktionalität, die RAPID von anderen
Programmiersprachen unterscheidet, z. B. Bewegungs-
instruktionen, E/A-Signale und die Kommunikation mit
dem FlexPendant.
3-Struktur Beschreibt die Verfahren zum Erstellen eines Pro-
gramms. Dieses Kapitel enthält außerdem eine kurze
Einführung in das Anwenden eines strukturierten Pro-
grammentwurfs.
4 Daten mit mehreren Werten Beschreibt Datenfelder und komplexe Datentypen.
5 RAPID-Instruktionen und - Hier wird kurz erläutert, worum es sich bei RAPID-Instruk-
Funktionen tionen und -Funktionen handelt.
6 Weiterführende Literatur Hier erfahren Sie, wo Sie weitere Informationen finden,
wenn Sie Ihr Studium von RAPID vertiefen möchten.
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 7
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Überblick über dieses Handbuch
Fortsetzung
Referenzen
Referenz Dokumentkennung
Technisches Referenzhandbuch - RAPID Überblick 3HAC16580-3
Technisches Referenzhandbuch - RAPID Instruktionen, Funktionen 3HAC16581-3
und Datentypen
Technical reference manual - RAPID kernel 3HAC16585-1
Bedienanleitung - IRC5 mit FlexPendant 3HAC16590-3
Revisionen
Revision Beschreibung
- Erste Ausgabe
A Den Datentyp dnum zu Variablen auf Seite 14 hinzugefügt.
8 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Produktdokumentation, M2004
Produktdokumentation, M2004
Kategorien für die Manipulatordokumentation
Die Manipulatordokumentation ist in mehrere Kategorien unterteilt. Die Liste beruht
auf der Informationsart in den Dokumenten, unabhängig davon, ob es sich um
Standardprodukte oder optionale Produkte handelt.
Alle Dokumente in der Liste können von ABB als DVD bestellt werden. Die
erwähnten Dokumente gelten für M2004-Manipulatorsysteme.
Produkthandbücher
Manipulatoren, Steuerungen, DressPack/SpotPack und die meiste andere Hardware
werden mit einem Produkthandbuch geliefert, das Folgendes enthält:
• Sicherheitsinformationen.
• Installation und Inbetriebnahme (Beschreibung der mechanischen Installation
und der elektrischen Anschlüsse).
• Wartung (Beschreibung aller erforderlichen vorbeugenden
Wartungsmaßnahmen einschließlich der entsprechenden Intervalle und der
Lebensdauer der Teile).
• Reparatur (Beschreibung aller empfohlenen Reparaturvorgänge,
einschließlich des Austauschs von Ersatzteilen).
• Kalibrierung.
• Stilllegung.
• Referenzinformation (Sicherheitsstandards, Einheitenumrechnung,
Schraubverbindungen, Werkzeuglisten).
• Ersatzteilliste mit Explosionszeichnungen (oder Referenzen zu separaten
Ersatzteillisten).
• Schaltpläne (oder Referenzen zu Schaltplänen).
Technische Referenzhandbücher
Die technischen Referenzhandbücher enthalten Referenzinformationen für
Robotics-Produkte.
• Technical reference manual - Lubrication in gearboxes: Beschreibung der
Typen und Mengen von Schmiermittel für die Manipulatorgetriebe.
• Technisches Referenzhandbuch - RAPID Überblick: Ein Überblick über die
RAPID-Programmiersprache.
• Technisches Referenzhandbuch - RAPID Instruktionen, Funktionen und
Datentypen: Beschreibung und Syntax aller RAPID-Instruktionen, -Funktionen
und -Datentypen.
• Technical reference manual - RAPID kernel: Eine formelle Beschreibung der
RAPID-Programmiersprache.
• Technisches Referenzhandbuch - Systemparameter: Beschreibung von
Systemparametern und Konfigurationsabläufen.
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 9
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Produktdokumentation, M2004
Fortsetzung
Anwendungshandbücher
Bestimmte Anwendungen (z. B. Software- oder Hardware-Optionen) werden in
Anwendungshandbüchern beschrieben. Ein Anwendungshandbuch kann eine
oder mehrere Anwendungen beschreiben.
Ein Anwendungshandbuch enthält im Allgemeinen folgende Informationen:
• Zweck der Anwendung (Aufgabe und Nutzen).
• Enthaltenes Material (z. B. Kabel, E/A-Karten, RAPID-Instruktionen,
Systemparameter, DVD mit PC-Software)
• Installieren von enthaltener oder erforderlicher Hardware.
• Bedienungsanleitung für die Anwendung.
• Beispiele für die Verwendung der Anwendung.
Bedienanleitungen
In den Bedienanleitungen wird die Handhabung der Produkte in der Praxis
beschrieben. Diese Handbücher richten sich an die Personen, die direkten
Bedienungskontakt mit dem Produkt haben, also Bediener der Produktionszelle,
Programmierer und Wartungsmitarbeiter.
Diese Gruppe von Handbüchern umfasst (u. a.):
• Bedienanleitung - Sicherheitsinformationen für Notfälle
• Bedienanleitung - Allgemeine Sicherheitsinformationen
• Bedienanleitung - Erste Schritte - IRC5 und RobotStudio
• Bedienanleitung - Einführung in RAPID
• Bedienanleitung - IRC5 mit FlexPendant
• Bedienanleitung - RobotStudio
• Bedienanleitung - Fehlerbehebung IRC5 für Steuerung und Manipulator.
10 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Sicherheit
Sicherheit
Sicherheit des Personals
Der Roboter ist sehr schwer und übt unabhängig von seiner Geschwindigkeit eine
extrem hohe Kraft aus. Auf eine Pause oder einen längeren Halt der Bewegung
kann eine gefährliche, plötzliche Bewegung folgen. Selbst wenn ein
Bewegungsmuster vorgegeben ist, kann ein externes Signal den Betrieb
beeinflussen und eine unvorhergesehene Bewegung auslösen.
Daher ist es wichtig, beim Betreten von abgesicherten Räumen alle
Sicherheitsbestimmungen einzuhalten.
Sicherheitsbestimmungen
Vor dem ersten Einsatz des Roboters müssen Sie sich unbedingt mit den
Sicherheitsbestimmungen im Handbuch Bedienanleitung - Allgemeine
Sicherheitsinformationen vertraut machen.
3HAC029364-003 Revision: A 11
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Terminologie
Terminologie
Über die Begriffe
Dieses Handbuch wurde generell für Anfänger in Bezug auf Programmierung und
Roboter verfasst. Es werden jedoch einige Begriffe verwendet, mit denen
möglicherweise nur Personen vertraut sind, die bereits Kenntnisse über
Programmierung und/oder Industrieroboter besitzen. Diese Begriffe werden in
diesem Terminologiekapitel erläutert.
Begriffe
Begriff Beschreibung
FlexPendant Ein Hand-Terminal zum Steuern eines Robotersystems.
Robotersteuerung Die Robotersteuerung ist im Prinzip ein Computer, der den Roboter
steuert.
Syntax Regeln, die bestimmen, wie Code in einer bestimmten Programmier-
sprache geschrieben werden darf. Sie kann als Grammatik der Program-
miersprache betrachtet werden.
Die Syntax einer Programmiersprache ist weitaus genauer geregelt als
die Syntax gewöhnlicher Sprachen. Die menschliche Intelligenz ist in
der Lage, den Sinn des Satzes „Ich schnell laufe“ zu verstehen, auch
wenn die Regeln der Syntax „Ich laufe schnell“ vorschreiben. Computer
hingegen verfügen über keine menschliche Intelligenz und verstehen
ausschließlich Anweisungen, deren Syntax zu 100 Prozent mit den
Regeln übereinstimmt.
12 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.1 Über RAPID
1 Grundlagen von RAPID
1.1 Über RAPID
Was ist RAPID?
Wenn Sie einen Computer zu einer Aktion veranlassen möchten, ist ein Programm
erforderlich. RAPID ist eine Programmiersprache zum Schreiben eines solchen
Programms.
Die ursprüngliche Sprache von Computern besteht nur aus den Zahlen 0 und 1.
Für Menschen ist diese Sprache praktisch nicht verständlich. Daher wurde für
Computer eine relativ einfach verständliche Sprache entwickelt – eine höhere
Programmiersprache. RAPID ist eine höhere Programmiersprache, die einige
englische Wörter (z. B.IF und FOR) enthält, damit sie für Menschen verständlich
ist.
Einfaches Beispiel für ein RAPID-Programm
Im Folgenden zeigen wir anhand eines einfachen Beispiels, wie ein
RAPID-Programm aussehen kann:
MODULE MainModule
VAR num length;
VAR num width;
VAR num area;
PROC main()
length := 10;
width := 5;
area := length * width;
TPWrite "The area of the rectangle is " \Num:=area;
END PROC
ENDMODULE
Dieses Programm berechnet die Fläche eines Rechtecks und gibt auf dem
FlexPendant Folgendes aus:
The area of the rectangle is 50
3HAC029364-003 Revision: A 13
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.2.1 Variablen
1.2 RAPID-Daten
1.2.1 Variablen
Datentypen
In RAPID gibt es viele unterschiedliche Datentypen. Vorerst beschäftigen wir uns
nur mit den vier allgemeinen Datentypen:
Datentyp Beschreibung
num Bei numerischen Daten kann es sich um ganze Zahlen und um Dezimal-
zahlen handeln, z. B. 10 oder 3,14159.
dnum Numerische Daten mit einer höheren Auflösung als num. Können ganze
Zahlen (für die Bearbeitung großer Werte) und Dezimalzahlen sein (mit
mehr Dezimalstellen). Zum Beispiel 4503599627370496 oder
3,141592653589793.
string Eine Zeichenfolge mit Text, z. B. „Dies ist eine Zeichenfolge“. Sie kann
maximal 80 Zeichen enthalten.
bool Eine boolesche (logische) Variable. Sie kann nur den Wert TRUE oder
FALSE aufweisen.
Alle anderen Datentypen basieren auf diesen vier Datentypen. Wenn Sie diese
Datentypen kennen und wissen, wie Sie Operationen mit ihnen ausführen und wie
sie zu komplexeren Datentypen kombiniert werden können, sind alle Datentypen
für Sie leicht zu verstehen.
Merkmale von Variablen
Eine Variable enthält einen Datenwert. Wenn das Programm angehalten und neu
gestartet wird, bleibt der Wert der Variablen erhalten, doch wenn der
Programmzeiger auf main verschoben wird, geht der Datenwert der Variablen
verloren.
Deklarieren einer Variablen
Beim Deklarieren einer Variablen werden der Name der Variablen und ihr Datentyp
definiert. Variablen werden mit dem Schlüsselwort VAR gemäß folgender Syntax
definiert:
VAR DatentypBezeichner;
Beispiel:
VAR num length;
VAR dnum pi;
VAR string name;
VAR bool finished;
Zuweisen von Werten
Einer Variablen wird mit der Instruktion := ein Wert zugewiesen.
length := 10;
pi := 3.141592653589793;
name := "John"
finished := TRUE;
Fortsetzung auf nächster Seite
14 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.2.1 Variablen
Fortsetzung
Beachten Sie, dass := kein Gleichheitszeichen ist. Das Zeichen bedeutet, dass
der Ausdruck auf der rechten Seite an die Variable auf der linken Seite übergeben
wird. Links von := darf nur eine Variable stehen.
Beispielsweise sind die folgenden Anweisungen ordnungsgemäßer RAPID-Code,
der dazu führt, dass reg1 den Wert 3 annimmt:
reg1 := 2;
reg1 := reg1 + 1;
Die Zuweisung kann gemeinsam mit der Variablendeklaration erfolgen:
VAR num length := 10;
VAR dnum pi := 3.141592653589793;
VAR string name := "John";
VAR bool finished := TRUE;
3HAC029364-003 Revision: A 15
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.2.2 Persistente Variablen
1.2.2 Persistente Variablen
Was ist eine persistente Variable?
Eine persistente Variable weist einen einzigen, jedoch wichtigen Unterschied zu
gewöhnlichen Variablen auf. In einer persistenten Variablen wird der Wert
gespeichert, der ihr zuletzt zugewiesen wurde, auch wenn das Programm
angehalten und ab dem Anfang des Programms neu gestartet wird.
Deklarieren einer persistenten Variablen
Persistente Variablen werden mit dem Schlüsselwort PERS deklariert. Bei der
Deklaration muss ein Anfangswert zugewiesen werden.
PERS num nbr := 1;
PERS string string1 := "Hello";
Beispiel:
Betrachten Sie das folgende Codebeispiel:
PERS num nbr := 1;
PROC main()
nbr := 2;
ENDPROC
Bei der Ausführung dieses Programms wird der Anfangswert in 2 geändert. Beim
nächsten Ausführen des Programms lautet der Programmcode wie folgt:
PERS num nbr := 2;
PROC main()
nbr := 2;
ENDPROC
16 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.2.3 Konstanten
1.2.3 Konstanten
Was ist eine Konstante?
Eine Konstante enthält wie eine Variable einen Wert. Jedoch wird der Wert immer
bei der Deklaration zugewiesen und kann danach nicht mehr geändert werden.
Die Konstante kann im Programm auf die gleiche Weise wie eine Variable verwendet
werden, mit dem Unterschied, dass der Konstanten kein neuer Wert zugewiesen
werden darf.
Konstantendeklaration
Konstanten werden mit dem Schlüsselwort CONST deklariert, auf das der Datentyp,
der Bezeichner und die Zuweisung eines Wertes folgen.
CONST num gravity := 9.81;
CONST string greating := "Hello"
Zweck der Verwendung von Konstanten
Wenn Sie statt einer Variablen eine Konstante verwenden, können Sie sicherstellen,
dass der Wert nicht im Programm geändert wird.
Es empfiehlt sich, eine Konstante zu verwenden statt den Wert direkt im Programm
zu schreiben, wenn Sie das Programm mit einem anderen Wert für die Konstante
aktualisieren müssen. Dann muss die Änderung nur an einer Stelle vorgenommen
werden, und Sie können ausschließen, dass ein Vorkommen des Wertes übersehen
wurde.
3HAC029364-003 Revision: A 17
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.2.4 Operatoren
1.2.4 Operatoren
Numerische Operatoren
Mit diesen Operatoren wird der Datentyp num verarbeitet und sie geben den
Datentyp num zurück. In den folgenden Beispielen sind die Variablen reg1, reg2
und reg3 vom Datentyp num.
Operator Beschreibung Beispiel:
+ Addition reg1 := reg2 + reg3;
- Subtraktion reg1 := reg2 - reg3;
Unäres Minus reg1 := -reg2;
* Multiplikation reg1 := reg2 * reg3;
/ Division reg1 := reg2 / reg3;
Relationale Operatoren
Diese Operatoren geben den Datentyp bool zurück.
In den Beispielen sind reg1 und reg2 vom Datentyp num und flag1 ist vom
Datentyp bool.
Operator Beschreibung Beispiel:
= gleich flag1 := reg1 = reg2;
flag1 ist TRUE, wenn reg1 gleich reg2 ist.
< kleiner als flag1 := reg1 < reg2;
flag1 ist TRUE, wenn reg1 kleiner als reg2 ist.
> größer als flag1 := reg1 > reg2;
flag1 ist TRUE, wenn reg1 größer als reg2 ist.
= reg2;
flag1 ist TRUE, wenn reg1 größer oder gleich
reg2 ist.
ungleich flag1 := reg1 reg2;
flag1 ist TRUE, wenn reg1 ungleich reg2 ist.
Logische Operatoren werden häufig gemeinsam mit der Instruktion IF verwendet.
Codebeispiele finden Sie unter Beispiele für logische Bedingungen und
IF-Anweisungen auf Seite 22.
Fortsetzung auf nächster Seite
18 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.2.4 Operatoren
Fortsetzung
Zeichenfolgenoperator
Operator Beschreibung Beispiel:
+ Zeichenfolgenverkettung VAR string firstname := "John";
VAR string lastname := "Smith";
VAR string fullname;
fullname := firstname + " " +
lastname;
Die Variable fullname enthält die Zeichenfolge
„John Smith“.
3HAC029364-003 Revision: A 19
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.3.1 IF THEN
1.3 Steuern des Programmablaufs
1.3.1 IF THEN
Der Programmablauf
Die bisher gezeigten Beispielprogramme wurden sequenziell von oben nach unten
abgearbeitet. Bei komplexeren Programmen sollten Sie steuern, welcher
Codeabschnitt in welcher Reihenfolge und mit welcher Anzahl von Wiederholungen
abgearbeitet wird. Zunächst beschreiben wir, wie Bedingungen konfiguriert werden,
die festlegen, ob eine Programmsequenz abgearbeitet wird.
IF
Die IF-Instruktion kann verwendet werden, um eine Reihe von Anweisungen nur
abzuarbeiten, wenn eine angegebene Bedingung erfüllt ist.
Wenn die logische Bedingung in der IF-Anweisung erfüllt ist, wird der
Programmcode zwischen den Schlüsselwörtern THEN und ENDIF abgearbeitet.
Wenn die Bedingung nicht erfüllt ist, wird der Code nicht abgearbeitet und die
Abarbeitung wird nach ENDIF fortgesetzt.
Beispiel:
In diesem Beispiel wird die Zeichenfolge string1 auf dem FlexPendant
ausgegeben, wenn die Zeichenfolge nicht leer ist. Wenn string1 eine leere
Zeichenfolge ist, also keine Zeichen enthält, wird keine Aktion ausgeführt.
VAR string string1 := "Hello";
IF string1 "" THEN
TPWrite string1;
ENDIF
ELSE
Eine IF-Anweisung kann auch Programmcode enthalten, der ausgeführt werden
soll, wenn die Bedingung nicht erfüllt ist.
Wenn die logische Bedingung in der IF-Anweisung erfüllt ist, wird der
Programmcode zwischen den Schlüsselwörtern THEN und ELSE abgearbeitet.
Wenn die Bedingung nicht erfüllt ist, wird der Code zwischen den Schlüsselwörtern
ELSE und ENDIF abgearbeitet.
Beispiel:
In diesem Beispiel wird die Zeichenfolge string1 auf dem FlexPendant
ausgegeben, wenn die Zeichenfolge nicht leer ist. Wenn string1 eine leere
Zeichenfolge ist, wird die Zeichenfolge "The string is empty" ausgegeben.
VAR string string1 := "Hello";
IF string1 "" THEN
TPWrite string1;
ELSE
TPWrite "The string is empty";
Fortsetzung auf nächster Seite
20 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.3.1 IF THEN
Fortsetzung
ENDIF
ELSEIF
Manchmal sind mindestens drei alternative Programmsequenzen vorhanden. Dann
können Sie mithilfe von ELSEIF mehrere Alternativen konfigurieren.
Beispiel:
In diesem Beispiel wird je nach dem Wert der Variablen time unterschiedlicher
Text ausgegeben.
VAR num time := 38.7;
IF time < 40 THEN
TPWrite "Part produced at fast rate";
ELSEIF time < 60 THEN
TPWrite "Part produced at average rate";
ELSE
TPWrite "Part produced at slow rate";
ENDIF
Beachten Sie, dass der erste Text ausgegeben wird, weil die erste Bedingung
erfüllt ist. Die beiden anderen Textzeichenfolgen werden nicht ausgegeben (obwohl
die Bedingung zutrifft, dass time kleiner als 60 ist).
3HAC029364-003 Revision: A 21
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.3.2 Beispiele für logische Bedingungen und IF-Anweisungen
1.3.2 Beispiele für logische Bedingungen und IF-Anweisungen
Beispiel:
Verwenden Sie die IF-Anweisung, um zu bestimmen, welcher Text auf dem
FlexPendant ausgegeben wird. Ausgabe auf dem FlexPendant, welches Teil am
schnellsten gefertigt wird.
VAR string part1 := "Shaft";
VAR num time1;
VAR string part2 := "Pipe";
VAR num time2;
PROC main()
time1 := 41.8;
time2 := 38.7;
IF time1 < time2 THEN
TPWrite part1 + " is fastest to produce";
ELSEIF time1 > time2 THEN
TPWrite part2 + " is fastest to produce";
ELSE
TPWrite part1 + " and " + part2 + " are equally fast to
produce";
ENDIF
ENDPROC
Beispiel:
Wenn für das Fertigen eines Teils mehr als 60 Sekunden benötigt werden, wird
auf dem FlexPendant eine Meldung ausgegeben. Wenn die boolesche Variable
full_speed den Wert FALSE aufweist, wird der Bediener in der Meldung
angewiesen, die Robotergeschwindigkeit zu erhöhen. Wenn full_speed den
Wert TRUE aufweist, wird der Bediener in der Meldung aufgefordert, die Ursache
für die langsame Fertigung zu ermitteln.
VAR num time := 62.3;
VAR bool full_speed := TRUE;
PROC main()
IF time > 60 THEN
IF full_speed THEN
TPWrite "Examine why the production is slow";
ELSE
TPWrite "Increase robot speed for faster production";
ENDIF
ENDIF
ENDPROC
22 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.3.3 FOR-Schleife
1.3.3 FOR-Schleife
Wiederholen einer Codesequenz
Eine weitere Möglichkeit zum Steuern des Programmablaufs ist die mehrfache
Wiederholung einer Programmcodesequenz.
Funktionsweise der FOR-Schleife
Mit dem folgenden Code wird 5 Mal „Hello“ ausgegeben:
FOR i FROM 1 TO 5 DO
TPWrite "Hello";
ENDFOR
Die Syntax der FOR-Anweisung lautet:
FOR counter FROM startvalue TO endvalue DO
zu wiederholender Programmcode
ENDFOR
Der Zähler muss nicht deklariert werden. Er fungiert jedoch als numerische Variable
in der FOR-Schleife. Bei der ersten Abarbeitung des Codes weist der Zähler den
Anfangswert auf. Anschließend wird der Wert des Zählers bei jeder Abarbeitung
des Codes um 1 erhöht. Der Code wird zum letzten Mal abgearbeitet, wenn der
Zähler gleich dem Endwert ist. Anschließend wird die Abarbeitung mit dem
Programmcode nach ENDFOR fortgesetzt.
Verwendung des Zählerwerts
Der Wert des Zählers kann in der FOR-Schleife verwendet werden.
Beispielsweise kann die Berechnung der Summe aller Zahlen von 1 bis 50
(1+2+3+...+49+50) wie folgt programmiert werden:
VAR num sum := 0;
FOR i FROM 1 TO 50 DO
sum := sum + i;
ENDFOR
Es ist nicht zulässig, dem Zähler in der FOR-Schleife einen Wert zuzuweisen.
3HAC029364-003 Revision: A 23
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.3.4 WHILE-Schleife
1.3.4 WHILE-Schleife
Wiederholung unter einer Bedingung
Das Wiederholen einer Codesequenz kann mit der bedingten Abarbeitung der
Codesequenz kombiniert werden. Mit der WHILE-Schleife setzt das Programm die
Wiederholung der Codesequenz fort, solange die Bedingung erfüllt ist.
WHILE-Syntax
Die Syntax für die WHILE-Schleife lautet:
WHILE condition DO
zu wiederholender Programmcode
ENDWHILE
Wenn die Bedingung von Anfang an nicht erfüllt ist, wird die Codesequenz niemals
abgearbeitet. Wenn die Bedingung erfüllt ist, wird die Abarbeitung der Codesequenz
solange wiederholt, bis die Bedingung nicht mehr erfüllt ist.
Beispiel:
Im folgenden Programmcode werden Zahlen (1+2+3+...) addiert, bis die Summe
100 ergibt.
VAR num sum := 0;
VAR num i := 0;
WHILE sum1 Grundlagen von RAPID
1.4.1 Allgemeine Regeln für die RAPID-Syntax
1.4 Regeln und Empfehlungen für RAPID-Syntax
1.4.1 Allgemeine Regeln für die RAPID-Syntax
Semikolon
Die allgemeine Regel lautet, dass jede Anweisung mit einem Semikolon enden
muss.
Beispiele
Variablendeklaration:
VAR num length;
Zuweisen von Werten:
area := length * width;
Die meisten Instruktionsaufrufe:
MoveL p10,v1000,fine,tool0;
Ausnahmen
Einige spezielle Instruktionen enden nicht mit einem Semikolon. Stattdessen geben
besondere Schlüsselwörter an, wo sie enden.
Beispiele für Instruktionen, die nicht mit einem Semikolon enden:
Instruktionsschlüsselwort Schlüsselwort für das Ende
IF ENDIF
FOR ENDFOR
WHILE ENDWHILE
PROC ENDPROC
Diese Schlüsselwörter sind zum Erstellen eines gut strukturierten RAPID-Programm
von großer Bedeutung. Sie werden weiter unten in diesem Handbuch ausführlich
beschrieben.
Kommentare
Zeilen, die mit ! beginnen, werden von der Robotersteuerung ignoriert. Verwenden
Sie dieses Zeichen, um Kommentare zum Code zu schreiben.
Beispiel:
! Calculate the area of the rectangle
area := length * width;
3HAC029364-003 Revision: A 25
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.1 Grundlagen von RAPID
1.4.2 Empfehlungen für RAPID-Code
1.4.2 Empfehlungen für RAPID-Code
Schlüsselwörter in Großbuchstaben
Die Groß-/Kleinschreibung wird in RAPID nicht beachtet, doch wird empfohlen,
alle reservierten Wörter (z. B. VAR, PROC) in Großbuchstaben zu schreiben. Eine
vollständige Liste der reservierten Wörter finden Sie im Technisches
Referenzhandbuch - RAPID Überblick.
Einrückungen
Verwenden Sie Einrückungen, um die Verständlichkeit des Programmcodes zu
erhöhen. Der gesamte Code innerhalb von PROC (zwischen PROC und ENDPROC)
sollte eingerückt sein. Der gesamte Code innerhalb einer IF--, FOR-- oder
WHILE-Anweisung sollte zusätzlich eingerückt sein.
Beim Programmieren mit dem FlexPendant erfolgt die Einrückung automatisch.
Beispiel:
VAR bool repeat;
VAR num times;
PROC main()
repeat := TRUE;
times := 3;
IF repeat THEN
FOR i FROM 1 TO times DO
TPWrite "Hello!";
ENDFOR
ENDIF
END PROC
Beachten Sie, dass leicht zu erkennen ist, wo die IF-Anweisung beginnt und endet.
Wenn mehrere IF-Anweisungen ohne Einrückung vorhanden sind, ist praktisch
nicht zu erkennen, welches ENDIF dem jeweiligen IF entspricht.
26 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.1 MoveL-Instruktion
2 RAPID-Roboterfunktionalität
2.1 Bewegungsinstruktionen
2.1.1 MoveL-Instruktion
Überblick
RAPID bietet den Vorteil, dass diese Sprache nicht nur den Großteil der
Funktionalität anderer höherer Programmiersprachen umfasst, sondern speziell
für die Steuerung von Robotern entworfen wurde. Vor allem enthält RAPID
Instruktionen zum Bewegen des Roboters.
MoveL
Eine einfache Bewegungsinstruktion kann wie folgt aussehen:
MoveL p10, v1000, fine, tool0;
wobei:
• MoveL ist eine Instruktion, mit der der Roboter linear (auf einer Geraden)
von seiner aktuellen Position zu der angegebenen Position bewegt wird.
• p10 gibt die Position an, zu der sich der Roboter bewegen soll.
• v1000 gibt an, dass die Geschwindigkeit des Roboters 1000 mm/s betragen
soll.
• fine gibt an, dass sich der Roboter genau an die angegebene Position
bewegen und auf der Strecke zur nächsten Position keine Ecken schneiden
soll.
• tool0 gibt an, dass sich der Montageflansch an der Spitze des Roboters an
die angegebene Position bewegen soll.
MoveL-Syntax
MoveL ToPoint Speed Zone Tool;
ToPoint
Der mit einer Konstanten vom Datentyp robtarget definierte Zielpunkt. Wenn
Sie mit dem FlexPendant programmieren, können Sie einen robtarget-Wert
zuweisen, indem Sie mit dem Roboter eine Position angeben. Wenn Sie offline
programmieren, kann das Berechnen der Koordinaten für eine Position schwierig
sein.
robtarget wird weiter unten im Abschnitt Zusammengesetzte Datentypen auf
Seite 50 ausführlicher erläutert. Vorerst reicht es aus zu wissen, dass x=600,
y=-100, z=800 wie folgt deklariert und zugewiesen werden kann:
CONST robtarget p10 := [ [600, -100, 800], [1, 0, 0, 0], [0, 0, 0,
0], [ 9E9, 9E9, 9E9, 9E9, 9E9, 9E9] ];
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 27
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.1 MoveL-Instruktion
Fortsetzung
Speed
Die Bewegungsgeschwindigkeit kann mit einer Konstanten vom Datentyp
speeddata definiert werden. Es gibt zahlreiche vordefinierte Werte, beispielsweise
die folgenden:
Vordefinierte speeddata Wert
v5 5 mm/s
v100 100 mm/s
v1000 1.000 mm/s
vmax Maximale Geschwindigkeit für den Roboter
Eine vollständige Liste mit vordefinierten speeddata-Werten finden Sie im
Technisches Referenzhandbuch - RAPID Instruktionen, Funktionen und Datentypen,
Abschnitt Datentypen und speeddata.
Wenn ein vordefinierter Wert verwendet wird, sollte er nicht deklariert oder
zugewiesen werden.
Zone
Gibt eine Verschleifzone an, die mit einer Konstanten vom Datentyp zonedata
definiert wird. Es gibt zahlreiche vordefinierte Werte, beispielsweise die folgenden:
Vordefinierte zonedata Wert
fine Der Roboter verfährt genau zur angegebenen Po-
sition.
z10 Die Roboterbahn kann Ecken schneiden, wenn sie
weniger als 10 mm von ToPoint entfernt ist.
z50 Die Roboterbahn kann Ecken schneiden, wenn sie
weniger als 50 mm von ToPoint entfernt ist.
Eine vollständige Liste mit vordefinierten zonedata-Werten finden Sie im
Technisches Referenzhandbuch - RAPID Instruktionen, Funktionen und Datentypen,
Abschnitt Datentypen und zonedata.
Wenn ein vordefinierter Wert verwendet wird, sollte er nicht deklariert oder
zugewiesen werden.
Die folgenden RAPID-Instruktionen führen zu der unten gezeigten Roboterbahn:
MoveL p10, v1000, z50, tool0;
MoveL p20, v1000, fine, tool0;
Fortsetzung auf nächster Seite
28 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.1 MoveL-Instruktion
Fortsetzung
xx0700000358
Tool
Gibt das vom Roboter verwendete Werkzeug an, das als persistente Variable vom
Datentyp tooldata definiert wird. Wenn eine Schweißpistole, eine Klebepistole
oder ein Stift am Roboter montiert ist, wird der ToPoint für die Spitze des
betreffenden Werkzeugs programmiert. Dies geschieht automatisch, wenn ein
tooldata deklariert und zugewiesen wurde und in der MoveL-Instruktion verwendet
wird.
tool0 ist ein vordefiniertes Werkzeug, das den Roboter ohne montiertes Werkzeug
darstellt. Es sollte nicht deklariert oder zugewiesen werden. Alle anderen Werkzeuge
sollten vor der Verwendung deklariert und zugewiesen werden.
3HAC029364-003 Revision: A 29
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.2 Koordinatensysteme
2.1.2 Koordinatensysteme
Basis-Koordinatensystem
Die Zielposition einer Bewegungsinstruktion wird in Form von Koordinaten in einem
Koordinatensystem angegeben. Wenn das Koordinatensystem angegeben wird,
ist die Position relativ zum Basis-Koordinatensystem des Roboters. Der Ursprung
des Basis-Koordinatensystems ist der Sockel des Roboters.
xx0700000397
Angepasste Koordinatensysteme
Es kann auch ein anderes Koordinatensystem definiert und in
Bewegungsinstruktionen verwendet werden. Das von der Bewegungsinstruktion
zu verwendende Koordinatensystem wird mit dem optionalen Argument \WObj
angegeben.
MoveL p10, v1000, z50, tool0 \WObj:=wobj1;
Weitere Informationen über das Definieren eines Koordinatensystems finden Sie
im Technisches Referenzhandbuch - RAPID Instruktionen, Funktionen und
Datentypen, Abschnitt Datentypen und wobjdata.
Weitere Informationen über Koordinatensysteme finden Sie im Technisches
Referenzhandbuch - RAPID Überblick, Abschnitt Koordinatensysteme.
30 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.3 Beispiele für MoveL
2.1.3 Beispiele für MoveL
Zeichnen eines Quadrats
Ein Roboter hält einen Stift über einem Blatt Papier auf einem Tisch. Der Roboter
soll die Spitze des Stifts zum unteren Rand des Blatts bewegen und dann ein
Quadrat zeichnen.
xx0700000362
PERS tooldata tPen := [ TRUE, [[200, 0, 30], [1, 0, 0 ,0]], [0.8,
[62, 0, 17], [1, 0, 0, 0], 0, 0, 0]];
CONST robtarget p10 := [ [600, -100, 800], [0.707170, 0, 0.707170,
0], [0, 0, 0, 0], [ 9E9, 9E9, 9E9, 9E9, 9E9, 9E9] ];
CONST robtarget p20 := [ [600, 100, 800], [0.707170, 0, 0.707170,
0], [0, 0, 0, 0], [ 9E9, 9E9, 9E9, 9E9, 9E9, 9E9] ];
CONST robtarget p30 := [ [800, 100, 800], [0.707170, 0, 0.707170,
0], [0, 0, 0, 0], [ 9E9, 9E9, 9E9, 9E9, 9E9, 9E9] ];
CONST robtarget p40 := [ [800, -100, 800], [0.707170, 0, 0.707170,
0], [0, 0, 0, 0], [ 9E9, 9E9, 9E9, 9E9, 9E9, 9E9] ];
PROC main()
MoveL p10, v200, fine, tPen;
MoveL p20, v200, fine, tPen;
MoveL p30, v200, fine, tPen;
MoveL p40, v200, fine, tPen;
MoveL p10, v200, fine, tPen;
ENDPROC
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 31
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.3 Beispiele für MoveL
Fortsetzung
Zeichnen mit Verschleifzonen
Es soll dieselbe Form wie im vorherigen Beispiel, doch mit einer Verschleifzone
von 20 mm bei p20 und einer Verschleifzone von 50 mm bei p40 gezeichnet werden.
xx0700000363
VAR tooldata tPen := ...
...
VAR robtarget p40 := ...
PROC main()
MoveL p10, v200, fine, tPen;
MoveL p20, v200, z20, tPen;
MoveL p30, v200, fine, tPen;
MoveL p40, v200, z50, tPen;
MoveL p10, v200, fine, tPen;
ENDPROC
32 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.4 Weitere Bewegungsinstruktionen
2.1.4 Weitere Bewegungsinstruktionen
Verschiedene Bewegungsinstruktionen
RAPID bietet eine Reihe von Bewegungsinstruktionen. Die häufigsten
Bewegungsinstruktionen sind MoveL, MoveJ und MoveC.
MoveJ
Mit MoveJ wird der Roboter schnell von einem Punkt zu einem anderen bewegt,
wenn diese Bewegung nicht auf einer Geraden erfolgen muss.
Verwenden Sie MoveJ, um den Roboter auf der kürzesten Strecke an einen Punkt
zu bewegen, der sich dicht an der gewünschten Arbeitsposition des Roboters
befindet. Eine MoveL-Instruktion kann nicht verwendet werden, wenn sich
beispielsweise der Robotersockel zwischen der aktuellen und der programmierten
Position befindet oder wenn die Umorientierung des Werkzeugs zu umfangreich
ist. In diesen Fällen empfiehlt sich die Verwendung von MoveJ.
Die Syntax von MoveJ entspricht der Syntax von MoveL.
Beispiel:
MoveJ p10, v1000, fine, tPen;
MoveC
MoveC wird verwendet, um den Roboter kreisförmig zu bewegen.
Beispiel:
MoveL p10, v500, fine, tPen;
MoveC p20, p30, v500, fine, tPen;
MoveL p40, v500, fine, tPen;
xx0700000364
3HAC029364-003 Revision: A 33
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.5 Abarbeitungsverhalten in Verschleifzonen
2.1.5 Abarbeitungsverhalten in Verschleifzonen
Warum erfolgt in Verschleifzonen eine spezielle Abarbeitung?
Die Abarbeitung eines Programms erfolgt in der Regel in der Reihenfolge, in der
die Anweisungen geschrieben wurden.
Im folgenden Beispiel bewegt sich der Roboter zunächst zu p10, berechnet den
Wert von reg1 und bewegt sich dann zu p20:
MoveL p10, v1000, fine, tool0;
reg1 := reg2 + reg3;
MoveL p20, v1000, fine, tool0;
Betrachten Sie jetzt jedoch dieses Beispiel:
MoveL p10, v1000, z50, tool0;
reg1 := reg2 + reg3;
MoveL p20, v1000, fine, tool0;
Wenn die Berechnung von reg1 erst beginnt, wenn sich der Roboter bei p10
befindet, muss der Roboter dort anhalten und auf die nächste Bewegungsinstruktion
warten. Tatsächlich wird jedoch der Code abgearbeitet, bevor die Roboterbewegung
ausgeführt wird. reg1 und die Roboterbahn in der Verschleifzone werden berechnet,
bevor der Roboter p10 erreicht.
Auswirkung auf das Programm
Häufig wirkt sich der genaue Zeitpunkt der Abarbeitung nicht auf das Programm
aus. Es gibt jedoch einige Fälle, in denen das Programm davon betroffen ist.
Angenommen, Sie möchten mit einer Sprühpistole eine Linie zwischen p10 und
p20 zeichnen und das Programm wie folgt schreiben:
MoveL p10, v300, z10, tspray;
! Start spraying
SetDO do1, 1;
MoveL p20, v300, z10, tspray;
! Stop spraying
SetDO do1, 0;
MoveL p30, v300, fine, tspray;
In diesem Fall sieht das Ergebnis etwa wie folgt aus:
xx0700000387
Fortsetzung auf nächster Seite
34 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.1.5 Abarbeitungsverhalten in Verschleifzonen
Fortsetzung
Lösung
Wenn Sie nicht fine verwenden, sondern in den Verschleifzonen Signale setzen,
können Sie das Problem mit speziellen Instruktionen, z. B. MoveLDO, TriggL und
DispL, lösen. Weitere Informationen über diese Instruktionen finden Sie im
Technisches Referenzhandbuch - RAPID Instruktionen, Funktionen und Datentypen.
Verwenden Sie nach einer Verschleifzone keine Warteinstruktionen oder umfangreiche Berechnungen
Die Robotersteuerung kann die Roboterbewegung in Zonenbahnen auch dann
berechnen, wenn sich zwischen den Bewegungsinstruktionen weitere Instruktionen
befinden. Wenn jedoch nach einer Bewegungsinstruktion mit einer Verschleifzone
eine Warteinstruktion vorhanden ist, kann dies vom Roboter nicht abgearbeitet
werden. Verwenden Sie in der Bewegungsinstruktion vor einer Warteinstruktion
fine.
Die Anzahl und Komplexität der Berechnungen, die von der Robotersteuerung
zwischen Bewegungsinstruktionen mit Verschleifzonen ausgeführt werden können,
ist begrenzt. Dies stellt hauptsächlich ein Problem dar, wenn nach einer
Bewegungsinstruktion mit einer Verschleifzone Prozeduren aufgerufen werden.
3HAC029364-003 Revision: A 35
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.2.1 E/A-Signale
2.2 E/A-Signale
2.2.1 E/A-Signale
Signale
Signale werden für die Kommunikation mit externe Ausrüstung verwendet, die
vom Roboter genutzt wird. Von der externen Ausrüstung werden Eingangssignale
gesetzt, mit denen im RAPID-Programm festgelegt werden kann, wann eine Aktion
mit dem Roboter ausgeführt wird. Ausgangssignale werden vom RAPID-Programm
gesetzt und signalisieren der externen Ausrüstung, dass sie eine Aktion ausführen
soll.
Einrichten von Signalen
Signale werden in den Systemparametern für das Robotersystem konfiguriert. Es
können benutzerdefinierte Namen für die Signale festgelegt werden. Sie sollten
nicht im RAPID-Programm deklariert werden.
Digitaler Eingang
Ein digitales Eingangssignal kann den Wert 0 oder 1 aufweisen. Das
RAPID-Programm kann den Wert des Signals lesen, jedoch nicht setzen.
Beispiel:
Wenn das digitale Eingangssignal di1 den Wert 1 aufweist, bewegt sich der
Roboter.
IF di1 = 1 THEN
MoveL p10, v1000, fine, tPen;
ENDIF
Digitaler Ausgang
Ein digitales Ausgangssignal kann den Wert 0 oder 1 aufweisen. Das
RAPID-Programm kann den Wert für ein digitales Ausgangssignal setzen und so
die externe Ausrüstung steuern. Der Wert eines digitalen Ausgangssignals wird
mit der Instruktion SetDO gesetzt.
Beispiel:
Der Roboter besitzt ein digitales Greifwerkzeug, das mit dem digitalen
Ausgangssignal do_grip geschlossen werden kann. Der Roboter bewegt sich an
die Position des Stifts und schließt den Greifer. Anschließend bewegt sich der
Roboter an die Position, an der er zeichnen soll, jetzt mithilfe des Werkzeugs tPen.
MoveJ p0, vmax, fine, tGripper;
SetDO do_grip, 1;
MoveL p10, v1000, fine, tPen;
Fortsetzung auf nächster Seite
36 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.2.1 E/A-Signale
Fortsetzung
Andere Signaltypen
Digitale Signale werden häufig eingesetzt und sind einfach zu verwenden. Wenn
ein Signal einen anderen Wert als 0 oder 1 aufweisen muss, können analoge
Signale und Gruppen digitaler Signale verwendet werden, die über andere Werte
verfügen können. Diese Typen von Signalen werden in diesem Handbuch nicht
behandelt.
3HAC029364-003 Revision: A 37
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.3.1 Kommunikation mit dem FlexPendant
2.3 Benutzerinteraktion
2.3.1 Kommunikation mit dem FlexPendant
Lese- und Schreibinstruktionen
RAPID bietet mehrere Instruktionen für die Ausgabe von Informationen an den
Roboterbediener sowie zum Empfangen von Eingaben des Bedieners. In den
vorherigen Beispielen war bereits TPWrite enthalten. Hier werden nur die
Instruktionen TPWrite, TPReadFK und TPReadNum behandelt.
TPWrite
Die Ausgabe einer Meldung an den Bediener kann mit der Instruktion TPWrite
erfolgen.
TPWrite "Now producing exhaust pipes";
xx0700000374
Ausgeben einer Zeichenfolgenvariablen
Die auf dem FlexPendant ausgegebene Zeichenfolge kann von einer
Zeichenfolgenvariablen stammen, oder es kann sich bei dem ausgegebenen Text
um eine Verkettung einer Zeichenfolgenvariablen mit einer anderen Zeichenfolge
handeln.
VAR string product := "exhaust pipe";
! Write only the product on the FlexPendant
TPWrite product;
! Write "Producing" and the product on the FlexPendant
TPWrite "Producing " + product;
Ausgeben einer numerischen Variablen
Mit dem optionalen Argument \Num kann nach der Zeichenfolge eine numerische
Variable hinzugefügt werden.
VAR num count := 13;
TPWrite "The number of produced units is: " \Num:=count;
Fortsetzung auf nächster Seite
38 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.3.1 Kommunikation mit dem FlexPendant
Fortsetzung
TPReadFK
Beim Schreiben eines RAPID-Programms, das einen Operator für eine Auswahl
erfordert, ist die Instruktion TPReadFK hilfreich. Sie ermöglicht das Anzeigen von
bis zu fünf Funktionstasten, und der Bediener kann die Taste auswählen, auf die
er tippen möchte. Die Tasten entsprechen den Werten 1 bis 5.
VAR num answer;
TPReadFK answer, "Select which figure to draw", "Square",
"Triangle", stEmpty, stEmpty, stEmpty;
IF answer = 1 THEN
! code to draw square
ELSEIF answer = 2 THEN
! code to draw triangle
ELSE
! do nothing
ENDIF
xx0700000376
Wenn der Benutzer „Square“ auswählt, erhält die numerische Variable answer
den Wert 1. Wenn der Benutzer „Triangle“ auswählt, erhält die numerische Variable
answer den Wert 2.
Es können fünf Funktionstasten angegeben werden. Wenn eine Taste nicht
verwendet wird, schreiben Sie statt des Textes für die Taste stEmpty.
TPReadNum
Mithilfe von TPReadNum kann der Bediener eine Zahl auf dem FlexPendant
ausgeben, statt nur eine Auswahl vorzunehmen.
VAR num answer;
TPReadNum answer, "How many times shall I draw the figure?";
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 39
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.2 RAPID-Roboterfunktionalität
2.3.1 Kommunikation mit dem FlexPendant
Fortsetzung
FOR i FROM 1 TO answer DO
! code to draw figure
ENDFOR
xx0700000378
Die numerische Variable answer erhält den vom Bediener eingegebenen Wert.
40 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.3 Struktur
3.1 RAPID-Prozedur
3 Struktur
3.1 RAPID-Prozedur
Was ist eine Prozedur?
In allen bisher betrachteten Beispielen für RAPID-Code wurde nur Code in der
Prozedur main abgearbeitet. Die Abarbeitung beginnt automatisch in der Prozedur
main. Es können jedoch mehrere Prozeduren vorhanden sein.
Eine Prozedur muss mit dem Schlüsselwort PROC vor dem Prozedurnamen, den
Prozedurargumenten und dem Programmcode, den die Prozedur ausführen soll,
deklariert werden. Eine Prozedur wird aus einer anderen Prozedur aufgerufen (mit
Ausnahme der Prozedur main, die automatisch beim Programmstart aufgerufen
wird).
Beispiel:
Wenn Sie vier Quadrate unterschiedlicher Größe zeichnen möchten, können Sie
vier Mal nahezu identischen Programmcode schreiben. Dies führt zu sehr
umfangreichem Code und verringert die Verständlichkeit des Programms. Ein
weitaus effizienteres Verfahren zum Schreiben dieses Programms besteht darin,
eine Prozedur zu schreiben, die das Quadrat zeichnet, und die Prozedur main
diese Prozedur vier Mal aufrufen zu lassen.
PERS tooldata tPen:= ...
CONST robtarget p10:= ...
PROC main()
! Call the procedure draw_square
draw_square 100;
draw_square 200;
draw_square 300;
draw_square 400;
ENDPROC
PROC draw_square(num side_size)
VAR robtarget p20;
VAR robtarget p30;
VAR robtarget p40;
! p20 is set to p10 with an offset on the y value
p20 := Offs(p10, 0, side_size, 0);
p30 := Offs(p10, side_size, side_size, 0);
p40 := Offs(p10, side_size, 0, 0);
MoveL p10, v200, fine, tPen;
MoveL p20, v200, fine, tPen;
MoveL p30, v200, fine, tPen;
MoveL p40, v200, fine, tPen;
MoveL p10, v200, fine, tPen;
ENDPROC
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 41
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.3 Struktur
3.1 RAPID-Prozedur
Fortsetzung
Prozedurargumente
Beim Deklarieren einer Prozedur werden alle Argumente innerhalb der Klammern
nach dem Prozedurnamen deklariert. Die Deklaration enthält den Datentyp und
Namen für jedes Argument. Der Wert des Arguments wird aus dem Prozeduraufruf
zugewiesen, und das Argument fungiert als Variable in der Prozedur (das Argument
kann nicht außerhalb der Prozedur verwendet werden).
PROC main()
my_procedure 14, "Hello", TRUE;
ENDPROC
PROC my_procedure(num nbr_times, string text, bool flag)
...
ENDPROC
In der oben dargestellten Prozedur my_procedure hat nbr_times den Wert 14,
text hat den Wert „Hello“ und flag hat den Wert TRUE.
Beim Aufruf der Prozedur ist die Reihenfolge der Argumente wichtig, um dem
richtigen Argument den richtigen Wert zuzuweisen. Im Prozeduraufruf werden
keine Klammern verwendet.
In der Prozedur deklarierte Variablen
In einer Prozedur deklarierte Variablen gelten nur für die betreffende Prozedur.
Daher kann im obigen Beispiel p10 in allen Prozeduren dieses Moduls verwendet
werden, doch p20, p30 und p40 können nur in der Prozedur draw_square
verwendet werden.
42 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.3 Struktur
3.2 Module
3.2 Module
Module
Ein RAPID-Programm kann aus einem oder mehreren Modulen bestehen. Jedes
Modul kann eine oder mehrere Prozeduren enthalten.
In den kleinen einfachen Programmen in diesem Handbuch wird nur ein Modul
verwendet. In einer komplexeren Programmierumgebung können einige
Standardprozeduren, die von vielen verschiedenen Programmen verwendet werden,
in ein eigenes Modul eingefügt werden.
Beispiel:
Das Modul MainModule enthält spezifischen Code für das Programm und gibt an,
welche Aktionen der Roboter in diesem Programm ausführen soll. Das Modul
figures_module enthält Standardcode, der in jedem Programm verwendet werden
kann, mit dem ein Quadrat, Rechteck oder Kreis gezeichnet werden soll.
MODULE MainModule
...
draw_square;
...
ENDMODULE
MODULE figures_module
PROC draw_square()
...
ENDPROC
PROC draw_triangle()
...
ENDPROC
PROC draw_circle()
...
ENDPROC
ENDMODULE
Programmmodule
Ein Programmmodul wird mit der Dateiendung .mod, z. B. figures_module.mod,
gespeichert.
Für die Robotersteuerung ist es ohne Belang, ob das Programm aus mehreren
Modulen besteht. Der einzige Grund für die Verwendung mehrerer Module ist eine
bessere Verständlichkeit und einfachere Wiederverwendung des Programms durch
Programmierer.
In der Robotersteuerung kann nur ein Programm aktiv sein, d. h., nur eines der
Module darf die Prozedur main enthalten.
Systemmodule
Systemmodule werden mit der Dateiendung .sys, z. B. system_data_module.sys,
gespeichert.
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 43
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.3 Struktur
3.2 Module
Fortsetzung
In ein Systemmodul sollten Daten und Prozeduren eingefügt werden, die im System
erhalten bleiben sollen, auch wenn das Programm geändert wird. Wenn
beispielsweise eine persistente Variable vom Typ tooldata in einem Systemmodul
deklariert wird, wird eine Neukalibrierung des Werkzeugs beibehalten, auch wenn
ein neues Programm geladen wird.
44 3HAC029364-003 Revision: A
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.3 Struktur
3.3 Strukturierter Entwurf
3.3 Strukturierter Entwurf
Struktur
Wenn Sie sich das erste Mal mit einem Problem auseinandersetzen, das Sie mit
einem RAPID-Programm lösen möchten, analysieren Sie zunächst das Problem
und seine Komponenten. Wenn Sie mit der Programmierung beginnen, ohne
zunächst den Entwurf gründlich zu durchdenken, ist das resultierende Programm
widersprüchlich. Ein Programm mit einem guten Entwurf ist weniger fehleranfällig
und für andere Personen leichter zu verstehen. Die für den Entwurf aufgewendete
Zeit wird beim Testen und Pflegen des Programms mehrfach eingespart.
Zerlegen Sie das Problem in einzelne Komponenten
Gehen Sie wie folgt vor, um das Problem in einfachere Komponenten zu zerlegen:
Aktion
1 Bestimmen Sie eine umfangreichere Funktionalität. Unterteilen Sie das Problem in
kleinere Bestandteile, die einfacher zu bewältigen sind.
2 Erstellen Sie eine Entwurfsstruktur. Zeichnen Sie eine Skizze der Funktionalitäten und
ihrer Wechselbeziehungen.
3 Überprüfen Sie die einzelnen Blöcke in der Entwurfsstruktur. Kann ein Block in noch
kleinere Bestandteile zerlegt werden? Was ist erforderlich, um den Block zu implemen-
tieren?
Beispiel:
Problembeschreibung
Erstellen Sie ein RAPID-Programm, mit dem Quadrate oder Dreiecke auf ein Blatt
Papier gezeichnet werden können. Lassen Sie den Bediener entscheiden, ob ein
Quadrat oder Dreieck gezeichnet werden soll. Wenn der Roboter die Form
gezeichnet hat, soll der Benutzer erneut dieselbe Auswahl treffen können, bis der
Bediener auf die Schaltfläche zum Beenden tippt.
Wenn der Roboter 10 Formen auf dasselbe Blatt gezeichnet hat, wird die Meldung
ausgegeben, dass das Papier ausgetauscht werden soll, und die Abarbeitung wird
erst fortgesetzt, wenn der Bediener auf die Schaltfläche „OK“ getippt hat.
Zwischen dem Erstellen der Zeichnungen wird überprüft, ob di1 1 ist. Wenn das
Signal nicht den Wert 1 aufweist, wird der Stift zu einem Spitzer bewegt, und do1
wird auf 1 gesetzt, um den Spitzer zu starten und den Stift langsam in den Spitzer
einzuführen. Normalerweise muss das Werkzeug neu definiert werden, da seine
Länge während des Spitzens abnimmt, doch wird dieser Schritt im Beispiel
übersprungen.
Fortsetzung auf nächster Seite
3HAC029364-003 Revision: A 45
© Copyright 2007, 2012 ABB. Alle Rechte vorbehalten.Sie können auch lesen
