ROBOTICS TechnischesReferenzhandbuch RAPIDÜberblick · Revision Beschreibung VeröffentlichtmitRobotWare6.01. • FürdiezusätzlicheTriggJIOs-Instruktion,sieheAktivierenvon

ROBOTICS

Technisches ReferenzhandbuchRAPID Überblick

Trace back information:Workspace R18-2 version a11Checked in 2018-10-11Skribenta version 5.3.008

Technisches ReferenzhandbuchRAPID Überblick

RobotWare 6.08

Dokumentnr: 3HAC050947-003Revision: H

© Copyright 2004-2018 ABB. Alle Rechte vorbehalten.Spezifikationen können ohne vorherige Ankündigung geändert werden.

Die Informationen in diesem Handbuch können ohne vorherige Ankündigung geändertwerden und stellen keine Verpflichtung von ABB dar. ABB übernimmt keinerleiVerantwortung für etwaige Fehler, die dieses Handbuch enthalten kann.Wenn nicht ausdrücklich in vorliegendem Handbuch angegeben, gibt ABB für keinehierin enthaltenen Informationen Sachmängelhaftung oder Gewährleistung fürVerluste, Personen- oder Sachschäden, Verwendbarkeit für einen bestimmten Zweckoder Ä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 beschriebenenProdukte ergeben.Dieses Handbuch darf weder ganz noch teilweise ohne vorherige schriftlicheGenehmigung von ABB vervielfältigt oder kopiert werden.Zur späteren Verwendung aufbewahren.Zusätzliche Kopien dieses Handbuchs können von ABB bezogen werden.

Übersetzung der Originalbetriebsanleitung.


ABB AB, RoboticsRobotics and MotionSe-721 68 Västerås

Schweden

Inhaltsverzeichnis7Überblick über dieses Handbuch .....................................................................................................9Benutzung dieses Handbuchs .........................................................................................................

111 Grundlagen der Programmierung mit RAPID111.1 Programmstruktur .............................................................................................111.1.1 Einleitung ..............................................................................................131.1.2 Grundlegende Elemente ...........................................................................171.1.3 Module ..................................................................................................201.1.4 Systemmodul User ..................................................................................211.1.5 Routinen ................................................................................................281.2 Programmdaten ................................................................................................281.2.1 Datentypen ............................................................................................301.2.2 Datendeklarationen .................................................................................371.3 Ausdrücke .......................................................................................................371.3.1 Typen von Ausdrücken .............................................................................401.3.2 Verwendung von Daten in Ausdrücken ........................................................411.3.3 Verwendung von Aggregaten in Ausdrücken ................................................421.3.4 Verwendung von Funktionsaufrufen in Ausdrücken .......................................441.3.5 Priorität zwischen Operatoren ....................................................................451.3.6 Syntax ...................................................................................................471.4 Instruktionen ....................................................................................................481.5 Steuern des Programmablaufs .............................................................................501.6 Verschiedene Instruktionen .................................................................................521.7 Bewegungseinstellungen ....................................................................................571.8 Bewegung .......................................................................................................661.9 Eingangs- und Ausgangssignale ..........................................................................701.10 Kommunikation .................................................................................................751.11 Interrupts ........................................................................................................801.12 Fehlerbehebung ................................................................................................841.13 UNDO .............................................................................................................871.14 System und Zeit ................................................................................................891.15 Mathematik ......................................................................................................921.16 Kommunikation mit einem externen Computer ........................................................931.17 Funktionen für Dateioperationen ..........................................................................941.18 Instruktionen zur Unterstützung von RAPID ...........................................................981.19 Kalibrierung und Service ....................................................................................

1001.20 Zeichenfolgenfunktionen ....................................................................................1021.21 Multitasking .....................................................................................................1081.22 Rückwärtsabarbeitung .......................................................................................

1132 Bewegung und E/A-Programmierung1132.1 Koordinatensysteme ..........................................................................................1132.1.1 Der Werkzeugarbeitspunkt (TCP) der Roboters ............................................1142.1.2 Koordinatensysteme zur Bestimmung der TCP-Position .................................1212.1.3 Koordinatensysteme zur Bestimmung der Werkzeugrichtung ..........................1242.2 Positionierung während der Abarbeitung von Programmen .......................................1242.2.1 Einleitung ..............................................................................................1262.2.2 Interpolation der Position und Orientierung des Werkzeugs ............................1302.2.3 Interpolation der Zonenbahnen ..................................................................1362.2.4 Unabhängige Achsen ...............................................................................1392.2.5 Softservo ...............................................................................................1402.2.6 Stopp und Neustart .................................................................................1412.3 Synchronisierung mit logischen Instruktionen .........................................................1462.4 Roboterkonfiguration .........................................................................................1512.5 Kinematisches Modell des Roboters .....................................................................1562.6 Bewegungsüberwachung/Kollisionserkennung .......................................................

Technisches Referenzhandbuch - RAPID Überblick 53HAC050947-003 Revision: H

© Copyright 2004-2018 ABB. Alle Rechte vorbehalten.

Inhaltsverzeichnis

1602.7 Singularitäten ...................................................................................................1632.8 Optimierte Beschleunigungsbegrenzung ...............................................................1642.9 Weltzonen ........................................................................................................1692.10 E/A-Prinzipien ...................................................................................................

1733 Glossar

175Index

6 Technisches Referenzhandbuch - RAPID Überblick3HAC050947-003 Revision: H


Inhaltsverzeichnis

Überblick über dieses HandbuchÜber dieses Handbuch

Das vorliegende Referenzhandbuch enthält eine ausführliche Erläuterung derProgrammiersprache sowie aller Instruktionen, Funktionen und Datentypen. DiesesHandbuch ist bei der Offline-Programmierung besonders hilfreich. UnerfahreneBenutzer sollten mit Bedienungsanleitung - IRC5 mit FlexPendant beginnen.Dieses Handbuch beschreibt RobotWare 6.

VerwendungDieses Handbuch sollte während der Programmierung gelesen werden.

Wer sollte dieses Handbuch lesen?Dieses Handbuch ist für Personen vorgesehen, die bereits Programmiererfahrungbesitzen, z.B. für Roboterprogrammierer.

KapiteleinteilungDieses Handbuch setzt sich aus den folgenden Kapiteln zusammen:

InhaltKapitel

Informationen zur Beantwortung von Fragen wie „Welches ist diegeeignete Instruktion?“ oder „Was bedeutet diese Instruktion?“.Dieses Kapitel beschreibt kurz alle Instruktionen, Funktionen undDatentypen gruppiert nach den Instruktionsauswahllisten, die Siefür die Programmierung verwenden. Es enthält außerdem eine Zu-sammenfassung der Syntax, die besonders nützlich für die Offline-Programmierung ist. Die internen Details der Sprache werdenebenfalls erläutert.

Grundlagen der Pro-grammierung mit RA-PID

Dieses Kapitel beschreibt die Koordinatensysteme des Roboters,seine Geschwindigkeit und andere Bewegungseigenschaften beider Abarbeitung.

Bewegung und E/A-Programmierung

Ein Glossar, mit dem das Verständnis erleichtert werden soll.Glossar

Referenzen

DokumentnummerReferenz

3HAC050941-003Bedienungsanleitung - IRC5 mit FlexPendant

3HAC050917-003TechnischesReferenzhandbuch - RAPID Instruktionen, Funktionenund Datentypen

3HAC050946--001Technical reference manual manual - RAPID kernel

3HAC050948-003Technisches Referenzhandbuch - Systemparameter

3HAC050798-003Anwendungshandbuch - Steuerungssoftware IRC5

Revisionen

BeschreibungRevision

Veröffentlicht mit RobotWare 6.0.-

Fortsetzung auf nächster SeiteTechnisches Referenzhandbuch - RAPID Überblick 73HAC050947-003 Revision: H


Überblick über dieses Handbuch

BeschreibungRevision

Veröffentlicht mit RobotWare 6.01.• Für die zusätzliche TriggJIOs-Instruktion, siehe Aktivieren von

Ausgängen oder Interrupts an bestimmten Positionen auf Seite 58.

A

Veröffentlicht mit RobotWare 6.02.• Trigonometrische Funktionen für den Datentyp dnum hinzugefügt,

siehe Arithmetische Funktionen auf Seite 89.• TriggDataCopy, TriggDataReset und TriggDataValid hinzu-

gefügt, siehe Aktivieren von Ausgängen oder Interrupts an bestimm-ten Positionen auf Seite 58.

• Für die zusätzliche SaveCfgData-Instruktion siehe Speichern vonKonfigurationsdaten auf Seite 95.

B

Veröffentlicht mit RobotWare 6.03.• Die Signaldatentypen haben jetzt den Datentyp semi value (mit fes-

tem Wert), sieheDatentypen ohne einenWert (non-value) auf Seite28und Eingangs- und Ausgangssignale auf Seite 66.

C

Veröffentlicht mit RobotWare 6.04.• Abschnitte zur Datendeklaration Variablendeklaration auf Seite 31

und Persistentendeklaration auf Seite 33 aktualisiert.• Geringfügige Korrekturen.

D

Veröffentlicht mit RobotWare 6.05.• Instruktionen DitherAct und DitherDeact entfernt.• Matrix-Funktionen auf Seite 91 wurde hinzugefügt.• Geringfügige Korrekturen.

E

Veröffentlicht mit RobotWare 6.06.• Instruktionen zur Unterstützung von RAPID auf Seite 94 wurde ak-

tualisiert.• Verhalten der Rückwärtsabarbeitung auf Seite110wurde aktualisiert.• Singularitäten auf Seite 160 wurde aktualisiert.• Geringfügige Korrekturen.

F

Veröffentlicht mit RobotWare 6.07.• Es wurden CrossProd, Max und Min zu Arithmetische Funktionen

auf Seite 89hinzugefügt.

G

Veröffentlicht mit RobotWare 6.08.• Geringfügige Korrekturen.• Aktualisierungen im Abschnitt Interpolation der Zonenbahnen auf

Seite 130.

H



Überblick über dieses HandbuchFortsetzung

Benutzung dieses HandbuchsVereinbarungen zur Schreibweise

Beispiele von Programmen werden immer in dem Format dargestellt, wie sie ineine Datei oder an einen Drucker ausgegeben werden. Dies unterscheidet sichwie folgt von der Anzeige am FlexPendant:

• Bestimmte Steuerungswörter, die für die Anzeige am FlexPendantausgeblendet sind, werden gedruckt, z. B. die Kennzeichnung von Anfangund Ende einer Routine.

• Daten- und Routinendeklarationen werden in formellem Format angegeben.Beispiel: VAR num reg1;

In den Beschreibungen in diesem Handbuch werden alle Namen von Instruktionen,Funktionen und Datentypen in nichtproportionaler Schrift dargestellt. Beispiel:TPWrite. Namen von Variablen, Systemparametern und Optionen sind kursivgedruckt. Kommentare in Beispielcode sind nicht übersetzt (auch wenn dasHandbuch übersetzt ist).

SyntaxregelnInstruktionen und Funktionen werden mit vereinfachter und formeller Syntaxbeschrieben. Wenn Sie mit dem FlexPendant programmieren, müssen Sie nur dievereinfachte Syntax kennen, da der Roboter automatisch dafür sorgt, dass diekorrekte Syntax benutzt wird.

Beispiel für vereinfachte SyntaxDies ist ein Beispiel für die vereinfachte Syntax mit der Instruktion TPWrite.

TPWrite String [\Num] | [\Bool] | [\Pos] | [\Orient] [\Dnum]

• Obligatorische Argumente sind nicht in Klammern eingeschlossen.• Optionale Argumente sind in eckige Klammern [ ] eingeschlossen. Diese

Argumente können weggelassen werden.• Argumente, die sich gegenseitig ausschließen, d. h. nicht gleichzeitig in einer

Instruktion vorhanden sein können, werden durch einen vertikalen Strich |voneinander getrennt.

• Argumente, die beliebig oft wiederholbar sind, werden in geschweifteKlammern { } eingeschlossen.

Im obigen Beispiel werden die folgenden Argumente verwendet:• String ist ein obligatorisches Argument.• Num, Bool, Pos, Orient und Dnum sind optionale Argumente.• Num, Bool, Pos, Orient und Dnum schließen sich gegenseitig aus.

Beispiel für formale SyntaxTPWrite

[String ':='] <expression (IN) of string>

['\'Num':=' <expression (IN) of num> ] |

['\'Bool':=' <expression (IN) of bool> ] |

['\'Pos':=' <expression (IN) of pos> ] |

['\'Orient ':=' <expression (IN) of orient> ]



Benutzung dieses Handbuchs

['\' Dnum':=' <expression (IN) of dnum]';'

• Der Text in den eckigen Klammern [ ] kann weggelassen werden.• Argumente, die sich gegenseitig ausschließen, d. h. nicht gleichzeitig in einer

Instruktion vorhanden sein können, werden durch einen vertikalen Strich |voneinander getrennt.

• Argumente, die beliebig oft wiederholbar sind, werden in geschweifteKlammern { } eingeschlossen.

• Symbole, die für die korrekte Syntax erforderlich sind, werden in einfacheAnführungszeichen (Apostrophen) ' ' eingeschlossen.

• Der Datentyp des Arguments und andere Eigenschaften sind in spitzeKlammern < > eingeschlossen. Ausführliche Informationen erhalten Sie inder Beschreibung der Parameter von Routinen.

Die grundlegenden Elemente der Sprache und bestimmte Instruktionen werden ineiner speziellen Syntax, EBNF, geschrieben. Diese beruht auf denselben Regeln,jedoch mit einigen Zusätzen.

• Das Symbol ::= bedeutet wird definiert als.• In spitze Klammern < > eingeschlossener Text wird in einer separaten Zeile

definiert.

Beispiel:GOTO <identifier> ';'

<identifier> ::= <ident> | <ID>

<ident> ::= <letter> {<letter> | <digit> | '_'}



Benutzung dieses HandbuchsFortsetzung

1 Grundlagen der Programmierung mit RAPID1.1 Programmstruktur

1.1.1 Einleitung

InstruktionenDas Programm besteht aus einer Reihe von Instruktionen, die die Arbeit desRoboters beschreiben. Daher gibt es bestimmte Instruktionen für die zahlreichenBefehle, z. B. eine zur Bewegung des Roboters, eine für das Setzen eines Ausgangsusw.Zu den Instruktionen gehört gewöhnlich eine Reihe von Argumenten, die definieren,welche Aktion in einer bestimmten Instruktion stattfinden soll. Die Instruktion fürdas Zurücksetzen eines Ausgangs beispielsweise enthält ein Argument, dasdefiniert, welcher Ausgang zurückgesetzt werden soll, z. B. Reset do5. DieseArgumente können auf eine der folgenden Arten angegeben werden:

• als numerischer Wert, z. B. 5 oder 4.6• als Verweis auf Daten, z. B. reg1• als Ausdruck, z. B. 5+reg1*2• als Funktionsaufruf, z. B. Abs(reg1)• als Zeichenfolgenwert, z. B. "Producing part A"

RoutinenEs gibt drei Arten von Routinen – Prozeduren, Funktionen und Interrupt-Routinen.

• Eine Prozedur wird als Unterprogramm verwendet.• Eine Funktion gibt einen Wert eines bestimmten Typs zurück und wird als

Argument einer Instruktion verwendet.• Interrupt-Routinen dienen der Behandlung von Interrupts (Unterbrechungen).

Eine Interrupt-Routine kann einem bestimmten Interrupt zugewiesen werden,z. B. wird sie beim Setzen eines Eingangs automatisch ausgeführt, wenndieser Interrupt auftritt.

DatenInformationen können auch als Daten gespeichert werden, z. B. Werkzeugdaten(die sämtliche Informationen über ein Werkzeug umfassen, wie TCP und Gewicht)und numerische Daten (die etwa zum Zählen der zu verarbeitenden Werkstückeverwendet werden können). Daten werden in verschiedene Datentypen gruppiert,die verschiedene Arten von Informationen beschreiben, z. B. Werkzeuge, Positionenund Lasten. Da diese Daten erzeugt und mit beliebigen Namen versehen werdenkönnen, gibt es keine Begrenzung für die Menge der Daten (außer derSpeicherkapazität). Diese Daten können global im Programm oder lokal in einerRoutine vorhanden sein.



1 Grundlagen der Programmierung mit RAPID1.1.1 Einleitung

Es gibt drei Arten von Daten: Konstanten, Variablen und Persistenten.• Eine Konstante stellt einen statischen Wert dar. Ihr kann ein neuer Wert nur

manuell zugewiesen werden.• Einer Variablen kann auch bei der Programmabarbeitung ein neuer Wert

zugewiesen werden.• Eine Persistente kann als „speichernde“ Variable beschrieben werden. Beim

Speichern eines Programms entspricht der Initialisierungswert dem aktuellenWert der Persistenten.

Weitere MerkmaleWeitere Merkmale der Sprache:

• Routineparameter• Arithmetische und logische Ausdrücke• Automatische Fehlerbehandlung• Modulare Programme• Multitasking

In der Sprache werden Groß- und Kleinschreibung nicht unterschieden, d. h.,Buchstaben in Groß- und Kleinschreibung werden als identisch betrachtet.



1 Grundlagen der Programmierung mit RAPID1.1.1 EinleitungFortsetzung

1.1.2 Grundlegende Elemente

BezeichnerBezeichner werden verwendet, um Modulen, Routinen, Daten und Labels einenNamen zuzuweisen. Beispiel:

MODULE module_name

PROC routine_name()

VAR pos data_name;

label_name:

Ein Bezeichner muss mit einem Buchstaben beginnen. Die übrigen Zeichen könnenBuchstaben, Ziffern oder Unterstriche (_) sein.Die maximale Länge jedes Bezeichners beträgt 32 Zeichen, von denen jedesZeichen signifikant ist. Groß- und Kleinschreibung wird bei Bezeichnern nichtunterschieden.

Reservierte WörterDie nachstehend aufgeführten Wörter sind reserviert. Sie haben eine besondereBedeutung in der Programmiersprache RAPID und dürfen daher nicht alsBezeichner benutzt werden.Es gibt auch eine Reihe vordefinierter Namen für Datentypen, Systemdaten,Anweisungen und Funktionen, die ebenfalls nicht als Bezeichner verwendet werdendürfen.

CASEBACKWARDANDALIAS

DIVDEFAULTCONSTCONNECT

ENDFORELSEIFELSEDO

ENDPROCENDMODULEENDIFENDFUNC

ENDWHILEENDTRAPENDTESTENDRECORD

FORFALSEEXITERROR

IFGOTOFUNCFROM

MODULEMODLOCALINOUT

ORNOVIEWNOTNOSTEPIN

READONLYRAISEPROCPERS

STEPRETURNRETRYRECORD

TOTHENTESTSYSMODULE

UNDOTRYNEXTTRUETRAP

WITHWHILEVIEWONLYVAR

XOR

Leerzeichen und ZeilenvorschubDie Programmiersprache RAPID kann frei formatiert werden, d. h., Sie könnenLeerzeichen beliebig verwenden, außer in:

• Bezeichnern• reservierten Wörtern



1 Grundlagen der Programmierung mit RAPID1.1.2 Grundlegende Elemente

• numerischen Werten• Platzhalter

Zeilenvorschub, Tabulator und Seitenvorschub können an allen Stellen, an denenein Leerzeichen vorkommt, verwendet werden, außer in Kommentaren.Bezeichner, reservierte Wörter und numerische Werte müssen voneinander durchein Leerzeichen, eine neue Zeile, einen Tabulator oder einen Seitenvorschubgetrennt sein.

Numerische WerteEin numerischer Wert lässt sich ausdrücken als:

• eine Ganzzahl, z. B. 3, -100, 3E2• eine Dezimalzahl, z. B. 3,5, -0,345, -245E-2

Der Wert muss innerhalb des Bereichs liegen, der durch die Norm ANSI IEEE 754für Gleitkommazahlen festgelegt ist.

Logische WerteEin logischer Wert lässt sich als TRUE oder FALSE ausdrücken.

ZeichenfolgenwerteEin Zeichenfolgenwert entspricht einer Folge von Zeichen (ISO 8859-1 (Latin-1))und Steuerzeichen (Nicht-ISO 8859-1 (Latin-1)) im numerischen Codebereich 0-255.Zeichencodes können enthalten sein, wodurch sich auch nicht druckbare Zeichen(Binärdaten) in die Zeichenfolge eingeben lassen. Zeichenfolgen können eineLänge von maximal 80 Zeichen haben.Beispiel:

"This is a string"

"This string ends with the BEL control character \07"

Wenn ein umgekehrter Schrägstrich (der einen Zeichencode kennzeichnet) oderdoppelte Anführungszeichen eingegeben werden sollen, müssen diese zweimalgeschrieben werden.Beispiel:

"This string contains a "" character"

"This string contains a \\ character"

KommentareDurch Kommentare wird ein Programm leichter verständlich. Kommentare habenkeinerlei Einfluss auf das Programm.Ein Kommentar beginnt mit einem Ausrufezeichen (!) und endet mit einemZeilenumbruchzeichen. Er nimmt den Rest der Zeile (beginnend mit demAusrufezeichen) ein und darf nicht außerhalb einer Moduldeklaration auftreten.

! comment

IF reg1 > 5 THEN

! comment

reg2 := 0;

ENDIF

Fortsetzung auf nächster Seite14 Technisches Referenzhandbuch - RAPID Überblick

3HAC050947-003 Revision: H© Copyright 2004-2018 ABB. Alle Rechte vorbehalten.

1 Grundlagen der Programmierung mit RAPID1.1.2 Grundlegende ElementeFortsetzung

PlatzhalterPlatzhalter können temporär eingesetzt werden, um „noch nicht definierte“ Teileeines Programms darzustellen. Ein Programm mit Platzhaltern ist syntaktischkorrekt und kann in den Programmspeicher geladen werden.

BeschreibungPlatzhalter

Datentypdefinition<TDN>

Datendeklaration<DDN>

Routinendeklaration<RDN>

formaler, optionaler, alternativer Parameter<PAR>

optionaler formaler Parameter<ALT>

formale (konforme) Datenfelddimension<DIM>

Instruktion<SMT>

Verweis auf Datenobjekt (Variable, Persistente oderParameter)

<VAR>

ELSE-IF-Klausel einer IF-Instruktion<EIT>

CASE-Klausel einer Testinstruktion<CSE>

Ausdruck<EXP>

Argument für Prozeduraufruf<ARG>

Bezeichner<ID>

DateivorspannEine Programmdatei kann mit dem folgenden Vorspann beginnen (er ist aber nichterforderlich):

%%%

VERSION:1

LANGUAGE:ENGLISH

%%%

Syntax

Bezeichner<identifier> ::= <ident> | <ID>

<ident> ::= <letter> {<letter> | <digit> | '_'}

Numerische Werte<num literal> ::=

<integer> [ <exponent> ]

| <decimal integer>) [<exponent>]

| <hex integer> | <octal integer>

| <binary integer>

| <integer> '.' [ <integer> ] [ <exponent> ]

| [ <integer> ] '.' <integer> [ <exponent> ]

<integer> ::= <digit> {<digit>}

<hex integer> ::= '0' ('X' | 'x')

<hex digit> {<hex digit>}

<octal integer> ::= '0' ('O' | 'o') <octal digit> {<octal digit>}

<binary integer> ::= '0' ('B' | 'b') <binary digit> {<binary digit>}



1 Grundlagen der Programmierung mit RAPID1.1.2 Grundlegende Elemente

Fortsetzung

<exponent> ::= ('E' | 'e') ['+' | '-'] <integer>

<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<hex digit> ::= <digit> | A | B | C | D | E | F | a | b | c | d |e | f

<octal digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

<binary digit> ::= 0 | 1

Logische Werte<bool literal> ::= TRUE | FALSE

Zeichenfolgenwerte<string literal> ::= '"' {<character> | <character code> } '"'

<character code> ::= '\' <hex digit> <hex digit>

<hex digit> ::= <digit> | A | B | C | D | E | F | a | b | c | d |e | f

Kommentare<comment> ::= '!' {<character> | <tab>} <newline>

Zeichen<character> ::= -- ISO 8859-1 (Latin-1)--

<newline> ::= -- newline control character --

<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<letter> ::= <upper case letter> | <lower case letter>

<upper case letter> ::=

A | B | C | D | E | F | G | H | I | J

| K | L | M | N | O | P | Q | R | S | T

| U | V | W | X | Y | Z | À | Á | Â | Ã

| Ä | Å | Æ | Ç | È | É | Ê | Ë | Ì | Í

| Î | Ï | 1) | Ñ | Ò | Ó | Ô | Õ | Ö | Ø

| Ù | Ú | Û | Ü | 2) | 3) | ß

<lower case letter> ::=

a | b | c | d | e | f | g | h | i | j

| k | l | m | n | o | p | q | r | s | t

| u | v | w | x | y | z | ß | à | á | â | ã

| ä | å | æ | ç | è | é | ê | ë | ì | í

| î | ï | 1) | ñ | ò | ó | ô | õ | ö | ø

| ù | ú | û | ü | 2) | 3) | ÿ

1) Isländischer Buchstabe eth.2) Buchstabe Y mit Akzent.3) Isländischer Buchstabe thorn.



1 Grundlagen der Programmierung mit RAPID1.1.2 Grundlegende ElementeFortsetzung

1.1.3 Module

EinleitungDas Programm ist in Programmmodule und Systemmodule gegliedert.

xx1100000550

ProgrammoduleEin Programmmodul kann aus verschiedenen Daten und Routinen bestehen. JedesModul oder das ganze Programm kann auf Diskette, RAM-Disk usw. kopiert werdenoder von dort geladen werden.Eines der Module enthält die Einstiegsprozedur, eine globale Prozedur, die alsMain bezeichnet wird. Die Abarbeitung des Programms bedeutet eigentlich dasAbarbeiten der Main-Prozedur. Das Programm kann viele Module umfassen, abernur eines davon enthält eine Hauptprozedur.Ein Modul kann z. B. die Schnittstelle mit einem Peripheriegerät definieren odergeometrische Daten enthalten, die entweder durch CAD-Systeme oder online perDigitalisierung (Teach-in-Programmierung) erstellt werden.Während kleine Installationen häufig nur ein Modul enthalten, können größereInstallationen über ein Hauptmodul verfügen, das auf Routinen und/oder Datenverweist, die sich in einem oder mehreren anderen Modulen befinden.



1 Grundlagen der Programmierung mit RAPID1.1.3 Module

SystemmoduleSystemmodule werden verwendet, um gemeinsame, systemspezifische Daten undRoutinen wie z. B. Werkzeuge zu definieren. Sie werden nicht zusammen mit einemProgramm gespeichert, d. h. jede Aktualisierung eines Systemmoduls beeinflusstalle vorhandenen oder später in den Programmspeicher geladenen Programme.

ModuldeklarationenEine Moduldeklaration gibt den Namen und die Attribute dieses Moduls an. DieseAttribute können offline ohne FlexPendant hinzugefügt werden. Nachstehend einigeBeispiele für die Attribute eines Moduls:

Wenn angegebenAttribute

Das Modul ist ein Systemmodul, andernfalls ein Programmmo-dul

SYSMODULE

Das Modul kann nicht bei schrittweiser Abarbeitung ausgeführtwerden

NOSTEPIN

Das Modul kann nicht geändert werdenVIEWONLY

Das Modul kann nicht geändert werden, das Attribut kann je-doch entfernt werden

READONLY

Das Modul kann nicht angezeigt, nur abgearbeitet werden.Globale Routinen können von anderen Modulen aus erreichtwerden und laufen stets als NOSTEPIN ab. Die aktuellen Wertefür globale Daten können von anderen Modulen oder vom Da-tenfenster des FlexPendant aus abgerufen werden. NOVIEWlässt sich nur offline an einem PC definieren.

NOVIEW

Beispiel:MODULE module_name (SYSMODULE, VIEWONLY)

!data type definition

!data declarations

!routine declarations

ENDMODULE

Ein Modul darf nicht denselben Namen wie ein anderes Modul oder eine globaleRoutine oder Daten haben.

ProgrammdateistrukturWie oben beschrieben, befinden sich alle Programmmodule in einem Programmmit einem bestimmten Programmnamen. Beim Speichern eines Programms aufder Flashdisk oder im Massenspeicher wird ein neues Verzeichnis mit dem Namendes Programms erstellt. In diesem Verzeichnis werden alle Programmmodule mitder Dateierweiterung .mod und einer Beschreibungsdatei gespeichert, die denNamen des Programms und die Erweiterung .pgf aufweist. Die Beschreibungsdateienthält eine Liste aller Module im Programm.

Syntax

Moduldeklaration<module declaration> ::=

MODULE <module name> [ <module attribute list> ]

<type definition list>

<data declaration list>



1 Grundlagen der Programmierung mit RAPID1.1.3 ModuleFortsetzung

<routine declaration list>

ENDMODULE

<module name> ::= <identifier>

<module attribute list> ::= '(' <module attribute> { ',' <moduleattribute> } ')'

<module attribute> ::=

SYSMODULE

| NOVIEW

| NOSTEPIN

| VIEWONLY

| READONLY

Hinweis

Bei Verwendung von mehreren Attributen müssen Sie die obige Reihenfolgeeinhalten; das Attribut NOVIEW kann nur allein oder gemeinsam mit dem AttributSYSMODULE angegeben werden.

<type definition list> ::= { <type definition> }

<data declaration list> ::= { <data declaration> }

<routine declaration list> ::= { <routine declaration> }



1 Grundlagen der Programmierung mit RAPID1.1.3 ModuleFortsetzung

1.1.4 Systemmodul User

EinleitungZur einfacheren Programmierung werden mit dem Roboter vordefinierte Datengeliefert. Diese Daten müssen nicht erstellt werden und sind daher direktverwendbar.Diese Daten vereinfachen die Erstprogrammierung. Jedoch empfiehlt es sichnormalerweise, den verwendeten Daten eigene Namen zu geben, damit dasProgramm besser lesbar ist.

InhaltUser enthält fünf numerische Datentypen (Register), ein Werkobjekt, eine Uhr undzwei symbolische Werte für digitale Signale.

DeklarationDatentypName

VAR num reg1:=0numreg1





VAR clock clock1clockclock1

User ist ein Systemmodul, d. h., es ist immer im Speicher des Roboters vorhanden,unabhängig vom jeweils geladenen Programm.



1 Grundlagen der Programmierung mit RAPID1.1.4 Systemmodul User

1.1.5 Routinen

EinleitungEs gibt drei Arten von Routinen (Unterprogramme): Prozeduren, Funktionen undInterrupts.

• Prozeduren geben keinen Wert zurück und werden im Kontext vonInstruktionen verwendet.

• Funktionen geben einen Wert eines bestimmten Typs zurück und werdenim Kontext von Instruktionen verwendet.

• Interrupt-Routinen dienen der Behandlung von Unterbrechungen. EineInterrupt-Routine kann mit einem bestimmten Interrupt verknüpft werden.Wenn dann dieser Interrupt in einer späteren Phase auftritt, wird die Routineautomatisch ausgeführt. Eine Interrupt-Routine lässt sich nicht explizit vomProgramm aus aufrufen.

RoutinengültigkeitsbereichDer Gültigkeitsbereich einer Routine entspricht dem Bereich, in dem die Routinesichtbar ist. Der optionale local-Befehl einer Routinendeklaration definiert eineRoutine als lokal (innerhalb des Moduls), andernfalls ist sie global.Beispiel:

LOCAL PROC local_routine (...

PROC global_routine (...

Für Routinen gelten die folgenden Gültigkeitsbereichsregeln:• Der Gültigkeitsbereich einer globalen Routine kann ein beliebiges Modul in

der Task umfassen.• Der Gültigkeitsbereich einer lokalen Routine umfasst das Modul, in dem sie

enthalten ist.• Innerhalb ihres Gültigkeitsbereichs verdeckt eine lokale Routine jede globale

Routine oder Daten mit demselben Namen.• Innerhalb ihres Gültigkeitsbereichs verdeckt eine Routine Instruktionen und

vordefinierte Routinen und Daten mit demselben Namen.

xx1100000551



1 Grundlagen der Programmierung mit RAPID1.1.5 Routinen

Im obigen Beispiel können von Routine h die folgenden Routinen aufgerufenwerden:

• Modul1: Routine c, d.• Modul2: Alle Routinen.

Der Name einer Routine darf nicht identisch mit dem Namen anderer Routinen,Daten oder Datentypen in demselben Modul sein. Der Name einer globalen Routinedarf nicht identisch mit dem Namen eines Moduls oder globaler Routinen, Datenoder Datentypen in einem anderen Modul sein.

ParameterDie Parameterliste einer Routinendeklaration gibt die Argumente (aktuelleParameter) an, die beim Aufruf einer Routine angegeben werden müssen/können.Es gibt vier verschiedene Arten von Parametern (im Zugriffsmodus):

• Normalerweise dient ein Parameter nur als Eingabe und wird alsRoutinenvariable behandelt. Durch Ändern dieser Variablen ändert sich dasentsprechende Argument nicht.

• Ein INOUT-Parameter gibt an, dass ein entsprechendes Argument eineVariable (insgesamt, als Element oder Komponente) oder eine vollständigePersistente sein muss, die durch die Routine geändert werden kann.

• Ein VAR-Parameter gibt an, dass ein entsprechendes Argument eine Variable(insgesamt, als Element oder Komponente) sein muss, die durch die Routinegeändert werden kann.

• Ein PERS-Parameter gibt an, dass ein entsprechendes Argument einevollständige Persistente sein muss, die durch die Routine geändert werdenkann.

Wenn ein INOUT-, VAR- oder PERS-Parameter aktualisiert wird, bedeutet dies, dassdas eigentliche Argument aktualisiert wird, d. h. mithilfe von Argumenten lassensich Werte an die aufrufende Routine übergeben.Beispiel:

PROC routine1 (num in_par, INOUT num inout_par,

VAR num var_par, PERS num pers_par)

Ein Parameter kann optional sein. In diesem Fall kann er aus der Argumentlisteeines Routinenaufrufs weggelassen werden. Ein optionaler Parameter wird durcheinen vorangestellten umgekehrten Schrägstrich (\) gekennzeichnet.Beispiel:

PROC routine2 (num required_par \num optional_par)

Auf den Wert eines optionalen Parameters, der aus einem Routinenaufrufweggelassen wird, kann nicht verwiesen werden. Dies bedeutet, dass einRoutinenaufruf auf optionale Parameter getestet werden muss, bevor ein optionalerParameter verwendet wird.Mehrere optionale Parameter können sich gegenseitig ausschließen (fürgegenseitigen Ausschluss deklariert sein), d. h. nur einer von beiden darf in einemRoutinenaufruf vorhanden sein. Dies wird durch einen senkrechten Strich (|)zwischen den betreffenden Parametern angegeben.



1 Grundlagen der Programmierung mit RAPID1.1.5 RoutinenFortsetzung

Beispiel:PROC routine3 (\num exclude1 | num exclude2)

Der Spezialtyp switch darf (nur) optionalen Parametern zugewiesen werden. Erbietet die Möglichkeit, Argumente zu wechseln, die nur durch Namen (nicht Werte)angegeben sind. In einen switch-Parameter kann kein Wert übertragen werden.Ein switch-Parameter kann nur verwendet werden, indem mit der vordefiniertenFunktion Present auf sein Vorhandensein überprüft wird.Beispiel:

PROC routine4 (\switch on | switch off)

...

IF Present (off ) THEN

...

ENDPROC

Datenfelder können als Argumente übergeben werden. Der Grad einesDatenfeldarguments muss mit dem Grad des entsprechenden formellen Parametersübereinstimmen. Die Dimension eines Datenfeldparameters ist konform (mit „*“markiert). Die tatsächliche Dimension hängt daher von der Dimension desentsprechenden Arguments in einem Routinenaufruf ab. Eine Routine kann mithilfeder vordefinierten Funktion Dim die tatsächliche Dimension eines Parametersbestimmen.Beispiel:

PROC routine5 (VAR num pallet{*,*})

RoutinenbeendigungDie Ausführung einer Prozedur wird entweder explizit durch eine RETURN-Instruktionbeendet oder implizit, wenn das Ende (ENDPROC, BACKWARD, ERROR oder UNDO)der Prozedur erreicht wird.Die Auswertung einer Funktion muss durch eine RETURN-Instruktion beendetwerden.Die Ausführung einer Interrupt-Routine wird entweder explizit durch eineRETURN-Instruktion beendet oder implizit, wenn das Ende (ENDTRAP, ERROR oderUNDO) dieser Interrupt-Routine erreicht wird. Die Ausführung fährt an dem Punktfort, an dem der Interrupt aufgetreten ist.




Fortsetzung

RoutinendeklarationenEine Routine kann Routinendeklarationen (einschließlich Parametern), Daten,einen Hauptteil, eine Rückwärtsbehandlung (nur Prozeduren), eineFehlerbehandlung und eine Abbruchbehandlung enthalten. Routinendeklarationenkönnen nicht verschachtelt werden, d. h. es kann keine Routine in einer Routinedeklariert werden.

xx1100000553

ProzedurdeklarationBeispielsweise Multiplikation aller Elemente in einem num-Datenfeld mit einemFaktor:

PROC arrmul( VAR num array{*}, num factor)

FOR index FROM 1 TO dim( array, 1 ) DO

array{index} := array{index} * factor;

ENDFOR

ENDPROC

FunktionsdeklarationEine Funktion kann einen beliebigen Datentypwert liefern, jedoch keinenDatenfeldwert.Beispiel: Rückgabe der Länge eines Vektors.

FUNC num veclen (pos vector)

RETURN Sqrt(Pow(vector.x,2)+Pow(vector.y,2)+Pow(vector.z,2));

ENDFUNC

Interrupt-DeklarationBeispielsweise Reaktion auf Interrupt „Zuführung leer“:

TRAP feeder_empty

wait_feeder;

RETURN;

ENDTRAP




ProzeduraufrufBeim Aufruf einer Prozedur sollen die Argumente verwendet werden, die denParametern der Prozedur entsprechen:

• Obligatorische Parameter müssen angegeben werden. Sie sind außerdemin der korrekten Reihenfolge anzugeben.

• Optionale Argumente können weggelassen werden.• Bedingte Argumente können zur Übergabe von Parametern von einem

Routinenaufruf an einen anderen verwendet werden.Siehe Verwendung von Funktionsaufrufen in Ausdrücken auf Seite 42.Der Name der Prozedur kann entweder statisch mit einem Bezeichner (früheBindung) festgelegt werden oder während der Laufzeit aus einer Zeichenfolge(späte Bindung) berechnet werden. Obwohl die frühe Bindung als normalerProzeduraufruf betrachtet wird, bietet die späte Bindung manchmal sehr effektiveund kompakte Lösungen. Späte Bindung wird durch Prozentzeichen vor und nachder Zeichenfolge definiert, die den Namen der Prozedur angibt.Beispiel:

! early binding

TEST products_id

CASE 1:

proc1 x, y, z;

CASE 2:

proc2 x, y, z;

CASE 3:

...

! same example using late binding

% “proc” + NumToStr(product_id, 0) % x, y, z;

...

! same example again using another variant of late binding

VAR string procname {3} :=[“proc1”, “proc2”, “proc3”];

...

% procname{product_id} % x, y, z;

...

Beachten Sie, dass die späte Bindung nur für den Aufruf von Prozeduren, nichtfür den Aufruf von Funktionen zur Verfügung steht. Wenn ein Verweis auf eineunbekannte Prozedur mit später Bindung erfolgt, wird die Systemvariable ERRNO

auf ERR_REFUNKPRC gesetzt. Wenn ein Verweis auf einen Prozeduraufruffehler(Syntax, nicht Prozedur) mit später Bindung erfolgt, wird die Systemvariable ERRNOauf ERR_CALLPROC gesetzt.

Syntax

Routinendeklaration<routine declaration> ::=

[LOCAL] ( <procedure declaration>

| <function declaration>

| <trap declaration> )

| <comment>

| <RDN>




Fortsetzung

Parameter<parameter list> ::=

<first parameter declaration> { <next parameter declaration> }

<first parameter declaration> ::=

<parameter declaration>

| <optional parameter declaration>

| <PAR>

<next parameter declaration> ::=

',' <parameter declaration>

| <optional parameter declaration>

| ','<optional parameter declaration>

| ',' <PAR>

<optional parameter declaration> ::=

'\' ( <parameter declaration> | <ALT> )

{ '|' ( <parameter declaration> | <ALT> ) }

<parameter declaration> ::=

[ VAR | PERS | INOUT] <data type>

<identifier> [ '{' ( '*' { ',' '*' } ) | <DIM>] '}'

| 'switch' <identifier>

Prozedurdeklaration<procedure declaration> ::=

PROC <procedure name>

'(' [ <parameter list> ] ')'


<instruction list>

[ BACKWARD <instruction list> ]

[ ERROR <instruction list> ]

[ UNDO <instruction list> ]

ENDPROC

<procedure name> ::= <identifier>

<data declaration list> ::= {<data declaration>}

Funktionsdeklaration<function declaration> ::=

FUNC <value data type>

<function name>

'(' [ <parameter list> ] ')'


<instruction list>



ENDFUNC

<function name> ::= <identifier>

Interrupt-Routinendeklaration<trap declaration> ::=

TRAP <trap name>


<instruction list>






ENDTRAP

<trap name> ::= <identifier>

Prozeduraufruf<procedure call> ::= <procedure> [ <procedure argument list> ] ';'

<procedure> ::=

<identifier>

| '%' <expression> '%'

<procedure argument list> ::= <first procedure argument> {<procedure argument> }

<first procedure argument> ::=

<required procedure argument>

| <optional procedure argument>

| <conditional procedure argument>

| <ARG>

<procedure argument> ::=

',' <required procedure argument>

| <optional procedure argument>

| ',' <optional procedure argument>

| <conditional procedure argument>

| ',' <conditional procedure argument>

| ',' <ARG>

<required procedure argument> ::= [ <identifier> ':=' ] <expression>

<optional procedure argument> ::= '\' <identifier> [ ':='<expression> ]

<conditional procedure argument> ::= '\' <identifier> '?' (<parameter> | <VAR> )




Fortsetzung

1.2 Programmdaten

1.2.1 Datentypen

EinleitungEs gibt drei Arten von Datentypen:

• Der Typ Atom ist unteilbar. Seine Definition beruht auf keinem anderen Typund er kann nicht in Teile oder Komponenten zerlegt werden, z. B. num.

• Der Datentyp Datensatz (record) ist ein zusammengesetzter Typ mitbenannten, geordneten Komponenten, z. B. pos. Eine Komponente kannden Typ „Atom“ oder „Datensatz“ haben.Ein Datensatzwert lässt sich als Aggregat-Darstellung ausdrücken. Beispiel:[ 300, 500, depth ] pos record aggregate value.Auf eine bestimmte Komponente von Datensatzelementen kann über ihrenNamen zugegriffen werden. Beispiel: pos1.x := 300; Zuweisung derx-Komponente von pos1.

• Ein alias-Datentyp ist per Definition gleich einem anderen Typ. Alias-Typenermöglichen die Klassifizierung von Datenobjekten.

Datentypen ohne einen Wert (non-value)Jeder verfügbare Datentyp ist entweder ein Datentyp mit einem Wert oder einDatentyp ohne einen Wert. Ein Datentyp mit einem Wert stellt einen Wert dar.Daten ohne einen Wert können nicht in wertorientierten Operationen verwendetwerden.

• Initialisierung• Zuweisung (:=)• Gleich (=) und ungleich (<>) Tests• TEST-Instruktionen• IN-(Zugriffsmodus)-Parameter in Routinenaufrufen• Funktions-(RETURN)-Datentypen

Die Signaldatentypen (signalai, signaldi, signalgi,signalao, signaldo, signalgo) sindvom Datentyp semi value (mit festem Wert). Diese Daten können mit Ausnahmevon Initialisierung und Zuweisung in wertorientierten Operationen verwendetwerden.In der Beschreibung eines Datentyps wird nur angegeben, ob er einen festen Wertoder keinen Wert hat.

Gleiche Datentypen (alias)Ein alias-Datentyp ist als mit einem anderen Typ gleich definiert. Daten mitdenselben Datentypen können miteinander ausgetauscht werden.Beispiel:

VAR num level;

VAR dionum high:=1;

level:= high;



1 Grundlagen der Programmierung mit RAPID1.2.1 Datentypen

Dies ist zulässig, da dionum ein alias-Datentyp für num ist.

Syntax<type definition>::=

[LOCAL] ( <record definition>

| <alias definition> )

| <comment>

| <TDN>

<record definition>::=

RECORD <identifier>

<record component list>

ENDRECORD

<record component list> ::=

<record component definition> |

<record component definition> <record component list>

<record component definition> ::=

<data type> <record component name> ';'

<alias definition> ::=

ALIAS <data type> <identifier> ';'

<data type> ::= <identifier>



1 Grundlagen der Programmierung mit RAPID1.2.1 Datentypen

Fortsetzung

1.2.2 Datendeklarationen

EinleitungEs gibt drei Arten von Daten:

• Einer Variablen kann während der Programmabarbeitung ein neuer Wertzugewiesen werden.

• Eine Persistente kann als dauerhafte Variable beschrieben werden. DasAktualisieren des Werts einer Persistenten bewirkt automatisch dasAktualisieren des Initialisierungswerts in der Persistentendeklaration. (BeimSpeichern eines Programms entspricht der Initialisierungswert in derDeklaration dem aktuellen Wert der Persistenten.)

• Eine Konstante stellt einen statischen Wert dar. Ihr kann kein neuer Wertzugewiesen werden.

Eine Datendeklaration dient der Einführung von Daten, indem ein Name(Bezeichner) mit einem Datentyp verknüpft wird. Außer vordefinierten Daten undSchleifenvariablen müssen alle verwendeten Daten deklariert werden.

DatengültigkeitsbereichDer Gültigkeitsbereich von Daten entspricht dem Bereich, in dem die Daten sichtbarsind. Der optionale local-Befehl einer Datendeklaration definiert Daten als lokal(innerhalb des Moduls), andernfalls sind sie global. Beachten Sie, dass derlocal-Befehl nur auf Modulebene, nicht innerhalb einer Routine benutzt werdenkann.

Beispiel:LOCAL VAR num local_variable;

VAR num global_variable;

ProgrammdatenDaten, die außerhalb einer Routine deklariert sind, werden als Programmdatenbezeichnet. Für Programmdaten gelten die folgenden Gültigkeitsbereichsregeln:

• Der Gültigkeitsbereich von vordefinierten oder globalen Programmdatenkann ein beliebiges Modul umfassen.

• Der Gültigkeitsbereich von lokalen Programmdaten umfasst das Modul, indem sie enthalten sind.

• Innerhalb ihres Gültigkeitsbereichs verdecken lokale Programmdaten alleglobalen Daten oder eine globale Routine mit demselben Namen(einschließlich Instruktionen und vordefinierter Routinen und Daten).

Programmdaten dürfen nicht denselben Namen wie andere Daten oder eine Routineim selben Modul haben. Globale Programmdaten dürfen nicht denselben Namenwie andere globale Daten oder eine Routine in einem anderen Modul haben.



1 Grundlagen der Programmierung mit RAPID1.2.2 Datendeklarationen

RoutinendatenDaten, die innerhalb einer Routine deklariert sind, werden als Routinendatenbezeichnet. Beachten Sie, dass die Parameter einer Routine auch als Routinendatenbehandelt werden. Für Routinendaten gelten die folgendenGültigkeitsbereichsregeln:

• Der Gültigkeitsbereich von Routinendaten umfasst die Routine, in der sieenthalten sind.

• Innerhalb ihres Gültigkeitsbereichs verdecken Routinendaten jede andereRoutine oder Daten mit demselben Namen.

Routinendaten dürfen nicht denselben Namen wie andere Daten oder ein Label inderselben Routine haben.

Beispiel:In diesem Beispiel können aus Routine e die folgenden Daten aufgerufen werden:

• Modul1: Daten c, d.• Modul2: Daten a, f, g, e1.

Die folgenden Daten können von Routine h aufgerufen werden:• Modul1: Daten d.• Modul2: Daten a, f, g, h1, c.

xx1100000554

VariablendeklarationEine Variable wird durch eine Variablendeklaration eingeführt und kann als globalgültig (keine Vorschrift nötig) oder als lokal gültig deklariert werden.Beispiel:MainModule wird in die Task T_ROB1 geladen.

MODULE MainModule

! The scope of this variable is within T_ROB1, i.e. it can be

! accessed from any module in T_ROB1.

VAR num global_var := 123;

! The scope of this variable is within this module.




Fortsetzung

LOCAL VAR num local_var := 789;

PROC main()

! The scope of this variable is within this procedure.

VAR num local_var2 := 321;

...

ENDPROC

ENDMODULE

Eine Variable, die in einem Modul deklariert ist, das als gemeinsam verwendetesModul installiert wurde, kann mit der Vorschrift TASK deklariert werden, sieheTechnisches Referenzhandbuch - Systemparameter, ParametergruppeController,Typ Automatic Loading of Modules. Der Zugriff auf eine solche Variable ist vonallen Tasks aus möglich, hat für jede Task aber einen eindeutigen Wert. ZumBeispiel hat daher das Ändern des Variablenwerts in einer Task keine Auswirkungauf andere Tasks.Beispiel:SharedModule wird als gemeinsam verwendet im System installiert.

MODULE SharedModule(SYSMODULE)

! This variable is accessible from all tasks, but has a

! unique value for each task.

TASK VAR num global_var := 123;

...

ENDMODULE

Das Verwenden der Vorschrift TASK in einem Modul, das nicht als gemeinsamverwendet installiert wurde, hat keine Auswirkung.Durch Hinzufügen von Maßangaben in der Deklaration können Variablen einesbeliebigen Typs im Format eines Datenfelds (Grad 1, 2 oder 3) angegeben werden.Eine Maßangabe ist ein ganzzahliger Wert größer 0.Beispiel:

VAR pos pallet{14, 18};

Variablen mit Werttypen können initialisiert werden (einen Anfangswert erhalten).Der Ausdruck für die Initialisierung einer Programmvariablen muss konstant sein.Beachten Sie, dass der Wert einer nicht initialisierten Variablen verwendet werdenkann, aber undefiniert, d. h. auf Null gesetzt ist, wenn es sich um einen num-Werthandelt. Eine Zeichenfolge wird auf eine leere Zeichenfolge gesetzt und einBoolescher Wert auf FALSE.Beispiel:

VAR string author_name := "John Smith";

VAR pos start := [100, 100, 50];

VAR num maxno{10} := [1, 2, 3, 9, 8, 7, 6, 5, 4, 3];

Der Initialisierungswert wird gesetzt, wenn:• Das Programmmodul wird geladen.• Der Programmzeiger wird zurückgesetzt, zum Beispiel "Programmzeiger auf

Main".



1 Grundlagen der Programmierung mit RAPID1.2.2 DatendeklarationenFortsetzung

PersistentendeklarationPersistenten dürfen nur auf Modulebene, nicht in einer Routine, deklariert werden.Persistenten können global im System (systemweit, keine Vorschrift nötig), globalin der Task (taskweit) oder lokal deklariert werden.Beispiel:Das folgende Modul wird in T_ROB1 und in T_ROB2 geladen.

MODULE MainModule

! The scope of this persistent is within the task it’s been

! loaded to. But, it will share the current value with any

! other task declaring the same persistent. I.e. changing the

! value in T_ROB1 will automatically change the value in T_ROB2.

PERS num globalpers := 123;

! The scope of this persistent is within the task this

! module has been loaded to.

TASK PERS num taskpers := 456;

! The scope of this persistent is within this module.

LOCAL PERS num localpers := 789;

...

ENDMODULE

Lokale und taskweite Persistenten müssen einen Initialisierungswert erhalten. Fürsystemweite Persistenten kann der Anfangswert weggelassen werden. DerAnfangswert muss ein Einzelwert (ohne Datenverweis oder Operanden) oder eineinzelnes Aggregat mit Elementen sein, die wiederum Einzelwerte oder einzelneAggregate sind.Beispiel:

PERS pos refpnt := [100.23, 778.55, 1183.98];

Durch Hinzufügen von Maßangaben in der Deklaration können Persistenten einesbeliebigen Typs im Format eines Datenfelds (Grad 1, 2 oder 3) angegeben werden.Eine Maßangabe ist ein ganzzahliger Wert größer 0.Beispiel:

PERS pos pallet{14, 18} := [...];

Wenn der aktuelle Wert einer Persistenten geändert wird, wird derInitialisierungswert (sofern nicht weggelassen) in der Persistentendeklarationaktualisiert. Da dies jedoch die Leistung beeinträchtigt, erfolgt die Aktualisierungnicht während der Programmabarbeitung. Der Anfangswert wird aktualisiert, wenndas Modul gespeichert wird („Backup“, „Modul speichern“, „Programm speichern“).Er wird auch aktualisiert, wenn das Programm bearbeitet wird. Im Fenster„Programmdaten“ am FlexPendant wird immer der aktuelle Wert der Persistentenangezeigt.Beispiel:

PERS num reg1 := 0;

...

reg1 := 5;




Fortsetzung

Nach dem Speichern des Moduls und nachdem der Code ausgeführt wurde, siehtdas gespeicherte Modul wie folgt aus:

PERS num reg1 := 5;

...

reg1 := 5;

KonstantendeklarationEine Konstante wird durch eine Konstantendeklaration eingeführt. Der Wert einerKonstanten lässt sich nicht ändern.Beispiel:

CONST num pi := 3.141592654;

Durch Hinzufügen von Maßangaben in der Deklaration kann eine Konstante einesbeliebigen Typs im Format eines Datenfelds (Grad 1, 2 oder 3) angegeben werden.Eine Maßangabe ist ein ganzzahliger Wert größer 0.

CONST pos seq{3} := [[614, 778, 1020], [914, 998, 1021], [814, 998,1022]];

Initialisieren von DatenDer Initialisierungswert für eine Konstante oder Variable kann ein konstanterAusdruck sein.Der Initialisierungswert für eine Persistente kann nur ein literaler Ausdruck sein.Beispiel:

CONST num a := 2;

CONST num b := 3;

!Correct syntax

CONST num ab := a + b;

VAR num a_b := a + b;

PERS num a__b := 5; !

!Faulty syntax

PERS num a__b := a + b;

Nachstehende Tabelle zeigt die Ereignisse in verschiedenen Aktivitäten, wie z. B.Neustart, neues Programm, Programmstart usw.

Pro-gramm-start(nachStopp)

Pro-gramm-start(nachZy-klus)

Pro-gramm-start(Routine-naufruf)

Pro-gramm-start (PZauf Cur-sor)

Pro-gramm-start (PZauf Rou-tine)

Pro-gramm-start (PZauf„main“)

Öffnen,Schlie-ßen oderneuesPro-gramm

Einschal-ten (Neu-start)

Syste-mereig-nis wirktsich ausauf

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

Initialisie-rung

Initialisie-rung

Initialisie-rung

Unverän-dert

Konstan-te

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

Initialisie-rung

Initialisie-rung

Initialisie-rung

Unverän-dert

Variable

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

Initialisie-rung i /

Unverän-dert

Persis-tente

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

GelöschtGelöschtGelöschtNeue An-forde-rung

Angefor-derte In-terrupts




Pro-gramm-start(nachStopp)

Pro-gramm-start(nachZy-klus)

Pro-gramm-start(Routine-naufruf)

Pro-gramm-start (PZauf Cur-sor)

Pro-gramm-start (PZauf Rou-tine)

Pro-gramm-start (PZauf„main“)

Öffnen,Schlie-ßen oderneuesPro-gramm

Einschal-ten (Neu-start)

Syste-mereig-nis wirktsich ausauf

KeineAusfüh-rung

KeineAusfüh-rung

KeineAusfüh-rung

KeineAusfüh-rung

KeineAusfüh-rung

Ausfüh-rung

Ausfüh-rung ii

KeineAusfüh-rung

Startrouti-neSYS_RE-SET (mitBewe-gungsein-stellun-gen)

Unverän-dert

Unverän-dert

Unverän-dert

Unverän-dert

SchließtSchließtSchließtSchließtDateien

Unverän-dert

Unverän-dert

Unverän-dert

GelöschtGelöschtGelöschtGelöschtNeu ge-setztnach Ein-schalten

Bahn

i Persistenten ohne Anfangswert werden nur initialisiert, wenn sie noch nicht deklariert sind.ii Erzeugt einen Fehler, wenn das aktuelle Taskprogramm einen semantischen Fehler enthält.

SpeicherklasseDie Speicherklasse eines Datenobjekts bestimmt,wann das System Speicherplatzfür das Datenobjekt belegt bzw. wieder freigibt. Die Speicherklasse einesDatenobjekts wird durch die Art des Datenobjekts und den Kontext seinerDeklaration bestimmt und kann statisch oder flüchtig sein.Konstanten, Persistenten und Modulvariablen sind statisch, d. h. sie befinden sichfür die Laufzeit einer Task fest im Speicher. Das bedeutet, dass jede Wertzuweisungfür eine Persistente oder Modulvariable bis zur nächsten Zuweisung gültig bleibt.Routinenvariablen sind flüchtig. Der Speicherplatz für den Wert einer flüchtigenVariablen wird erst beim Aufruf der Routine belegt, die die Deklaration der Variablenenthält. Der Speicherplatz wird bei der Rückkehr zur aufrufenden Routine wiederfreigegeben. Der Wert einer Routinenvariablen ist somit vor dem Aufruf der Routinestets undefiniert und geht nach Beendigung der Routine stets verloren (wirdundefiniert).In einer Folge von rekursiven Routinenaufrufen (eine Routine ruft sich selbst direktoder indirekt auf) erhält jede Instanz der Routine einen eigenen Speicherbereichfür die gleiche Routinenvariable – mehrere Instanzen derselben Variablen werdenangelegt.

Syntax

Datendeklaration<data declaration> ::=

[LOCAL] ( <variable declaration>

| <persistent declaration>

| <constant declaration> )

| TASK <persistent declaration>

| <comment>

| <DDN>




Fortsetzung

Variablendeklaration<variable declaration> ::=

VAR <data type> <variable definition> ';'

<variable definition> ::=

<identifier> [ '{' <dim> { ',' <dim> } '}' ]

[ ':=' <constant expression> ]

<dim> ::= <constant expression>

Persistentendeklaration<persistent declaration> ::=

PERS <data type> <persistent definition> ';'

<persistent definition> ::=


[ ':=' <literal expression> ]

Hinweis

Der literale Ausdruck darf nur für systemweite Persistenten weggelassen werden.

Konstantendeklaration<constant declaration> ::=

CONST <data type> <constant definition> ';'

<constant definition> ::=


':=' <constant expression>

<dim> ::= <constant expression>




1.3 Ausdrücke

1.3.1 Typen von Ausdrücken

BeschreibungEin Ausdruck gibt die Auswertung eines Werts an. Er kann z. B. wie folgt verwendetwerden:

Beispiel: a:=3*b/c;in einer Zuweisungsinstruktion

Beispiel: IF a>=3 THEN ...als Bedingung in einer IF-Instruktion

Beispiel: WaitTime time;als Argument in einer Instruktion

Beispiel: a:=Abs(3*b);als Argument in einem Funktionsaufruf

Arithmetische AusdrückeAnhand eines arithmetischen Ausdrucks wird ein numerischer Wert errechnet.Beispiel:

2*pi*radius

ErgebnistypOperandentypenBetriebOperator

num inum + numAddition+

dnum idnum + numAddition+

wie ii , i+num, +dnum oder+pos

Unäres Pluszeichen+

pospos + posVektoraddition+

num inum - numSubtraktion-

dnum idnum - dnumSubtraktion-

wie ii, i-num oder -posUnäres Minuszeichen-

wie ii, i-num, -dnum oder-pos

Unäres Minuszeichen-

pospos - posVektorsubtraktion-

num inum * numMultiplikation*

dnum idnum * dnumMultiplikation*

posnum * pos oder pos *num

Skalare Vektormultipli-kation

*

pospos * posVektorprodukt*

orientorient * orientVerknüpfung von Dre-hungen

*

numnum / numDivision/

dnumdnum / dnumDivision/

numnum DIV numGanzzahlendivisionDIV iii

dnumdnum DIV dnumGanzzahlendivisionDIV iii

numnum MOD numGanzzahlmodulo;Rest

MOD iii



1 Grundlagen der Programmierung mit RAPID1.3.1 Typen von Ausdrücken


dnumdnum MOD dnumGanzzahlmodulo;Rest

MOD iii

i Behält die exakte ganzzahlige Repräsentation, solange Operanden und Ergebnis innerhalb desganzzahligen Teilbereichs des numerischen Typs bleiben.

ii Das Ergebnis erhält denselben Typ wie der Operand. Wenn der Operand einen Alias-Datentypaufweist, erhält das Ergebnis den Alias-Basistyp (num, dnum oder pos).

iii Ganzzahloperationen, z. B. 14 DIV 4=3, 14 MOD 4=2. (Nicht ganzzahlige Operanden sind unzulässig.)

Logische AusdrückeAnhand eines logischen Ausdrucks wird ein logischer Wert (TRUE/FALSE)errechnet.Beispiel:

a>5 AND b=3


boolnum < numkleiner als<

booldnum < dnumkleiner als<

boolnum <= numkleiner oder gleich<=

booldnum <= dnumkleiner oder gleich<=

boolany i = anygleich=

boolnum >= numgrößer oder gleich>=

booldnum >= dnumgrößer oder gleich>=

boolnum > numgrößer als>

booldnum > dnumgrößer oder gleich>

boolany <> anyungleich<>

boolbool AND boolundAND

boolbool XOR boolexklusives OderXOR

boolbool OR booloderOR

boolNOT boolunäres Nicht; Negati-on

NOT

i Nur Wertdatentypen. Operanden müssen die gleichen Typen sein.

xx1100000555



1 Grundlagen der Programmierung mit RAPID1.3.1 Typen von AusdrückenFortsetzung

ZeichenfolgenausdrückeEin Zeichenfolgenausdruck wird verwendet, um Operationen an Zeichenfolgenauszuführen.Beispiel: “IN” + “PUT” liefert das Ergebnis “INPUT”


stringstring + stringZeichenfolgenverket-tung

+



1 Grundlagen der Programmierung mit RAPID1.3.1 Typen von Ausdrücken

Fortsetzung

1.3.2 Verwendung von Daten in Ausdrücken

EinleitungEine ganze Variable, Persistente oder Konstante kann Teil eines Ausdrucks sein.Beispiel:

2*pi*radius

DatenfelderEine als Datenfeld deklarierte Variable, Persistente oder Konstante kann auf dasganze Datenfeld oder ein einzelnes Element bezogen werden.Auf ein Datenfeldelement wird mithilfe der Indexnummer des Elements verwiesen.Der Index ist ein ganzzahliger Wert größer 0 und darf die deklarierte Dimensionnicht überschreiten. Indexwert 1 wählt das erste Element aus. Die Anzahl derElemente in der Indexliste muss dem deklarierten Grad (1, 2 oder 3) des Datenfeldsangepasst sein.Beispiel:

VAR num row{3};

VAR num column{3};

VAR num value;

! get one element from the array

value := column{3};

! get all elements in the array

row := column;

DatensätzeEine als Datensatz deklarierte Variable, Persistente oder Konstante kann auf denganzen Datensatz oder eine einzelne Komponente bezogen werden.Auf eine Datensatzkomponente wird mithilfe des Komponentennamens verwiesen.Beispiel:

VAR pos home;

VAR pos pos1;

VAR num yvalue;

..

! get the Y component only

yvalue := home.y;

! get the whole position

pos1 := home;



1 Grundlagen der Programmierung mit RAPID1.3.2 Verwendung von Daten in Ausdrücken

1.3.3 Verwendung von Aggregaten in Ausdrücken

EinleitungEin Aggregat wird für den Wert eines Datensatzes oder Datenfelds verwendet.Beispiel:

! pos record aggregate

pos := [x, y, 2*x];

! pos array aggregate

posarr := [[0, 0, 100], [0,0,z]];

VoraussetzungenEs muss möglich sein, den Datentyp eines Aggregats durch den Kontext zubestimmen. Der Datentyp jedes Aggregatelements muss gleich dem Typ desentsprechenden Elements vom bestimmten Typ sein.Beispiel (Aggregattyp pos - festgelegt durch p1):

VAR pos pl;

p1 :=[1, -100, 12];

Beispiel für unzulässige Verwendung (nicht zulässig, da der Datentyp keines derAggregate anhand des Kontexts bestimmt werden kann):

VAR pos pl;

IF [1, -100, 12] = [a,b,b,] THEN



1 Grundlagen der Programmierung mit RAPID1.3.3 Verwendung von Aggregaten in Ausdrücken

1.3.4 Verwendung von Funktionsaufrufen in Ausdrücken

EinleitungEin Funktionsaufruf initiiert die Auswertung einer bestimmten Funktion undempfängt den Wert, den die Funktion zurückgibt.Beispiel:

Sin(angle)

ArgumenteDie Argumente eines Funktionsaufrufs werden benutzt, um Daten an die (und ggf.von der) aufgerufenen Funktion zu übertragen. Der Datentyp eines Argumentsmuss gleich dem Typ des entsprechenden Parameters der Funktion sein. OptionaleArgumente können weggelassen werden, aber die Reihenfolge der (vorhandenen)Argumente muss mit der Reihenfolge der formellen Parameter übereinstimmen.Zusätzlich können zwei oder mehr optionale Argumente so deklariert sein, dasssie sich gegenseitig ausschließen, d. h. die Argumentliste darf nur eines von beidenenthalten.Ein erforderliches (obligatorisches) Argument wird durch ein Komma (,) vomvorherigen Argument getrennt. Der formelle Parametername kann angegeben oderweggelassen werden.

BeschreibungBeispiel:

Zwei erforderliche Argumente, mit oder ohne Para-metername.

Polar(3.937, 0.785398)

Polar(Dist:=3.937,Angle:=0.785398)

Ein erforderliches Argument, mit einem Schalteroder ohne einen Schalter.

Cosine(45)

Cosine(0.785398\Rad)

Ein erforderliches Argument, mit einem optionalenArgument oder ohne ein optionales Argument.

Dist(p2)

Dist(\distance:=pos1, p2)

Einem optionalen Argument müssen ein umgekehrter Schrägstrich „\“ und derformelle Parametername vorangehen. Ein Argument des Typs „switch“ (Schalter)ist ein Sonderfall; es darf keinen Argumentausdruck enthalten. Stattdessen kannein solches Argument entweder „vorhanden“ oder „nicht vorhanden“ sein.Bedingte Argumente werden zur Unterstützung der reibungslosen Weitergabe vonoptionalen Argumenten durch Ketten von Routineaufrufen verwendet. Ein bedingtesArgument wird als „vorhanden“ erachtet, wenn der angegebene optionale Parameter(der aufrufenden Funktion) vorhanden ist. Andernfalls wird er als ausgelassenbetrachtet. Beachten Sie, dass der angegebene Parameter optional sein muss.Beispiel:

PROC Read_from_file (iodev File \num Maxtime)

..

character:=ReadBin (File \Time?Maxtime);

! Max. time is only used if specified when calling the routine

! Read_from_file

..

ENDPROC



1 Grundlagen der Programmierung mit RAPID1.3.4 Verwendung von Funktionsaufrufen in Ausdrücken

ParameterDie Parameterliste einer Funktion weist jedem Parameter einen Zugriffsmodus zu.Der Zugriffsmodus kann in, inout, var oder pers lauten:

• Ein IN-Parameter (Standardvorgabe) erlaubt einen beliebigen Ausdruck alsArgument. Die aufgerufene Funktion betrachtet den Parameter als Konstante.

• Ein INOUT-Parameter erfordert, dass das entsprechende Argument eineVariable (als Ganzes, Datenfeld-Element oder Datensatzkomponente) odereine vollständige Persistente ist. Die aufgerufene Funktion erhält vollständigenZugriff (Lesen/Schreiben) auf das Argument.

• Ein VAR-Parameter erfordert, dass das entsprechende Argument eine Variable(als Ganzes, Datenfeld-Element oder Datensatzkomponente) ist. Dieaufgerufene Funktion erhält vollständigen Zugriff (Lesen/Schreiben) auf dasArgument.

• Ein PERS-Parameter erfordert, dass das entsprechende Argument einevollständige Persistente ist. Die aufgerufene Funktion erhält vollständigenZugriff (Lesen/Aktualisieren) auf das Argument.



1 Grundlagen der Programmierung mit RAPID1.3.4 Verwendung von Funktionsaufrufen in Ausdrücken

Fortsetzung

1.3.5 Priorität zwischen Operatoren

PrioritätsregelnDie relative Priorität der Operatoren bestimmt die Reihenfolge, in der sieausgewertet werden. Klammern bieten eine Möglichkeit, die Priorität der Operatorenzu ändern. Nachstehende Regeln legen die folgende Operatorpriorität fest:

BedienerPriorität

* / DIV MODHöchste

+ -

< > <> <= >= =

AND

XOR OR NOTNiedrigste

Ein Operator mit höchster Priorität wird vor einem Operator mit niedriger Prioritätausgewertet. Operatoren derselben Priorität werden von links nach rechtsausgewertet.

KommentarReihenfolge der BerechnungBeispielausdruck

von links nach rechts(a + b) + ca + b + c

* höher als +a + (b * c)a + b * c

von links nach rechts(a OR b) OR ca OR b OR c

AND höher als OR(a AND b) OR (c AND d)a AND b OR c AND d

< höher als AND(a < b) AND (c < d)a < b AND c < d



1 Grundlagen der Programmierung mit RAPID1.3.5 Priorität zwischen Operatoren

1.3.6 Syntax

Ausdrücke<expression> ::= <expr> | <EXP>

<expr> ::= [ NOT ] <logical term> { ( OR | XOR ) <logical term> }

<logical term> ::= <relation> { AND <relation> }

<relation> ::= <simple expr> [ <relop> <simple expr> ]

<simple expr> ::= [ <addop> ] <term> { <addop> <term> }

<term> ::= <primary> { <mulop> <primary> }

<primary> ::=

<literal>

| <variable>

| <persistent>

| <constant>

| <parameter>

| <function call>

| <aggregate>

| '(' <expr> ')'

Bediener<relop> ::= '<' | '<=' | '=' | '>' | '>=' | '<>'

<addop> ::= '+' | '-'

<mulop> ::= '*' | '/' | DIV | MOD

Konstante Werte<literal> ::= <num literal>

| <string literal>

| <bool literal>

Daten<variable> ::=

<entire variable>

| <variable element>

| <variable component>

<entire variable> ::= <ident>

<variable element> ::= <entire variable> '{' <index list> '}'

<index list> ::= <expr> { ',' <expr> }

<variable component> ::= <variable> '.' <component name>

<component name> ::= <ident>

<persistent> ::=

<entire persistent>

| <persistent element>

| <persistent component>

<constant> ::=

<entire constant>

| <constant element>

| <constant component>

Aggregate<aggregate> ::= '[' <expr> { ',' <expr> } ']'



1 Grundlagen der Programmierung mit RAPID1.3.6 Syntax

Funktionsaufrufe<function call> ::= <function> '(' [ <function argument list> ]

')'

<function> ::= <ident>

<function argument list> ::= <first function argument> { <functionargument> }

<first function argument> ::=

<required function argument>

| <optional function argument>

| <conditional function argument>

<function argument> ::=

',' <required function argument>

| <optional function argument>

| ',' <optional function argument>

| <conditional function argument>

| ',' <conditional function argument>

<required function argument> ::= [ <ident> ':=' ] <expr>

<optional function argument> ::= '\' <ident> [ ':=' <expr> ]

<conditional function argument> ::= '\' <ident> '?' <parameter>

Spezialausdrücke<constant expression> ::= <expression>

<literal expression> ::= <expression>

<conditional expression> ::= <expression>

Parameter<parameter> ::=

<entire parameter>

| <parameter element>

| <parameter component>



1 Grundlagen der Programmierung mit RAPID1.3.6 SyntaxFortsetzung

1.4 Instruktionen

BeschreibungInstruktionen werden nacheinander abgearbeitet, es sei denn, eine Instruktion imProgrammablauf oder ein Interrupt oder ein Fehler verursacht, dass die Abarbeitungan einer anderen Stelle fortfährt.Die meisten Instruktionen werden durch ein Semikolon (;) abgeschlossen. EinLabel wird durch einen Doppelpunkt (:) beendet. Einige Instruktionen könnenweitere Instruktionen enthalten und werden durch bestimmte Schlüsselwörterabgeschlossen:

AbschlusswortInstruktion

ENDIFIF

ENDFORFOR

ENDWHILEWHILE

ENDTESTTEST

Beispiel:WHILE index < 100 DO

.

index := index + 1;

ENDWHILE

AuswahllistenAlle Instruktionen sind in bestimmten Gruppen zusammengefasst, die in denfolgenden Abschnitten beschrieben werden. Diese Gruppen sind mit den Gruppenin den Auswahllisten identisch, die verwendet werden, wenn imFlexPendant-Programmeditor einem Programm neue Instruktionen hinzugefügtwerden.

Syntax<instruction list> ::= { <instruction> }

<instruction> ::=

[<instruction according to separate chapter in this manual>

| <SMT>



1 Grundlagen der Programmierung mit RAPID1.4 Instruktionen

1.5 Steuern des Programmablaufs

EinleitungDas Programm läuft in der Regel sequenziell ab, d. h. eine Instruktion nach deranderen. Gelegentlich sind Instruktionen erforderlich, die diese sequenzielleAbarbeitung unterbrechen und eine andere Instruktion aufrufen, um verschiedeneSituationen abzudecken, die bei einer Abarbeitung eintreten können.

Grundsätze der ProgrammierungDer Programmablauf kann nach fünf verschiedenen Prinzipien gesteuert werden:

• Durch Aufruf einer anderen Routine (Prozedur) und nach deren AbarbeitungFortfahren mit der Instruktion, die auf den Routineaufruf folgt.

• Durch Abarbeiten verschiedener Instruktionen, je nachdem, ob einebestimmte Voraussetzung erfüllt ist.

• Durch Wiederholen der Instruktionsfolge, bis eine bestimmte Voraussetzungerfüllt ist.

• Durch Sprung auf ein Label innerhalb derselben Routine.• Durch Stoppen der Programmabarbeitung.

Aufruf einer anderen Routine

AnwendungInstruktion

Aufruf einer anderen Routine (Sprung auf die Routine)ProcCall

Aufruf von Prozeduren mit bestimmten NamenCallByVar

Rückkehr zur ursprünglichen RoutineRETURN

Programmsteuerung innerhalb der Routine


Ausführen einer Instruktion nur dann, wenn eine Voraussetzungerfüllt ist

Compact IF

Abarbeiten einer Sequenz aus verschiedenen Instruktionen,je nachdem, ob eine Voraussetzung erfüllt ist

IF

Bestimmte Anzahl an Wiederholungen eines Programmab-schnitts

FOR

Wiederholen einer Sequenz aus verschiedenen Instruktionen,solange eine bestimmte Voraussetzung erfüllt ist

WHILE

Ausführen verschiedener Instruktionen abhängig vom Werteines Ausdrucks

TEST

Sprung auf ein LabelGOTO

Angabe eines Labels (Zeilenname)label

Stoppen der Programmabarbeitung


Anhalten der ProgrammabarbeitungStop



1 Grundlagen der Programmierung mit RAPID1.5 Steuern des Programmablaufs


Stoppen der Programmabarbeitung, wenn ein Neustart nichterlaubt ist

EXIT

Temporäres Stoppen der Programmabarbeitung zu Testzwe-cken

Break

Stoppen der Programmabarbeitung und RoboterbewegungenSystemStopAction

Stoppen des aktuellen Zyklus


Stoppen des aktuellen Zyklus und Setzen des Programmzeigersauf die erste Instruktion in der Hauptroutine.

ExitCycle

Wenn der Abarbeitungsmodus CONT gewählt ist, fährt die Ab-arbeitung mit dem nächsten Programmzyklus fort.



1 Grundlagen der Programmierung mit RAPID1.5 Steuern des Programmablaufs

Fortsetzung

1.6 Verschiedene Instruktionen

EinleitungVerschiedene Instruktionen werden verwendet, um:

• Datenwerte zuzuweisen,• eine vorgegebene Zeit oder bis zur Erfüllung einer Voraussetzung zu warten,• einen Kommentar in das Programm einzufügen,• Programmmodule zu laden.

Zuweisen eines DatenwertsDaten können beliebige Werte zugewiesen werden. Beispielsweise können Datenmit einem konstanten Wert (z. B. 5) initialisiert oder mit einem arithmetischenAusdruck (z. B. reg1+5*reg3) aktualisiert werden.


Zuweisen eines Datenwerts:=

WartenDie Programmierung eines Roboters kann Wartezeiten oder das Warten bis zurErfüllung einer Voraussetzung vorsehen, z. B. bis ein Eingang gesetzt ist.


Vorgegebene Wartezeit oder warten, bis sich der Roboter nichtmehr bewegt

WaitTime

Warten, bis eine Voraussetzung erfüllt istWaitUntil

Warten, bis ein digitaler Eingang gesetzt istWaitDI

Warten, bis ein digitaler Ausgang gesetzt istWaitDO

KommentareKommentare werden nur zur besseren Verständlichkeit in das Programm eingefügt.Die Programmabarbeitung beeinflusst ein Kommentar nicht.


Kommentar zum Programm. Eine Zeile, die mit ! beginnt, istein Kommentar und wird durch die Programmabarbeitungignoriert.

!

Laden von ProgrammmodulenProgrammmodule können aus dem Massenspeicher geladen oder aus demProgrammspeicher gelöscht werden. Auf diese Weise lassen sich umfangreicheProgramme mit nur wenig Speicher verwalten.


Programmmodul in den Programmspeicher ladenLoad

Programmmodul aus dem Programmspeicher entladenUnLoad

Programmmodul während der Abarbeitung in den Programm-speicher laden

StartLoad



1 Grundlagen der Programmierung mit RAPID1.6 Verschiedene Instruktionen


Das Modul mit der Programmtask verbinden, wenn es mitStartLoad geladen wurde

WaitLoad

Das Laden eines Moduls abbrechen, das mit der InstruktionStartLoad geladen wird

CancelLoad

Überprüft Programmreferenzen.CheckProgRef

Programmmodul speichernSave

Modul aus dem Programmspeicher löschenEraseModule

AnwendungDatentyp

Programmierung eines Ladevorgangsloadsession

Verschiedene Funktionen


Überprüfen, ob ein Datenobjekt eine gültige Ganzzahl istTryInt

AnwendungFunktion

Aktuelle Betriebsart des Roboters lesenOpMode

Aktuellen Programmabarbeitungsmodus des Roboters lesenRunMode

Aktuellen Nichtbewegungs-Abarbeitungsmodus der Programm-task lesen

NonMotionMode

Dimension eines Datenfelds abrufenDim

Ermitteln, ob beim Aufruf einer Routine ein optionaler Parame-ter vorhanden war

Present

Gibt den Datentypnamen für eine angegebene Variable zurückType

Prüfen, ob ein Parameter eine Persistente istIsPers

Prüfen, ob ein Parameter eine Variable istIsVar

Basisdaten

DefiniertDatentyp

Logische Daten (mit den Werten „true“ oder „false“)bool

Numerische Werte (Dezimalzahlen oder Ganzzahlen)num

Numerische Werte (Dezimalzahlen oder Ganzzahlen). Datentypmit einem größeren Wertebereich als num.

dnum

Zeichenfolgenstring

Routineparameter ohne einen Wertswitch

Konvertierungsfunktion

AnwendungFunktion

Konvertiert eine Zeichenfolge mit einem definierten Byte-Da-tenformat in den Datentyp Byte.

ByteToStr

Konvertiert einen Byte-Datentyp in eine Zeichenfolge mit einemdefinierten Byte-Datenformat.

StrToByte



1 Grundlagen der Programmierung mit RAPID1.6 Verschiedene Instruktionen

Fortsetzung

1.7 Bewegungseinstellungen

EinleitungEinige Bewegungseigenschaften des Roboters werden durch logische Instruktionenbestimmt, die für alle Bewegungen gelten:

• TCP-Höchstgeschwindigkeit• Höchstgeschwindigkeit und Geschwindigkeitsoverride• Beschleunigung• Verwaltung verschiedener Roboterkonfigurationen• Nutzlast• Verhalten in der Nähe von singulären Punkten• Programmverschiebung• Softservo• Abstimmungswerte• Aktivierung und Deaktivierung des Ereignispuffers• Zonenbahnwarnungen unterdrücken

Grundsätze der ProgrammierungDie grundlegenden Eigenschaften der Roboterbewegung werden durch Datenbestimmt, die für jede Positionierinstruktion angegeben werden. Einige Datenwerden jedoch in separaten Instruktionen festgelegt, die für alle Bewegungengelten, bis sich diese Daten ändern.Die allgemeinen Bewegungseinstellungen werden mit einer Reihe von Instruktionenangegeben, können aber auch mithilfe der Systemvariablen C_MOTSET oderC_PROGDISP gelesen werden.Standardwerte werden unter folgenden Bedingungen automatisch gesetzt (durchAbarbeiten der Routine SYS_RESET im Systemmodul BASE_SHARED):

• bei Verwendung des Neustart-ModusReset System (System zurücksetzen),• beim Laden eines neuen Programms,• wenn das Programm vom Anfang gestartet wird.

Funktion „TCP-Höchstgeschwindigkeit“

AnwendungFunktion

Gibt die TCP-Höchstgeschwindigkeit für den verwendetenRobotertyp zurück.

MaxRobSpeed



1 Grundlagen der Programmierung mit RAPID1.7 Bewegungseinstellungen

Definieren der GeschwindigkeitDie absolute Geschwindigkeit wird als Argument in der Positionierinstruktionprogrammiert. Zusätzlich kann die Höchstgeschwindigkeit und derGeschwindigkeitsoverride (ein Prozentsatz der programmierten Geschwindigkeit)definiert werden.Die Geschwindigkeitsbeschränkung kann auch festgelegt werden. Sie kommtspäter zum Tragen, sobald ein Systemeingangssignal gesetzt wird.

DefiniertInstruktion

Höchstgeschwindigkeit und GeschwindigkeitsoverrideVelSet

Aktualisiert den Geschwindigkeitsoverride für die gegenwärtigausgeführte Bewegung.

SpeedRefresh

Stellen Sie die Geschwindigkeitsbeschränkung für eine Achseein. Sie wird später durch ein Systemeingangssignal übernom-men.

SpeedLimAxis

Stellen Sie die Geschwindigkeitsbeschränkung für Kontroll-punkte ein. Sie wird später durch ein Systemeingangssignalübernommen.

SpeedLimCheckPoint

Definieren der BeschleunigungWenn z. B. mit zerbrechlichen Werkstücken gearbeitet wird, kann dieBeschleunigung für einen Teil des Programms verringert werden.


Definiert die Höchstbeschleunigung.AccSet

Beschränkt die Beschleunigung/Verzögerung des Werkzeugs(und der Greiferlast) im Welt-Koordinatensystem.

WorldAccLim

Setzt die Beschränkungen für TCP-Beschleunigung und/oderTCP-Verzögerung entlang der Bewegungsbahn oder setzt siezurück.

PathAccLim

Definieren der KonfigurationsverwaltungDie Konfiguration des Roboters wird gewöhnlich während der Bewegung überprüft.Bei achsenweiser Bewegung wird die korrekte Konfiguration erzielt. Bei linearerund kreisförmiger Bewegung bewegt sich der Roboter stets in die nächstmöglicheKonfiguration, aber anhand einer Prüfung wird untersucht, ob diese Konfigurationmit der programmierten übereinstimmt. Dies lässt sich aber auch ändern.


Konfigurationssteuerung ein/aus während achsenweiser Bewe-gung

ConfJ

Konfigurationsprüfung ein/aus während linearer BewegungConfL

Definieren der NutzlastUm die beste Roboterleistung zu erzielen, muss die korrekte Nutzlast definiertwerden.


Die Nutzlast des GreifersGripLoad




Fortsetzung

Definieren des Verhaltens in der Nähe von singulären PunktenDer Roboter kann so programmiert werden, dass er singuläre Punkte meidet, indemer automatisch die Werkzeugorientierung ändert.


Die Interpolationsmethode durch singuläre PunkteSingArea

Aktivierung und Deaktivierung des EreignispuffersDer Ereignispuffer kann aktiviert und deaktiviert werden, um eine optimaleRoboterleistung und ein gutes Anwendungsverhalten zu erreichen, wenn eineAnwendung mit Feinpunkten und eine kontinuierliche Anwendung, bei der Signaleaufgrund langsamer Prozessausrüstung im Vorfeld gesetzt werden müssen,kombiniert werden.


Aktiviert den konfigurierten EreignispufferActEventBuffer

Deaktiviert die Verwendung des EreignispuffersDeactEventBuffer

Zonenbahnwarnungen unterdrückenUm Warnmeldungen am FlexPendant bei einem Zonenbahnausfall zu vermeiden,können diese Warnungen aktiviert und deaktiviert werden.


Zonenbahnwarnungen unterdrückenCornerPathWarningTRUE;

Zonenbahnwarnungen aktivierenCornerPathWarningFALSE;

Verschieben eines ProgrammsWenn ein Teil eines Programms verschoben werden muss, z. B. nach einer Suche,kann eine Programmverschiebung hinzugefügt werden.


Aktiviert die Programmverschiebung.PDispOn

Aktiviert eine Programmverschiebung durch Angeben einesWerts.

PDispSet

Deaktiviert die Programmverschiebung.PDispOff

Aktiviert einen zusätzlichen Achsen-OffsetEOffsOn

Aktiviert einen zusätzlichen Achsen-Offset durch Angeben ei-nes Werts

EOffsSet

Deaktiviert einen zusätzlichen Achsen-OffsetEOffsOff

AnwendungFunktion

Berechnet eine Programmverschiebung anhand von drei Posi-tionen.

DefDFrame

Berechnet eine Programmverschiebung anhand von sechsPositionen.

DefFrame

Entfernt eine Programmverschiebung aus einer Position.ORobT



1 Grundlagen der Programmierung mit RAPID1.7 BewegungseinstellungenFortsetzung

AnwendungFunktion

Definiert ein Koordinatensystem aus ursprünglichen Positionenund verschobenen Positionen.

DefAccFrame

SoftservoEine oder mehrere Roboterachsen können „soft“ eingestellt werden. BeiVerwendung dieser Funktion kann der Roboter z. B. eine Federzange wechseln.


Aktiviert Softservo für eine oder mehrere Achsen.SoftAct

Deaktiviert Softservo.SoftDeact

Anpassen der Roboter-AbstimmungswerteGenerell wird die Leistung des Roboters automatisch optimiert, in einigen extremenFällen kann beispielsweise ein Überfahren einer Position vorkommen. Sie könnendie Abstimmungswerte des Roboters nachstellen, um die gewünschte Leistungzu erzielen.


Anpassen der Roboter-AbstimmungswerteTuneServo

Abstimmung auf Normal zurücksetzenTuneReset

Geometrische Bahnauflösung anpassenPathResol

Art der Werkzeugumorientierung bei kreisförmiger InterpolationCirPathMode

AnwendungDatentyp

Stellt die Art der Abstimmung als symbolische Konstante dar.tunetype

WeltzonenBis zu 10 verschiedene Volumen können im Arbeitsraum des Roboters definiertwerden. Diese können verwendet werden für:

• Anzeige, dass der TCP des Roboters einen definierten Teil des Arbeitsraumsdarstellt,

• Beschränkung des Arbeitsbereichs des Roboters, um eine Kollision mit demWerkzeug zu vermeiden,

• Definieren eines gemeinsamen Arbeitsraums für zwei Roboter. DerArbeitsraum steht dann nur jeweils einem Roboter zur Verfügung.

Die Instruktionen in der folgenden Tabelle sind nur verfügbar, wenn der Robotermit der Option World Zones ausgestattet ist.


Definiert eine globale Zone in der Form eines Quaders.WZBoxDef

Definiert eine globale Zone in der Form eines Zylinders.WZCylDef

Definiert eine globale Zone in der Form einer Kugel.WZSphDef

Definiert eine globale Zone in Achsenkoordinaten.WZHomeJointDef

Definiert eine globale Zone in Achsenkoordinaten zur Beschrän-kung des Arbeitsraums.

WZLimJointDef




Fortsetzung


Aktiviert Grenzüberwachung für eine globale Zone.WZLimSup

Aktiviert das Setzen von digitalen Ausgängen in einer globalenZone.

WZDOSet

Deaktiviert die Überwachung einer temporären globalen Zone.WZDisable

Aktiviert die Überwachung einer temporären globalen Zone.WZEnable

Löscht die Überwachung einer temporären globalen Zone.WZFree

Identifiziert eine temporäre globale Zone.wztemporary

Identifiziert eine stationäre globale Zone.wzstationary

Beschreibt die Geometrie einer globalen Zone.shapedata

Verschiedenes für Bewegungseinstellungen


Wartet, bis Roboter und die zusätzliche Achse einen Stopp-punkt erreichen oder null Geschwindigkeit haben.

WaitRob

AnwendungDatentyp

Bewegungseinstellungen außer Programmverschiebungmotsetdata

Programmverschiebungprogdisp



1 Grundlagen der Programmierung mit RAPID1.7 BewegungseinstellungenFortsetzung

1.8 Bewegung

Prinzip für RoboterbewegungDie Roboterbewegungen werden als Bewegungen von einer Position zur anderenprogrammiert, d. h. „Bewegung von der aktuellen Position zu einer neuen Position“.Die Bahn zwischen diesen beiden Positionen berechnet das Robotersystemautomatisch.

Grundsätze der ProgrammierungDie grundlegenden Bewegungseigenschaften, wie z. B. die Art der Bahn, werdendurch die Wahl der geeigneten Positionierinstruktionen angegeben.Die übrigen Bewegungseigenschaften werden durch Daten definiert, die dieArgumente der Instruktion darstellen:

• Positionsdaten (Endposition für Roboter und zusätzliche Achsen)• Geschwindigkeitsdaten (gewünschte Geschwindigkeit)• Zonendaten (Positionsgenauigkeit)• Werkzeugdaten (z. B. TCP-Position)• Werkobjektdaten (zum Beispiel das aktuelle Koordinatensystem)

Einige Bewegungseigenschaften des Roboters werden durch logische Instruktionenbestimmt, die für alle Bewegungen gelten (siehe Bewegungseinstellungen aufSeite 52):

• Höchstgeschwindigkeit und Geschwindigkeitsoverride• Beschleunigung• Verwaltung verschiedener Roboterkonfigurationen• Nutzlast• Verhalten in der Nähe von singulären Punkten• Programmverschiebung• Softservo• Abstimmungswerte• Aktivierung und Deaktivierung des Ereignispuffers

Der Roboter und die zusätzlichen Achsen werden mit denselben Instruktionenpositioniert. Die zusätzlichen Achsen werden in konstanter Geschwindigkeit bewegtund erreichen die Endposition gleichzeitig mit dem Roboter.

Positionierungsinstruktionen

Art der BewegungInstruktion

Der TCP bewegt sich auf einer kreisförmigen Bahn.MoveC

Achsenbewegung.MoveJ

Der TCP bewegt sich auf einer linearen Bahn.MoveL

Absolute Achsenbewegung.MoveAbsJ

Bewegt eine lineare oder drehende externe Achse ohne TCP.MoveExtJ



1 Grundlagen der Programmierung mit RAPID1.8 Bewegung


Für eine kreisförmige Bewegung des Roboters und der Festle-gung eines analogen Ausgangs in der Ecke

MoveCAO

Bewegt den Roboter kreisförmig und setzt einen digitalenAusgang in der Mitte der Zonenbahn.

MoveCDO

Für eine kreisförmige Bewegung des Roboters und das Fest-legen des Gruppenausgangssignals in der Ecke

MoveCGO

Für eine Achsenbewegung des Roboters und das Festlegendes analogen Ausgangs in der Ecke

MoveJAO

Bewegt den Roboter durch Achsenbewegung und setzt einendigitalen Ausgang in der Mitte der Zonenbahn.

MoveJDO

Für eine Achsenbewegung des Roboters und Einstellen einesGruppenausgangs in der Ecke

MoveJGO

Für eine kreisförmige Bewegung des Roboters und das Fest-legen des analogen Ausgangs in der Ecke

MoveLAO

Bewegt den Roboter linear und setzt einen digitalen Ausgangin der Mitte der Zonenbahn.

MoveLDO

Für eine lineare Bewegung des Roboters und das Festlegeneines digitalen Ausgangs in der Ecke

MoveLGO

Bewegt den Roboter kreisförmig und arbeitet eine RAPID-Prozedur ab.

MoveCSync

Bewegt den Roboter mittels Achsenbewegungen und führt eineRAPID-Prozedur durch.

MoveJSync

Bewegt den Roboter linear und arbeitet eine RAPID-Prozedurab.

MoveLSync

SuchenWährend der Bewegung kann der Roboter z. B. die Position des Werkobjektssuchen. Die gesuchte Position (durch ein Sensorsignal angegeben) wird gespeichertund kann später zur Positionierung des Roboters oder zur Berechnung einerProgrammverschiebung verwendet werden.


Der TCP bewegt sich auf einer kreisförmigen Bahn.SearchC

Der TCP bewegt sich auf einer linearen Bahn.SearchL

Achsenbewegung einer mechanischen Einheit ohne TCP.SearchExtJ

Aktivieren von Ausgängen oder Interrupts an bestimmten PositionenGewöhnlich werden logische Instruktionen beim Übergang von einerPositionierinstruktion zu einer anderen abgearbeitet. Falls jedoch spezielleBewegungsinstruktionen verwendet werden, können diese stattdessen ausgeführtwerden, wenn der Roboter eine bestimmte Position einnimmt.


Bewegt den Roboter (TCP) kreisförmig mit einer aktiviertenTriggerbedingung.

TriggC

Definiert eine E/A-Prüfung an einer vorgegebenen PositionTriggCheckIO



1 Grundlagen der Programmierung mit RAPID1.8 BewegungFortsetzung


Definiert eine Triggerbedingung für das Setzen eines Ausgangsan einer vorgegebenen Position mit der Möglichkeit, die Verzö-gerung in der externen Ausrüstung zeitlich zu kompensieren.

TriggEquip

Kopieren des Inhalts in eine triggdata-VariableTriggDataCopy

Zurücksetzen des Inhalts in einer triggdata-VariablenTriggDataReset

Definiert eine Triggerbedingung für das Erhöhen oder Verrin-gern eines analogen Ausgangssignals an einer vorgegebenenPosition mit der Möglichkeit, die Verzögerung in der externenAusrüstung zeitlich zu kompensieren.

TriggRampAO

Bewegt den Roboter (TCP) achsenweise mit einer aktiviertenTriggerbedingung.

TriggJ

Bewegen Sie den Roboter (TCP) Achse für Achse mit eineraktivierten E/A-Triggerbedingung.

TriggJIOs

Definiert eine Triggerbedingung für das Abarbeiten einer Inter-rupt-Routine an einer vorgegebenen Position.

TriggInt

Definiert eine Triggerbedingung für das Setzen eines Ausgangsan einer vorgegebenen Position.

TriggIO

Bewegt den Roboter (TCP) linear mit einer aktivierten Trigger-bedingung.

TriggL

Bewegt den Roboter (TCP) linear mit einer aktivierten E-/A-Triggerbedingung.

TriggLIOs

Rückwärtsbewegung auf der Bahn mit einer RESTART-Ereignis-routine.

StepBwdPath

Erstellt einen internen Überwachungsprozess im System, umbei jedem Programmstopp (STOP) oder Notstopp (QSTOP) imSystem angegebene Prozesssignale auf Null zu setzen undNeustartdaten in einer angegebenen persistenten Variablenzu erzeugen.

TriggStopProc

AnwendungFunktionen

Prüfen, ob der Inhalt in einer triggdata-Variablen gültig istTriggDataValid

AnwendungDatentypen

Triggerbedingungentriggdata

Analoge E/A-Triggerbedingungaiotrigg

Daten für TriggStopProcrestartdata

Triggerbedingungen für TriggJIOs und TriggLIOstriggios

Triggerbedingungen für TriggJIOs und TriggLIOstriggstrgo

Triggerbedingungen für TriggJIOs und TriggLIOstriggiosdnum

Steuerung des analogen Ausgangssignals proportional zum aktuellen TCP


Definiert Bedingungen und Aktionen zur Steuerung einesanalogen Ausgangssignals mit einem Wert, der proportionalzur aktuellen TCP-Geschwindigkeit ist.

TriggSpeed




Fortsetzung

Bewegungssteuerung bei einem Fehler/InterruptUm einen Fehler oder einen Interrupt zu korrigieren, kann die Bewegung temporärgestoppt und dann wieder neu gestartet werden.


Definiert Bedingungen und Aktionen zur Steuerung einesanalogen Ausgangssignals mit einem Wert, der proportionalzur aktuellen TCP-Geschwindigkeit ist.

StopMove

Startet die Roboterbewegungen neu.StartMove

Startet die Roboterbewegungen neu und unternimmt einenneuen Versuch in einer unteilbaren Sequenz.

StartMoveRetry

Setzt den Stopp des Bewegungsstatus zurück, startet jedochdie Roboterbewegungen nicht.

StopMoveReset

Speichert die zuletzt erzeugte Bahn.StorePath

Erzeugt erneut eine Bahn, die früher gespeichert wurde.RestoPath

Löscht die gesamte Bewegungsbahn auf der Ebene der aktu-ellen Bewegungsbahn.

ClearPath

Ruft die aktuelle Bahnebene ab.PathLevel

Setzt synchronisierte koordinierte Bewegungen auf Store-Path-Ebene aus.

SyncMoveSuspend i

Nimmt synchronisierte koordinierte Bewegungen auf Store-Path-Ebene wieder auf.

SyncMoveResume i

i Wenn der Roboter mit der Option MultiMove Coordinated ausgestattet ist.

AnwendungFunktion

Ruft den Status der Flags zum Stoppen der Bewegung ab.IsStopMoveAct

Abrufen von Roboterdaten in ein MultiMove-SystemVerwendet, um Name oder Verweis auf den Roboter in der aktuellen Programmtaskabzurufen.

AnwendungFunktion

Ruft ggf. den Namen des gesteuerten Roboters in der aktuellenProgrammtask ab.

RobName

AnwendungDaten

Ruft ggf. Daten ab, die einen Verweis auf den gesteuertenRoboter in der aktuellen Programmtask enthalten.

ROB_ID

Steuern zusätzlicher AchsenDer Roboter und die zusätzlichen Achsen werden gewöhnlich mit denselbenInstruktionen positioniert. Einige Instruktionen beeinflussen jedoch nur dieBewegungen der zusätzlichen Achsen.


Deaktiviert eine externe mechanische Einheit.DeactUnit

Aktiviert eine externe mechanische Einheit.ActUnit

Definiert eine Nutzlast für eine mechanische Einheit.MechUnitLoad




AnwendungFunktion

Liest das aktuelle Drehmoment des Roboters und der externenAchsenmotoren und kann verwendet werden, um festzustellen,ob ein Servo-Greifer eine Last hält oder nicht.

GetMotorTorque

Ruft den Namen von mechanischen Einheiten im Robotersys-tem ab.

GetNextMechUnit

Prüft, ob eine mechanische Einheit aktiviert ist.IsMechUnitActive

Unabhängige AchsenRoboterachse 6 (und 4 am IRB 1600, 2600 und 4600, mit Ausnahme vonID-Versionen) oder eine zusätzliche Achse kann unabhängig von anderenBewegungen bewegt werden. Der Arbeitsraum einer Achse kann auch zurückgesetztwerden, wodurch sich die Zyklusdauer verringert.Die Instruktionen in der folgenden Tabelle sind nur verfügbar, wenn der Robotermit der Option Independent Axis ausgestattet ist.


Ändert den Modus einer Achse in „unabhängig“ und bewegtsie an eine absolute Position.

IndAMove

Ändert den Modus einer Achse in „unabhängig“ und beginntdie kontinuierliche Bewegung der Achse.

IndCMove

Ändert den Modus einer Achse in „unabhängig“ und bewegtdie Achse um einen Delta-Abstand.

IndDMove

Ändert den Modus einer Achse in „unabhängig“ und bewegtdie Achse an eine relative Position (innerhalb der Achsendre-hung).

IndRMove

Ändert den Modus einer Achse in unabhängig und/oder setztden Arbeitsraum zurück.

IndReset

Setzt die Position von Handgelenkachsen an Manipulatorenmit Hohlgelenken (wie z. B. IRB 5402 und IRB 5403) zurück.

HollowWristReset i

i Kann nur für Robotermodell IRB 5402 und IRB 5403 verwendet werden.Die Funktionen in der folgenden Tabelle sind nur verfügbar, wenn der Roboter mitder Option Independent Axis ausgestattet ist.

AnwendungFunktion

Prüft, ob eine unabhängige Achse in Position ist.IndInpos

Prüft, ob eine unabhängige Achse die programmierte Geschwin-digkeit erreicht hat.

IndSpeed

BahnkorrekturDie Instruktionen, Funktionen und Datentypen in den folgenden Tabellen sind nurverfügbar, wenn der Roboter mit der OptionPath offset oderRobotWare-Arc sensorausgestattet ist.


Prüft, ob eine unabhängige Achse in Position ist.CorrCon

Prüft, ob eine unabhängige Achse die programmierte Geschwin-digkeit erreicht hat.

CorrWrite




Fortsetzung


Trennt die Verbindung mit einem zuvor verbundenen Korrek-turgenerator.

CorrDiscon

Trennt alle Verbindungen mit Korrekturgeneratoren.CorrClear

AnwendungFunktion

Liest die gesamten Korrekturen, die von allen verbundenenKorrekturgeneratoren durchgeführt werden.

CorrRead

AnwendungDatentyp

Fügt dem Bahn-Koordinatensystem geometrische Offsetshinzu.

corrdescr

BahnaufzeichnungDie Instruktionen, Funktionen und Datentypen in den folgenden Tabellen sind nurverfügbar, wenn der Roboter mit der Option Path Recovery ausgestattet ist.


Startet die Aufzeichnung der Bahn des RobotersPathRecStart

Beendet die Aufzeichnung der Bahn des RobotersPathRecStop

Bewegt den Roboter rückwärts entlang einer aufgezeichnetenBahn.

PathRecMoveBwd

Bewegt den Roboter zurück an die Position, an der PathRec-MoveBwd abgearbeitet wurde.

PathRecMoveFwd

AnwendungFunktion

Prüft, ob die Bahnaufzeichnung aktiv und eine aufgezeichneteRückwärtsbahn verfügbar ist.

PathRecValidBwd

Prüft, ob die Bahnaufzeichnung zur Vorwärtsbewegung benutztwerden kann.

PathRecValidFwd

AnwendungDatentyp

Identifiziert einen Stopppunkt für die Bahnaufzeichnung.pathrecid

Conveyor TrackingDie Instruktionen in der folgenden Tabelle sind nur verfügbar, wenn der Robotermit der Option Conveyor tracking ausgestattet ist.


Warten auf Werkobjekt am Förderer.WaitWObj

Legt das Werkobjekt am Förderer ab.DropWObj

Servo Tracking für TaktfördererDie Instruktionen in der folgenden Tabelle sind nur verfügbar, wenn der Robotermit der Option Conveyor tracking ausgestattet ist.


Fügt ein Objekt manuell einer Objektqueue hinzu.IndCnvAddObject





Beginnt die Überwachung des digitalen Eingangs und arbeitetbei Auslösung eine Indexbewegung ab.

IndCnvEnable

Das System beendet die Überwachung des digitalen Eingangs.IndCnvDisable

Stellt die Taktförderer-Funktion ein.IndCnvInit

Zum Bewegen oder Abarbeiten einer Bewegungsinstruktionfür den Taktförderer muss das System in den Normalmodusversetzt werden, was mithilfe dieser Instruktion oder durchSetzen des PZ auf „main“ erfolgt.

IndCnvReset

Dies stellt das Verhalten der Funktionen des Taktförderers ein.indcnvdata

SensorsynchronisierungSensorsynchronisierung ist die Funktion, durch die sich die Robotergeschwindigkeitnach einem Sensor richtet, der an einem Förderer oder einer Motorachse montiertwerden kann.Die Instruktionen in der folgenden Tabelle sind nur verfügbar, wenn der Robotermit der Option Sensor Synchronization ausgestattet ist.


Verbindet mit einem Objekt im Startfenster an einer sensorme-chanischen Einheit.

WaitSensor

Startet oder stoppt die Synchronisierung der Roboterbewegungmit der Sensorbewegung.

SyncToSensor

Trennt die Verbindung mit dem aktuellen Objekt.DropSensor

Lastidentifikation und Kollisionserkennung


Deaktiviert/aktiviert die Bewegungsüberwachung.MotionSup i

Gültige Roboterposition für ParameteridentifikationParIdPosValid

Gültiger Robotertyp für ParameteridentifikationParIdRobValid

Lastidentifikation der Werkzeug- oder NutzlastLoadId

Lastidentifikation von externem ManipulatorManLoadId

i Nur wenn der Roboter mit der Option Collision Detection ausgestattet ist.

AnwendungDatentyp

Ganzzahl mit einer symbolischen Konstanten darstellenloadidnum

Ganzzahl mit einer symbolischen Konstanten darstellenparidnum

Ganzzahl mit einer symbolischen Konstanten darstellenparidvalidnum

Positionierfunktionen

AnwendungFunktion

Addiert einen Offset zu einer Roboterposition, ausgedrückt inRelation zum Werkobjekt.

Offs

Addiert einen Offset, ausgedrückt im Werkzeug-Koordinaten-system.

RelTool




Fortsetzung

AnwendungFunktion

Berechnet robtarget aus jointtarget.CalcRobT

Liest die aktuelle Position (nur x, y, z des Roboters).CPos

Liest die aktuelle Position (das vollständige robtarget).CRobT

Liest die aktuellen Achsenwinkel.CJointT

Liest die aktuellen Motorwinkel.ReadMotor

Liest den aktuellen Werkzeugdatenwert.CTool

Liest den aktuellen Werkobjektdaten-Wert.CWObj

Entfernt eine Programmverschiebung von einer Position.ORobT

Spiegelt eine Position.MirPos

Berechnet Achsenwinkel anhand des robtarget.CalcJointT

Der Abstand zwischen zwei PositionenDistance

Überprüft die unterbrochene Bahn nach einem Stromausfall.

AnwendungFunktion

Prüft, ob die Bahn beim Stromausfall unterbrochen wurde.PFRestart

Statusfunktionen

AnwendungFunktion

Liest den Geschwindigkeitsoverride, den der Bediener imProgrammeditor oder im Fenster Produktion festgelegt hat.

CSpeedOverride

BewegungsdatenBewegungsdaten werden als Argument in den Positionierinstruktionen verwendet.

DefiniertDatentyp

Die Endpositionrobtarget

Die Endposition für eine MoveAbsJ- oder MoveExtJ-Instruktionjointtarget

Die Geschwindigkeitspeeddata

Die Genauigkeit der Position (Stopppunkt oder Fly-By-Punkt)zonedata

Das Werkzeug-Koordinatensystem und die Last des Werkzeugstooldata

Das Werkobjekt-Koordinatensystemwobjdata

Das Erreichen der Positionstoppointdata

Eine Zahl, anhand derer die Synchronisierung von mehrerenkoordinierten Synchronbewegungen gesteuert wird

identno

Basisdaten für Bewegungen

DefiniertDatentyp

Eine Position (x, y, z)pos

Eine Orientierungorient

Ein Koordinatensystem (Position + Orientierung)pose




DefiniertDatentyp

Die Konfiguration der Roboterachsenconfdata

Die Position der zusätzlichen Achsenextjoint

Die Position der Roboterachsenrobjoint

Eine Lastloaddata

Eine externe mechanische Einheitmecunit

Weitere Informationen

Beschrieben inOptionen

Anwendungshandbuch - Steuerungssoftware IRC5Collision DetectionSensor SynchronizationIndependent AxisPath OffsetPath Recovery

Anwendungshandbuch - Conveyor TrackingConveyor tracking

Anwendungshandbuch - MultiMoveMultiMove

Anwendungshandbuch - Arc und Arc SensorRobotWare-Arc




Fortsetzung

1.9 Eingangs- und Ausgangssignale

SignaleDer Roboter kann mit einer Anzahl von digitalen und analogen Benutzersignalenausgestattet werden, die sich im Programm ablesen und ändern lassen.

Grundsätze der ProgrammierungDie Signalnamen werden in den Systemparametern definiert. Diese Namen stehenim Programm stets zum Lesen oder Setzen von E/A-Operationen zur Verfügung.Der Wert eines analogen Signals oder einer digitalen Signalgruppe wird alsnumerischer Wert angegeben.

Ändern eines Signalwerts


Invertieren des Werts eines digitalen AusgangssignalsInvertDO

Erzeugen eines Impulses auf einem digitalen AusgangssignalPulseDO

Zurücksetzen eines digitalen Ausgangssignals (auf 0)Reset

Setzen eines digitalen Ausgangssignals (auf 1)Set

Ändern des Werts eines analogen AusgangssignalsSetAO

Ändern des Werts eines digitalen Ausgangssignals (symboli-scher Wert, z. B. high/low)

SetDO

Ändern des Werts einer Gruppe von digitalen Ausgangssigna-len

SetGO

Lesen eines EingangssignalwertsDer Wert eines Eingangssignals kann direkt im Programm gelesen werden, zumBeispiel:

! Digital input

IF di1 = 1 THEN ...

! Digital group input (smaller than 23 bits)

IF gi1 = 5 THEN ...

! Analog input

IF ai1 > 5.2 THEN ...

Die folgenden behebbaren Fehler können erzeugt werden. Die Fehler können ineiner Fehlerbehandlungsroutine behoben werden. Die Systemvariable ERRNOwird auf folgenden Wert gesetzt:ERR_NO_ALIASIO_DEF , dass die Signalvariable eine in RAPID angegebeneVariable ist. Sie wurde nicht an ein E/A-Signal, das in der E/A-Konfiguration mitInstruktion AliasIO definiert wurde.ERR_NORUNUNIT, wenn kein Kontakt mit der E/A-Einheit vorhanden ist.ERR_SIG_NOT_VALID, wenn auf das E/A-Signal nicht zugegriffen werden kann(gilt nur für ICI-Feldbus).



1 Grundlagen der Programmierung mit RAPID1.9 Eingangs- und Ausgangssignale

Lesen eines AusgangssignalwertsDer Wert eines Eingangssignals kann direkt im Programm gelesen werden, zumBeispiel:

! Digital output

IF do1 = 1 THEN ...

! Digital group output (smaller than 23 bits)

IF go1 = 5 THEN ...

! Analog output

IF ao1 > 5.2 THEN ...


Lesen des Werts großer GruppensignaleGruppensignale zwischen 23 Bits bis 32 Bits müssen von einer Funktion gelesenund in dnum konvertiert werden.

! Digital group input (larger than 23 bits)

IF GInputDnum(gi1) = 4294967295 THEN ...

! Digital group output (larger than 23 bits)

IF GOutputDnum(go1) = 4294967295 THEN ...


Testen von Eingangs- oder Ausgangssignalen


Wartet, bis ein digitaler Eingang gesetzt oder zurückgesetztwird.

WaitDI

Wartet, bis ein digitaler Ausgang gesetzt oder zurückgesetztwird.

WaitDO

Wartet, bis eine Gruppe digitaler Eingangssignale auf einenWert gesetzt wird.

WaitGI

Wartet, bis eine Gruppe digitaler Ausgangssignale auf einenWert gesetzt wird.

WaitGO




Fortsetzung


Wartet, bis ein analoger Eingang kleiner oder größer als einbestimmter Wert ist.

WaitAI

Wartet, bis ein analoger Ausgang kleiner oder größer als einbestimmter Wert ist.

WaitAO

Definiert:Funktion

Testet, ob ein digitaler Eingang gesetzt istTestDI

Gültiges E/A-Signal, auf das zugegriffen werden sollValidIO

Abruf von Informationen zur Herkunft eines E/A-Signals.GetSignalOrigin

DefiniertDatentyp

Gibt die Herkunft des E/A-Signals an.signalorigin

Deaktivieren und Aktivieren von E/A-ModulenE/A-Module werden automatisch beim Start aktiviert, aber sie können während derProgrammabarbeitung deaktiviert und später wieder aktiviert werden.


Deaktiviert ein E/A-ModulIODisable

Aktiviert ein E/A-ModulIOEnable

Definieren von Eingangs- und Ausgangssignalen


Definiert ein Signal mit einem AliasnamenAliasIO

DefiniertDatentyp

Symbolischer Wert eines digitalen Signalsdionum

Name eines analogen Eingangssignalssignalai

Name eines analogen Ausgangssignalssignalao

Name eines digitalen Eingangssignalssignaldi

Name eines digitalen Ausgangssignalssignaldo

Name einer Gruppe digitaler Eingangssignalesignalgi

Name einer Gruppe digitaler Ausgangssignalesignalgo

Gibt die Herkunft des E/A-Signals an.signalorigin

Abrufen des Status von E/A-Bus und -Einheit


Ruft den aktuellen Status des E/A-Busses ab.IOBusState

DefiniertFunktion

Gibt den aktuellen Status der E/A-Einheit zurück.IOUnitState



1 Grundlagen der Programmierung mit RAPID1.9 Eingangs- und AusgangssignaleFortsetzung

DefiniertDatentyp

Status der E/A-Einheitiounit_state

Status des E/A-Bussesbustate

Starten des E/A-Busses


Startet einen E/A-Bus.IOBusStart




Fortsetzung

1.10 Kommunikation

Kommunikation über serielle KanäleEs gibt vier Möglichkeiten der Kommunikation über serielle Kanäle:

• Meldungen können an das FlexPendant ausgegeben werden und derAnwender kann Fragen beantworten, z. B. über die Anzahl der zuverarbeitenden Werkstücke.

• Zeichenbasierte Informationen können in Textdateien im Massenspeichergeschrieben oder aus diesen gelesen werden. So lassen sich z. B.Produktionsstatistiken speichern und später an einem PC verarbeiten.Informationen können auch direkt auf einem an das Robotersystemangeschlossenen Drucker ausgegeben werden.

• Binärdaten können zwischen dem Robotersystem und beispielsweise einemSensor übertragen werden.

• Binärdaten können zwischen dem Robotersystem und einem anderenComputer z. B. mithilfe eines Verbindungsprotokolls übertragen werden.

Grundsätze der ProgrammierungDie Entscheidung über die Verwendung von zeichenbasierten oder binären Datenhängt davon ab, wie die Ausstattung, mit der der Roboter kommuniziert, dieseInformationen verarbeitet. Eine Datei kann z. B. Daten enthalten, die inzeichenbasiertem oder binärem Format gespeichert werden.Wenn gleichzeitige Kommunikation in beide Richtungen erforderlich ist, mussBinärübertragung gewählt werden.Jeder verwendete serielle Kanal bzw. jede verwendete Datei muss zuerst geöffnetwerden. Dabei erhält der Kanal/die Datei einen Deskriptor, der dann beimLesen/Schreiben als Referenz dient. Das FlexPendant kann jederzeit benutztwerden und muss nicht geöffnet werden.Sowohl der Text als auch der Wert bestimmter Datentypen können gedruckt werden.

Kommunikation mithilfe des FlexPendant, Funktionsgruppe TP


Inhalt der Anzeige am FlexPendant löschenTPErase

Auf die Anzeige am FlexPendant schreibenTPWrite

Text auf die Anzeige des FlexPendant schreiben und gleichzei-tig diese Meldung im Fehlerprotokoll des Programms speichern.

ErrWrite

Funktionstasten beschriften und betätigte Funktionstaste able-sen

TPReadFK

Numerischen Wert am FlexPendant ablesenTPReadDnum

Numerischen Wert am FlexPendant ablesenTPReadNum

Am FlexPendant ein Fenster von RAPID wählenTPShow

Fenster des FlexPendants mit einer symbolischen Konstantendarstellen

tpnum



1 Grundlagen der Programmierung mit RAPID1.10 Kommunikation

Kommunikation mithilfe des FlexPendant, Funktionsgruppe UI


Meldung auf das FlexPendant schreibenUIMsgBox

Am FlexPendant gedrückte Taste lesenGrundlegender Typ

Über RAPID eine Anwendung am FlexPendant öffnenUIShow

AnwendungFunktion

Meldung auf das FlexPendant schreibenUIMessageBox

Am FlexPendant gedrückte Taste lesenErweiterter Typ

Numerischen Wert am FlexPendant ablesenUIDnumEntry

Numerischen Wert am FlexPendant einstellenUIDnumTune

Numerischen Wert am FlexPendant ablesenUINumEntry

Numerischen Wert am FlexPendant einstellenUINumTune

Text vom FlexPendant lesenUIAlphaEntry

Objekt in einer Liste vom FlexPendant auswählenUIListView

Verbindung des FlexPendant mit dem System prüfenUIClientExist

AnwendungDatentyp

Symbol mit einer symbolischen Konstanten darstellenicondata

Taste mit einer symbolischen Konstanten darstellenbuttondata

Menülistenobjekte definierenlistitem

Ausgewählte Taste mit einer symbolischen Konstanten darstel-len

btnres

Instanz-ID für UIShowuishownum

Lesen/Schreiben in/aus zeichenbasierten seriellen Kanälen/Dateien


Kanal/Datei zum Lesen oder Schreiben öffnenOpen

Text in Kanal/Datei schreibenWrite

Kanal/Datei schließenClose

AnwendungFunktion

Numerischen Wert lesenReadNum

Zeichenfolge lesenReadStr

Kommunikation mithilfe binärer serieller Kanäle/Dateien/Feldbusse


Serielle/n Kanal/Datei für binäre Datenübertragung öffnenOpen

In binäre/n serielle/n Kanal/Datei schreibenWriteBin

In beliebige/n binäre/n serielle/n Kanal/Datei schreibenWriteAnyBin




Fortsetzung


Zeichenfolge in binäre/n serielle/n Kanal/Datei schreibenWriteStrBin

Dateizeiger an Beginn der Datei setzenRewind

Kanal/Datei schließenClose

Eingangspuffer eines seriellen Kanals löschenClearIOBuff

Aus beliebigem binärem seriellen Kanal lesenReadAnyBin

Daten des Typs rawbytes in binäre/n serielle/n Kanal/Datei/Feld-bus schreiben

WriteRawBytes

Daten des Typs rawbytes aus binärem/r seriellem/r Kanal/Da-tei/Feldbus lesen

ReadRawBytes

AnwendungFunktion

Aus binärem seriellen Kanal lesenReadBin

Zeichenfolge aus binärem/r seriellem/r Kanal/Datei lesenReadStrBin

Kommunikation mit rawbytesNachstehende Instruktionen und Funktionen werden für die Unterstützung derKommunikationsinstruktionen WriteRawBytes und ReadRawBytes eingesetzt.


Rawbytes-Variable auf null setzenClearRawBytes

Aus einer Rawbytes-Variablen in eine andere kopierenCopyRawBytes

Inhalt einer Variablen in einen Container des Typs rawbytespacken

PackRawBytes

Inhalt eines Containers vom Typ rawbytes in eine Variableentpacken

UnPackRawBytes

Header einer DeviceNet-Meldung in einen Container mit Raw-bytes packen

PackDNHeader

AnwendungFunktion

Die aktuelle Länge gültiger Bytes in einer Rawbyte-Variablenabrufen

RawBytesLen

Daten für serielle Kanäle/Dateien/Feldbusse

DefiniertDatentyp

Ein Verweis auf eine/n seriellen Kanal/Datei, der/die zum Lesenund Schreiben verwendet werden kann

iodev

Allgemeiner Datencontainer für die Kommunikation mit E/A-Geräten

rawbytes

Kommunikation mit Sockets


Erstellen eines neuen SocketsSocketCreate

Verbindung mit Remote-Computer herstellen (nur Clientanwen-dungen)

SocketConnect



1 Grundlagen der Programmierung mit RAPID1.10 KommunikationFortsetzung


Senden von Daten an Remote-ComputerSocketSend

Senden von Daten an Remote-ComputerSocketSendTo

Daten vom Remote-Computer empfangenSocketReceive

Daten vom Remote-Computer empfangenSocketReceiveFrom

Schließen des SocketsSocketClose

Socket an einen Port binden (nur Serveranwendungen)SocketBind

Verbindungen prüfen (nur Serveranwendungen)SocketListen

Verbindungen akzeptieren (nur Serveranwendungen)SocketAccept

AnwendungFunktion

Abrufen des aktuellen Socket-StatusSocketGetStatus

Überprüfung eines Sockets auf vorhandene Daten hin.SocketPeek

DefiniertDatentyp

Socketgerätsocketdev

Socketstatussocketstatus

Kommunikation mithilfe von RAPID Message Queues

DefiniertDatentyp

rmqheader gehört zum Datentyp rmqmessage und dient zumBeschreiben der Meldung.

rmqheader i

Ein allgemeiner Datencontainer, der bei der Kommunikationmit der Funktionalität RAPID Message Queue verwendet wird.

rmqmessage

Identitätsnummer einer RAPID-Task oder eines Robot Applica-tion Builder-Clients

rmqslot

Anfordern und Aktivieren von Interrupts für einen bestimmtenDatentyp

IRMQMessage

Sucht die Identitätsnummer der für eine RAPID-Task oder einenRobot Application Builder-Client konfigurierten Warteschlange.

RMQFindSlot

Ruft die erste Meldung aus der Warteschlange für die Task ab.RMQGetMessage

Extrahiert die Daten aus einer Meldung.RMQGetMsgData

Extrahieren von Headerinformationen aus einer MeldungRMQGetMsgHeader

Sendet Daten an die Warteschlange einer für eine RAPID-Taskoder einen SDK-Client konfigurierten Warteschlange.

RMQSendMessage

Senden einer Meldung und Warten auf die AntwortRMQSendWait

Leert die RMQ, die mit der Instruktion zum Ausführen der Taskverbunden ist.

RMQEmptyQueue

Wartet bis zum Eintreffen einer Meldung oder bis zu einemTimeout.

RMQReadWait

i Nur wenn der Roboter mit mindestens einer der Optionen FlexPendant Interface, PC Interface oderMultitasking ausgestattet ist.




Fortsetzung

AnwendungFunktion

Ruft den Namen eines RAPID Message Queue-Clients anhandeiner angegebenen Identitätsnummer, d. h. aus einem angege-benen rmqslot, ab.

RMQGetSlotName i

i Nur wenn der Roboter mit mindestens einer der Optionen FlexPendant Interface, PC Interface oderMultitasking ausgestattet ist.



1 Grundlagen der Programmierung mit RAPID1.10 KommunikationFortsetzung

1.11 Interrupts

EinleitungInterrupts sind im Programm definierte Ereignisse, die durch Interrupt-Nummernidentifiziert werden. Ein Interrupt tritt auf, wenn eine Interrupt-Bedingung wahr ist.Im Unterschied zu Fehlern ist das Auftreten eines Interrupts nicht direkt mit einerbestimmten Codeposition verbunden. Beim Auftreten eines Interrupts wird dienormale Programmabarbeitung angehalten und die Steuerung an eineInterrupt-Routine übergeben.Selbst wenn das Robotersystem das Auftreten eines Interrupts sofort erkennt (nurdurch die Geschwindigkeit der Hardware verzögert), kann die Reaktion, d. h. derAufruf der entsprechenden Interrupt-Routine, nur an besonderenProgrammpositionen erfolgen, und zwar:

• beim Einlesen der nächsten Instruktion,• jederzeit bei der Ausführung einer Warteinstruktion, z. B. WaitUntil,• jederzeit bei der Ausführung einer Bewegungsinstruktion, z. B. MoveL.

Dadurch entsteht normalerweise eine Verzögerung von 2 bis 30 ms zwischenErkennung des Interrupts und Reaktion, je nachdem, welche Bewegung zur Zeitdes Interrupts ausgeführt wird.Das Übergeben von Interrupts kann blockiert und freigegeben sein. Wenn Interruptsblockiert sind, werden auftretende Interrupts in eine Warteschlange eingereiht undkönnen nur nach erneuter Freigabe übergeben werden. Beachten Sie, dass dieInterrupt-Warteschlange mehrere wartende Interrupts enthalten kann. Interruptsin einer Warteschlange werden in der Reihenfolge ihres Auftretens abgearbeitet(FIFO, First In, First Out). Bei der Abarbeitung einer Interrupt-Routine werdenInterrupts stets blockiert.Bei schrittweiser Ausführung und bei Programmstopp werden keine Interruptsbehandelt. Interrupts in einer Warteschlange bei einem Halt werden verworfen,und Interrupts, die während eines Halts erzeugt wurden, werden nicht behandelt.Ausgenommen sind sichere Interrupts, siehe Sicherer Interrupt auf Seite 77.Die maximale Anzahl gleichzeitig definierter Interrupts ist auf 100 proProgrammtask beschränkt.

Grundsätze der ProgrammierungJedem Interrupt wird eine Interrupt-Identität zugewiesen. Er erhält seine Identitätdurch Erstellen einer Variablen (mit dem Datentyp intnum) und der Verbindungder Variablen mit einer Interrupt-Routine.Die Interrupt-Identität (Variable) wird dann verwendet, um einen Interruptanzufordern, d. h. die Ursache des Interrupts anzugeben. Dies kann eines derfolgenden Ereignisse sein:

• Ein Eingang oder Ausgang wurde auf 1 oder 0 gesetzt.• Eine vorgegebene Zeitdauer läuft ab, nachdem ein Interrupt angefordert

wurde.• Eine bestimmte Position wird erreicht.



1 Grundlagen der Programmierung mit RAPID1.11 Interrupts

Ein angeforderter Interrupt wird automatisch aktiviert, kann jedoch vorübergehenddeaktiviert werden. Dies ist auf zwei Arten möglich:

• Alle Interrupts können blockiert werden. Alle Interrupts, die in dieserZeitspanne auftreten, werden in eine Warteschlange eingereiht und dannautomatisch erzeugt, wenn Interrupts wieder freigegeben werden.

• Einzelne Interrupts können deaktiviert werden. Alle Interrupts, die in dieserZeitspanne auftreten, werden ignoriert.

Verbinden von Interrupts mit Interrupt-Routinen


Verbinden einer Variablen (Interrupt-Identität) mit einer Inter-rupt-Routine

CONNECT

Anfordern von Interrupts

Für Anforderung vonInstruktion

Interrupt von einem digitalen EingangssignalISignalDI

Interrupt von einem digitalen AusgangssignalISignalDO

Interrupt von einer Gruppe digitaler EingangssignaleISignalGI

Interrupt von einer Gruppe digitaler AusgangssignaleISignalGO

Interrupt von einem analogen EingangssignalISignalAI

Interrupt von einem analogen AusgangssignalISignalAO

Zeitgesteuerter InterruptITimer

Positionsbedingter Interrupt (aus der Bewegungsauswahlliste)TriggInt

Ein Interrupt beim Ändern einer Persistenten.IPers

Fordert einen Interrupt an und gibt ihn frei, wenn ein Fehlerauftritt

IError

Ein Interrupt, wenn von einer RAPID Message Queue ein an-gegebener Datentyp empfangen wird

IRMQMessage i

i Nur wenn der Roboter mit der Option FlexPendant Interface, PC Interface oder Multitaskingausgestattet ist.

Abbrechen von Interrupts


Abbrechen (Löschen) eines InterruptsIDelete

Freigeben/Blockieren von Interrupts


Deaktivieren eines einzelnen InterruptsISleep

Aktivieren eines einzelnen InterruptsIWatch

Blockieren aller InterruptsIDisable

Freigeben aller InterruptsIEnable



1 Grundlagen der Programmierung mit RAPID1.11 InterruptsFortsetzung

Interruptdaten


Bezieht in einer Interrupt-Routine alle Informationen über denInterrupt, der die Abarbeitung der Interrupt-Routine verursachthat.

GetTrapData

Bezieht in einer Interrupt-Routine numerische Informationen(Domäne, Typ und Nummer) über einen Fehler, eine Statusän-derung oder eine Warnung, die die Abarbeitung der Interrupt-Routine verursacht hat.

ReadErrData

Datentyp von Interrupts

AnwendungDatentyp

Definiert die Identität eines Interrupts.intnum

Enthält die Interruptdaten, die die Abarbeitung der aktuellenInterrupt-Routine ausgelöst haben.

trapdata

Gibt einen Fehlertyp an (Schweregrad des Fehlers).errtype

Fordert einen Interrupt an und gibt ihn frei, wenn ein Fehlerauftritt.

errdomain

Gibt eine Fehlerdomäne an.errdomain

Sicherer InterruptEinige Instruktionen, z. B. ITimer und ISignalDI, können gemeinsam mit sicherenInterrupts verwendet werden. Sichere Interrupts sind Interrupts, die in dieWarteschlange gestellt werden, wenn sie während eines Stopps oder währendeiner schrittweisen Abarbeitung eintreffen. Die Interrupts in der Warteschlangewerden behandelt, sobald die kontinuierliche Abarbeitung beginnt. Ihre Behandlungerfolgt in der Reihenfolge ihres Auftretens (FIFO). Interrupts, die während einesStopps in die Warteschlange gestellt werden, werden ebenfalls behandelt. DieInstruktion ISleep kann nicht gemeinsam mit sicheren Interrupts verwendetwerden.

Handhabung von InterruptsDurch die Definition wird ein Interrupt dem System bekannt gegeben. DieseDefinition gibt die Interrupt-Bedingung an, aktiviert den Interrupt und gibt ihn frei.Beispiel:

VAR intnum sig1int;

ISignalDI di1, high, sig1int;

Ein aktivierter Interrupt kann deaktiviert werden (und umgekehrt).Für die Dauer der Deaktivierung wird jeder neu erzeugte Interrupt des angegebenenTyps ignoriert.Beispiel:

! deactivate

ISleep sig1int;

! activate

IWatch sig1int;




Fortsetzung

Ein blockierter Interrupt kann freigegeben werden (und umgekehrt).Für die Dauer der Blockierung wird jeder neu erzeugte Interrupt des angegebenenTyps in eine Warteschlange gestellt und erst dann abgearbeitet, wenn die Interruptswieder freigegeben sind.Beispiel:

! disable

IDisable sig1int;

1 enable

IEnable sig1int;

Das Löschen eines Interrupts entfernt seine Definition. Es ist nicht erforderlich,eine Interrupt-Definition explizit zu entfernen. Jedoch kann ein neuer Interrupt erstdann mit einer Interrupt-Variablen definiert werden, wenn die vorherige Definitiongelöscht wurde.Beispiel:

IDelete sig1int;

Interrupt-RoutinenInterrupt-Routinen dienen der Behandlung von Unterbrechungen. EineInterrupt-Routine kann mithilfe der Instruktion CONNECT mit einem bestimmtenInterrupt verbunden werden. Beim Auftreten eines Interrupts wird die Steuerungsofort an die zugehörige Interrupt-Routine (falls vorhanden) übergeben. Wenn einInterrupt auftritt, mit dem keine Interrupt-Routine verbunden ist, wird dies alsschwerwiegender Fehler betrachtet, d. h. die Programmabarbeitung wird sofortbeendet.Beispiel:

VAR intnum empty;

VAR intnum full;

PROC main()

! Connect trap routines

CONNECT empty WITH etrap;

CONNECT full WITH ftrap;

! Define feeder interrupts

ISignalDI di1, high, empty;

ISignalDI di3, high, full;

...

! Delete interrupts

IDelete empty;

IDelete full;

ENDPROC

! Responds to “feeder empty” interrupt

TRAP etrap

open_valve;

RETURN;

ENDTRAP

! Responds to “feeder full” interrupt

TRAP ftrap

close_valve;



1 Grundlagen der Programmierung mit RAPID1.11 InterruptsFortsetzung

RETURN;

ENDTRAP

Mehrere Interrupts können mit derselben Interrupt-Routine verbunden sein. DieSystemvariable INTNO enthält die Interrupt-Nummer und kann von derInterrupt-Routine zur Identifizierung eines Interrupts verwendet werden. NachErgreifen der erforderlichen Maßnahme kann eine Interrupt-Routine durch eineRETURN-Instruktion oder bei Erreichen des Endes (ENDTRAP oder ERROR) dieserInterrupt-Routine beendet werden. Die Abarbeitung fährt an der Stelle fort, an derder Interrupt aufgetreten ist.




Fortsetzung

1.12 Fehlerbehebung

EinleitungViele bei der Abarbeitung eines Programms auftretende Fehler können imProgramm behoben werden, d. h. die Programmabarbeitung muss nichtunterbrochen werden. Diese Fehler werden entweder durch das System erkannt(z. B. Division durch Null) oder durch das Programm (z. B. Fehler wie das Einleseneines falschen Werts durch einen Strichcodeleser).Ein Abarbeitungsfehler ergibt eine abnormale Situation hinsichtlich der Abarbeitungeines bestimmten Programmteils. Durch einen Fehler wird die weitere Abarbeitungunmöglich (oder zumindest riskant). “Überlauf“ und „Division durch null“ sindBeispiele für Fehler.

FehlernummernFehler werden durch eine eindeutige Fehlernummer identifiziert und stets durchdas System erkannt. Bei Auftreten eines Fehlers wird die normaleProgrammabarbeitung angehalten und die Steuerung an die Fehlerbehandlungübergeben. Das Konzept der Fehlerbehandlungen ermöglicht, während desProgrammablaufs auf Fehler zu reagieren und sie möglicherweise zu beheben.Wenn eine weitere Abarbeitung nicht möglich ist, stellt die Fehlerbehandlungzumindest sicher, dass das Programm auf geeignete Weise abgebrochen wird.

Grundsätze der ProgrammierungWenn ein Fehler auftritt, wird die Fehlerbehandlungsroutine (falls vorhanden)aufgerufen. Es ist auch möglich, einen Fehler innerhalb des Programms zu erzeugenund dann direkt auf die Fehlerbehandlungsroutine überzugehen.In einer Fehlerbehandlungsroutine können Fehler mithilfe normaler Instruktionenbehandelt werden. Anhand der Systemdaten ERRNO kann der Typ des aufgetretenenFehlers bestimmt werden. Eine Rückkehr von der Fehlerbehandlungsroutine istdann auf verschiedene Arten möglich (RETURN, RETRY, TRYNEXT und RAISE).Wenn die aktuelle Routine keine Fehlerbehandlungsroutine umfasst, wird direktan die Fehlerbehandlungsroutine des Robotersystems übergeben. Die interneFehlerbehandlungsroutine gibt eine Fehlermeldung aus und stoppt dieProgrammabarbeitung mit dem Programmzeiger auf der fehlerhaften Instruktion.

Erzeugen einer Fehlersituation innerhalb der Programminstruktion


Einen Fehler „erzeugen“ und die Fehlerbehandlung aufrufenRAISE

Instruktion zum Vergeben einer Fehlernummer


Eine neue RAPID-Systemfehlernummer vergebenBookErrNo



1 Grundlagen der Programmierung mit RAPID1.12 Fehlerbehebung

Neustart/Rückkehr von der Fehlerbehandlung


Programmabarbeitung stoppen, wenn ein schwerwiegenderFehler auftritt

EXIT

Fehlerbehandlung von der Routine aufrufen, die die aktuelleRoutine aufgerufen hat

RAISE

Erneut die Instruktion abarbeiten, die den Fehler verursachthat

RETRY

Instruktion nach der Instruktion abarbeiten, die den Fehlerverursacht hat

TRYNEXT

Zu der Routine zurückkehren, die die aktuelle Routine aufgeru-fen hat

RETURN

Von einer NOSTEPIN-Routine wird der Fehler auf Benutzere-bene an die Fehlerbehandlung gemeldet.

RaiseToUser

Eine Instruktion, die die beiden Instruktionen StartMove undRETRY ersetzt. Sie nimmt die Bewegung wieder auf und führterneut die Instruktion aus, die den Fehler verursacht hat.

StartMoveRetry

Zuletzt angeforderte Warnmeldung überspringenSkipWarn

Die Anzahl der gezählten Wiederholungen zurücksetzenResetRetryCount

AnwendungFunktion

Restliche Anzahl an WiederholungenRemainingRetries

Generieren eines Prozessfehlers


Eine Fehlermeldung am FlexPendant anzeigen und im Mel-dungsprotokoll des Roboters speichern.

ErrLog

Einen Fehler innerhalb des Programms erzeugen und danndie Fehlerbehandlung der Routine aufrufen

ErrRaise

AnwendungFunktion

Prozessorfehler während der Roboterbewegung generierenProcerrRecovery

Daten für Fehlerbehandlung

AnwendungDatentyp

Ursache des Fehlerserrnum

Text in einer Fehlermeldungerrstr

Konfiguration für Fehlerbehandlung

DefiniertSystemparameter

Anzahl der Wiederholungen einer fehlgeschlagenen Instruktion,wenn die Fehlerbehandlung RETRY verwendet. No Of Retrygehört zum Typ SystemMisc in der Parametergruppe Control-ler.

No Of Retry




Fortsetzung

FehlerbehandlungenJede Routine kann eine Fehlerbehandlung enthalten. Die Fehlerbehandlung isteigentlich ein Teil der Routine, und der Gültigkeitsbereich jeglicher Routinendatenumfasst auch die Fehlerbehandlung. Wenn ein Fehler während der Abarbeitungder Routine auftritt, wird die Steuerung an die Fehlerbehandlung übergeben.Beispiel:

FUNC num safediv( num x, num y)

RETURN x / y;

ERROR

IF ERRNO = ERR_DIVZERO THEN

TPWrite "The number cannot be equal to 0";

RETURN x;

ENDIF

ENDFUNC

Die Systemvariable ERRNO enthält die Fehlernummer des (zuletzt aufgetretenen)Fehlers und kann von der Fehlerbehandlung zur Identifizierung dieses Fehlersverwendet werden. Nachdem die erforderlichen Maßnahmen ergriffen wurden,kann die Fehlerbehandlung:

• die Abarbeitung wieder aufnehmen, beginnend mit der Instruktion, in der derFehler aufgetreten ist. Dies erfolgt mit der Instruktion RETRY. Wenn dieseInstruktion erneut denselben Fehler verursacht, finden bis zu vierFehlerkorrekturen statt. Danach wird die Abarbeitung angehalten. Damitmehr als vier Versuche möglich sind, müssen Sie den Systemparameter NoOf Retry konfigurieren (siehe TechnischesReferenzhandbuch - Systemparameter).

• Die Abarbeitung mit der Instruktion fortsetzen, die auf die Instruktion folgt,in der der Fehler aufgetreten ist. Dies erfolgt mit der Instruktion TRYNEXT.

• Die Steuerung mithilfe der Instruktion RETURN an die aufrufende Routinezurückgeben. Wenn es sich bei der Routine um eine Funktion handelt, mussdie Instruktion RETURN einen geeigneten Rückgabewert enthalten.

• Den Fehler mithilfe der Instruktion RAISE an die aufrufende Routineübergeben.

System-FehlerbehandlungWenn ein Fehler in einer Routine auftritt, die keine Fehlerbehandlung enthält, oderwenn das Ende der Fehlerbehandlung erreicht wurde (ENDFUNC, ENDPROC oderENDTRAP), wird die System-Fehlerbehandlung aufgerufen. DieSystem-Fehlerbehandlung meldet den Fehler und stoppt die Abarbeitung.In einer Folge von Routineaufrufen kann jede Routine ihre eigene Fehlerbehandlungenthalten. Wenn ein Fehler in einer Routine ohne Fehlerbehandlung auftritt undder Fehler explizit mithilfe der Instruktion RAISE übergeben wird, tritt dieser Fehlererneut beim Aufruf der Routine auf – und der Fehler wird weitergegeben. Wennder Beginn einer Aufruffolge (die Einstiegsroutine der Task) erreicht wird, ohnedass eine Fehlerbehandlung gefunden wurde, oder wenn das Ende einer beliebigenFehlerbehandlung innerhalb der Aufruffolge erreicht wird, wird dieSystem-Fehlerbehandlung aufgerufen. Die System-Fehlerbehandlung meldet den



1 Grundlagen der Programmierung mit RAPID1.12 FehlerbehebungFortsetzung

Fehler und stoppt die Abarbeitung. Da das System (als Reaktion auf einen Interrupt)eine Interrupt-Routine aufrufen kann, erfolgt eine etwaige Übergabe eines Fehlersvon einer Interrupt-Routine an die System-Fehlerbehandlung.Eine Fehlerkorrektur ist für Instruktionen in der Rückwärtsbehandlung nichtverfügbar. Solche Fehler werden stets an die System-Fehlerbehandlung übergeben.Es ist nicht möglich, auf Fehler innerhalb einer Fehlerbehandlung gezielt zureagieren. Solche Fehler werden stets an die System-Fehlerbehandlung übergeben.

Vom Programm gemeldete FehlerNeben den durch das Robotersystem ermittelten und gemeldeten Fehlern kannein Programm mithilfe der Instruktion RAISE explizit Fehler melden. DieseInstruktion kann verwendet werden, um komplexe Fehlersituationen zu lösen. Sieermöglicht beispielsweise die Rückkehr aus einer tiefen Verschachtelung vonAufrufen. Fehlernummern 1-90 können mit der Instruktion RAISE verwendet werden.Explizit gemeldete Fehler werden genau so wie Fehler behandelt, die das Systemmeldet.

Das EreignisprotokollFür Fehler, die von einer Fehlerbehandlung behandelt werden, wird dennoch einEintrag in das Ereignisprotokoll geschrieben. Im Ereignisprotokoll können Sienachverfolgen, welche Fehler aufgetreten sind.Wenn ein Fehler behandelt werden soll, ohne dass ein Eintrag im Ereignisprotokollerfolgt, verwenden Sie in der Fehlerbehandlung die Instruktion SkipWarn. Dieskann nützlich sein, wenn Sie mit der Fehlerbehandlung einen Test ausführenmöchten (z. B. ob eine Datei vorhanden ist), ohne Spuren zu hinterlassen, falls derTest fehlschlägt.




Fortsetzung

1.13 UNDO

EinleitungRAPID-Routinen können eine Behandlung UNDO enthalten. Die Behandlung wirdautomatisch ausgeführt, wenn der Programmzeiger aus der Routine heraus bewegtwird. Dies soll dazu beitragen, dass Nebeneffekte nach teilweise abgearbeitetenRoutinen beseitigt werden, z. B. beim Abbruch von modalen Instruktionen (wiedem Öffnen einer Datei). Die meisten Teile der RAPID-Sprache können in einerBehandlung UNDO verwendet werden, jedoch gibt es einige Beschränkungen, z.B. Bewegungsinstruktionen.

TerminologieDie folgenden Begriffe beziehen sich auf UNDO.

• UNDO: Die Abarbeitung des Bereinigungscodes vor einem Zurücksetzendes Programms.

• Behandlung UNDO: Ein optionaler Teil einer RAPID-Prozedur oder -Funktion,die RAPID-Code enthält, der bei einem UNDO abgearbeitet wird.

• Routine UNDO: Eine Prozedur oder Funktion mit einer Behandlung UNDO.• Aufruffolge: Alle Prozeduren oder Funktionen, die derzeit durch noch nicht

abgeschlossene Routinenaufrufe miteinander verbunden sind. Soll in derRoutine Main starten, sofern nicht anders angegeben.

• Kontext UNDO: Wenn die aktuelle Routine einer Aufruffolge angehört, diein einer Behandlung UNDO gestartet wird.

Verwendung von UNDOEine RAPID-Routine kann an einer beliebigen Stelle abgebrochen werden, indemder Programmzeiger aus der Routine bewegt wird. In einigen Fällen ist ein Abbruchnicht empfehlenswert, insbesondere wenn das Programm bestimmte empfindlicheRoutinen abarbeitet. Mithilfe von UNDO können Sie solche empfindlichen Routinenvor einem unerwarteten Zurücksetzen des Programms schützen. Mit UNDO ist esmöglich, dass beim Abbruch der Routine ein bestimmter Code automatischausgeführt wird. Dieser Code sollte in der Regel Bereinigungsaktionen ausführen,z. B. das Schließen einer Datei.

UNDO-Verhalten im EinzelnenWenn UNDO aktiviert wird, werden alle UNDO-Behandlungen in der aktuellenAufruffolge abgearbeitet. Diese Behandlungsroutinen sind optionale Teile einerRAPID-Prozedur oder Funktion, die RAPID-Code enthält. Die aktuell aktivenUNDO-Behandlungen gehören Prozeduren oder Funktionen an, die aufgerufenund noch nicht abgeschlossen wurden, d. h. den Routinen in der aktuellenAufruffolge.UNDO wird aktiviert, wenn der Programmzeiger unerwartet aus einer UNDO-Routineheraus bewegt wird, z. B. wenn der Benutzer den Programmzeiger in Mainverschiebt. UNDO wird auch beim Abarbeiten einer EXIT-Instruktion gestartet, umdas Programm zurückzusetzen, oder wenn das Programm aus einem anderenGrund zurückgesetzt wird, etwa beim Ändern der Konfiguration oder beim Löschen



1 Grundlagen der Programmierung mit RAPID1.13 UNDO

des Programms oder Moduls. UNDO wird jedoch nicht gestartet, wenn dasProgramm das Ende der Routine oder eine RETURN-Instruktion erreicht, und dasProgramm kehrt wie gewöhnlich aus der Routine zurück.Wenn die Aufruffolge mehrere UNDO-Routinen enthält, werden dieUNDO-Behandlungen der Routinen in derselben Reihenfolge verarbeitet, in derdie Routinen in das Hauptprogramm zurückgekehrt wären (von unten nach oben).Die UNDO-Behandlung mit dem geringsten Abstand zum Ende der Aufruffolgewird zuerst abgearbeitet, und diejenige mit dem geringsten Abstand zu Main wirdzuletzt abgearbeitet.

EinschränkungenEine UNDO-Behandlung kann auf jede Variable und jedes Symbol zugreifen, dasvom normalen Routinenbereich aus erreichbar ist, einschließlich auf lokal deklarierteVariablen. RAPID-Code, der in UNDO-Kontext ausgeführt werden soll, unterliegtjedoch bestimmten Beschränkungen.Eine UNDO-Behandlung darf nicht STOP, BREAK, RAISE oder RETURN enthalten.Wenn versucht wird, eine dieser Instruktionen im UNDO-Kontext zu verwenden,wird die Instruktion ignoriert und eine ELOG-Warnung generiert.Bewegungsinstruktionen, z. B. MoveL, sind im UNDO-Kontext ebenfalls untersagt.Die Abarbeitung in UNDO verläuft immer kontinuierlich, schrittweise Abarbeitungist nicht möglich. Wenn UNDO startet, wird der Abarbeitungsmodus automatischauf kontinuierlich eingestellt. Nach Beendigung des UNDO-Vorgangs wird wiederder vorherige Abarbeitungsmodus eingestellt.Falls das Programm bei der Abarbeitung einer UNDO-Behandlung gestoppt wird,unterbleibt der Rest der Behandlung. Wenn die Aufruffolge weitere noch nichtabgearbeitete UNDO-Behandlungen enthält, werden diese ebenfalls ignoriert. Dieshat eine ELOG-Warnung zur Folge. Dazu gehört auch ein Stopp wegen einesLaufzeitfehlers.Der Programmzeiger ist in einer UNDO-Behandlung nicht sichtbar. Bei derAbarbeitung von UNDO bleibt der Programmzeiger an seiner vorherigen Position,wird aber nach Beendigung der UNDO-Behandlung(en) aktualisiert.Eine EXIT-Instruktion bricht UNDO auf ähnliche Weise ab wie ein Laufzeitfehleroder ein Stop. Die übrigen UNDO-Behandlungen werden ignoriert und derProgrammzeiger wird in Main verschoben.

Beispiel:Programm:

PROC B

TPWrite "In Routine B";

Exit;

UNDO

TPWrite "In UNDO of routine B";

ENDPROC

PROC A

TPWrite "In Routine A";



1 Grundlagen der Programmierung mit RAPID1.13 UNDOFortsetzung

B;

ENDPROC

PROC main

TPWrite "In main";

A;

UNDO

TPWrite "In UNDO of main";

ENDPROC

Ausgabe:In main

In Routine A

In Routine B

In UNDO of routine B

In UNDO of main

xx1100000588



1 Grundlagen der Programmierung mit RAPID1.13 UNDOFortsetzung

1.14 System und Zeit

BeschreibungSystem- und Zeitinstruktionen gestatten dem Anwender, Zeit zu messen, zukontrollieren und aufzuzeichnen.

Grundsätze der ProgrammierungClock-Instruktionen ermöglichen dem Anwender, Uhren als Stoppuhren zuverwenden. Auf diese Weise kann das Roboterprogramm jedes gewünschte Ereigniszeitlich steuern.Aktuelle Zeit und aktuelles Datum können als Zeichenfolge abgerufen werden.Diese Zeichenfolge lässt sich dann dem Bediener am FlexPendant anzeigen oderals Zeit- und Datumsstempel in Protokolldateien verwenden.Es ist auch möglich, Komponenten der aktuellen Systemzeit als numerischen Wertabzurufen. Damit kann das Roboterprogramm eine Aktion zu einem bestimmtenZeitpunkt oder Wochentag ausführen.

Zeitliches Festlegen eines Ereignisses mit einer Uhr


Zurücksetzen einer Uhr, die für die Zeitsteuerung verwendetwird

ClkReset

Starten einer Uhr, die für die Zeitsteuerung verwendet wirdClkStart

Stoppen einer Uhr, die für die Zeitsteuerung verwendet wirdClkStop

AnwendungFunktion

Lesen einer Uhr, die für die Zeitsteuerung verwendet wirdClkRead

AnwendungDatentyp

Zeitsteuerung – speichert eine gemessene Dauer in Sekundenclock

Lesen der aktuellen Uhrzeit und des aktuellen Datums

AnwendungFunktion

Lesen des aktuellen Datums als ZeichenfolgeCDate

Lesen der aktuellen Uhrzeit als ZeichenfolgeCTime

Lesen der aktuellen Uhrzeit als numerischer WertGetTime

Abrufen der Zeitinformationen aus einer Datei

AnwendungFunktion

Abrufen des letzten Zeitpunkts einer DateiänderungFileTimeDnum

Abrufen des Dateiänderungszeitpunkts für das geladene ModulModTimeDnum

Überprüfen, ob ein Programmmodul vorhanden ist.ModExist



1 Grundlagen der Programmierung mit RAPID1.14 System und Zeit

Abrufen der Größe des freien Programmspeichers

AnwendungFunktion

Abrufen der Größe des freien ProgrammspeichersProgMemFree



1 Grundlagen der Programmierung mit RAPID1.14 System und ZeitFortsetzung

1.15 Mathematik

BeschreibungMathematische Instruktionen und Funktionen dienen der Berechung und demÄndern des Werts von Daten.

Grundsätze der ProgrammierungBerechnungen erfolgen normalerweise mithilfe der Zuweisungsinstruktion, z. B.reg1:= reg2 + reg3 / 5. Es gibt auch einige Instruktionen für einfacheBerechnungen, z. B. das Löschen einer numerischen Variablen.

Einfache Berechnungen mit numerischen Daten


Löscht den Wert.Clear

Addiert oder subtrahiert einen Wert.Add

Erhöhung um 1Incr

Verringerung um 1Decr

Komplexere Berechnungen


Durchführen von Berechnungen mit beliebigen Datentypen.:=

Arithmetische Funktionen

AnwendungFunktion

Berechnet den absoluten Wert.Abs

Berechnet den absoluten Wert.AbsDnum

Rundet einen numerischen Wert.Round

Rundet einen numerischen Wert.RoundDnum

Schneidet einen numerischen Wert ab.Trunc

Schneidet einen numerischen Wert ab.TruncDnum

Gibt den größten von zwei Werten zurück.Max

Gibt den kleinsten von zwei Werten zurück.Min

Berechnet die Quadratwurzel.Sqrt

Berechnet die Quadratwurzel.SqrtDnum

Berechnet den Exponentialwert zur Basis e.Exp

Berechnet den Exponentialwert zu einer beliebigen Basis.Pow

Berechnet den Exponentialwert zu einer beliebigen Basis.PowDnum

Berechnet den Cosinus.ACos

Berechnet den Cosinus.ACosDnum

Berechnet den Arcussinus.ASin



1 Grundlagen der Programmierung mit RAPID1.15 Mathematik

AnwendungFunktion

Berechnet den Arcussinus.ASinDnum

Berechnet den Arcustangens im Bereich [-90,90].ATan

Berechnet den Arcustangens im Bereich [-90,90].ATanDnum

Berechnet den Arcustangens im Bereich [-180,180].ATan2

Berechnet den Arcustangens im Bereich [-180,180].ATan2Dnum

Berechnet den Cosinus.Cos

Berechnet den Cosinus.CosDnum

Berechnet den Sinus.Sin

Berechnet den Sinus.SinDnum

Berechnet den Tangens.Tan

Berechnet den Tangens.TanDnum

Berechnet Eulersche Winkel aus einer Orientierung.EulerZYX

Berechnet die Orientierung aus Eulerschen Winkeln.OrientZYX

Invertiert eine Koordinatenverschiebung.PoseInv

Multipliziert Koordinatenverschiebungen.PoseMult

Multipliziert eine Koordinatenverschiebung mit einem Vektor.PoseVect

Berechnet die Länge eines pos-Vektors.VectMagn

Berechnet das Skalarprodukt von zwei pos-Vektoren.DotProd

Das Kreuz- (oder Vektor-) Produkt zweier Positionsvektorenberechnen.

CrossProd

Normalisiert eine nichtnormalisierte Orientierung (Quarternion).NOrient

Funktionen für Zeichenfolgen und Ziffern

AnwendungFunktion

Numerischer Vergleich von zwei Zeichenfolgen, die nur ausZiffern bestehen.

StrDigCmp

Arithmetische Operationen mit zwei Zeichenfolgen, die nur ausZiffern bestehen.

StrDigCalc

AnwendungDatentyp

Zeichenfolge, die nur Ziffern enthältstringdig

Bit-Funktionen


Löscht ein angegebenes Bit in definierten byte- oder dnum-Daten.

BitClear

Setzt ein angegebenes Bit auf 1 in definierten byte- oder dnum-Daten.

BitSet



1 Grundlagen der Programmierung mit RAPID1.15 MathematikFortsetzung

AnwendungFunktion

Prüft, ob ein angegebenes Bit in definierten byte-Daten auf 1gesetzt ist.

BitCheck

Prüft, ob ein angegebenes Bit in definierten dnum-Daten auf1 gesetzt ist.

BitCheckDnum

Arbeitet eine logische bitweise AND-Operation an byte-Datenab.

BitAnd

Arbeitet eine logische bitweiseAND-Operation an dnum-Datenab.

BitAndDnum

Arbeitet eine logische bitweise NEGATION-Operation an byte-Daten ab.

BitNeg

Arbeitet eine logische bitweise NEGATION-Operation an dnum-Daten ab.

BitNegDnum

Arbeitet eine logische bitweise OR-Operation an byte-Datenab.

BitOr

Arbeitet eine logische bitweise OR-Operation an dnum-Datenab.

BitOrDnum

Arbeitet eine logische bitweise XOR-Operation an byte-Datenab.

BitXOr

Arbeitet eine logische bitweise XOR-Operation an dnum-Datenab.

BitXOrDnum

Arbeitet eine logische bitweise LEFT SHIFT -Operation an byte-Daten ab.

BitLSh

Arbeitet eine logische bitweise LEFT SHIFT -Operation andnum-Daten ab.

BitLShDnum

Arbeitet eine logische bitweise RIGHT SHIFT -Operation anbyte-Daten ab.

BitRSh

Arbeitet eine logische bitweise RIGHT SHIFT -Operation andnum-Daten ab.

BitRShDnum

AnwendungDatentyp

Wird mit Instruktionen und Funktionen für die Bitbearbeitungverwendet. (8 Bits).

byte

Wird mit Instruktionen und Funktionen für die Bitbearbeitungverwendet. (52 Bits).

dnum

Matrix-Funktionen


Lösen linearer Gleichungssysteme in der Form A*x=b.MatrixSolve

Berechnen einer QR-Faktorisierung einer (m x n) Matrix A.MatrixSolveQR

Berechnen einer Einzelwertzerlegung (Singular Value Decom-position, SVD).

MatrixSVD



1 Grundlagen der Programmierung mit RAPID1.15 Mathematik

Fortsetzung

1.16 Kommunikation mit einem externen Computer

BeschreibungDer Roboter kann durch einen übergeordneten Computer gesteuert werden. Indiesem Fall wird ein spezielles Kommunikationsprotokoll für die Übertragung vonInformationen benutzt.

Grundsätze der ProgrammierungDie Informationen zwischen Roboter und Computer werden über ein gemeinsamesKommunikationsprotokoll übertragen. Der Roboter und der Computer könneneinander ohne Programmierung verstehen. Der Computer kann z. B. Werte in denProgrammdaten ändern, ohne dass eine Programmierung erforderlich ist (außerzur Definition dieser Daten). Eine Programmierung ist nur nötig, wennprogrammgesteuerte Informationen vom Robotersystem an den übergeordnetenComputer gesendet werden müssen.

Senden einer programmgesteuerten Meldung vom Roboter an einen Computer


Senden einer Meldung an den übergeordneten ComputerSCWrite i

i Nur wenn der Roboter mit der Option PC interface/backup ausgestattet ist.



1 Grundlagen der Programmierung mit RAPID1.16 Kommunikation mit einem externen Computer

1.17 Funktionen für Dateioperationen

Instruktionen


Erstellen eines neuen VerzeichnissesMakeDir

Löschen eines VerzeichnissesRemoveDir

Öffnen eines Verzeichnisses für die weitere UntersuchungOpenDir

Schließen eines Verzeichnisses, das mit OpenDir geöffnetwurde.

CloseDir

Löschen einer DateiRemoveFile

Umbenennen einer DateiRenameFile

Kopieren einer DateiCopyFile

Funktionen

AnwendungFunktion

Prüfen des DateitypsISFile

Abrufen der Größe eines DateisystemsFSSize

Abrufen der Größe einer angegebenen DateiFileSize

Lesen des nächsten Eintrags in einem VerzeichnisReadDir

Datentypen

AnwendungDatentyp

Durchlaufen von Verzeichnisstrukturendir



1 Grundlagen der Programmierung mit RAPID1.17 Funktionen für Dateioperationen

1.18 Instruktionen zur Unterstützung von RAPID

BeschreibungVerschiedene Funktionen zur Unterstützung der Programmiersprache RAPID:

• Abrufen von Systemdaten• Lesen von Konfigurationsdaten• Schreiben von Konfigurationsdaten• Neustarten der Steuerung• Testen von Systemdaten• Abrufen von Objektnamen• Abrufen von Tasknamen• Suchen nach Symbolen• Abrufen des aktuellen Ereignistyps, der aktuellen Abarbeitungsbehandlung

oder Abarbeitungsebene• Lesen von Serviceinformationen

Abrufen von SystemdatenDiese Instruktion ruft den Wert und (optional) den Symbolnamen für die aktuellenSystemdaten des angegebenen Typs ab.


Daten und Name des derzeit aktiven Werkzeugs oder Werkob-jekts abrufen.

GetSysData

Setzt den Status für den im Einrichtbetrieb verschobenenProgrammzeiger zurück.

ResetPPMoved

Aktiviert einen angegebenen Systemdatennamen für einenangegebenen Datentyp.

SetSysData

AnwendungFunktion

Testet die Systemidentität.IsSysID

Informationen über die Bewegung des Programmzeigers (PZ)abrufen.

IsStopStateEvent

Überprüft, ob der Programmzeiger im Einrichtbetrieb verscho-ben wurde.

PPMovedInManMode

Prüft, ob die Abarbeitung am Robot Controller (RC) oder VirtualController (VC) erfolgt.

RobOS

Abrufen von Informationen über das SystemFunktion zum Abrufen von Informationen über Seriennummer, Software-Version,Robotertyp, LAN-IP-Adresse oder Steuerungssprache

AnwendungFunktion

Abrufen von Informationen über das SystemGetSysInfo



1 Grundlagen der Programmierung mit RAPID1.18 Instruktionen zur Unterstützung von RAPID

Abrufen von Informationen über den Speicher

AnwendungFunktion

Abrufen der Größe des freien ProgrammspeichersProgMemFree

Lesen von KonfigurationsdatenDiese Instruktion liest ein Attribut eines angegebenen Systemparameters.


Liest ein Attribut eines angegebenen Systemparameters.ReadCfgData

Schreiben von KonfigurationsdatenDiese Instruktion schreibt ein Attribut eines angegebenen Systemparameters.


Schreibt ein Attribut eines angegebenen Systemparameters.WriteCfgData

Speichern von KonfigurationsdatenInstruktion zum Speichern des Systemparameters in einer Datei.


Speichert Systemparameter in einer DateiSaveCfgData

Neustarten der Steuerung


Führt einen Warmstart der Steuerung durch, beispielsweisewenn Sie Systemparameter von RAPID geändert haben.

WarmStart

Instruktionen für Texttabellen


Installiert eine Texttabelle im System.TextTabInstall

AnwendungFunktion

Ruft die Nummer einer anwenderdefinierten Texttabelle ab.TextTabGet

Ruft eine Zeichenfolge aus den Systemtexttabellen ab.TextGet

Testet, ob der Name der Texttabelle (Textressourcen-Zeichen-folge) verwendet werden kann.

TextTabFreeToUse

Abrufen von ObjektnamenDiese Instruktion ruft den Namen eines originalen Datenobjekts für ein aktuellesArgument oder aktuelle Daten ab.


Gibt den Namen des originalen Datenobjekts zurück.ArgName




Fortsetzung

Abrufen von Informationen über die Tasks

AnwendungFunktion

Ruft die Identität der aktuellen Programmtask samt ihrem Na-men und ihrer Nummer ab.

GetTaskName

Abrufen der Nummer der aktuellen BewegungsplanungMotionPlannerNo

Prüfen Sie, ob eine Task ausgeführt wirdTaskIsExecuting

Abrufen des aktuellen Ereignistyps, der aktuellen Abarbeitungsbehandlung oder Abarbeitungsebene

AnwendungFunktion

Den aktuellen Ereignisroutinentyp abrufenEventType

Ruft den Typ der Abarbeitungsbehandlung ab.ExecHandler

Ruft die Abarbeitungsebene ab.ExecLevel

AnwendungDatentyp

Typ der Ereignisroutine.event_type

Typ der Abarbeitungsbehandlunghandler_type

Abarbeitungsebeneexec_level

Rufen Sie den aktuellen Status des Taskauswahlfeldes für eine Programmtask ab.

AnwendungFunktion

Rufen Sie den aktuellen Status des Taskauswahlfeldes abGetTSPStatus

Prüfen Sie, ob eine normale Task aktiv istTaskIsActive

AnwendungDatentyp

Status des Taskauswahlfeldestsp_status

Suchen nach SymbolenMit diesen Instruktionen werden Datenobjekte im System gesucht.


Einen neuen Wert für alle Datenobjekte eines bestimmten Typssetzen, die einer vorgegebenen Grammatik entsprechen

SetAllDataVal

Zusammen mit GetNextSym können Datenobjekte aus demSystem abgerufen werden.

SetDataSearch

Ruft einen Wert von einem Datenobjekt ab, das mit einer Zei-chenfolgenvariablen angegeben ist.

GetDataVal

Einen Wert für ein Datenobjekt setzen, das mit einer Zeichen-folgenvariablen angegeben ist.

SetDataVal

AnwendungFunktion

Zusammen mit SetDataSearch können Datenobjekte ausdem System abgerufen werden.

GetNextSym



1 Grundlagen der Programmierung mit RAPID1.18 Instruktionen zur Unterstützung von RAPIDFortsetzung

AnwendungDatentyp

Enthält Informationen darüber, wo ein bestimmtes Objekt imSystem definiert ist.

datapos

Lesen von Serviceinformationen


Serviceinformationen aus dem System lesen.GetServiceInfo




Fortsetzung

1.19 Kalibrierung und Service

BeschreibungEine Reihe von Instruktionen stehen für Kalibrierung und Test des Robotersystemszur Verfügung.

Kalibrierung des Werkzeugs


Drehung eines sich bewegenden Werkzeugs kalibrierenMToolRotCalib

Werkzeugarbeitspunkt (TCP) eines sich bewegenden Werk-zeugs kalibrieren

MToolTCPCalib

Werkzeugarbeitspunkt (TCP) und Drehung eines stationärenWerkzeugs kalibrieren

SToolRotCalib

Werkzeugarbeitspunkt (TCP) eines stationären Werkzeugskalibrieren

SToolTCPCalib

Verschiedene Kalibrierungsmethoden

AnwendungFunktion

Anwender-Koordinatensystem für eine Rotationsachse berech-nen

CalcRotAxisFrame

Anwender-Koordinatensystem für eine Rotationsachse berech-nen, wenn sich der Master-Roboter und die externe Achse inunterschiedlichen RAPID-Tasks befinden.

CalcRotAxFrameZ

Definiert ein Koordinatensystem aus ursprünglichen Positionenund verschobenen Positionen.

DefAccFrame

Wertzuweisung an das Prüfsignal des RobotersystemsEin Referenzsignal, z. B. eine Motordrehzahl, kann einem analogen Ausgangssignalan der Rückwand des Robotersystems zugewiesen werden.


Definieren eines PrüfsignalsTestSignDefine

Alle Prüfsignaldefinitionen zurücksetzenTestSignReset

AnwendungFunktion

Lesen eines PrüfsignalwertsTestSignRead

AnwendungDatentyp

Zum Programmieren der Instruktion TestSignDefinetestsignal



1 Grundlagen der Programmierung mit RAPID1.19 Kalibrierung und Service

Aufzeichnen einer AbarbeitungDie aufgezeichneten Daten werden zur späteren Analyse in einer Datei gespeichertund sind zur Fehlersuche in RAPID-Programmen insbesondere fürMultitasking-Systeme gedacht.


Aufzeichnung von Instruktions- und Zeitdaten während derAbarbeitung starten

SpyStart

Aufzeichnung von Instruktions- und Zeitdaten während derAbarbeitung stoppen

SpyStop



1 Grundlagen der Programmierung mit RAPID1.19 Kalibrierung und Service

Fortsetzung

1.20 Zeichenfolgenfunktionen

BeschreibungZeichenfolgefunktionen werden für Vorgänge mit Zeichenfolgen verwendet, z. B.Kopieren, Verketten, Vergleichen, Suchen, Konvertieren usw.

Grundlegende Abläufe

AnwendungDatentyp

Zeichenfolge.string

Vordefinierte Konstanten STR_DIGIT, STR_UPPER, STR_LOWERund STR_WHITE.

AnwendungInstruktion/Operator

Zuweisen eines Werts (Kopie der Zeichenfolge):=

Zeichenfolgenverkettung+

AnwendungFunktion

Länge der Zeichenfolge abrufenStrLen

Teil der Zeichenfolge abrufenStrPart

Vergleich und Suche

AnwendungOperator

Auf Gleichheit überprüfen=

Auf Ungleichheit überprüfen<>

AnwendungFunktion

Prüfen, ob Zeichen einer Zeichenmenge angehörtStrMemb

Suchen nach Zeichen in einer ZeichenfolgeStrFind

Suchen nach Muster in einer ZeichenfolgeStrMatch

Prüfen, ob Zeichenfolgen geordnet sindStrOrder

Konvertierung

AnwendungFunktion

Konvertiert einen numerischen dnum-Wert in einen numeri-schen num-Wert

DnumToNum

Numerischen Wert in eine Zeichenfolge konvertierenDnumToStr

Konvertiert einen numerischen num-Wert in einen numerischendnum-Wert

NumToDnum

Numerischen Wert in eine Zeichenfolge konvertierenNumToStr

Wert in eine Zeichenfolge konvertierenValToStr

Zeichenfolge in einen Wert konvertierenStrToVal

Zeichenfolge zuordnenStrMap

Zeichenfolge in Byte konvertierenStrToByte



1 Grundlagen der Programmierung mit RAPID1.20 Zeichenfolgenfunktionen

AnwendungFunktion

Byte in Zeichenfolgendaten konvertierenByteToStr

Zahl, die in einer lesbaren Zeichenfolge mit der Basis 10 ange-geben ist, in die Basis 16 konvertieren

DecToHex

Zahl, die in einer lesbaren Zeichenfolge mit der Basis 16 ange-geben ist, in die Basis 10 konvertieren

HexToDec



1 Grundlagen der Programmierung mit RAPID1.20 Zeichenfolgenfunktionen

Fortsetzung

1.21 Multitasking

BeschreibungDie Ereignisse in einer Roboterstation erfolgen häufig parallel, warum sind danndie Programme nicht parallel?MultitaskingRAPID ist eine Möglichkeit, Programme (pseudo-) parallel abzuarbeiten.Ein paralleles Programm kann in den Vordergrund oder Hintergrund eines anderenProgramms gestellt werden. Es kann sich auch auf der gleichen Ebene wie einanderes Programm befinden.Informationen über alle Einstellungen finden Sie im TechnischesReferenzhandbuch - Systemparameter.

EinschränkungenEs bestehen einige Einschränkungen bei der Benutzung von Multitasking RAPID.

• Mischen Sie parallele Programme nicht mit einem SPS. Die Reaktionszeitist dieselbe wie die Interrupt-Antwortzeit für eine Task. Dies trifft nur dannzu, wenn die Task nicht im Hintergrund eines anderen aktiven Programmsabläuft.

• Beim Ausführen einer Wait-Instruktion im Einrichtbetrieb wird nach 3Sekunden ein Simulationsfeld angezeigt. Dies tritt nur in einerNORMAL-Taskauf.

• Bewegungsinstruktionen können nur in der Bewegungstask abgearbeitetwerden (Informationen zur Taskbindung zu Programminstanz 0 finden Sieim Technisches Referenzhandbuch - Systemparameter).

• Die Abarbeitung einer Task stoppt, während andere Tasks auf dasDateisystem zugreifen, d. h. wenn der Bediener ein Programm speichert oderöffnet oder wenn das Programm in einer Task dieLade-/Lösch-/Lese-/Schreib-Instruktion verwendet.

• Das FlexPendant kann nur auf NORMAL-Tasks zugreifen. Daher kann dieEntwicklung von RAPID-Programmen für SEMISTATIC - oder STATIC-Tasksnur erfolgen, wenn der Code in die NORMAL-Task geladen wird, oder siemüssen offline programmiert werden.

GrundlagenZur Nutzung dieser Funktion muss das Robotersystem mit einer zusätzlichen TASKfür jedes zusätzliche Programm konfiguriert werden. Tasks können vom TypNORMAL, STATIC oder SEMISTATIC sein.Bis zu 20 verschiedene Tasks können pseudoparallel ablaufen. Jede Task bestehtwie das normale Programm aus einer Reihe von Modulen. Alle Module in einerTask sind lokal.In jeder Task sind Variablen, Konstanten und Persistenten lokal, jedoch nichtglobale Persistenten. Eine Persistente ist standardmäßig als global definiert, wennsie nicht als LOCAL oder TASK deklariert wird. Auf eine globale Persistente mitdemselben Namen und Typ kann in allen Tasks zugegriffen werden, in denen siedeklariert ist. Wenn zwei globale Persistenten denselben Namen aufweisen, ihr



1 Grundlagen der Programmierung mit RAPID1.21 Multitasking

Typ oder ihr Umfang (Datenfelddimension) jedoch unterschiedlich ist, tritt einLaufzeitfehler auf.Eine Task verfügt über eine eigene Interrupt-Behandlung, und die Ereignisroutinenwerden nur für den eigenen Systemstatus (z. B. Start/Stopp/Neustart...) ausgelöst.

Allgemeine Instruktionen und Funktionen


Mehrere Programmtasks an einem bestimmten Punkt in jedemProgramm synchronisieren

WaitSyncTask i

i Wenn der Roboter mit der Option MultiTasking ausgestattet ist.

AnwendungFunktion

Exklusive Rechte für spezielle Bereiche des RAPID-Codesoder Systemressourcen abrufen (Typ Benutzerabfrage)

TestAndSet

Exklusive Rechte für spezielle Bereiche des RAPID-Codesoder Systemressourcen abrufen (Typ Interrupt-Steuerung)

WaitTestAndSet

Prüfen, ob die Programmtask eine mechanische Einheit steuert.TaskRunMec

Prüfen, ob die Programmtask einen TCP-Roboter steuertTaskRunRob

Abrufen des Namens der mechanischen EinheitGetMecUnitName

AnwendungDatentyp

Verfügbare Programmtasks im System identifizierentaskid

Den Namen eines Synchronisierungspunkts angebensyncident

Mehrere RAPID-Programmtasks angebentasks

MultiMove-System mit koordinierten Robotern


Sequenz von synchronisierten Bewegungen startenSyncMoveOn i

Synchronbewegungen beendenSyncMoveOff

Synchronbewegungen zurücksetzenSyncMoveUndo

i Wenn der Roboter mit der Option MultiMove Coordinated ausgestattet ist.

AnwendungFunktion

Mitteilen, ob die aktuelle Task in synchronisiertem Modus istIsSyncMoveOn

Gibt die Anzahl synchronisierter Tasks zurück.TasksInSync

AnwendungDatentyp

Den Namen eines Synchronisierungspunkts angebensyncident i

Mehrere RAPID-Programmtasks angebentasks

Identität für Bewegungsinstruktionenidentno

i Wenn der Roboter mit der Option MultiTasking ausgestattet ist.




Fortsetzung

Synchronisieren der TasksIn vielen Anwendungen überwacht eine Parallel-Task eine Station völlig unabhängigvon den anderen Tasks, die abgearbeitet werden. In solchen Fällen ist keinSynchronisierungsmechanismus erforderlich. Jedoch gibt es andere Anwendungen,die wissen müssen, welche Aktion beispielsweise die Main-Task ausführt.

Synchronisierung mithilfe des AbfragebetriebsDies ist zwar die einfachste Methode, aber die Verarbeitungsgeschwindigkeit istam langsamsten. Persistente Variablen werden gemeinsam mit der InstruktionWaitUntil, IF, WHILE oder GOTO verwendet.Bei der Verwendung der Instruktion WaitUntil wird alle 100 ms eine interneAbfrage ausgeführt. Führen Sie in anderen Implementierungen keine häufigerenAbfragen durch.

Beispiel:TASK 1:

MODULE module1

PERS bool startsync:=FALSE;

PROC main()

startsync:= TRUE;

ENDPROC

ENDMODULE

TASK 2:MODULE module2


PROC main()

WaitUntil startsync;

ENDPROC

ENDMODULE

Synchronisierung mithilfe eines InterruptsDie Instruktionen SetDO und ISignalDO werden verwendet.

Beispiel:TASK 1:

MODULE module1

PROC main()

SetDO do1,1;

ENDPROC

ENDMODULE


VAR intnum isiint1;

PROC main()

CONNECT isiint1 WITH isi_trap;

ISignalDO do1, 1, isiint1;

WHILE TRUE DO

WaitTime 200;



1 Grundlagen der Programmierung mit RAPID1.21 MultitaskingFortsetzung

ENDWHILE

IDelete isiint1;

ENDPROC

TRAP isi_trap

.

ENDTRAP

ENDMODULE

Kommunikation zwischen den TasksAlle Typen von Daten können zwischen zwei (oder mehr) Tasks mitglobal-persistenten Variablen übertragen werden.Eine global-persistente Variable ist global in allen Tasks. Die persistente Variablemuss in allen Tasks, die sie deklarieren, denselben Typ und dieselbe Größe(Datenfeldgröße) aufweisen. Andernfalls tritt ein Laufzeitfehler auf.

Beispiel:TASK 1:

MODULE module1


PERS string stringtosend:=””;

PROC main()

stringtosend:=”this is a test”;

startsync:= TRUE

ENDPROC

ENDMODULE



PERS string stringtosend:=””;

PROC main()

WaitUntil startsync;

!read string

IF stringtosend = “this is a test” THEN

...

ENDIF

ENDPROC

ENDMODULE

TasktypenTasks können vom Typ NORMAL, STATIC oder SEMISTATIC sein.STATIC - und SEMISTATIC-Tasks werden in der Systemstartsequenz gestartet.Wenn die Task vom Typ STATIC ist, wird sie an der aktuellen Position neu gestartet(an der der PZ sich beim Abschalten des Systems befand). Wenn aber der Typ auf




Fortsetzung

SEMISTATIC eingestellt ist, wird die Task bei jedem Einschalten von Anfang anneu gestartet und Module, die in den Systemparametern angegeben sind, werdenneu geladen, wenn die Moduldatei neuer als das geladene Modul ist.Tasks des Typs NORMAL werden beim Start nicht gestartet. Sie werden aufherkömmliche Art, z. B. über das FlexPendant, gestartet.

PrioritätenDie einzige Möglichkeit, die Tasks standardmäßig auszuführen, besteht darin, alleTasks auf derselben Ebene umlaufend (ein Basisschritt für jede Instanz)abzuarbeiten. Die Priorität einer Task kann aber geändert werden, indem die Taskin den Hintergrund einer anderen Task gestellt wird. Der Hintergrund wird dannnur abgearbeitet, wenn der Vordergrund auf Ereignisse wartet oder die Abarbeitunggestoppt hat (im Leerlauf ist). Ein Roboterprogramm mit Bewegungsinstruktionenbefindet sich meistens im Leerlauf.Nachstehendes Beispiel beschreibt einige Situationen, in denen das System 10Tasks enthält (siehe Abbildung 9).Umlaufkette 1: Task 1, 2 und 9 sind aktiv.Umlaufkette 2: Task 1, 4, 5, 6 und 9 sind aktiv, Task 2 und 3 sind im Leerlauf.Umlaufkette 3: Task 3, 5 und 6 sind aktiv, Task 1, 2, 9 und 10 sind im Leerlauf.Umlaufkette 4: Task 7 und 8 sind aktiv, Task 1, 2, 3, 4, 5, 6, 9 und 10 sind imLeerlauf.

xx1100000589

Abbildung 9: Die Tasks können unterschiedliche Prioritäten haben



1 Grundlagen der Programmierung mit RAPID1.21 MultitaskingFortsetzung

TrustLevelTrustLevel behandelt das Systemverhalten, wenn eine Task des TypsSEMISTATICoder STATIC angehalten wird oder nicht abgearbeitet werden kann.

• SysFail – Dies ist das Standardverhalten. Alle anderen Tasks des TypsNORMALwerden ebenfalls angehalten, und das System wird auf den StatusSYS_FAIL gesetzt. Alle Befehle zum manuellen Bewegen und Programmstartwerden abgewiesen. Nur ein neuer Warmstart kann das System zurücksetzen.Diese Einstellung sollte nur verwendet werden, wenn die TaskSicherheitsüberwachungen ausführt.

• SysHalt – Alle Tasks vom Typ NORMAL werden angehalten. Das Systemwird erzwungenermaßen in den Zustand „Motoren aus“ versetzt. Wenn dasSystem sich wieder im Zustand „Motoren ein“ befindet, kann der Robotermanuell bewegt werden, aber ein neuer Versuch, das Programm zu starten,wird zurückgewiesen. Ein neuer Warmstart setzt das System zurück.

• SysStop – Alle Tasks vom Typ NORMAL werden angehalten, können aberneu gestartet werden. Das manuelle Bewegen des Roboters ist ebenfallsmöglich.

• NoSafety – Nur die aktuelle Task wird gestoppt.Siehe Technisches Referenzhandbuch - Systemparameter, ParametergruppeController, Typ Task.

EmpfehlungBei der Festlegung von Taskprioritäten ist Folgendes zu beachten:

• Verwenden Sie bei Überwachungs-Tasks stets den Interrupt-Mechanismusoder Schleifen mit Verzögerungen. Anderenfalls erhält das FlexPendant niegenügend Zeit, um mit dem Anwender zu interagieren. Und wenn sich dieÜberwachungs-Task im Vordergrund befindet, erlaubt sie nie die Abarbeitungeiner anderen Task im Hintergrund.




Fortsetzung

1.22 Rückwärtsabarbeitung

BeschreibungEin Programm kann Instruktion für Instruktion rückwärts abgearbeitet werden. Diefolgenden allgemeinen Einschränkungen gelten für die Rückwärtsabarbeitung:

• Eine Rückwärtsabarbeitung aus einer IF, FOR, WHILE und TEST-Instruktionheraus ist nicht möglich.

• Nach Erreichen des Routinenbeginns ist es nicht möglich, rückwärts aus derRoutine auszusteigen.

• Instruktionen für Bewegungseinstellungen und einige andere Instruktionen,die Bewegungen beeinflussen, können nicht rückwärts abgearbeitet werden.Beim Versuch, eine solche Instruktion abzuarbeiten, wird eine Warnung indas Ereignisprotokoll geschrieben.

RückwärtsbehandlungenProzeduren können eine Rückwärtsbehandlung beinhalten, durch die dieRückwärtsabarbeitung eines Prozeduraufrufs definiert wird. Wenn eine Routine ineiner Rückwärtsbehandlung aufgerufen wird, wird die Routine vorwärts abgearbeitet.Die Rückwärtsbehandlung ist eigentlich ein Teil der Prozedur und der Bereichjeglicher Routinendaten umfasst auch die Rückwärtsbehandlung der Prozedur.Instruktionen in der Rückwärts- oder Fehlerbehandlung einer Routine dürfen nichtrückwärts abgearbeitet werden. Verschachtelungen in der Rückwärtsabarbeitungsind nicht möglich, d. h., zwei Instruktionen in einer Aufrufkette können nichtgleichzeitig rückwärts abgearbeitet werden.Eine Prozedur ohne Rückwärtsbehandlung kann nicht rückwärts abgearbeitetwerden. Eine Prozedur mit einer leeren Rückwärtsbehandlung wird als „keineOperation“ abgearbeitet.

Beispiel 1:PROC MoveTo ()

MoveL p1,v500,z10,tool1;

MoveC p2,p3,v500,z10,tool1;


BACKWARD




ENDPROC

Wenn die Prozedur während einer Vorwärtsabarbeitung aufgerufen wird, trittFolgendes ein:




Beispiel 2:PROC MoveTo ()





1 Grundlagen der Programmierung mit RAPID1.22 Rückwärtsabarbeitung


BACKWARD




ENDPROC

Wenn die Prozedur während einer Vorwärtsabarbeitung aufgerufen wird, wirdfolgender Code abgearbeitet (der Code der Prozedur bis zur Rückwärtsbehandlung):




Wenn die Prozedur während einer Rückwärtsabarbeitung aufgerufen wird, wirdfolgender Code abgearbeitet (der Code der Prozedur in der Rückwärtsbehandlung):




Beschränkungen bei Bewegungsinstruktionen in der RückwärtsbehandlungTyp und Sequenz der Bewegungsinstruktion in der Rückwärtsbehandlung müssenden Typ und die Sequenz der Vorwärtsabarbeitung in derselben Routine spiegeln:

xx1100000633

Beachten Sie, dass die Reihenfolge von CirPoint p2 und ToPoint p3 in MoveCgleich sein sollte.Bewegungsinstruktionen sind alle Instruktionen, die Bewegungen des Robotersoder zusätzlicher Achsen zur Folge haben, MoveL, SearchC, TriggJ, ArcC oderPaintL.

WARNUNG

Jede Abweichung von dieser Programmierungsbeschränkung in derRückwärtsbehandlung kann eine falsche Rückwärtsbewegung verursachen. Füreinen Teil der Rückwärtsbahn können lineare Bewegungen kreisförmig ausgeführtwerden und umgekehrt.




Fortsetzung

Verhalten der Rückwärtsabarbeitung

MoveC- und nostepin-RoutinenBei der schrittweisen Vorwärtsabarbeitung einer MoveC-Instruktion hält der Roboteram Kreispunkt an (die Instruktion wird in zwei Schritten abgearbeitet). Jedoch hältder Roboter bei der schrittweisen Rückwärtsabarbeitung einer MoveC-Instruktionnicht am Kreispunkt an (die Instruktion wird in einem Schritt abgearbeitet).Es ist nicht erlaubt, von Vorwärts- in Rückwärtsabarbeitung zu wechseln, wennder Roboter eine MoveC-Instruktion abarbeitet.Um von einer Vorwärts- zu einer Rückwärtsabarbeitung in einer Nostepin-Routinezu wechseln, oder umgekehrt, muss der Systemparameter StepOutNoStepineingestellt sein.

Ziel, Bewegungsart und GeschwindigkeitBei der Rückwärtsabarbeitung des Programmcodes gibt ein Programmzeiger dienächste auszuführende Instruktion an, und ein Bewegungszeiger gibt dieBewegungsinstruktion an, die der Roboter ausführt.Bei der Rückwärtsabarbeitung des Programmcodes gibt der Programmzeiger dieInstruktion über dem Bewegungszeiger an. Wenn der Programmzeiger eineBewegungsinstruktion und der Bewegungszeiger eine weitereBewegungsinstruktion angibt, geht die nächste Rückwärtsbewegung zu dem Ziel,das der Programmzeiger angibt, und verwendet die Bewegungsart undGeschwindigkeit, die der Bewegungszeiger angibt.Eine Ausnahme hinsichtlich der Geschwindigkeit der Rückwärtsabarbeitung stelltdie Instruktion MoveExtJ dar. Diese Instruktion verwendet die mit dem robtarget

verbundene Geschwindigkeit bei der Vorwärts- und der Rückwärtsabarbeitung.



1 Grundlagen der Programmierung mit RAPID1.22 RückwärtsabarbeitungFortsetzung

Beispiel:Dieses Beispiel illustriert das Verhalten bei der Rückwärtsabarbeitung vonBewegungsinstruktionen. Programm- und Bewegungszeiger helfen Ihnen, denÜberblick über die Position der RAPID-Abarbeitung und des Roboters zu behalten.

xx1100000634

ProgrammzeigerA

BewegungszeigerB

Markieren des robtarget, auf das sich der Roboter zubewegt bzw. das erbereits erreicht hat.

C

1 Das Programm wird vorwärts abgearbeitet, bis der Roboter in p5 ist. DerBewegungszeiger gibt p5 an und der Programmzeiger gibt die nächsteBewegungsinstruktion (MoveL p6) an.

2 Beim ersten Drücken der Rückwärts-Taste bewegt sich der Roboter nicht,aber der Programmzeiger springt zur vorherigen Instruktion (MoveC p3,p4). Das ist die Instruktion, die beim nächsten Drücken der Rückwärtstasteausgeführt wird.

3 Beim zweiten Drücken der Rückwärts-Taste bewegt sich der Roboter mit derGeschwindigkeit v300 linear zu p4. Das Ziel dieser Bewegung (p4) wird ausderMoveC-Instruktion genommen. Bewegungsart (linear) und Geschwindigkeitwerden aus der darunter liegenden Instruktion (MoveL p5) genommen. DerBewegungszeiger gibt p4 an und der Programmzeiger bewegt sich nachoben zu MoveL p2.

4 Beim dritten Drücken der Rückwärts-Taste bewegt sich der Roboterkreisförmig mit der Geschwindigkeit v100 über p3 zu p2. Das Ziel p2 wirdaus der MoveL p2-Instruktion genommen. Bewegungsart (kreisförmig),




Fortsetzung

Kreispunkt (p3) und Geschwindigkeit werden aus der Instruktion MoveC

genommen. Der Bewegungszeiger gibt p2 an und der Programmzeiger bewegtsich nach oben zu MoveL p1.

5 Beim vierten Drücken der Rückwärts-Taste bewegt sich der Roboter mit derGeschwindigkeit v200 linear zu p1. Der Bewegungszeiger gibt p1 an und derProgrammzeiger bewegt sich nach oben zu MoveJ p0.

6 Beim ersten Drücken der Vorwärts-Taste bewegt sich der Roboter nicht, aberder Programmzeiger springt zur nächsten Instruktion (MoveL p2).

7 Beim zweiten Drücken der Vorwärts-Taste bewegt sich der Roboter mit derGeschwindigkeit v200 linear zu p2.



1 Grundlagen der Programmierung mit RAPID1.22 RückwärtsabarbeitungFortsetzung

2 Bewegung und E/A-Programmierung2.1 Koordinatensysteme

2.1.1 Der Werkzeugarbeitspunkt (TCP) der Roboters

BeschreibungDie Position des Roboters und seine Bewegungen beziehen sich stets auf denWerkzeugarbeitspunkt (TCP). Dies ist gewöhnlich ein definierter Punkt amWerkzeug, z. B. die Düsenspitze einer Klebepistole, die Mitte eines Greifers oderdie Elektrodenspitze einer Punktschweißzange.Mehrere TCPs (Werkzeuge) können definiert werden, aber es kann nur jeweilseines aktiv sein. Wenn eine Position gespeichert wird, ist das die Position desTCP. Dies ist auch der Punkt, der sich in einer vorgegebenen Geschwindigkeitentlang einer vorgegebenen Bahn bewegt.Wenn der Roboter ein Werkobjekt hält und an einem stationären Werkzeug arbeitet,wird ein stationärer TCP verwendet. Wenn dieses Werkzeug aktiv ist, beziehensich programmierte Bahn und Geschwindigkeit auf das Werkobjekt SieheStationäreTCPs auf Seite 123.


Beschrieben in

Technisches Referenzhandbuch - Systempa-rameter

Definition des Welt-Koordinatensystems

Bedienungsanleitung - IRC5mit FlexPendantDefinition des Anwender-Koordinatensys-tems

Bedienungsanleitung - IRC5mit FlexPendantDefinition des Objekt-Koordinatensystems

Bedienungsanleitung - IRC5mit FlexPendantDefinition des Werkzeug-Koordinatensys-tems

Bedienungsanleitung - IRC5mit FlexPendantDefinition des Werkzeugarbeitspunkts

Bedienungsanleitung - IRC5mit FlexPendantDefinition des Verschiebungs-Koordinaten-systems

Bedienungsanleitung - IRC5mit FlexPendantManuelle Bewegung in unterschiedlichenKoordinatensystemen



2 Bewegung und E/A-Programmierung2.1.1 Der Werkzeugarbeitspunkt (TCP) der Roboters

2.1.2 Koordinatensysteme zur Bestimmung der TCP-Position

BeschreibungDie Werkzeugposition (TCP) kann in verschiedenen Koordinatensystemenangegeben werden, um die Programmierung und Anpassung von Programmen zuvereinfachen.Das definierte Koordinatensystem hängt von der vorgesehenen Roboteraktion ab.Wenn kein Koordinatensystem definiert ist, beziehen sich alle Stellungen desRoboters auf das Basis-Koordinatensystem.

Basis-KoordinatensystemIn einer einfachen Anwendung kann die Programmierung imBasis-Koordinatensystem erfolgen. Hier entspricht die z-Achse desKoordinatensystems der Achse 1 des Roboters (siehe Abbildung 10).

xx1100000611

Abbildung 10: Das Basis-Koordinatensystem

Dem Basis-Koordinatensystem liegt der Sockel des Roboters zugrunde:• Der Ursprung befindet sich am Schnittpunkt zwischen Achse 1 und der

Sockelmontagefläche.• Die xy-Ebene stimmt mit der Sockelmontagefläche überein.• Die x-Achse weist nach vorne.• Die y-Achse weist nach links (aus der Perspektive des Roboters).• Die z-Achse weist nach oben.

Welt-KoordinatensystemBei einem stehend montierten Roboter ist die Programmierung imBasis-Koordinatensystem einfach. Wenn der Roboter jedoch hängend montiertist, ist die Programmierung im Basis-Koordinatensystem schwieriger, da dieRichtungen der Achsen nicht mit den Grundrichtungen des Arbeitsraumsübereinstimmen. In solchen Fällen ist es nützlich, ein Welt-Koordinatensystem zudefinieren. Das Welt-Koordinatensystem stimmt mit dem Basis-Koordinatensystemüberein, falls es nicht speziell definiert wird.Gelegentlich arbeiten mehrere Roboter im selben Arbeitsraum einer Anlage. Indiesem Fall ermöglicht ein gemeinsames Welt-Koordinatensystem, dass die



2 Bewegung und E/A-Programmierung2.1.2 Koordinatensysteme zur Bestimmung der TCP-Position

Roboterprogramme miteinander kommunizieren. Ein solches System kann auchvorteilhaft sein, wenn sich die Positionen auf einen festen Punkt in der Werkstattbeziehen. Beachten Sie dazu auch das Beispiel in Abbildung 11.

xx1100000612

Abbildung 11: Zwei Roboter (einer davon hängend montiert) mit einem gemeinsamenWelt-Koordinatensystem




Fortsetzung

Anwender-KoordinatensystemEin Roboter kann mit verschiedenen Vorrichtungen oder Arbeitsflächen inverschiedenen Stellungen und Orientierungen arbeiten. Für jede Vorrichtung kannein Anwender-Koordinatensystem definiert werden. Wenn alle Positionen inObjektkoordinaten gespeichert sind, ist bei der Verlagerung einer Vorrichtungkeine Neuprogrammierung erforderlich. Durch Bewegen/Drehen desAnwender-Koordinatensystems um denselben Betrag wie die Vorrichtung folgenalle programmierten Positionen der Vorrichtung und eine Neuprogrammierungerübrigt sich.Das Anwender-Koordinatensystem wird auf der Basis des Welt-Koordinatensystemsdefiniert (siehe Abbildung 12).

xx1100000613

Abbildung 12: Zwei Anwender-Koordinatensysteme beschreiben die Stellung von zwei verschiedenenVorrichtungen



2 Bewegung und E/A-Programmierung2.1.2 Koordinatensysteme zur Bestimmung der TCP-PositionFortsetzung

Objekt-KoordinatensystemDas Anwender-Koordinatensystem wird benutzt, um verschiedeneKoordinatensysteme für verschiedene Vorrichtungen oder Arbeitsflächen zuerhalten. Eine Vorrichtung kann jedoch mehrere Werkobjekte umfassen, die derRoboter verarbeiten oder handhaben muss. Daher hilft es häufig, einKoordinatensystem für jedes Objekt zu definieren, damit das Programm bei einerBewegung des Objekts oder für ein neues Objekt mit gleichen Eigenschaftenleichter angepasst werden kann. Ein Koordinatensystem, das auf ein Objektbezogen wird, ist ein Objekt-Koordinatensystem. Dieses Koordinatensystem eignetsich auch für Offline-Programmierung, da die angegebenen Positionen gewöhnlichdirekt aus einer Zeichnung des Werkobjekts übernommen werden können. DasObjekt-Koordinatensystem lässt sich beim manuellen Bewegen des Robotersverwenden.Das Objekt-Koordinatensystem wird auf der Basis desAnwender-Koordinatensystems definiert (siehe Abbildung 13).

xx1100000614

Abbildung 13: Zwei Objekt-Koordinatensysteme beschreiben die Position von zwei verschiedenenWerkobjekten in derselben Vorrichtung

Die programmierten Positionen werden immer relativ zu einemObjekt-Koordinatensystem definiert. Wenn eine Vorrichtung bewegt/gedreht wird,kann dies durch Bewegen/Drehen des Anwender-Koordinatensystems kompensiertwerden. Weder die programmierten Positionen noch die definiertenObjekt-Koordinatensysteme müssen geändert werden. Wenn das Werkobjektbewegt/gedreht wird, kann dies durch Bewegen/Drehen desObjekt-Koordinatensystems kompensiert werden.Wenn das Anwender-Koordinatensystem beweglich ist, d. h. koordinierte zusätzlicheAchsen verwendet werden, bewegt sich das Objekt-Koordinatensystem mit dem




Fortsetzung

Anwender-Koordinatensystem. Dadurch ist es möglich, den Roboter in Bezug aufdas Objekt zu bewegen, selbst wenn die Werkbank manipuliert wird.

Verschiebungs-KoordinatensystemManchmal muss dieselbe Bahn an verschiedenen Stellen des Objekts durchlaufenwerden. Damit diese Positionen nicht jedes Mal neu programmiert werden müssen,kann ein so genanntes Verschiebungs-Koordinatensystem definiert werden. DiesesKoordinatensystem lässt sich auch zusammen mit Suchläufen verwenden, umUnterschiede in den Positionen der einzelnen Teile zu kompensieren.Das Verschiebungs-Koordinatensystem wird auf der Basis desObjekt-Koordinatensystems definiert (siehe Abbildung 14).

xx1100000615

Abbildung 14: Wenn eine Programmverschiebung aktiv ist, werden alle Positionen verschoben




Koordinierte zusätzliche Achsen

Koordinierung des Anwender-KoordinatensystemsWenn das Werkobjekt auf eine externe mechanische Einheit gelegt wird, die sichbewegt, während der Roboter eine im Objekt-Koordinatensystem definierte Bahnabarbeitet, kann ein bewegliches Anwender-Koordinatensystem definiert werden.Position und Orientierung des Anwender-Koordinatensystems hängt in diesemFall von den Achsendrehungen der externen Einheit ab. Die programmierte Bahnund die Geschwindigkeit beziehen sich so auf das Werkobjekt (siehe Abbildung15) und es muss nicht berücksichtigt werden, dass das Objekt von der externenEinheit bewegt wird.

xx1100000616

Abbildung 15: Ein Anwender-Koordinatensystem, das so definiert ist, dass es den Bewegungen einerexternen, mechanischen 3-Achsen-Einheit folgt .




Fortsetzung

Koordinierung des Basis-KoordinatensystemsEin bewegliches Koordinatensystem kann auch für den Sockel des Robotersdefiniert werden. Dies ist für eine Anlage interessant, in der der Roboter z. B. aufeiner Verfahrachse oder in einem Portal montiert ist. Position und Orientierungdes Basis-Koordinatensystems hängen wie für das beweglicheAnwender-Koordinatensystem von den Drehungen der externen Einheit ab. Dieprogrammierte Bahn und die Geschwindigkeit beziehen sich auf dasObjekt-Koordinatensystem (siehe Abbildung 16) und es muss nicht berücksichtigtwerden, dass der Robotersockel von der externen Einheit bewegt wird. Einkoordiniertes Anwender-Koordinatensystem und ein koordiniertesBasis-Koordinatensystem können gleichzeitig definiert sein.

xx1100000617

Abbildung 16: Koordinierte Interpolationmit einer Verfahrachse, auf der das Basis-Koordinatensystemdes Roboters bewegt wird.

Damit beim Bewegen betroffener Einheiten das Anwender- und dasBasis-Koordinatensystem berechnet werden kann, muss dem RobotersystemFolgendes bekannt sein:

• die Kalibrierungspositionen des Anwender- und desBasis-Koordinatensystems

• die Relationen zwischen den Winkeln der zusätzlichen Achsen und dieTranslation/Drehung des Anwender- und Basis-Koordinatensystems.

• Diese Relationen werden in den Systemparametern definiert.




2.1.3 Koordinatensysteme zur Bestimmung der Werkzeugrichtung

BeschreibungDie Orientierung eines Werkzeugs an einer programmierten Position wird durchdie Orientierung des Werkzeug-Koordinatensystems vorgegeben. DasWerkzeug-Koordinatensystem bezieht sich auf das Handgelenk-Koordinatensystem,das am Montageflansch am Handgelenk des Roboters definiert ist.

Handgelenk-KoordinatensystemIn einer einfachen Anwendung kann das Handgelenk-Koordinatensystem verwendetwerden, um die Orientierung des Werkzeugs zu definieren. Hier entspricht diez-Achse des Koordinatensystems der Achse 6 des Roboters (siehe Abbildung 17).

xx1600000580

Abbildung 17: Das Handgelenk-Koordinatensystem

Das Handgelenk-Koordinatensystem kann nicht geändert werden und ist immermit dem Montageflansch des Roboters in folgender Hinsicht identisch:

• Der Ursprung befindet sich im Mittelpunkt des Montageflanschs (auf derMontagefläche).

• Die x-Achse weist in die entgegengesetzte Richtung zur Passbohrung desMontageflanschs.

• Die z-Achse weist nach außen im rechten Winkel zum Montageflansch.

Werkzeug-KoordinatensystemDas am Montageflansch des Roboters befestigte Werkzeug benötigt häufig seineigenes Koordinatensystem zur Definition seines TCP, das den Ursprung desWerkzeug-Koordinatensystems darstellt. Das Werkzeug-Koordinatensystem kannauch genutzt werden, um die erforderlichen Bewegungsrichtungen beim manuellenBewegen des Roboters einzustellen.Wenn ein Werkzeug beschädigt oder ausgetauscht wird, müssen Sie einfach nurdas Werkzeug-Koordinatensystem neu definieren. Das Programm mussnormalerweise nicht geändert werden.



2 Bewegung und E/A-Programmierung2.1.3 Koordinatensysteme zur Bestimmung der Werkzeugrichtung

Der TCP (Ursprung) wird als der Punkt am Werkzeug gewählt, der korrektpositioniert sein muss, z. B. die Düsenspitze einer Klebepistole. DieWerkzeug-Koordinatenachsen werden dem entsprechenden Werkzeug zugeordnet.

xx1600000581

Abbildung 18: Werkzeug-Koordinatensystem, wie es gewöhnlich für einen Lichtbogenschweißbrenner(links) und eine Punktschweißzange (rechts) definiert wird.

Das Werkzeug-Koordinatensystem wird auf der Basis desHandgelenk-Koordinatensystems definiert (siehe Abbildung 19).

xx1600000582

Abbildung 19: DasWerkzeug-Koordinatensystemwird in Relation zumHandgelenk-Koordinatensystemdefiniert, hier für einen Greifer.



2 Bewegung und E/A-Programmierung2.1.3 Koordinatensysteme zur Bestimmung der WerkzeugrichtungFortsetzung

Stationäre TCPsWenn der Roboter ein Werkobjekt hält und an einem stationären Werkzeug arbeitet,wird ein stationärer TCP verwendet. Wenn dieses Werkzeug aktiv ist, beziehensich programmierte Bahn und Geschwindigkeit auf das Werkobjekt, das der Roboterhält.Dies bedeutet eine Umkehr der Koordinatensysteme (siehe Abbildung 20).

xx1100000635

Abbildung 20: Bei Verwendung eines stationären TCP beruht dasObjekt-Koordinatensystemgewöhnlichauf dem Handgelenk-Koordinatensystem

Im Beispiel in Abbildung 20 wird weder das Anwender-Koordinatensystem nocheine Programmverschiebung verwendet. Es ist jedoch möglich, diese zu benutzen.In diesem Fall werden sie einander zugeordnet wie in Abbildung 21 gezeigt.

xx1100000636

Abbildung 21: Programmverschiebung kann auch zusammenmit stationären TCPs verwendet werden



2 Bewegung und E/A-Programmierung2.1.3 Koordinatensysteme zur Bestimmung der Werkzeugrichtung

Fortsetzung

2.2 Positionierung während der Abarbeitung von Programmen

2.2.1 Einleitung

Ausführung von BewegungenWährend der Programmabarbeitung steuern Positionierinstruktionen imRoboterprogramm alle Bewegungen. Die Hauptaufgabe der Positionierinstruktionenbesteht darin, die folgenden Informationen über die Ausführung der Bewegung zuliefern:

• den Zielpunkt der Bewegung (als Position des Werkzeugarbeitspunkts,Orientierung des Werkzeugs, Konfiguration des Roboters und Stellung derzusätzlichen Achsen);

• die Interpolationsmethode, anhand deren der Zielpunkt erreicht wird, z. B.achsenweise, lineare oder kreisförmige Interpolation;

• die Geschwindigkeit des Roboters und der zusätzlichen Achsen;• Die Zonendaten (definieren, wie der Roboter und die zusätzlichen Achsen

den Zielpunkt passieren sollen, beispielsweise Stopppunkt oderFly-By-Punkt).

• die Koordinatensysteme (Werkzeug, Anwender und Objekt), die für dieBewegung benutzt werden.

Alternativ zur Definition der Geschwindigkeit des Roboters und der zusätzlichenAchsen kann die Bewegungsdauer programmiert werden. Dies sollte jedoch beiVerwendung der Pendelfunktion unterlassen werden. Stattdessen sollten dieGeschwindigkeiten der Orientierung und der zusätzlichen Achsen begrenzt werden,wenn kleine oder keine TCP-Bewegungen ausgeführt werden.

WARNUNG

In Anwendungen zur Materialhandhabung und Palletierung mit intensiven undhäufigen Bewegungen kann die Überwachung des Antriebssystems ausgelöstwerden und den Roboter stoppen, um die Überhitzung von Antriebsstufen oderMotoren zu verhindern. Wenn dies geschieht, muss die Zyklusdauer etwas erhöhtwerden, indem die programmierte Geschwindigkeit oder Beschleunigung reduziertwird.


Beschrieben in:

TechnischesReferenzhandbuch - RAPID Instruktionen,Funktionen und Datentypen

Definition der Geschwindigkeit


Definition der Zonen (Zonenbanhen)


Instruktion für die achsenweise In-terpolation


Instruktion für lineare Interpolation



2 Bewegung und E/A-Programmierung2.2.1 Einleitung

Beschrieben in:


Instruktion für kreisförmige Interpo-lation


Instruktion für modifizierte Interpola-tion

Singularitäten auf Seite 160Singularität

Synchronisierung mit logischen Instruktionen aufSeite 141

Simultane Abarbeitung von Program-men

Technisches Referenzhandbuch - SystemparameterCPU-Optimierung



2 Bewegung und E/A-Programmierung2.2.1 Einleitung

Fortsetzung

2.2.2 Interpolation der Position und Orientierung des Werkzeugs

Achsenweise InterpolationWenn die Bahngenauigkeit nicht besonders wichtig ist, kann mit dieser Art derBewegung das Werkzeug rasch von einer Position zu einer anderen bewegt werden.Achsenweise Interpolation gestattet auch das Bewegen einer Achse von einemOrt zu einem anderen innerhalb des Arbeitsraums in einer einzigen Bewegung.Alle Achsen bewegen sich mit konstanter Achsengeschwindigkeit vom Startpunktzum Zielpunkt (siehe Abbildung 22).

xx1100000637

Abbildung 22: Achsenweise Interpolation ist häufig die schnellste Methode für die Bewegung zwischenzwei Punkten, während die Roboterachsen der Bahn folgen, die am genauesten zwischen Startpunktund Zielpunkt (aus der Perspektive der Achsenwinkel) liegt.

Die Geschwindigkeit des Werkzeugarbeitspunkts wird in mm/s (imObjekt-Koordinatensystem) ausgedrückt. Während die Interpolation achsenweiseerfolgt, entspricht die Geschwindigkeit nicht genau dem programmierten Wert.Während der Interpolation wird die Geschwindigkeit der beschränkenden Achsebestimmt, d. h. der Achse, die sich am schnellsten in Relation zu ihrerHöchstgeschwindigkeit bewegt, um die Bewegung auszuführen. DieGeschwindigkeiten der übrigen Achsen werden dann so berechnet, dass alleAchsen gleichzeitig den Zielpunkt erreichen.Alle Achsen werden koordiniert, um eine von der Geschwindigkeit unabhängigeBahn zu erhalten. Die Beschleunigung wird automatisch für die beste Leistung desRoboters optimiert.

Lineare InterpolationWährend der linearen Interpolation bewegt sich der TCP entlang einer Geradenzwischen Start- und Zielpunkt (siehe Abbildung 23).

xx1100000638

Abbildung 23: Lineare Interpolation ohne Umorientierung des Werkzeugs

Um eine lineare Bahn im Objekt-Koordinatensystem zu erhalten, müssen dieRoboterachsen eine nichtlineare Bahn im Achsenraum verfolgen. Je weniger lineardie Konfiguration des Roboters ist, umso mehr Beschleunigungen und



2 Bewegung und E/A-Programmierung2.2.2 Interpolation der Position und Orientierung des Werkzeugs

Verzögerungen sind erforderlich, um das Werkzeug geradlinig zu bewegen unddie gewünschte Werkzeugorientierung zu erzielen. Wenn die Konfiguration extremnichtlinear ist (z. B. in der Nähe von Handgelenk- und Arm-Singularitäten), benötigeneine oder mehrere Achsen ein höheres Drehmoment als die Motoren abgebenkönnen. In diesem Fall wird die Geschwindigkeit aller Achsen automatisch reduziert.Die Orientierung des Werkzeugs bleibt während der gesamten Bewegung konstant,sofern keine Umorientierung programmiert wurde. Bei einer Umorientierung wirddas Werkzeug in konstanter Geschwindigkeit gedreht.Eine maximale Rotationsgeschwindigkeit (in Grad pro Sekunde) kann beim Drehendes Werkzeugs angegeben werden. Wenn dies ein niedriger Wert ist, erfolgt dieUmorientierung fließend, ungeachtet der Geschwindigkeit, die für denWerkzeugarbeitspunkt definiert ist. Ist es jedoch ein hoher Wert, wird dieGeschwindigkeit für die Umorientierung nur durch die Höchstgeschwindigkeit derMotoren begrenzt. Solange kein Motor den Grenzwert des Drehmomentsüberschreitet, wird die definierte Geschwindigkeit beibehalten. Wenn jedoch einerder Motoren den Grenzwert überschreitet, wird die Geschwindigkeit dervollständigen Bewegung (hinsichtlich Position und Orientierung) reduziert.Alle Achsen werden koordiniert, um eine von der Geschwindigkeit unabhängigeBahn zu erhalten. Die Beschleunigung wird automatisch optimiert.

Kreisförmige InterpolationEine Kreisbahn wird mithilfe von drei programmierten Positionen als Kreissegmentdefiniert. Der erste zu programmierende Punkt ist der Startpunkt des Kreissegments.Der nächste Punkt ist ein Hilfspunkt (Kreispunkt), der die Krümmung des Kreisesdefiniert. Der dritte Punkt ist der Endpunkt des Kreisbogens (siehe Abbildung 24).Die drei programmierten Punkte sollten in regelmäßigen Abständen auf demKreisbogen liegen, um diesen so präzise wie möglich zu beschreiben.Die für den Hilfspunkt definierte Orientierung wird verwendet, um zwischen derkurzen und der langen Verwindung für die Orientierung vom Start- zum Zielpunktzu wählen.Wenn die programmierte Orientierung in Relation zum Kreis am Start- und Zielpunktgleich und die Orientierung am Hilfspunkt in Relation zum Kreis ähnlich ist, bleibtdie Orientierung des Werkzeugs in Relation zur Bahn konstant.

xx1100000639

Abbildung 24: Kreisförmige Interpolation mit einer kurzen Umorientierung für ein Kreissegment miteinem Startpunkt, einem Kreispunkt und einem Zielpunkt.




Fortsetzung

Wenn die Orientierung am Hilfspunkt jedoch näher zur um 180° gedrehtenOrientierung programmiert wird, wird die alternative Verwindung gewählt (sieheAbbildung 25).

xx1100000640

Abbildung 25: Kreisförmige Interpolation mit langer Verwindung für die Orientierung wird erzielt, indemdie Orientierung am Kreispunkt in entgegengesetzter Richtung im Vergleich zum Startpunkt definiertwird.

Solange alle Motordrehmomente unter den zulässigen Höchstwerten liegen, bewegtsich das Werkzeug in der programmierten Geschwindigkeit am Kreisbogen entlang.Wenn das Drehmoment eines der Motoren nicht ausreicht, wird die Geschwindigkeitautomatisch an den entsprechenden Teilen des Kreisbogens reduziert.Alle Achsen werden koordiniert, um eine von der Geschwindigkeit unabhängigeBahn zu erhalten. Die Beschleunigung wird automatisch optimiert.



2 Bewegung und E/A-Programmierung2.2.2 Interpolation der Position und Orientierung des WerkzeugsFortsetzung

SingArea\WristWährend der Abarbeitung in der Nähe eines singulären Punkts kann die lineareoder kreisförmige Interpolation problematisch sein. In diesem Fall ist es am besten,eine modifizierte Interpolation zu verwenden, wobei die Handgelenk-Achsenachsenweise interpoliert werden und der TCP eine lineare oder kreisförmige Bahnverfolgt. Die Orientierung des Werkzeugs unterscheidet sich jedoch etwas von derprogrammierten Orientierung. Die resultierende Orientierung am programmiertenPunkt kann sich auch aufgrund von zwei Singularitäten von der programmiertenOrientierung unterscheiden.

xx1100000641

Die erste Singularität tritt auf, wenn sich der TCP direkt vor Achse 2 (a2 in obigerAbbildung) befindet. Der TCP kann sich nicht auf die andere Seite von Achse 2bewegen, stattdessen werden Achse 2 und 3 etwas mehr gebeugt, um den TCPauf derselben Seite zu halten. Die Orientierung der Bewegung wird dann von derprogrammierten Orientierung um denselben Winkelbetrag entfernt.Die zweite Singularität tritt auf, wenn der TCP in der Nähe der z-Achse von Achse1 passiert (z1 in obiger Abbildung). Achse 1 dreht sich in diesem Fall in vollerGeschwindigkeit und die Werkzeugorientierung folgt auf dieselbe Weise. DieRichtung der Drehung hängt davon ab, auf welche Seite sich der TCP bewegt. Eswird empfohlen, in der Nähe der z-Achse zur achsenweisen Interpolation zuwechseln (MoveJ). Beachten Sie, dass der TCP die Singularität bestimmt, nichtder WCP wie bei Verwendung von SingArea\Off.Im Fall SingArea\Wrist ist die Orientierung am Kreishilfspunkt dieselbe wieprogrammiert. Das Werkzeug hat jedoch keine konstante Richtung in Relation zurKreisebene wie bei normaler kreisförmiger Interpolation. Wenn die Kreisbahn aneiner Singularität vorbeiführt, muss die Orientierung der programmierten Positionengelegentlich geändert werden, um große Handgelenkbewegungen zu vermeiden.Diese können auftreten, wenn eine vollständige Handgelenk-Neukonfiguration beiAbarbeitung des Kreises generiert wird (Achsen 4 und 6 werden um je 180°bewegt).




Fortsetzung

2.2.3 Interpolation der Zonenbahnen

BeschreibungZonenbahnen werden verwendet, um fortlaufende Bewegungen an programmiertenPositionen vorbei auszuführen. So können Positionen in hoher Geschwindigkeitohne überflüssiges Abbremsen passiert werden. Ein Fly-By-Punkt generiert ander programmierten Position vorbei eine Zonenbahn (parabolische Bahn). Beginnund Ende dieser Zonenbahn werden durch eine Zone um die programmierte Positiondefiniert (siehe Abbildung 26).

Corner zone

for the TCP path

Corner path

Programmed

position

xx1100000643

Abbildung 26: Ein Fly-By-Punkt generiert eine Zonenbahn, um die programmierte Position zu passieren.

Alle Achsen werden koordiniert, um eine von der Geschwindigkeit unabhängigeBahn zu erhalten. Geschwindigkeit und Beschleunigung werden automatischoptimiert.

Definieren einer ZonenbahnDie Größe der Verschleifzone wird im Datentyp zonedata festgelegt, der alsArgument bei Bewegungsinstruktionen verwendet wird. Weitere Informationenfinden Sie unter zonedata in Technisches Referenzhandbuch - RAPIDInstruktionen, Funktionen und Datentypen.

Fließende Übergänge zwischen verschiedenen GeschwindigkeitenWenn unterschiedliche TCP-Geschwindigkeiten vor und nach der Zonenpositionprogrammiert wurden, erfolgt der Übergang in der Zonenbahn fließend, ohne dietatsächliche Bahn zu beeinflussen.Wenn vor und nach der Zonenposition verschiedeneUmorientierungsgeschwindigkeiten programmiert wurden und damit die Bewegungbeschränkt wird, erfolgt der Übergang von einer Geschwindigkeit zur nächsten inder Zonenbahn fließend.



2 Bewegung und E/A-Programmierung2.2.3 Interpolation der Zonenbahnen

Feinabstimmung der BahnWenn das Werkzeug in der Zonenbahn einen Prozess ausführen soll (z. B.Lichtbogenschweißen, Kleben oder Wasserstrahlschneiden), kann die Größe derZone für die gewünschte Bahn eingestellt werden. Wenn die Form einerparabolischen Zonenbahn nicht der Objektgeometrie entspricht, können dieprogrammierten Positionen näher aneinander platziert werden. Damit ist eineAnnäherung an die gewünschte Bahn durch zwei oder mehr kleine parabolischeBahnen möglich.

Zonenbahnen mit UmorientierungEin Fly-By-Punkt kann eine Zonengröße für die TCP-Position (Positionszone) undeine Zonengröße für die Werkzeugumorientierung und die Bewegung zusätzlicherAchsen (Umorientierungs- und zusätzliche Achsenzone) aufweisen.Die Umorientierungs- und zusätzliche Achsenzone kann analog zur Positionszonedefiniert werden. Die Umorientierung und zusätzliche Achsenzone ist in der Regelgrößer als die Positionszone eingestellt. In diesem Fall beginnt die Umorientierungmit der Interpolation in Richtung der Orientierung der nächsten Position, bevor dieZonenbahn beginnt. Die Umorientierung wird dann fließender.Das Werkzeug wird umorientiert, sodass die Orientierung am Ende der Zonedieselbe ist, als wäre ein Stopppunkt programmiert (siehe Abbildung 29a-b).Beachten Sie, dass die Orientierung außerhalb der Umorientierung und derzusätzlichen Achsenzone für beide Fälle gleich ist (Position C–E), sich dieOrientierung innerhalb der Zone jedoch sanfter als die programmierten Positionenändert.

p1

p2

p3

A B

C

D

E

xx1100000647

Abbildung 29a: Wenn drei Positionen mit unterschiedlichen Werkzeugorientierungen als Stopppunkteprogrammiert sind, sieht die Programmabarbeitung wie dargestellt aus.




Fortsetzung

Position zone

Reorientation and

additional axis zone

p1

p2

p3

C

D

E

xx1100000648

Abbildung 29b: Wenn die mittlere Position ein Fly-By-Punkt ist, sieht die Programmabarbeitung wiedargestellt aus.

Die Umorientierungs- und zusätzliche Achsenzone wird gewöhnlich in mmausgedrückt. Auf diese Weise können Sie direkt bestimmen, an welcher Stelle derBahn die Orientierungszone beginnt und endet. Wenn das Werkzeug nicht bewegtwird, wird die Größe der Zone in Drehwinkelgraden anstelle von TCP-mmangegeben.Die Umorientierungs- und zusätzliche Achsenzone wird wie bei der Orientierungauch für zusätzliche Achsen verwendet. Wenn die Umorientierungs- und zusätzlicheAchsenzone größer als die Positionszone eingestellt wird, startet die Interpolationder zusätzlichen Achsen zum Ziel der nächsten programmierten Position, bevordie TCP-Zonenbahn beginnt. Dies kann auf dieselbe Weise für fließenderezusätzliche Achsenbewegungen verwendet werden wie die Werkzeugorientierungfür fließendere Handgelenkbewegungen benutzt wird.



2 Bewegung und E/A-Programmierung2.2.3 Interpolation der ZonenbahnenFortsetzung

Zonenbahnen beim Wechseln der InterpolationsmethodeZonenbahnen werden auch generiert, wenn die Interpolationsmethode gewechseltwird. Die Interpolationsmethode in der aktuellen Zonenbahn wird dann so gewählt,dass der Übergang von einer Methode zur nächsten so fließend wie möglich erfolgt.Wenn die Zonen für die Orientierung und Position nicht dieselbe Größe aufweisen,können in der Zonenbahn mehrere Interpolationsmethoden benutzt werden (sieheAbbildung 30).

xx1100000649

Abbildung 30: Interpolation beim Wechsel der Interpolationsmethode. Zwischen p1 und p2 wurdelineare Interpolation programmiert, zwischen p2 und p3 achsenweise Interpolation und zwischen p3und p4 Sing Area\Wrist-Interpolation.

Wenn die Interpolation von einer normalen TCP-Bewegung auf eine Umorientierungohne eine TCP-Bewegung oder umgekehrt wechselt, wird keine Verschleifzonegeneriert. Dies ist auch der Fall, wenn die Interpolation zu oder von einer externenachsenweisen Bewegung ohne TCP-Bewegung wechselt.

Interpolation beim Wechsel des KoordinatensystemsWenn das Koordinatensystem in einer Zonenbahn gewechselt wird, z. B. ein neuerTCP oder ein neues Werkobjekt, wird achsenweise Interpolation der Zonenbahnverwendet. Dies gilt auch beim Wechsel von einer koordinierten Operation in einenicht koordinierte Operation und umgekehrt.




Fortsetzung

Größenreduktion der programmierten VerschleifzonenWenn programmierte Positionen nahe beieinander liegen, ist es nicht ungewöhnlich,dass sich die programmierten Zonen überlappen. Um eine genau definierte Bahnzu erhalten und jederzeit eine optimale Geschwindigkeit zu erreichen, reduziertder Roboter die Größe der Zone. Standardmäßig reduziert er die Größe der Zoneauf die Hälfte der Entfernung von einer programmierten Position zur anderen.

Verhalten bei standardmäßigen ZoneneinstellungenBei Standardeinstellungen führen programmierte Zonen, die mehr als die Hälfteder Entfernung zu einem benachbarten Punkt erreichen, zu einer reduzierten Zone(siehe folgende Abbildung). Der gleiche Zonenradius wird standardmäßig für denEingangspfad und den Ausgangspfad zu oder von einer programmierten Positionverwendet.

p1

p2

p3

p4

Generated

path

Programmed

position zone

Corner zone as

calculated by the robot

xx1800000780

Interpolationmit zu großen Positionszonen. Die Zonen um p3 ist größer als der halbe Abstand zwischenp2 und p3. Daher reduziert der Roboter die Größe der Zonen so, dass sie gleich dem halben Abstandzwischen p2 und p3 sind, wodurch sich innerhalb der Zonen eine symmetrische Zonenbahn ergibt.

Sowohl die Positionszone als auch die Umorientierungs- und die zusätzlicheAchsenzone können überlappen. Sobald eine dieser Zonenbahnzonen zu groß ist,wird diese Zone verkleinert.

Hinweis

Die Verschleifzone kann durch Änderung der Systemparameter Relative zonesize with finepoint (Thema Motion, Typ Motion Planner) mehr als die Hälfte derEntfernung zu einem benachbarten Feinpunkt erreichen.Die Größe der Verschleifzone kann für die Eingangs- und Ausgangsbahnunterschiedlich sein, wenn Sie den Systemparameter Allow asymmetric zones(Thema Motion, Typ Motion Planner) einstellen.Siehe Technisches Referenzhandbuch - Systemparameter.



2 Bewegung und E/A-Programmierung2.2.3 Interpolation der ZonenbahnenFortsetzung

Planung der Zeit für Fly-By-PunkteGelegentlich können programmierte Fly-By-Punkte einen Stopppunkt auslösen,wenn die nächste Bewegung nicht rechtzeitig berechnet wird. Dies kann infolgenden Fällen geschehen:

• Eine Reihe logischer Instruktionen mit langen Programmabarbeitungszeitenwird zwischen kurzen Bewegungen programmiert.

• Die Punkte liegen sehr nahe beieinander und es sind hohe Geschwindigkeiteneingestellt.

Wenn Stopppunkte ein Problem darstellen, verwenden Sie simultaneProgrammabarbeitung.Verwenden Sie die Instruktion CornerPathWarning, um Warnungen ausZonenbahnfehlern zu unterdrücken.




Fortsetzung

2.2.4 Unabhängige Achsen

BeschreibungEine unabhängige Achse bewegt sich unabhängig von anderen Achsen imRobotersystem. Der Modus einer Achse kann in „unabhängig“ und später wiederin „normal“ geändert werden.Spezielle Instruktionen handhaben die unabhängigen Achsen. Vier verschiedeneBewegungsinstruktionen geben die Achsenbewegung an. Beispielsweise startetdie Instruktion IndCMove eine kontinuierliche Bewegung der Achse. Die Achsebewegt sich dann in konstanter Geschwindigkeit (unabhängig von den Aktionendes Roboters), bis eine neue Unabhängig-Instruktion abgearbeitet wird.Für die Rückkehr in den Normalmodus wird die Reset-Instruktion IndReset

verwendet. Die Reset-Instruktion kann auch eine neue Referenz für das Messsystemder Achse setzen, eine Art neue Achsensynchronisierung. Sobald die Achse wiederim Normalmodus ist, kann sie als normale Achse betrieben werden.

ProgrammabarbeitungEine Achse wechselt sofort beim Abarbeiten der Instruktion Ind_Move in denunabhängigen Modus. Dies geschieht, selbst wenn sich die Achse zu diesemZeitpunkt bewegt, z. B. wenn ein vorheriger Punkt als Fly-By-Punkt programmiertwurde oder wenn simultane Programmabarbeitung benutzt wird.Wenn erneut die Instruktion Ind_Move abgearbeitet wird, bevor die vorherigeabgeschlossen wurde, überschreibt die neue Instruktion sofort die alte.Wird die Abarbeitung eines Programms gestoppt, während sich eine unabhängigeAchse bewegt, stoppt auch diese Achse. Beim Neustart des Programms startetdie unabhängige Achse automatisch. Zwischen unabhängigen Achsen und anderenAchsen im Normalmodus findet keine aktive Koordinierung statt.Wenn sich eine Achse bei einem Stromausfall im unabhängigen Modus befindet,kann das Programm nicht neu gestartet werden. Eine Fehlermeldung wird angezeigtund das Programm muss von vorne begonnen werden.Beachten Sie, dass eine mechanische Einheit nicht deaktiviert werden kann, wennsich eine ihrer Achsen im unabhängigen Modus befindet.



2 Bewegung und E/A-Programmierung2.2.4 Unabhängige Achsen

Schrittweise AbarbeitungWährend der schrittweisen Abarbeitung wird eine unabhängige Achse nur dannbewegt, wenn eine andere Instruktion abgearbeitet wird. Die Bewegung der Achseerfolgt auch schrittweise mit der Abarbeitung anderer Instruktionen, wie inAbbildung 33 beschrieben.

xx1100000652

Abbildung 33: Schrittweise Abarbeitung unabhängiger Achsen.

BewegenAchsen im unabhängigen Modus können nicht manuell bewegt werden. Bei einemVersuch, die Achse manuell zu bewegen, wird ein Fehler gemeldet. Mit derInstruktion IndReset oder durch Setzen des Programmzeigers auf „main“ könnenSie den unabhängigen Modus verlassen.

ArbeitsbereichDer physische Arbeitsbereich entspricht der vollständigen Bewegung der Achse.Der logische Arbeitsbereich ist der Bereich, den RAPID-Instruktionen verwendenund den Sie im Fenster „Bewegen“ ablesen können.Nach der Synchronisierung (aktualisierter Umdrehungszähler) stimmen derphysische und der logische Arbeitsbereich überein. Mit der Instruktion IndReset

können Sie den logischen Arbeitsbereich bewegen, wie in Abbildung 34 gezeigt.

xx1100000653

Abbildung 34: Mit der Instruktion IndReset können Sie den logischen Arbeitsbereich verschieben.

Die Auflösung der Positionen verringert sich, je weiter sie von der logischenNullposition entfernt sind. Niedrige Auflösung mit einer starr eingestellten Steuerungkann zu inakzeptablen Drehmomenten, Rauschen und instabiler Steuerung führen.Prüfen Sie bei der Installation die Einstellung der Steuerung und die Bewegungen



2 Bewegung und E/A-Programmierung2.2.4 Unabhängige Achsen

Fortsetzung

an der Grenze des Arbeitsbereichs. Prüfen Sie außerdem, ob die Positionsauflösungund das Bahnverhalten akzeptabel sind.

Geschwindigkeit und BeschleunigungIm Einrichtbetrieb mit reduzierter Geschwindigkeit wird die Geschwindigkeit einerunabhängigen Achse auf das gleiche Maß reduziert, als wäre sie abhängig.Beachten Sie, dass die Funktion IndSpeed nicht TRUE ist, wenn dieAchsengeschwindigkeit reduziert ist.Die Instruktion VelSet und prozentuale Geschwindigkeitskorrektur imProduktionsfenster sind für unabhängige Bewegungen aktiv. Beachten Sie, dassKorrekturen über das Produktionsfenster den Wert TRUE aus der FunktionIndSpeed blockieren.Im unabhängigen Modus wird der niedrigste Wert für Beschleunigung undVerzögerung, der in der Konfigurationsdatei angegeben ist, sowohl für dieBeschleunigung als auch für die Verzögerung verwendet. Dieser Wert kann durchden Wert der Rampe in der Instruktion reduziert werden (1 – 100 %). Die InstruktionAccSet beeinflusst keine unabhängigen Achsen.

RoboterachsenNur Roboterachse 6 kann als unabhängige Achse verwendet werden. Gewöhnlichwird nur die Instruktion IndReset für diese Achse benutzt. Jedoch kann dieInstruktion IndReset auch für Achse 4 der Modelle IRB 1600, 2600 und 4600benutzt werden (nicht für ID-Versionen). Bei der Verwendung der InstruktionIndReset für Roboterachse 4 darf Achse 6 nicht unabhängig sein.Wenn Achse 6 als unabhängige Achse benutzt wird, können Singularitätsproblemeauftreten, da die normale, aus sechs Achsen bestehende Koordinatentransformationimmer noch verwendet wird. Arbeiten Sie bei diesem Problem dasselbe Programmmit Achse 6 im Normalmodus ab. Modifizieren Sie die Punkte oder verwenden Siedie Instruktion SingArea\Wrist oder MoveJ.Achse 6 ist auch intern aktiv für die Berechnung der Bahn. Als Resultat hiervonkann eine interne Bewegung von Achse 6 die Geschwindigkeit anderer Achsen imSystem verringern.Der unabhängige Arbeitsbereich für Achse 6 wird mit Achse 4 und 5 inGrundstellung definiert. Wenn sich Achse 4 oder 5 nicht in der Grundstellungbefindet, wird der Arbeitsbereich für Achse 6 bedingt durch die Getriebekopplungverschoben. Das Auslesen der Position vom FlexPendant für Achse 6 wird mit denPositionen von Achse 4 und 5 über die Getriebekopplung kompensiert.



2 Bewegung und E/A-Programmierung2.2.4 Unabhängige AchsenFortsetzung

2.2.5 Softservo

BeschreibungEinige Anwendungen erfordern einen Servomechanismus, der wie einemechanische Feder wirkt. Dies bedeutet, dass die vom Roboter auf das Werkobjektausgeübte Kraft als Funktion des Abstands zwischen der programmierten Position(hinter dem Werkobjekt) und der Kontaktposition (Roboterwerkzeug – Werkobjekt)zunimmt.

Softness (Weichheit)Das Verhältnis zwischen Positionsabweichung und Kraft wird durch den ParameterSoftness (Weichheit) definiert. Je größer dieser Parameter, umso größer ist dieerforderliche Positionsabweichung, die zur Erzeugung derselben Kraft erforderlichist.Der Weichheitsparameter wird im Programm gesetzt und seine Werte können anbeliebiger Stelle im Programm geändert werden. Verschiedene Weichheitswertekönnen für verschiedene Achsen gesetzt werden. Auch ist es möglich, Achsen mitnormalem Servomechanismus zusammen mit Achsen mit Softservo zu verwenden.Das Aktivieren und Deaktivieren des Softservomechanismus sowie das Ändernder Weichheitswerte kann erfolgen, während sich der Roboter bewegt. In diesemFall erfolgt eine Abstimmung zwischen den verschiedenen Servomechanismenund verschiedenen Weichheitswerten, um fließende Übergänge zu erzielen. DieAbstimmungsdauer kann im Programm durch den Parameter „ramp“ (Rampe)gesetzt werden. Mit ramp = 1 erfolgen die Übergänge in 0,5 Sekunden. ImAllgemeinen beträgt die Übergangsdauer ramp x 0.5 in Sekunden.

Hinweis

Der Softservomechanismus sollte nicht aktiviert werden, solange eine Kraftzwischen dem Roboter und dem Werkobjekt wirkt.

Hinweis

Bei hohen Weichheitswerten besteht das Risiko, dass dieServopositionsabweichungen so groß sind, dass sich die Achsen außerhalb desArbeitsbereichs des Roboters bewegen.



2 Bewegung und E/A-Programmierung2.2.5 Softservo

2.2.6 Stopp und Neustart

Stoppen von BewegungenEine Bewegung kann auf drei Arten gestoppt werden:

• Bei einem normalen Stopp hält der Roboter auf der Bahn an, was einenNeustart vereinfacht.

• Bei einem abrupten Stopp hält der Roboter schneller als beim normalenStopp an, aber die Verzögerungsbahn folgt nicht der programmierten Bahn.Diese Stoppmethode wird beispielsweise für einen Suchlauf verwendet, beidem die Bewegung so schnell wie möglich angehalten werden muss.Bei einem abrupten Stopp hält der Roboter schneller als beim Softstopp an,aber die Verzögerungsbahn folgt nicht der programmierten Bahn. DieseStoppmethode wird beispielsweise für einen Suchlauf verwendet, bei demdie Bewegung so schnell wie möglich angehalten werden muss.

• Bei einem schnellen Stopp werden die mechanischen Bremsen verwendet,um aus Sicherheitsgründen einen möglichst kurzen Bremsweg zu erzielen.Dabei ist die Bahnabweichung gewöhnlich größer als bei einem abruptenStopp.

Starten von BewegungenNach einem (beliebigen) Stopp ist ein Neustart stets auf der unterbrochenen Bahnmöglich. Wenn der Roboter außerhalb der programmierten Bahn gestoppt wurde,beginnt der Neustart mit einer Rückkehr an die Position auf der Bahn, an der derRoboter hätte anhalten sollen.Ein Neustart nach einem Stromausfall ist gleich mit einem Neustart nach einemschnellen Stopp. Beachten Sie dabei, dass der Roboter immer vor dem Neustartdes unterbrochenen Programmablaufs zur Bahn zurückkehrt, selbst dann, wennder Stromausfall während der Ausführung einer logischen Instruktion eingetretenist. Beim Neustart werden alle Zeiten von Anfang an gezählt, z. B. die rechtzeitigePositionierung oder eine Unterbrechung in der Instruktion WaitTime.



2 Bewegung und E/A-Programmierung2.2.6 Stopp und Neustart

2.3 Synchronisierung mit logischen Instruktionen

Logische InstruktionenGewöhnlich werden Instruktionen im Programm sequenziell abgearbeitet. LogischeInstruktionen können jedoch auch an bestimmten Positionen oder während einerlaufenden Bewegung abgearbeitet werden.Eine logische Instruktion ist eine beliebige Instruktion, die keine Roboterbewegungoder zusätzliche Achsenbewegung erzeugt, z. B. eine E/A-Instruktion.

Sequenzielle Programmabarbeitung an StopppunktenFalls eine Positionierinstruktion als Stopppunkt programmiert wurde, wird dienachfolgende Instruktion erst ausgeführt, wenn der Roboter und die zusätzlichenAchsen im Stillstand sind, d. h. wenn die programmierte Position erreicht wurde(siehe Abbildung 35).

xx1100000654

Abbildung 35: Eine logische Instruktion nach einem Stopppunkt wird erst ausgeführt, wenn dieZielposition erreicht wurde.

Sequenzielle Programmabarbeitung an Fly-By-PunktenWenn eine Positionierinstruktion als Fly-By-Punkt programmiert wurde, werdendie nachfolgenden logischen Instruktionen einige Zeit vor Erreichen der größtenZone ausgeführt (für Position, Orientierung oder zusätzliche Achsen). SieheAbbildung 36 und Abbildung 37. Diese Instruktionen werden nacheinanderabgearbeitet.

xx1100000655

Abbildung 36: Eine logische Instruktion nach einem Fly-By-Punkt wird vor Erreichen der größten Zoneabgearbeitet.



2 Bewegung und E/A-Programmierung2.3 Synchronisierung mit logischen Instruktionen

xx1100000656

Abbildung 37: Eine logische Instruktion nach einem Fly-By-Punkt wird vor Erreichen der größten Zoneabgearbeitet.

Die Dauer der Abarbeitung (DT) ist aus folgenden Zeitkomponentenzusammengesetzt:

• Der Zeitdauer, die der Roboter zur Planung der nächsten Bewegung benötigt:ca. 0,1 Sekunden.

• Der Roboterverzögerung (Folgeverzögerung) in Sekunden: 0 bis -1,0Sekunden, abhängig von der Geschwindigkeit und der tatsächlichenVerzögerungsleistung des Roboters.

Simultane Abarbeitung von ProgrammenSimultane Abarbeitung von Programmen kann mithilfe des Arguments \Conc inder Positionierinstruktion programmiert werden. Dieses Argument wird fürFolgendes verwendet:

• Abarbeitung von einer oder mehreren logischen Instruktionen gleichzeitigmit der Roboterbewegung, um die Zyklusdauer zu verringern (z. B. bei derKommunikation über serielle Kanäle).

Gleichzeitig mit einer Positionierinstruktion mit dem Argument \Concwerden auchdie folgenden logischen Instruktionen nacheinander abgearbeitet:Wenn sich der Roboter nicht bewegt oder die vorherige Positionierinstruktion miteinem Stopppunkt endet, werden die logischen Instruktionen abgearbeitet, sobalddie aktuelle Positionierinstruktion beginnt (gleichzeitig mit der Bewegung). SieheAbbildung 38.Wenn die vorherige Positionierinstruktion mit einem Fly-By-Punkt endet, werdendie logischen Instruktionen in einer vorgegebenen Zeit (DT) vor Erreichen der



2 Bewegung und E/A-Programmierung2.3 Synchronisierung mit logischen InstruktionenFortsetzung

größten Zone abgearbeitet (für Position, Orientierung oder zusätzliche Achsen).Siehe Abbildung 39.

xx1100000657

Abbildung 38: Bei der simultanen Programmabarbeitung nach einem Stopppunkt werden einePositionierinstruktion und darauf folgende logische Instruktionen gleichzeitig gestartet.

xx1100000658

Abbildung 39: Bei simultaner Programmabarbeitung nach einem Fly-By-Punkt beginnt die Abarbeitungder logischen Instruktionen vor den Positionierinstruktionen mit dem Argument \Conc.

Instruktionen, die Bewegungen wie ConfL und SingArea indirekt beeinflussen,werden auf die gleiche Weise wie andere logische Instruktionen abgearbeitet. Siebeeinflussen jedoch nicht die Bewegungen, die durch vorherigePositionierinstruktionen festgelegt wurden.




Fortsetzung

Wenn mehrere Positionierinstruktionen mit dem Argument \Conc und mehrerelogische Instruktionen in einer langen Folge gemischt sind, gilt Folgendes:

• Logische Instruktionen werden unmittelbar in der programmierten Reihenfolgeabgearbeitet. Dies erfolgt gleichzeitig mit der Bewegung (siehe Abbildung40), d. h. die logischen Instruktionen werden auf der Bahn in einer früherenPhase abgearbeitet, als sie programmiert wurden.

xx1100000659

Abbildung 40 Wenn mehrere Positionierinstruktionen mit dem Argument \Conc nacheinanderprogrammiert wurden, werden alle verbundenen logischen Instruktionen gleichzeitig mit demAusführender ersten Position abgearbeitet.

Bei der simultanen Programmabarbeitung werden die folgenden Instruktionenprogrammiert, um die Sequenz abzuschließen und anschließendPositionierinstruktionen und logische Instruktionen neu zu synchronisieren:

• eine Positionierinstruktion auf einen Stopppunkt ohne das Argument \Conc• die Instruktion WaitTime oder WaitUntil mit dem Argument \Inpos.

Synchronisierung der BahnUm Prozesseinrichtungen (für Anwendungen wie Kleben, Lackieren undLichtbogenschweißen) mit den Bewegungen des Roboters zu synchronisieren,können verschiedene Arten von Bahnsynchronisierungssignalen erzeugt werden.Mit einem so genannten Positionierungsereignis wird ein Triggersignal erzeugt,sobald der Roboter eine vordefinierte Position auf der Bahn passiert. Bei einemZeitereignis wird ein Signal in einer vordefinierten Zeitdauer vor dem Stoppen desRoboters an einer Stoppposition erzeugt. Darüber hinaus steuert das System auchPendelereignisse, die Impulse in vordefinierten Phasenwinkeln einerPendelbewegung generieren.



2 Bewegung und E/A-Programmierung2.3 Synchronisierung mit logischen InstruktionenFortsetzung

Alle mit Positionen synchronisierten Signale können sowohl vor (vorauseilend) alsauch nach (verzögert) dem Zeitpunkt erzeugt werden, an dem der Roboter dievordefinierte Position passiert. Die Position wird durch eine programmierte Positiondefiniert und kann als Strecke vor der programmierten Position eingestellt werden.Die typische Wiederholgenauigkeit für einen Satz digitaler Ausgänge auf der Bahnbeträgt +/-2 ms.Bei einem Stromausfall und Neustart in einer Trigg-Instruktion werden alleTriggerereignisse noch einmal auf der verbleibenden Bewegungsbahn für dieTrigg-Instruktion generiert.


Beschrieben in:

Bewegung auf Seite 57Positionierinstruktionen

Technisches Referenzhandbuch - RAPID Instruktionen, Funk-tionen und Datentypen

Definition der Zonengröße




Fortsetzung

2.4 Roboterkonfiguration

Verschiedene Arten der RoboterkonfigurationGewöhnlich ist es möglich, dieselbe Stellung und Orientierung desRoboterwerkzeugs auf verschiedene Weise mithilfe verschiedenerZusammenstellungen von Achsenwinkeln zu erzielen. Wir nennen dieseMöglichkeiten verschiedene Roboterkonfigurationen.Wenn sich beispielsweise eine Position etwa in der Mitte einer Arbeitsstationbefindet, können einige Roboter von oben und unten an diese Position gelangen,wenn sie verschiedene Stellungen von Achse 1 verwenden (siehe Abbildung 41).

xx1100000660

Abbildung 41: Zwei verschiedene Armkonfigurationen erreichen dieselbe Position und Orientierung.In der Konfiguration rechts wurde der Arm nach hinten gedreht. Achse 1 wird um 180 Grad gedreht.

Einige Roboter können auch diese Position von oben und unten bei gleicherStellung von Achse 1 erreichen. Dies ist für Robotertypen mit erweitertemArbeitsbereich der Achse 3 möglich (siehe Abbildung 42).

xx1100000661

Abbildung 42: IRB140 mit zwei verschiedenen Armkonfigurationen zum Erreichen derselben Positionund Orientierung. Der Winkel von Achse 1 ist identisch für beide Konfigurationen. Die Konfigurationrechts wird erzielt, indem der untere Arm nach vorne und der obere Arm nach hinten gedreht wird.



2 Bewegung und E/A-Programmierung2.4 Roboterkonfiguration

Dieselbe Wirkung wird erreicht, wenn der vordere Teil des oberen Roboterarms(Achse 4) umgedreht und Achsen 5 und 6 in die gewünschte Stellung undOrientierung gedreht werden (siehe Abbildung 43).

xx1100000662

Abbildung 43: Zwei verschiedene Handgelenkkonfigurationen erreichen dieselbe Position undOrientierung. In der Konfiguration, in der der vordere Teil des Oberarms nach oben weist (unten),wurden die Achsen 4, 5 und 6 um 180 Grad gedreht, um die Konfiguration zu erreichen, in der dervordere Teil des Oberarms nach unten weist (oben).

Festlegen der RoboterkonfigurationBeim Programmieren einer Roboterstellung wird zudem mit confdata cf1,cf4, cf6, cfx eine Roboterkonfiguration festgelegt.Wie die Roboterkonfiguration festgelegt wird, ist je nach Robotertyp unterschiedlich(eine vollständige Beschreibung finden Sie unter TechnischesReferenzhandbuch - RAPID Instruktionen, Funktionen und Datentypen – confdata).Für die meisten Robotertypen beinhaltet dies jedoch die Definition derentsprechenden Vierteldrehungen für Achse 1, 4 und 6. Wenn beispielsweiseAchse 1 zwischen 0 und 90 Grad aufweist, ist cf1=0, siehe Abbildung unten.

xx1100000663

Abbildung 44: Eine Vierteldrehung für einen positiven Achsenwinkel




Fortsetzung

xx1100000664

Abbildung 45: Eine Vierteldrehung für einen negativen Achsenwinkel

Konfigurationssteuerung und -überwachungUm eine gut definierte Roboterbewegung zu erhalten, sollte der Roboter bei derProgrammabarbeitung exakt die Konfiguration erreichen, die programmiert wurde.Dazu sollten die Konfigurationssteuerung und -überwachung mit ConfL\On oderConfJ\On genutzt werden. Die Konfigurationsüberwachung vergleicht dieKonfiguration der programmierten Stellung mit der tatsächlichen Position desRoboters.Bei einer linearen Bewegung bewegt sich der Roboter stets zur am genauestenentsprechenden Konfiguration. Wenn die Konfigurationsüberwachung mitConfL\Onaktiv ist, wird eine Überprüfung vorgenommen, um festzustellen, ob es möglichist, die programmierte Konfiguration zu erreichen. Wenn dies nicht möglich ist,wird das Programm angehalten. Wenn die Bewegung abgeschlossen ist (in einerZone oder Feinpunkt), wird auch überprüft, ob der Roboter die programmierteKonfiguration erreicht hat. Unterscheidet sich die Konfiguration, wird das Programmangehalten. Eine detaillierte Beschreibung der Konfigurationsdaten für einenspeziellen Robotertyp finden Sie unter Datentyp confdata, in TechnischesReferenzhandbuch - RAPID Instruktionen, Funktionen und Datentypen.Während einer achsenweisen Bewegung bewegt sich der Roboter immer zurprogrammierten Konfiguration, wenn ConfJ\On verwendet wird. Es erfolgt keineÜberwachung der Achsenbewegung, wenn die Konfigurationsüberwachung aktiviertwurde. Je nach Differenz zwischen der Startpunkt-Konfiguration und derEndpunkt-Konfiguration kann eine große Bewegung, besonders des Handgelenks,ein Ergebnis sein. Wenn die Konfigurationsüberwachung nicht aktiv ist, bewegtsich der Roboter in die angegebene Stellung und Orientierung mit der Konfiguration,deren Achsenwerte denen des Startpunkts am ehesten entsprechen.Wenn die Abarbeitung einer programmierten Stellung wegen einesKonfigurationsfehlers gestoppt wird, hat das häufig eine der folgenden Ursachen:

• Die Stellung wurde offline mit einer falschen Konfiguration programmiert.• Das Roboterwerkzeug wurde gewechselt, daher übernimmt der Roboter eine

andere Konfiguration als die programmierte.• Auf die Stellung erfolgt eine aktive Koordinatensystemoperation

(Verschiebung, Anwender, Objekt, Basis).• Die korrekte Konfiguration in der Zielstellung können Sie ermitteln, indem

Sie den Roboter in die Nähe positionieren und die Konfiguration amFlexPendant ablesen.



2 Bewegung und E/A-Programmierung2.4 RoboterkonfigurationFortsetzung

Wenn sich die Konfigurationsparameter aufgrund einer aktiven Operation in einemKoordinatensystem ändern, kann die Konfigurationsprüfung deaktiviert werden.

Ausführliche Informationen für ConfJMoveJ mit ConfJ\Off:

• Der Roboter wird an die programmierte Position bewegt, mit einerAchsenposition, die den geringsten Abstand zur Achsenposition des Startsaufweist. Daher wird die confdata in der Instruktion nicht verwendet. KeineKonfigurationsüberwachung wird ausgeführt.

MoveJ mit ConfJ\On:• Der Roboter wird an die programmierte Position bewegt, mit einer

Achsenposition, bei der die entsprechende Konfiguration der in confdata

programmierten Konfiguration am ehesten entspricht.• Wenn eine Programmverschiebung oder eine Bahnkorrektur aktiv ist, besteht

das Risiko, dass sich die programmierte Konfiguration von derOriginalposition unterscheidet. Als Ergebnis kann der Roboter großeBewegungen der Handgelenkachse durchführen, um die programmierteKonfiguration zu erzielen.

Ausführliche Informationen für ConfLMoveL mit ConfL\Off:

• Der Roboter wird entlang einer geraden Linie an die programmierte Positionbewegt, mit einer Achsenposition, die den geringsten Abstand zurAchsenposition des Starts aufweist. Daher wird die confdata in derInstruktion nicht verwendet und es erfolgt keine Konfigurationsüberwachung.

MoveL mit ConfL\On:• Zunächst wird die Endposition in den Achsen berechnet. Das Ergebnis wird

anhand der programmierten confdata bestimmt. Anschließend werden dieAchsenwerte für die Konfigurationsachsen in der Endposition mit denentsprechenden Achsen für die Startposition verglichen.Sind die neuen Konfigurationsdaten verglichen mit der Startposition inOrdnung, ist die Bewegung zulässig. Anderenfalls wird der Roboter in derStartposition mit einer Fehlermeldung angehalten. Weitere Informationenzum zulässigen Konfigurationsfehler für verschiedene Robotertypen findenSie in der Beschreibung von confdata, TechnischesReferenzhandbuch - RAPID Instruktionen, Funktionen und Datentypen.

• Wenn es vor dem Start der Bewegung keine Fehlermeldung gab, überprüftdas System die Konfiguration erneut, wenn die Bewegung beendet wird.Wenn sie nicht mit der programmierten Konfiguration übereinstimmt, wirddas Programm angehalten.


Beschrieben in:

Technisches Referenzhandbuch - RAPID Instruk-tionen, Funktionen und Datentypen

Definition der Roboterkonfiguration




Fortsetzung

Beschrieben in:

Bewegung auf Seite 57Aktivieren/Deaktivieren der Konfigurati-onsprüfung



2 Bewegung und E/A-Programmierung2.4 RoboterkonfigurationFortsetzung

2.5 Kinematisches Modell des Roboters

RoboterkinematikStellung und Orientierung eines Roboters wird aus dem kinematischen Modellseiner mechanischen Struktur bestimmt. Jede Installation erfordert eine spezifischeDefinition des mechanischen Modells. Für ABB-Master- und externeStandardroboter sind diese Modelle in der Steuerung vordefiniert.

Master-RoboterDas kinematische Modell des Master-Roboters legt die Stellung und Orientierungdes Roboterwerkzeugs relativ zu seiner Basis als Funktion der Roboterachsenwinkelfest.Die kinematischen Parameter für die Armlängen, Offsets und Achsenstellungensind für jeden Robotertyp in der Konfigurationsdatei vordefiniert.

xx1100000666

Abbildung 46: Kinematische Struktur eines Roboters des Typs IRB 1400



2 Bewegung und E/A-Programmierung2.5 Kinematisches Modell des Roboters

Eine Kalibrierungsprozedur unterstützt die Definition des Basis-Koordinatensystemsdes Master-Roboters relativ zum Welt-Koordinatensystem.

xx1100000667

Abbildung 47: Basis-Koordinatensystem des Master-Roboters

Externer RoboterDie Koordinierung mit einem externen Roboter erfordert auch ein kinematischesModell für den externen Roboter. Eine Reihe vordefinierter Klassen von 2- und3-dimensionalen mechanischen Strukturen wird unterstützt.

xx1100000668

Abbildung 48: Kinematische Struktur eines Roboters des Typs ORBIT 160B nach einem vordefiniertenModell



2 Bewegung und E/A-Programmierung2.5 Kinematisches Modell des RobotersFortsetzung

Kalibrierungsprozeduren zur Definition des Basis-Koordinatensystems relativ zumWelt-Koordinatensystem werden für jede Klasse von Strukturen zur Verfügunggestellt.

xx1100000669

Abbildung 49: Basis-Koordinatensystem eines Roboters des Typs ORBIT_160B

xx1100000670

Abbildung 50: Referenzpunkte auf Drehteller für Kalibrierung des Basis-Koordinatensystems einesRoboters des Typs ORBIT_160B in der Grundstellung nach einem vordefinierten Modell




Fortsetzung

Allgemeine KinematikMechanische Strukturen, die nicht durch vordefinierte Strukturen unterstützt werden,können mithilfe eines allgemeinen kinematischen Modells modelliert werden. Diesist möglich für externe Roboter.Die Modellierung basiert auf der Denavit-Hartenberg-Konvention. WeitereInformationen hierzu finden Sie in „Introduction to Robotics, Mechanics & Control“von John J. Craigh (Addison-Wesley 1986).

xx1100000671

Abbildung 51: Kinematische Struktur eines Roboters des Typs ORBIT 160B nach einem allgemeinenkinematischen Modell

Eine Kalibrierungsprozedur unterstützt die Definition des Basis-Koordinatensystemsdes externen Roboters relativ zum Welt-Koordinatensystem.

xx1100000672

Abbildung 52: Basis-Koordinatensystemeines Roboters des TypsORBIT_160B nach einem allgemeinenkinematischen Modell



2 Bewegung und E/A-Programmierung2.5 Kinematisches Modell des RobotersFortsetzung

xx1100000673

Abbildung 53: Referenzpunkte auf Drehteller für Kalibrierung des Basis-Koordinatensystems einesRoboters des Typs ORBIT_160B in der Grundstellung (Achsen = 0 Grad)


Beschrieben in:

Technisches Referenzhandbuch - Systempa-rameter

Definition der allgemeinen Kinematik einesexternen Roboters




Fortsetzung

2.6 Bewegungsüberwachung/Kollisionserkennung

EinleitungBewegungsüberwachung ist die Bezeichnung für eine Reihe von Funktionen fürhochempfindliche, modellbasierte Überwachung der Roboterbewegungen.Bewegungsüberwachung umfasst Funktionalität für die Erkennung von Kollisionen,Blockierungen und falschen Lastdefinitionen. Diese Funktionalität wirdKollisionserkennung genannt (Option Collision Detection).Die Kollisionserkennung kann ausgelöst werden, wenn die Daten für die am Robotermontierten Lasten nicht korrekt sind. Hierzu gehören Lastdaten für Werkzeuge,Nutzlasten und Armlasten. Wenn die Werkzeug- oder Nutzlastdaten unbekanntsind, können sie über die Funktionalität zur Lastidentifizierung definiert werden.Daten über die Armlast können nicht identifiziert werden.Beim Auslösen der Kollisionserkennung werden die Motorenmomente umgekehrtund die mechanischen Bremsen aktiviert, um den Roboter zu stoppen. Der Roboterbewegt sich dann eine kurze Strecke auf der Bahn zurück, um etwaige Restenergienaus einer Kollision oder Blockade abzubauen. Anschließend stoppt der Robotererneut und bleibt im Zustand „Motoren ein“. Nachstehende Abbildung zeigt einetypische Kollision.Die Bewegungsüberwachung ist standardmäßig nur aktiv, wenn mindestens eineAchse (einschließlich zusätzlicher Achsen) in Bewegung ist. Bei einem Stillstandaller Achsen wird die Funktion deaktiviert. Damit wird überflüssiges Auslösen durchexterne Prozesskräfte vermieden. Der Systemparameter Collision detection atstandstill ermöglicht die Erfassung einer Kollision auch im Stillstand. WeitereInformationen finden Sie unter TechnischesReferenzhandbuch - Systemparameter.

Einstellen der Stufe für die KollisionserkennungDie Kollisionserkennung verwendet eine variable Überwachungsstufe. Bei niedrigenGeschwindigkeiten ist die Empfindlichkeit höher als bei hohen Geschwindigkeiten.Daher sind bei Normalbetrieb keine Einstellungen der Funktion durch den Anwendererforderlich. Jedoch ist es möglich, die Funktion ein- und auszuschalten und dieÜberwachungsstufen einzustellen. Separate Einstellparameter stehen für manuelleBewegungen und die Programmabarbeitung zur Verfügung. Die verschiedenenEinstellungsparameter werden im TechnischesReferenzhandbuch - Systemparameter ausführlicher beschrieben.Die RAPID-Instruktion MotionSup schaltet die Funktion ein und aus und ermöglichtdie Änderung der Überwachungsstufe. Dies ist nützlich in Anwendungen, in denenin bestimmten Teilen des Zyklus externe Prozesskräfte auf den Roboter einwirken.Die Instruktion MotionSup wird in Technisches Referenzhandbuch - RAPIDInstruktionen, Funktionen und Datentypen ausführlicher beschrieben.Die Einstellung erfolgt in Prozent, wobei 100 % den Basiswerten entspricht. Einhöherer Prozentwert ergibt ein weniger empfindliches System, ein kleinerer Wertbewirkt das Gegenteil. Beachten Sie unbedingt, dass der Einstellwert sowohl inden Systemparametern als auch in der RAPID-Instruktion berücksichtigt werdenmuss. Beispiel: Wenn der Einstellwert in den Systemparametern 150 % und in der



2 Bewegung und E/A-Programmierung2.6 Bewegungsüberwachung/Kollisionserkennung

RAPID-Instruktion 200 % beträgt, ergibt sich daraus eine Überwachungsstufe von300 %.

xx1100000674

Es gibt eine Höchststufe, auf die die Kollisionserkennung eingestellt werden kann.Diese Einstellung beträgt standardmäßig 300 %. Sie kann jedoch über denSystemparameter motion_sup_max_level geändert werden.




Fortsetzung

Ändern der BewegungsüberwachungGehen Sie wie folgt vor, um am FlexPendant die Bewegungsüberwachung zuändern.

1 Tippen Sie im ABB-Menü auf Systemeinstellungen und dann aufÜberwachung.

2 Tippen Sie auf die Taskliste und wählen Sie eine Task aus. Bei mehrerenTasks müssen die gewünschten Werte für jede Task einzeln eingestelltwerden.

3 Tippen Sie auf EIN/AUS, um die Bahnüberwachung zu deaktivieren oder zuaktivieren. Tippen Sie auf -/+, um die Empfindlichkeit einzustellen. DieEmpfindlichkeit kann auf einen Wert zwischen 0 und 300 eingestellt werden.Die Bahnüberwachung betrifft nur Roboter im Automatikbetrieb und imEinrichtbetrieb 100 %, es sei denn, die OptionCollision Detection ist installiert.

4 Tippen Sie auf EIN/AUS, um die Überwachung manueller Bewegungen zudeaktivieren oder zu aktivieren. Tippen Sie auf -/+, um die Empfindlichkeiteinzustellen. Die Empfindlichkeit kann auf einen Wert zwischen 0 und 300eingestellt werden. Diese Einstellung wirkt sich nur aus, wenn die OptionCollision Detection installiert ist.

Weitere Informationen zu Collision Detection finden Sie unterAnwendungshandbuch - Steuerungssoftware IRC5.

Digitale AusgängeDer digitale Ausgang MotSupOn ist gesetzt (1), wenn die Kollisionserkennung aktivist, und nicht gesetzt (0), wenn die Kollisionserkennung deaktiviert ist. BeachtenSie, dass eine Zustandsänderung der Funktion wirksam wird, wenn eine Bewegungbeginnt. Wenn also die Kollisionserkennung aktiv ist und sich der Roboter bewegt,ist MotSupOn gesetzt. Wenn der Roboter gestoppt und die Funktion deaktiviertwird, ist MotSupOn immer noch gesetzt. Wenn der Roboter beginnt, sich zubewegen, wird MotSupOn auf Tief geschaltet.Der digitale Ausgang MotSupTrigg wird gesetzt, wenn die Kollisionserkennungausgelöst wird. Er bleibt gesetzt, bis der Fehlercode bestätigt wird, entweder amFlexPendant oder durch den digitalen Eingang AckErrDialog.Die digitalen Ausgänge werden ausführlicher unter Bedienungsanleitung - IRC5mit FlexPendant und Technisches Referenzhandbuch - Systemparameterbeschrieben.

EinschränkungenDie Bewegungsüberwachung ist nur für die Roboterachsen verfügbar. FürVerfahreinheiten, Orbit-Stations oder andere externe Manipulatoren steht sie nichtzur Verfügung.Die Kollisionserkennung wird deaktiviert, wenn mindestens eine Achse imunabhängigen Achsenmodus ausgeführt wird. Dies ist auch der Fall, wenn einezusätzliche Achse als unabhängige Achse ausgeführt wird.



2 Bewegung und E/A-Programmierung2.6 Bewegungsüberwachung/KollisionserkennungFortsetzung

Die Kollisionserkennung kann ausgelöst werden, wenn der Roboter im Modus„Softservo“ betrieben wird. Daher ist es bei Verwendung dieses Modus ratsam,die Kollisionserkennung auszuschalten.Das Ausschalten der Kollisionserkennung über die RAPID-Instruktion MotionSupwird erst wirksam, wenn der Roboter seine Bewegung startet. Daher kann derdigitale Ausgang MotSupOn vorübergehend beim Programmstart gesetzt sein,bevor der Roboter beginnt, sich zu bewegen.Die Strecke, die sich der Roboter nach einer Kollision auf der Bahn zurückbewegt,ist proportional zur Geschwindigkeit der Bewegung vor der Kollision. Bei wiederholteintretenden Kollisionen mit niedriger Geschwindigkeit bewegt sich der Robotereventuell nicht weit genug zurück, um die Restenergien der Kollision abzubauen.Infolgedessen kann der Roboter möglicherweise nicht manuell bewegt werden,ohne die Überwachung auszulösen. Schalten Sie in diesem Fall dieKollisionserkennung über das Menü „Bewegen“ vorübergehend aus und entfernenSie den Roboter manuell vom Hindernis.Bei einer harten Kollision während der Programmabarbeitung kann es einigeSekunden dauern, bevor sich der Roboter auf seiner Bahn rückwärts bewegt.Wenn der Roboter auf einer Verfahrachse montiert ist, sollte dieKollisionserkennung ausgeschaltet werden, sobald sich die Verfahrachse bewegt.Andernfalls kann die Kollisionserkennung während der Bewegung der Verfahrachseausgelöst werden, ohne dass eine tatsächliche Kollision vorliegt.


Beschrieben in:

Bewegung auf Seite 57RAPID-Instruktion MotionSup

TechnischesReferenzhandbuch - Systemparame-ter

Systemparameter für Einstellungen


E/A-Signale für die Bewegungsüberwa-chung


Kollisionserkennung bei Stillstand

Bedienungsanleitung - IRC5 mit FlexPendantLasterkennung




Fortsetzung

2.7 Singularitäten

BeschreibungEinige Positionen im Arbeitsraum des Roboters können mit einer unendlichenAnzahl von Roboterkonfigurationen zur Positionierung und Orientierung desWerkzeugs erreicht werden. Diese Positionen, so genannte singuläre Punkte(Singularitäten), bilden ein Problem für die Berechnung der Roboterarmwinkel aufder Basis der Werkzeugposition und -orientierung.Im Wesentlichen besitzt ein Roboter zwei Arten von Singularitäten:

• Arm-Singularitäten• Handgelenk-Singularitäten

Arm-Singularitäten sind alle Konfigurationen, bei denen die Mitte des Handgelenks(Schnittpunkt der Achsen 4, 5 und 6) direkt über Achse 1 endet (siehe Abbildung54). Handgelenk-Singularitäten sind Konfigurationen, bei denen Achse 4 und Achse6 auf derselben Linie liegen, d. h. Achse 5 hat einen Winkel gleich 0 (sieheAbbildung 55).

xx1100000675

Abbildung 54: Die Arm-Singularität befindet sich am Schnittpunkt zwischen der Mitte des Handgelenksund Achse 1.



2 Bewegung und E/A-Programmierung2.7 Singularitäten

xx1100000676

Abbildung 55: Die Handgelenk-Singularität tritt ein, wenn Achse 5 bei 0 Grad liegt.

Singularitätspunkte von Robotern ohne ParallelstangeRoboter ohne Parallelstange (Roboter mit serieller Verbindung) verfügen über dieHandgelenk-Singularität und die Arm-Singularität, genau wie Roboter mitParallelstange. Zusätzlich besitzen sie noch eine dritte Art von Singularität. DieseSingularität tritt bei Roboterstellungen auf, bei denen die Mitte des Handgelenkssowie die Drehachsen der Achsen 2 und 3 auf einer Geraden liegen (siehenachstehende Abbildung).

xx1100000677

Abbildung 56: Der zusätzliche Singularitätspunkt des IRB140

Singularitätspunkte von Robotern mit serieller Verbindung und 7 AchsenRoboter mit serieller Verbindung und 7 Achsen, wie z. B. der IRB 14000, verfügenüber alle Singularitäten von 6-Achsen-Robotern und weisen noch zwei zusätzlicheSingulariäten auf.



2 Bewegung und E/A-Programmierung2.7 Singularitäten

Fortsetzung

Die erste Singularität tritt ein, wenn der Winkel der Achse 2 Null entspricht, sodasssich Achse 1 und Achse 7 auf derselben Linie befinden. Dies ist identisch mit derHandgelenk-Singularität.Die zweite Singularität bezieht sich auf die Berechnung des Armwinkels und variiertje nachdem welche Referenzrichtung konfiguriert ist, da die Singularität eintritt,wenn sich WCP auf der Referenzrichtung befindet. Weitere Informationen findenSie in den Systemparametern Arm-Angle Reference Direction inBedienungsanleitung - IRB 14000.

Programmabarbeitung durch SingularitätenBei der Achseninterpolation treten keine Probleme auf, wenn der Roboter singulärePunkte passiert.Bei der Ausführung einer linearen oder kreisförmigen Bahn in der Nähe einerSingularität können die Geschwindigkeiten in einigen Achsen (1 und 6/4 und 6)sehr hoch sein. Damit die zulässige Höchstgeschwindigkeit nicht überschrittenwird, wird die Geschwindigkeit auf der linearen Bahn reduziert.Die hohen Achsengeschwindigkeiten können durch Verwendung des Modus(SingArea\Wrist) verringert werden, wenn die Handgelenkachsen inAchsenwinkeln interpoliert werden, während die lineare Bahn desRoboterwerkzeugs beibehalten wird. Dies ergibt jedoch einen Orientierungsfehlerim Vergleich zur vollständigen linearen Interpolation.Beachten Sie, dass sich die Roboterkonfiguration erheblich ändert, wenn derRoboter die Nähe einer Singularität mit linearer oder kreisförmiger Interpolationpassiert. Um die Neukonfiguration zu verhindern, sollte die erste Position an deranderen Seite der Singularität mit einer Orientierung programmiert werden, durchdie sich die Neukonfiguration erübrigt.Außerdem sollte beachtet werden, dass der Roboter nicht in seiner Singularitätsein darf, wenn nur externe Achsen bewegt werden. Dies könnte zu überflüssigenBewegungen der Roboterachsen führen.Bei Robotern mit 7 oder mehr Achsen, kann der Roboter den Armwinkelmöglicherweise automatisch ausrichten, um einige Singularitäten zu vermeiden.Weitere Informationen dazu erhalten Sie in der Bedienungsanleitung Ihres Roboters.

Manuelle Bewegung durch SingularitätenBei der Achseninterpolation treten keine Probleme auf, wenn der Roboter singulärePunkte passiert.Bei der linearen Interpolation kann der Roboter singuläre Punkte nicht passieren.Während der Bewegung von großen Gelenken kann die Annäherung anSingularitäten zu einer Verminderung der TCP-Geschwindigkeit führen.


Beschrieben in:

Technisches Referenzhandbuch - RAPID In-struktionen, Funktionen und Datentypen

Steuerung des Roboterverhaltens bei derAbarbeitung in der Nähe von singulärenPunkten



2 Bewegung und E/A-Programmierung2.7 SingularitätenFortsetzung

2.8 Optimierte Beschleunigungsbegrenzung

BeschreibungBeschleunigung und Geschwindigkeit des Roboters werden ständig kontrolliert,damit die definierten Grenzen nicht überschritten werden.Die Grenzen werden durch das Anwenderprogramm (z. B. programmierteGeschwindigkeit oder AccSet) oder durch das System selbst definiert (z. B.maximales Drehmoment in Getriebe oder Motor, maximales Drehmoment odermaximale Kraft in Roboterstruktur).

LastdatenSolange die Lastdaten (Masse, Zentrum der Schwerkraft und Trägheit) innerhalbder Grenzen des Lastdiagramms liegen und korrekt in die Werkzeugdateneingegeben wurden, sind keine anwenderdefinierten Beschleunigungsgrenzenerforderlich und die Lebensdauer des Roboters ist automatisch gewährleistet.Wenn die Lastdaten außerhalb der Grenzen des Lastdiagramms liegen, könnenbesondere Einschränkungen erforderlich sein, d. h. AccSet oder geringereGeschwindigkeit, wie auf Anfrage von ABB mitgeteilt.

TCP-BeschleunigungTCP-Beschleunigung und -Geschwindigkeit steuert die Bahnplanung mithilfe einesvollständigen dynamischen Modells der Roboterarme, einschließlichanwenderdefinierter Lasten.TCP-Beschleunigung und -Geschwindigkeit hängen von der Stellung,Geschwindigkeit und Beschleunigung aller Achsen zu jedem Zeitpunkt ab, dahervariiert die tatsächliche Beschleunigung ständig. Auf diese Weise wird eine optimaleZyklusdauer erzielt, d. h. eine oder mehrere Grenzen sind zu jedem Zeitpunkt aufihrem Höchstwert. Das bedeutet, dass jederzeit die maximale Fähigkeit derRobotermotoren und -struktur genutzt wird.



2 Bewegung und E/A-Programmierung2.8 Optimierte Beschleunigungsbegrenzung

2.9 Weltzonen

Beschreibung von WeltzonenBei Verwendung von Weltzonen (Option World Zones) stoppt der Roboter seineBewegung oder ein digitaler Ausgang wird automatisch gesetzt, falls sich derRoboter in einem speziellen, anwenderdefinierten Bereich befindet.Anwendungsbeispiele:

• Zwei Roboter benutzen teilweise überlagernde Arbeitsbereiche. DurchÜberwachung der Signale können die Systeme sicherstellen, dass die beidenRoboter nicht miteinander kollidieren.

• Externe Einrichtungen befinden sich im Arbeitsbereich des Roboters. Eskann ein „verbotener“ Arbeitsbereich definiert werden, damit der Roboternicht mit diesen externen Einrichtungen zusammenstößt.

• Der Roboter befindet sich an einer Position, an der der Start derProgrammabarbeitung von einem SPS zulässig ist.

WARNUNG

Aus Sicherheitsgründen darf diese Software nicht zum Schutz von Personalbenutzt werden. Verwenden Sie hierfür Hardware-Schutzausrüstung.

Verwenden von WeltzonenVerwenden Sie Weltzonen zu folgenden Zwecken:

• Um anzuzeigen, dass der Werkzeugarbeitspunkt sich in einem speziellenTeil des Arbeitsbereichs befindet.

• Für die Beschränkung des Arbeitsbereichs des Roboters, um eine Kollisionmit dem Werkzeug zu vermeiden.

• Zur Definition eines gemeinsamen Arbeitsbereichs für zwei Roboter, wobeider Bereich immer nur jeweils einem Roboter zur Verfügung steht.



2 Bewegung und E/A-Programmierung2.9 Weltzonen

Definition von Weltzonen im Welt-KoordinatensystemWeltzonen werden im Welt-Koordinatensystem definiert. Die Seiten der Quaderliegen parallel zu den Koordinatenachsen, und die Zylinderachse liegt parallel zurz-Achse des Welt-Koordinatensystems.

xx1100000678

Eine Weltzone kann so definiert werden, dass sie innerhalb oder außerhalb desQuaders, der Kugel oder des Zylinders liegt.Die Weltzone kann auch in Achsen definiert werden. Die Zone muss für alle Roboteroder zusätzlichen Achsen zwischen (innerhalb) oder nicht zwischen (außerhalb)zwei Achsenwerten definiert werden.

Überwachung des Roboter-TCP

xx1100000679

Der einzige Punkt am Roboter, dessen Bewegung überwacht wird, ist derWerkzeugarbeitspunkt.Der TCP wird unabhängig vom Betriebsmodus, z. B. beim manuellen Bewegenoder bei der Programmabarbeitung, immer überwacht.




Fortsetzung

Stationäre TCPsWenn der Roboter ein Werkobjekt hält und an einem stationären Werkzeug arbeitet,wird ein stationärer TCP verwendet. Falls dieses Werkzeug aktiv ist, bewegt essich nicht, und wenn es sich innerhalb einer Weltzone befindet, bleibt es immer indieser Weltzone.

Aktionen

Setzen eines digitalen Ausgangs, wenn der TCP in einer Weltzone istDiese Aktion setzt einen digitalen Ausgang, wenn sich der TCP in einer Weltzonebefindet. Sie wird verwendet, um anzuzeigen, dass der Roboter in einer bestimmtenZone gestoppt hat.

xx1100000680

Setzen eines digitalen Ausgangs, bevor der TCP eine Weltzone erreichtDiese Aktion setzt einen digitalen Ausgang, bevor der TCP eine Weltzone erreicht.Mit ihr kann der Roboter direkt innerhalb einer Weltzone gestoppt werden.

xx1100000681

Stoppen des Roboters, bevor der TCP eine Weltzone erreichtEine Weltzone kann außerhalb des Arbeitsbereichs definiert werden. Der Roboterstoppt dann mit dem Werkzeugarbeitspunkt auf dem Weg zur Weltzone, kurz bevorer die Zone erreicht.

xx1100000682

Wenn der Roboter etwa durch Lösen der Bremsen oder manuelles Verfahren ineine Weltzone bewegt wird, die als „außerhalb des Arbeitsbereichs“ definiert ist,



2 Bewegung und E/A-Programmierung2.9 WeltzonenFortsetzung

kann der Roboter nur noch durch manuelles Verfahren oder manuelles Bewegenbei gelösten Bremsen aus dieser Zone gebracht werden.

Mindestgröße von WeltzonenDie Überwachung der Bewegung des Werkzeugarbeitspunkts (TCP) erfolgt andiskreten Punkten mit einer Abtastrate zwischen den Punkten, die von derBahnauflösung abhängt. Es obliegt dem Anwender, die Zonen so groß einzurichten,dass der Roboter keine Zone durchfahren kann, ohne in der Zone geprüft zu werden.Stellen Sie daher die Zone etwas größer ein als die Mindestgröße.

xx1100000683

Wenn derselbe digitale Ausgang für mehrere Weltzonen verwendet wird, muss derAbstand zwischen den Zonen die Mindestgröße (siehe obige Tabelle) überschreiten,um einen fehlerhaften Zustand des Ausgangs zu verhindern.Es ist möglich, dass der Roboter durch eine Ecke der Zone fahren kann, ohnebemerkt zu werden, falls die Dauer des Zonenaufenthalts zu kurz ist. Stellen Siedaher die Zone größer ein als den gefährlichen Bereich.

xx1100000684

Wenn Weltzonen in Verbindung mit Softservo verwendet werden, muss dieZonengröße zusätzlich erweitert werden, um die Verzögerung durch Softservoauszugleichen. Die Softservoverzögerung ist der Abstand zwischen dem TCP desRoboters und der Weltzonenüberwachung zur Interpolationszeit. Die




Fortsetzung

Softservoverzögerung wird erhöht, wenn mit der Instruktion SoftAct eine höhereWeichheit definiert wird.

Maximale Anzahl an WeltzonenMaximal 20 Weltzonen können gleichzeitig definiert sein.

Stromausfall, Neustart und Motoren einStationäre Weltzonen werden bei einem Stromausfall oder beim Abschalten desSystems gelöscht und müssen beim Einschalten des Systems durch eineEreignisroutine, verbunden mit dem Ereignis NETZ_EIN, erneut initialisiert werden.Temporäre Weltzonen bleiben bei Stromausfall oder Abschalten des Systemserhalten, werden aber beim Laden eines neuen Programms oder beim Start einesProgramms aus dem Hauptprogramm gelöscht.Die digitalen Ausgänge für die Weltzonen werden erst bei Motoren ein aktualisiert.Das bedeutet, dass bei einem Neustart der Steuerung der Weltzonenstatus währenddes Startens auf eine Zone außerhalb des Arbeitsbereichs gesetzt wird. Beimersten MOTORS ON nach einem Neustart wird der Weltzonenstatus ordnungsgemäßaktualisiert.Wenn der Roboter während MOTORS OFF bewegt wird, wird der Weltzonenstatuserst beim nächsten MOTORS ON-Befehl aktualisiert.Ein harter Not-Aus (kein SoftAS, SoftGS oder SoftES) kann einen falschenWeltzonenstatus zur Folge haben, da sich der Roboter während der Stoppbewegungin eine Zone oder aus ihr heraus bewegen kann, ohne dass die Signale der Weltzoneaktualisiert werden. Die Weltzonensignale werden nach einem MOTORS ON-Befehlordnungsgemäß aktualisiert.


KoordinatensystemeBewegung und E/A-Prinzi-pien


Datentypen:• wztemporary

• wzstationary

• shapedata


Instruktionen:• WZBoxDef

• WZSphDef

• WZCylDef

• WZHomeJointDef

• WZLimJointDef

• WZLimSup

• WZDOSet

• WZDisable

• WZEnable

• WZFree



2 Bewegung und E/A-Programmierung2.9 WeltzonenFortsetzung

2.10 E/A-Prinzipien

BeschreibungDas Robotersystem enthält gewöhnlich eine oder mehrere E/A-Karten. Jede dieserKarten umfasst verschiedene digitale und analoge Kanäle, die vor ihrer Verwendungmit logischen Signalen verbunden werden müssen. Dies erfolgt über dieSystemparameter und wurde normalerweise schon durch Standardnamen vorAuslieferung des Roboters vorgenommen. Bei der Programmierung müssen immerlogische Signale verwendet werden.Ein physischer Kanal kann mit mehreren logischen Signalen verbunden sein,jedoch muss er keine logischen Anschlüsse besitzen (siehe Abbildung 57).

xx1100000685

Abbildung 57: Damit eine E/A-Karte benutzt werden kann, müssen ihre Kanäle logische Signale erhalten.In obigemBeispiel ist der physische Ausgang 2mit zwei verschiedenen logischen Signalen verbunden.IN16 hat dagegen kein logisches Signal und kann daher nicht benutzt werden.

SignaleigenschaftenDie Eigenschaften eines Signals hängen vom verwendeten physischen Kanal sowievon der Definition des Kanals in den Systemparametern ab. Der physische Kanalbestimmt Zeitverzögerungen und Spannungshöhen (siehe Produktspezifikation).Die Eigenschaften, Filterzeiten und Skalierung zwischen programmierten undphysischen Werten werden in den Systemparametern definiert.Wenn die Stromversorgung des Roboters eingeschaltet ist, werden alle Signaleauf null gesetzt. Sie werden jedoch nicht durch Not-Aus oder ähnliche Ereignissebeeinflusst.Ein Ausgangssignal kann innerhalb des Programms auf eins oder null gesetztwerden. Dies ist auch über eine Verzögerung oder einen Impuls möglich. Wird einImpuls oder verzögertes Umschalten für ein Ausgangssignal angefordert, wird dasProgramm weiter abgearbeitet. Die Änderung wird dann ausgeführt, ohne dieübrige Abarbeitung des Programms zu beeinflussen. Wenn andererseits ein neuer



2 Bewegung und E/A-Programmierung2.10 E/A-Prinzipien

Wechsel für dasselbe Ausgangssignal angefordert wird, bevor eine vorgegebeneZeit abgelaufen ist, wird das erste Umschalten nicht ausgeführt (siehe Abbildung58).

xx1100000686

Abbildung 58: Die Instruktion SetDO wird nicht ausgeführt, da ein neuer Befehl erteilt wurde, bevordie Zeitverzögerung abgelaufen ist.

Signale für InterruptsInterrupt-Funktionalität von RAPID kann mit digitalen Signalwechseln verbundensein. Die Funktion kann auf eine ansteigende oder abfallende Signalflankereagieren. Bei sehr schnellen Signalwechseln ist es jedoch möglich, dass derInterrupt verpasst wird.Beispiel: Eine Funktion ist mit dem Signal do1 verbunden und der Programmcodelautet wie folgt:

SetDO do1,1;

SetDO do1,0;

Das Signal geht zunächst in den Zustand „High“ (1) und dann nach wenigenMillisekunden in den Zustand „Low“ (0). In diesem Fall wird der Interruptmöglicherweise verpasst. Damit der Interrupt nicht verpasst wird, stellen Sie sicher,dass der Ausgang gesetzt ist, bevor Sie ihn zurücksetzen.Beispiel:

SetDO do1,1;

WaitDO do1 ,1;

SetDO do1,0;

Auf diese Weise werden keine Interrupts verpasst.

SystemsignaleLogische Signale können mit speziellen Systemfunktionen verbunden werden.Wenn z. B. ein Eingang mit der Systemfunktion Start verbunden ist, erfolgt einautomatischer Programmstart, sobald dieser Eingang freigegeben wird. DieseSystemfunktionen werden generell nur im Automatikmodus freigegeben.



2 Bewegung und E/A-Programmierung2.10 E/A-PrinzipienFortsetzung

QuerverbindungenDigitale Signale können so miteinander verbunden werden, dass sie sichautomatisch gegenseitig beeinflussen.

• Ein Ausgangssignal kann mit einem oder mehreren Eingangs- oderAusgangssignalen verbunden sein.

• Ein Eingangssignal kann mit einem oder mehreren Eingangs- oderAusgangssignalen verbunden sein.

• Wenn dasselbe Signal in mehreren Querverbindungen benutzt wird, ist derWert dieses Signals gleich dem zuletzt aktivierten (geänderten) Wert.

• Querverbindungen können verknüpft werden, d. h. eine Querverbindungkann eine andere beeinflussen. Sie dürfen jedoch nicht zirkulär verbundenwerden, z. B. durch eine Querverbindung zwischen di1 und di2, währendeine Querverbindung zwischen di2 und di1 besteht.

• Wenn eine Querverbindung an einem Eingangssignal besteht, wird dieentsprechende physische Verbindung automatisch deaktiviert. Änderungenam physischen Kanal werden daher nicht erkannt.

• Impulse oder Verzögerungen werden nicht über Querverbindungenübertragen.

• Logische Bedingungen können mithilfe von NOT, AND und OR definiert werden(erfordert die Option Advanced functions).

BeschreibungBeispiele

Wenn di1 geändert wird, werden di2, di3 und do4 in den entspre-chenden Wert geändert.

di2=di1

di3=di2

do4=di2

Wenn do7 auf 1 gesetzt wird, wird do8 ebenfalls auf 1 gesetzt.Wenn dann di5 auf 0 gesetzt wird, wird do8 ebenfalls geändert(obwohl do7 immer noch 1 ist).

do8=do7

do8=di5

do5 wird auf 1 gesetzt, wenn di6 und do1 auf 1 gesetzt sind.do5 = di6 ANDdo1

EinschränkungenMaximal 10 Signale können gleichzeitig gepulst und maximal 20 Signale gleichzeitigverzögert werden.


Beschrieben in

Technisches Referenzhandbuch - Systempara-meter

Definition von E/A-Karten und -Signalen

Eingangs- und Ausgangssignale auf Seite 66Instruktionen für die Handhabung vonE/A

Bedienungsanleitung - IRC5 mit FlexPendantManuelle Handhabung von E/A



2 Bewegung und E/A-Programmierung2.10 E/A-Prinzipien

Fortsetzung

Diese Seite wurde absichtlich leer gelassen

3 GlossarGlossar

BeschreibungBegriff

Die Teile einer Instruktion, die geändert werden können, d. h. allesaußer dem Namen der Instruktion.

Argument

Der Modus, in dem der Wahlschalter für die Betriebsart auf folgen-dem Symbol steht:

xx1100000688

Automatikbetrieb

Ein Teil eines Datensatzes.Komponente

Die Stellung der Roboterachsen an einer bestimmten Position.Konfiguration

Daten, die nur manuell geändert werden können.Konstante

Die Bahn, die beim Passieren eines Fly-By-Punkts erzeugt wird.Zonenbahn

Der Teil einer Routine oder von Daten, der ihre Eigenschaften de-finiert.

Deklaration

Dialogfelder auf dem FlexPendant müssen immer bestätigt werden(gewöhnlich durch Tippen auf OK oder Abbrechen), bevor sie ge-schlossen werden können.

Dialog/Dialogfeld

Ein separater Teil einer Routine, in dem ein Fehler behoben werdenkann. Die normale Programmabarbeitung kann dann automatischneu gestartet werden.

Fehlerbehandlung

Eine Folge von Daten und zugehörigen Operanden, z. B. reg1+5oder reg1>5.

Ausdruck

Ein Punkt, den der Roboter in einem bestimmten Abstand passiert,ohne anzuhalten. Die Entfernung zu diesem Punkt hängt von derGröße der programmierten Zone ab.

Fly-By-Punkt

Eine Routine, die einen Wert zurückgibt.Funktion

Eine Anzahl digitaler Signale, die zusammengefasst sind und wieein einzelnes Signal behandelt wird.

Gruppensignal

Ein Ereignis, das kurzzeitig die Programmabarbeitung unterbrichtund eine Interrupt-Routine abarbeitet.

Interrupt

Elektrische Eingänge und Ausgänge.E/A

Die Routine, die normalerweise gestartet wird, wenn die Start-Taste gedrückt wird.

Main-Routine

Der Modus, in dem der Schalter für die Betriebsart auf folgendemSymbol steht:

xx1100000687

Einrichtbetrieb



3 Glossar

BeschreibungBegriff

Eine Gruppe von zusätzlichen Achsen.Mechanische Einheit

Eine Gruppe von Routinen und Daten, d. h. ein Teil des Programms.Modul

Der Zustand des Roboters, d. h. ob die Stromversorgung zu denMotoren geschaltet ist oder nicht.

Motors On/Off

Das Bedienfeld an der Vorderseite der Steuerung.Bedienfeld

Die Richtung eines Endeffektors.Orientierung

Die Eingangsdaten einer Routine, die mit dem Aufruf der Routineübertragen werden. Sie entsprechen den Argumenten einer Instruk-tion.

Parameter

Eine Variable, deren Wert persistent ist.Persistente

Eine Routine, die bei ihrem Aufruf eigenständig eine Instruktionbilden kann.

Prozedur

Der Satz von Instruktionen und Daten, die die Aufgabe des Robo-tersystems definieren.

Programm

Programme enthalten jedoch keine Systemmodule.

Daten, die in einem Modul oder im vollständigen Programm verwen-det werden können.

Programmdaten

Ein Modul des Roboterprogramms, das beim Kopieren des Pro-gramms auf eine Diskette übertragen wird.

Programmmodul

Ein zusammengesetzter Datentyp.Datensatz

Ein Unterprogramm.Routine

Lokale Daten, die nur in einer Routine verwendet werden können.Routinendaten

Die Instruktion, die als Erste abgearbeitet wird, wenn die Program-mabarbeitung beginnt.

Startpunkt

Ein Punkt, an dem der Roboter anhält, bevor er mit dem nächstenPunkt fortfährt.

Stopppunkt

Ein Modul, das immer im Programmspeicher vorhanden ist. BeimLaden eines neuen Programms bleiben die Systemmodule imProgrammspeicher.

Systemmodul

Die Einstellungen, die das Robotersystem und seine Eigenschaftendefinieren, so genannte Konfigurationsdaten.

Systemparameter

Der Punkt, normalerweise die Spitze des Werkzeugs, der sichentlang der programmierten Bahn mit der programmierten Ge-schwindigkeit bewegt.

Werkzeugarbeitspunkt(TCP)

Die Routine, die die Aktionen festlegt, die bei Eintreten eines be-stimmten Interrupts auszuführen sind.

Interrupt-Routine

Daten, die das Programm ändern kann, die aber ihren Inhalt verlie-ren (wieder ihren Anfangswert annehmen), wenn das Programmerneut gestartet wird.

Variable

Der Roboter wird mit verschiedenen Fenstern (oder Ansichten) amFlexPendant programmiert und bedient, z. B. demProgrammeditor-Fenster und dem Kalibrierungsfenster. Ein Fenster kann durchWechseln zu einem anderen Fenster oder durch Tippen auf dieSchaltfläche „Schließen“ in der oberen rechten Ecke geschlossenwerden.

Fenster

Der kugelförmige Raum, der einen Fly-By-Punkt umgibt. Sobaldder Roboter diese Zone betritt, beginnt er sich zur nächsten Positionzu bewegen.

Zone



3 GlossarFortsetzung

Index77 axes robots, 161

AAbarbeitungsbehandlung, 96Abarbeitungsebene, 96Achsenbewegung, 57, 126Achsenkonfiguration, 146achsenweise Interpolation, 126Aggregat, 28Aggregate

Ausdrücke, 41alias-Datentypen, 28AND, 38Anwender-Koordinatensystem, 116, 119Argument, 173

bedingt, 42Argumente

Beschreibung, 11arithmetische Ausdrücke, 37arithmetische Funktionen, 89Atom, Datentyp, 28Ausdruck, 173Ausdrücke, 37

arithmetisch, 37logisch, 38Zeichenfolge, 39

Ausgangssignale, 66Auswahllisten, 47Automatikbetrieb, 173

BBahnaufzeichnung, 62Bahnkorrektur, 61Basis-Koordinatensystem, 114, 120Bedienfeld, 174bedingtes Argument, 42Beenden der Routine, 23Bewegung, 57Bewegungsdaten, 64Bewegungseinstellungen

Instruktionen, 52Bewegungsinstruktionen, 57Bewegungsüberwachung, 156Bezeichner, 13binäre Kommunikation, 71Bit-Funktionen, 90bool, 51

Cconfdata, 147ConfJ, 149ConfL, 149CONST, 34Conveyor Tracking, 62

DDateiinstruktion, 71Dateivorspann, 15Daten, 28

Beschreibung, 11Deklarationen, 30Gültigkeitsbereich, 30in Ausdrücken verwendet, 40

initialisieren, 34Konstante, 30Persistente, 30Programm, 30Routine, 31Speicherklasse, 35Variable, 30Zuweisen von Werten, 50

DatenfelderAusdrücke, 40Variablen, 32

Datensatz, 174Datensatz (record), 28Datensätze

Ausdrücke, 40Datentypen, 28

Aggregate, 28alias, 28Atom, 28Datensatz (record), 28fester Wert, 28Komponenten, 28ohne einen Wert, 28

Datentypen mit einem festen Wert, 28Datentypen ohne einen Wert (non-value), 28Deklaration, 173

Modul, 18Routine, 24

DeklarationenKonstanten, 34Persistenten, 33Variablen, 31

Dialogfeld, 173DIV, 37dnum, 51

EE/A, 173E/A-Prinzipien, 169E/A-Signale, 66E/A-Synchronisierung, 141Eingangssignale, 66Einrichtbetrieb, 173Ereignisprotokoll, 83Ereignistyp, 96ERRNO, 82

FFehlerbehandlung, 173Fehlerbehandlungen, 82Fehlerbehebung, 80Fehlernummern, 80Fenster, 174fest positionierte E/A, 144fly-by point, 130Fly-By-Punkt, 141, 173Funktion, 21, 173Funktionen für Dateioperationen, 93Funktionsaufrufe, 42Funktionsdeklaration, 24

Ggleiche Datentypen, 28global

Daten, 30Routine, 21

Glossar, 173



Index

Groß-/Kleinschreibung, 12Gruppensignal, 173Gültigkeitsbereich


HHandgelenk-Koordinatensystem, 121Hauptroutine, 17

IInitialisieren von Daten, 34INOUT, 22Instruktionen

Auswahllisten, 47Beschreibung, 11Programmablauf, 48

Interpolation, 126, 130Interrupt, 173Interrupt-Deklaration, 24Interrupt-Routine, 21, 174Interrupt-Routinen, 75, 78Interrupts, 58, 75

KKalibrierung, 98kinematische Modelle, 151Kollisionserkennung, 63, 156Kommentar, 14Kommentare, 50Kommunikation, 92Kommunikationsinstruktionen, 70Kommunikation über serielle Kanäle, 71Komponente eines Datensatzes, 28, 173Konfiguration, 173

Roboter, 146Konfigurationsdaten, 95Konstante, 30, 173Konstanten, 34

Initialisierungswerte, 34Konvertierung, 100Konvertierungen, 51Koordinatensysteme, 113, 151koordinierte zusätzliche Achsen, 119kreisförmige Bewegung, 57, 127kreisförmige Interpolation, 127

LLaden von Modulen, 50Lastidentifikation, 63lineare Bewegung, 57, 126lineare Interpolation, 126logische Ausdrücke, 38logische Werte, 14lokal


MMain-Routine, 173Mathematische Instruktionen, 89mechanische Einheit, 174MOD, 37modifizierte lineare Interpolation, 129Modul, 174Moduldeklaration, 18Module, 17

Beschreibung, 17Motors on/off, 174MultiMove, 60, 103Multitasking, 102

NNeustarten der Steuerung, 95NOT, 38num, 51numerische Werte, 14

OObjekt-Koordinatensystem, 117Operatorpriorität, 44optionaler Parameter, 22OR, 38Orientierung, 174

PParameter, 22, 174PERS, 33Persistente, 30, 174Persistenten, 33

Initialisierungswerte, 34Platzhalter, 15Positionierfunktionen, 63Positionierungsinstruktionen, 57Priorität

Operatoren, 44Tasks, 106

Programm, 17, 174Programmablauf-Instruktionen, 48Programmdaten, 28, 30, 174Programmmodul, 174Programmodul, 17Prozedur, 21, 174Prozeduraufruf, 25Prozedurdeklaration, 24

Qquarter revolutions, 147Querverbindungen, 171

RRAPID Message Queues, 73rawbyte-Kommunikation, 72reservierte Wörter, 13Roboterkinematik, 151Roboterkonfiguration, 146Roboter mit serieller Verbindung, 161Routine, 21, 174Routinen

Beschreibung, 11Routinendaten, 31, 174Routinendeklaration, 24Rückwärtsabarbeitung, 108Rückwärtsbehandlung, 108

SSensorsynchronisierung, 63Service, 98Serviceinformationen, 97Servo Tracking, 62Signale, 66, 169simultane Abarbeitung, 142Singularitäten, 129, 160Socket-Kommunikation, 72



Index

Softservo, 55, 139Speicher, 95Startpunkt, 174stationärer TCP, 123Statusfunktionen, 64Stopp, 140Stoppen der Programmabarbeitung, 48Stopppunkt, 174string, 51Suchinstruktionen, 58switch, 23, 51Synchronisierung, 141Synchronisierung der Bahn, 144Syntaxregeln, 9Systemdaten, 94Systemmodul, 18, 174Systemparameter, 174

TTaktförderer, 62Tasks, 96, 102task selection panel, 96TCP, 113, 174

stationär, 123

UÜberwachung

Roboterkonfiguration, 148Überwachung der Roboterkonfiguration, 148Uhr, 87unabhängige Achsen, 61, 136

UNDO, 84unterbrochene Bahn, 64User Systemmodul, 20

VVAR, 31Variable, 30, 174Variablen, 31

Datenfelder, 32Initialisierungswerte, 34

Verschiebungs-Koordinatensystem, 118

WWarteinstruktionen, 50Welt-Koordinatensystem, 114Weltzonen, 55, 164Werkzeugarbeitspunkt, 113, 174Werkzeug-Koordinatensystem, 121

XXOR, 38

ZZeichenfolge, 14Zeichenfolgenausdrücke, 39Zeichenfolgenfunktionen, 100Zeitinstruktionen, 87Zone, 130, 174Zonenbahn, 130, 173zusätzliche Achsen, 60, 119Zuweisen von Datenwert, 50



Index

ABB AB, RoboticsRobotics and MotionS-721 68 VÄSTERÅS, SwedenTelephone +46 (0) 21 344 400

ABB AS, RoboticsRobotics and MotionNordlysvegen 7, N-4340 BRYNE, NorwayBox 265, N-4349 BRYNE, NorwayTelephone: +47 22 87 2000

ABB Engineering (Shanghai) Ltd.Robotics and MotionNo. 4528 Kangxin HighwayPuDong DistrictSHANGHAI 201319, ChinaTelephone: +86 21 6105 6666

ABB Inc.Robotics and Motion1250 Brown RoadAuburn Hills, MI 48326USATelephone: +1 248 391 9000

abb.com/robotics

3HAC050947-003,Rev

H,de


Documents

ROBOTICS TechnischesReferenzhandbuch RAPIDÜberblick · Revision Beschreibung VeröffentlichtmitRobotWare6.01. • FürdiezusätzlicheTriggJIOs-Instruktion,sieheAktivierenvon