Controller
Werbung
Beschneiden: Oben: 61,5 mm Unten: 61,5 mm Links: 43,5 mm Rechts: 43,5 mm Controller Beschreibung Programmieranleitung CMXR FTL-Basis Beschreibung 560 315 de 1002b [752 931] Ausgabe _____________________________________________________ 1002b Bezeichnung ______________________________________ GDCP-CMXR-SW-DE Bestell-Nr. __________________________________________________ 560 315 Festo AG & Co KG., D-73734 Esslingen, 2010 Internet: http://www.festo.com E-Mail: [email protected] Weitergabe sowie Vervielfältigung dieses Dokuments, Verwertung und Mitteilung seines Inhalts verboten, soweit nicht ausdrücklich gestattet. Zuwiderhandlungen verpflichten zu Schadenersatz. Alle Rechte vorbehalten, insbesondere das Recht, Patent-, Gebrauchsmuster- oder Geschmacksmusteranmeldungen durchzuführen. Festo GDCP-CMXR-SW-DE de Version 1.0 3 Verzeichnis der Revisionen Ersteller: Handbuchname: GDCP-CMXR-SW-DE Dateiname: Speicherort der Datei: Lfd. Nr. Beschreibung Revisions-Index Datum der Änderung 001 Erstellung 0805NH 25.06.2008 002 Anpassung an Version 1.20 0909a 25.08.2009 003 Anpassung an CMXR-C2 Version 1.0 1002b 24.03.2010 4 Festo GDCP-CMXR-SW-DE de Version 1.0 INHALTSVERZEICHNIS INHALTSVERZEICHNIS 1. Einleitung............................................................................................................ 13 1.1 Gültigkeit........................................................................................................... 13 2. Sicherheitshinweise ............................................................................................ 14 2.1 Gebrauch der Dokumentation ............................................................................ 14 2.2 Bestimmungsgemäßer Gebrauch ....................................................................... 14 2.3 Qualifiziertes Personal ....................................................................................... 15 2.4 Sicherheitshinweise zu den Produkten .............................................................. 15 2.5 Sicherheitshinweise zu diesem Handbuch ......................................................... 15 2.6 Sicherheitsanweisungen für das beschriebene Produkt ..................................... 16 3. Programmbearbeitung ........................................................................................ 17 3.1 Allgemein .......................................................................................................... 17 3.2 Interpreter ......................................................................................................... 17 3.3 Programmstart .................................................................................................. 17 3.4 Satzvorlauf ........................................................................................................ 17 3.5 Programmstruktur ............................................................................................. 19 3.6 FTL-Projekte ...................................................................................................... 19 3.6.1 Globales FTL-Projekt........................................................................... 20 3.7 FTL-Programme ................................................................................................. 20 3.7.1 Projektglobale Programme ................................................................. 20 3.8 FTL-Datendatei „<Name>.tid“.............................................................................. 21 3.8.1 Programmlokale Daten ....................................................................... 21 3.8.2 Projektglobale Daten .......................................................................... 21 3.8.3 Systemglobale Daten ......................................................................... 22 3.8.4 Instanziierung von Variablen .............................................................. 23 4. Sprachaufbau ...................................................................................................... 25 4.1 Formatierung ..................................................................................................... 25 4.2 Bezeichner......................................................................................................... 25 4.3 Schlüsselwörter ................................................................................................. 25 4.4 Zahlenkonstante ................................................................................................ 26 4.5 Zeichenketten .................................................................................................... 26 4.6 Operatoren und Begrenzungszeichen ................................................................ 26 4.6.1 Arithmetische Operatoren .................................................................. 27 4.6.2 Logische Operatoren .......................................................................... 27 4.6.3 Vergleichsoperatoren ......................................................................... 27 Festo GDCP-CMXR-SW-DE de Version 1.0 5 INHALTSVERZEICHNIS 4.6.4 4.6.5 Sonstige Operatoren .......................................................................... 28 Begrenzungszeichen .......................................................................... 28 5. Grunddatentypen ................................................................................................ 29 5.1 Boolescher Datentyp (BOOL) ............................................................................. 30 5.2 Ganzzahl-Typen, REAL-Datentyp, Bitmuster-Typen ............................................ 31 5.3 Klammern .......................................................................................................... 31 5.4 Zeichenketten (STRING) ..................................................................................... 32 5.5 Strukturierte Datentypen ................................................................................... 32 5.6 Arrays ................................................................................................................ 32 5.6.1 Initialisierung von Arrays .................................................................... 34 5.6.2 Bestimmen der Arraygrenzen mit LOW und HIGH ................................ 34 5.7 Referenzvariablen (Mapping) ............................................................................. 36 5.7.1 Deklaration von Referenzvariablen, <MAPTO> ..................................... 37 5.7.2 Verbinden von Referenzvariablen, <MAP> ............................................ 37 5.7.3 Prüfen von Referenzvariablen, <IS_MAPPED> ...................................... 37 6. Variablendeklarationen ...................................................................................... 39 6.1 Initialisierung .................................................................................................... 39 7. Ausdrücke ........................................................................................................... 40 7.1 Ausführungsreihenfolge in Ausdrücken ............................................................. 40 8. Programmsteuerung ........................................................................................... 41 8.1 Anweisungen ..................................................................................................... 41 8.2 Wertzuweisung <:=> .......................................................................................... 41 8.3 Bedingungen ..................................................................................................... 41 8.4 Verzweigung <IF…THEN> ..................................................................................... 42 8.5 Sprungbefehle ................................................................................................... 43 8.5.1 Sprungmarke <LABEL>......................................................................... 44 8.5.2 Bedingter Sprung <IF…GOTO> .............................................................. 44 8.5.3 Absoluter Sprung <GOTO> ................................................................... 45 8.6 Schleifen ........................................................................................................... 45 8.6.1 WHILE-Anweisung <WHILE> ................................................................. 45 8.6.2 LOOP-Anweisung <LOOP> .................................................................... 46 8.7 Unterprogramme ............................................................................................... 47 8.7.1 Unterprogrammaufruf <CALL>.............................................................. 48 8.7.2 Programmrücksprung <RETURN> ......................................................... 49 8.8 Parallele Programme ......................................................................................... 50 8.8.1 Paralleles Programm starten <RUN> .................................................... 51 8.8.2 Paralleles Programm beenden <KILL> .................................................. 51 6 Festo GDCP-CMXR-SW-DE de Version 1.0 INHALTSVERZEICHNIS 8.9 Beeinflussen des Satzvorlaufes ......................................................................... 52 8.9.1 WAIT – Anweisung mit Zeit <WaitTime>................................................ 52 8.9.2 WAIT- Anweisung mit Bedingung <WAIT> ............................................. 53 8.9.3 WaitOnPath – Anweisung mit Zeit <WaitOnPath> ................................. 55 8.9.4 WaitOnPos – Anweisung mit Zeit <WaitOnPos> .................................... 56 8.9.5 WaitOnMainRun – Warten auf Hauptlauf <WaitOnMainRun> ................ 57 8.10 DO Anweisung ................................................................................................... 58 8.11 Kommentare einfügen <//> ................................................................................. 60 8.12 Programmzeile deaktivieren <##> ....................................................................... 60 9. Bewegungsbefehle ............................................................................................. 62 9.1 Positionsbeschreibung ...................................................................................... 62 9.1.1 Achsposition ...................................................................................... 62 9.1.2 Kartesische Position ........................................................................... 65 9.1.3 Teachen von Positionsvariable ........................................................... 67 9.2 Point-To-Point-Bewegung <Ptp>.......................................................................... 67 9.2.1 Teachen der Ptp Bewegung ................................................................ 70 9.3 Relative Point-To-Point-Bewegung <PtpRel> ....................................................... 70 9.4 Bewegung einer Achse, <MoveAxisPtp>, <MoveAxisCart> ..................................... 72 9.4.1 Teachen der Position bei MoveAxisPtp und MoveAxisCart .................. 74 9.5 Linearbewegung <Lin> ........................................................................................ 76 9.5.1 Teachen der Lin Bewegung ................................................................. 78 9.6 Relative Linearbewegung <LinRel> ...................................................................... 78 9.7 Zirkularbewegung mit Stützpunkt ...................................................................... 80 9.7.1 Funktionsweise .................................................................................. 80 9.7.2 Ebenendefinition ................................................................................ 81 9.7.3 Zirkularbefehl mit Stützpunkt <CircIp> ................................................. 83 9.7.4 Zirkularbefehl mit Stützpunkt, PTP-Anfahrt <PtpToCircIp>.................... 85 9.7.5 Zirkularbefehl mit Stützpunkt, Lin Anfahrt <LinToCircIp> ...................... 87 9.7.6 Teachen der Zirkularbefehle ............................................................... 88 9.8 Stoppen der Bewegung <StopMove> .................................................................. 89 9.9 Stoppen des Programms <StopProgram> ............................................................ 90 10. Dynamikbefehle .................................................................................................. 91 10.1 Autom. Begrenzung der Dynamik, Dynamiklimiter ............................................. 92 10.2 Geschwindigkeiten <Vel> .................................................................................... 93 10.3 Beschleunigung <Acc> ........................................................................................ 94 10.4 Ruck <Jerk> ......................................................................................................... 95 10.5 Override ............................................................................................................ 97 10.5.1 Override am Handbediengerät <Ovr> ................................................... 97 10.5.2 Dynamikoverride <DynOvr> ................................................................. 99 Festo GDCP-CMXR-SW-DE de Version 1.0 7 INHALTSVERZEICHNIS 10.6 Beschleunigungsrampen ................................................................................. 100 10.6.1 Setzen von Rampenformen <Ramp> .................................................. 101 10.7 Konstante Bahngeschwindigkeit einschalten <VconstOn> ................................. 102 10.8 Konstante Bahngeschwindigkeit ausschalten <VconstOff> ................................ 104 11. Überschleifbefehle............................................................................................ 105 11.1 Nullsegmente .................................................................................................. 106 11.2 Grenzbereich ................................................................................................... 107 11.3 Geschwindigkeitsüberschleifen ....................................................................... 108 11.3.1 Mit Prozentfaktor <OvlVel> ................................................................ 108 11.4 Geometrisches Überschleifen .......................................................................... 110 11.4.1 Überschleifen der Achsen X, Y und Z <OvlCart> .................................. 110 12. Referenzsysteme (Nullpunktverschiebung) ...................................................... 112 12.1 Bezug des Referenzsystems ............................................................................ 112 12.2 Daten des Referenzsystems ............................................................................. 113 12.3 Referenzsystem mit direkten Werten <SetRefSys> ............................................ 114 12.4 Referenzsystem mit 3 Punkten <SetRefSys3P> .................................................. 115 12.4.1 Teachen des Referenzsystem SetRefSys3P ....................................... 116 12.5 Referenzsystem Welt <SetRefSysWorld> ........................................................... 118 12.6 Referenzsystem Dynamisch <SetRefSysDyn> > .................................................. 118 12.7 Beispiel ........................................................................................................... 119 13. Referenzieren einer Kinematik .......................................................................... 121 13.1 Referenzfahrt <RefAxis> .................................................................................... 121 13.2 Asynchrone Referenzfahrt <RefAxisAsync> ........................................................ 123 13.3 Warten auf Ende der Referenzfahrt <WaitRefFinished> ..................................... 125 13.4 Status einer Achse abfragen <IsAxisReferenced> .............................................. 126 14. Werkzeuge ........................................................................................................ 127 14.1 Werkzeugdaten ............................................................................................... 127 14.1.1 Daten TCP-Vektor ............................................................................. 127 14.2 Aktivieren von Werkzeugdaten <Tool> .............................................................. 130 14.2.1 Auswirkung von TCP-Daten .............................................................. 130 15. PROFIBUS-Schnittstelle.................................................................................... 135 15.1 Boolesche Ein- und Ausgänge, plc_InBool, plc_OutBool .................................. 136 15.2 Integer-Variablen 32 Bit, plc_Dint .................................................................... 137 15.3 Positionen, plc_AxisPos, plc_CartPos ............................................................... 138 15.4 Referenzsysteme, plcRefSys ............................................................................ 139 15.5 Programmierter Halt <ProgHold> ...................................................................... 140 8 Festo GDCP-CMXR-SW-DE de Version 1.0 INHALTSVERZEICHNIS 16. FTL Schnittstelle zur internen SPS (nur für Mehrachscontroller mit CoDeSys) . 142 16.1 FTL Systemvariablen ........................................................................................ 142 16.1.1 Beispiel mit Systemvariablen ........................................................... 143 16.1.2 Beispiel mit Systemvariablen und MAP Befehl .................................. 144 17. Meldesystem .................................................................................................... 145 17.1 Meldetexte ...................................................................................................... 145 17.2 Information <SetInfo> ....................................................................................... 147 17.3 Warnung <SetWarning> .................................................................................... 148 17.4 Fehlermeldung <SetError>................................................................................. 149 18. Funktionen ........................................................................................................ 151 18.1 Aktuelle Position lesen <ReadActualPos> .......................................................... 151 18.2 Zielposition lesen <ReadTargetPos> .................................................................. 152 18.3 Positionswert dauerhaft speichern <SavePosition> ........................................... 153 18.4 Lesen der Systemzeit <Time> ........................................................................... 153 18.5 Umwandeln Zeit in Text <TimeToStr> ................................................................ 154 18.6 Sinus <SIN>, <ASIN> ........................................................................................... 155 18.7 Cosinus <COS>, <ACOS> ..................................................................................... 156 18.8 Tangens <TAN>, <ATAN> .................................................................................... 158 18.9 Cotangens <COT>, <ACOT> ................................................................................. 159 18.10 Tangens2 <ATAN2> ........................................................................................... 160 18.11 Logarithmus <LN> ............................................................................................. 160 18.12 Exponent <EXP> ................................................................................................ 160 18.13 Absolutwert <ABS> ........................................................................................... 161 18.14 Quadratwurzel <SQRT> ..................................................................................... 161 18.15 Bitweise schieben <SHR>, <SHL>........................................................................ 162 18.16 Bitweise rotieren <ROR>, <ROL> ......................................................................... 163 18.17 Wert nach String wandeln <STR> ....................................................................... 164 18.18 ASCII Wert in Zeichen wandeln <CHR> ............................................................... 164 18.19 Zeichen in ASCII Wert wandeln <ORD>............................................................... 164 18.20 Bit in einer WORD Variable setzen <SetBit> ....................................................... 165 18.21 Bit in einer WORD Variable löschen <ResetBit> ................................................. 166 18.22 Bit in einer WORD Variable prüfen <CheckBit>................................................... 167 19. Bausteine .......................................................................................................... 168 19.1 Funktionen ...................................................................................................... 169 19.2 Variable ........................................................................................................... 169 19.3 Laufzeitverhalten ............................................................................................. 170 Festo GDCP-CMXR-SW-DE de Version 1.0 9 INHALTSVERZEICHNIS 19.3.1 Parameter ovlEnable ........................................................................ 170 19.4 Digitaler Eingangsbaustein DIN ....................................................................... 171 19.4.1 Instanziierung .................................................................................. 171 19.4.2 Methoden ........................................................................................ 173 19.4.3 Auf Zustand warten, Methode Wait / WaitN ...................................... 174 19.4.4 Zustand Lesen Methode Read .......................................................... 174 19.4.5 Steigende Flanke Methode RisingEdge ............................................. 174 19.4.6 Flanke rücksetzen Methode ResetRisingEdge ................................... 175 19.5 Digitaler Ausgangsbaustein DOUT ................................................................... 175 19.5.1 Instanziierung .................................................................................. 175 19.5.2 Variable............................................................................................ 177 19.5.3 Methoden ........................................................................................ 178 19.5.4 Auf Zustand warten, Methode Wait / WaitN ...................................... 179 19.5.5 Zustand Lesen Methode Read .......................................................... 179 19.5.6 Steigende Flanke, Methode RisingEdge ............................................ 179 19.5.7 Flanke rücksetzen, ResetRisingEdge ................................................. 180 19.5.8 Setzen und rücksetzen, Methode Set / Reset ................................... 180 19.5.9 Setzen des Ausgangs, Methode Write............................................... 181 19.5.10 Setzen des Ausgangs auf bestimmte Dauer, Methode Pulse ............. 181 19.6 Analoger Eingangsbaustein AIN ....................................................................... 182 19.6.1 Instanziierung .................................................................................. 182 19.6.2 Variable............................................................................................ 184 19.6.3 Methoden ........................................................................................ 184 19.6.4 Warten bis Wert kleiner/größer, Methode WaitLss , WaitGrt ............. 185 19.6.5 Warten bis Wert im/aus Bereich, Methode WaitIns, WaitOuts........... 186 19.6.6 Abfragen des Wertes, Methode Read ................................................ 186 19.7 Analoger Ausgangsbaustein AOUT ................................................................... 187 19.7.1 Instanziierung .................................................................................. 187 19.7.2 Variable............................................................................................ 188 19.7.3 Methoden ........................................................................................ 189 19.7.4 Schreiben des Ausgangswertes, Methode Write ............................... 190 19.7.5 Warten bis Wert größer/kleiner, Methode WaitLss, WaitGrt .............. 190 19.7.6 Warten bis Wert im/aus Bereich, Methode WaitIns, WaitOuts .................. 191 19.7.7 Ausgangswert lesen, Methode Read ................................................. 191 19.8 Uhrenbaustein CLOCK...................................................................................... 192 19.8.1 Instanziierung .................................................................................. 192 19.8.2 Methoden ........................................................................................ 193 19.8.3 Starten der Uhr, Methode Start ........................................................ 194 19.8.4 Stoppen der Uhr, Methode Stop ....................................................... 194 19.8.5 Rücksetzen der Uhr, Methode Reset ................................................. 194 19.8.6 Auslesen der Uhr, Methode Read ..................................................... 194 19.8.7 Zeitwert in String konvertieren, Methode ToStr ................................ 195 10 Festo GDCP-CMXR-SW-DE de Version 1.0 INHALTSVERZEICHNIS 19.9 Encoder-Baustein ENCODER ............................................................................ 196 19.9.1 Instanziierung .................................................................................. 196 19.9.2 Variable............................................................................................ 198 19.9.3 Methoden ........................................................................................ 198 19.9.4 Encoder setzen, Methode Set ........................................................... 198 19.9.5 Encoder lesen Methode Read ........................................................... 199 19.10 CANopen Baustein COPDEVICE ........................................................................ 200 19.10.1 Instanziierung .................................................................................. 200 19.10.2 Methoden ........................................................................................ 201 19.10.3 SDO schreiben, Methode WriteSDO .................................................. 201 19.10.4 SDO lesen, Methode ReadSDOSigned .............................................. 202 19.10.5 SDO lesen, Methode ReadSDOUnsigned .......................................... 203 20. Peripheriesignale .............................................................................................. 204 20.1 Arbeiten mit digitalen Ein- und Ausgängen ...................................................... 204 20.2 Arbeiten mit analogen Ein- und Ausgängen ...................................................... 204 21. Programmierung von Ereignissen ..................................................................... 206 21.1 Unterstütze Ereignisse ..................................................................................... 206 21.2 Verwendung des FTL Befehlssatzes ................................................................. 207 21.3 Zeitüberwachung ............................................................................................. 208 21.4 Ereignis Steuerungshochlauf, <onstartup> ........................................................ 208 21.5 Ereignisse der Programmsteuerung ................................................................. 209 21.5.1 Laufzeitverhalten während dem LadenFehler! Textmarke nicht definiert. 21.5.2 Laufzeitverhalten während des Betriebs ........................................... 209 21.5.3 Überlappung von Programmereignissen ........................................... 210 21.5.4 Verwendung verschiedener Projekte/Programme ............................. 211 21.5.5 Beispiel: Ansteuern eines Applikators beim Kleben .......................... 212 21.6 Ereignisse für Tasten F1 und F2 ....................................................................... 213 21.7 Spezielle FTL-Befehle für Anwendung mit Ereignissen...................................... 215 21.7.1 Abfrage der aktiven Betriebsart, <GetAutoModeActive, GetManualModeActive> .................................................................... 215 21.7.2 FTL Programm laden, <LoadProgram> ................................................ 215 21.8 Meldetexte der Ereignisprogramme ................................................................. 217 22. Einfache Schaltpunkte ...................................................................................... 219 22.1 Einfacher Schaltpunkt mit Bewegungsbefehl, <DO> .......................................... 219 22.2 Einfacher Schaltpunkt, <OnPosition> ................................................................ 220 22.3 Verhalten im Überschleifbereich ...................................................................... 220 22.4 Laufzeitverhalten der DO Anweisung ............................................................... 221 Festo GDCP-CMXR-SW-DE de Version 1.0 11 INHALTSVERZEICHNIS 23. Bahnschaltpunkte ............................................................................................. 222 23.1 Bahnsegment .................................................................................................. 222 23.2 Verhalten im Überschleifbereich ...................................................................... 223 23.3 Schaltpunkt mit prozentualer Verschiebung, <OnParameter> ............................ 224 23.4 Schaltpunkt beliebig auf der Bahn, <OnDistance> ............................................. 225 23.5 Schaltpunkt auf einer Schaltebene, <OnPlane> ................................................. 228 23.5.1 Teachen der Position zur Schaltebene .............................................. 230 23.6 Optionaler Zeitoffset ........................................................................................ 231 23.6.1 Systemreaktion bei unzulässigem Zeitwert....................................... 232 23.7 Randbedingungen ........................................................................................... 233 23.7.1 Einzelschritt Betrieb ......................................................................... 233 23.7.2 Wartebefehle, die den Hauptlauf beeinflussen ................................. 233 23.7.3 Setzen der Satzzeigers ..................................................................... 233 23.7.4 Einfluss des Overrides ...................................................................... 234 23.7.5 Arbeiten im Handbetrieb mit reduzierter Geschwindigkeit ................ 235 23.7.6 Unterbrechung des Programmes ...................................................... 235 23.8 Nicht ausgeführte Schaltpunkte....................................................................... 236 24. Beispiele ........................................................................................................... 237 24.1 Stoppen von Bewegungen ............................................................................... 237 24.2 Arbeiten mit Ein- und Ausgangsbausteinen...................................................... 240 24.3 Steuerung des Satzvorlaufs ............................................................................. 241 24.4 Arbeiten mit Greifern ....................................................................................... 242 24.4.1 Vakuumgreifer ................................................................................. 243 24.4.2 Pneumatische Parallelgreifer ............................................................ 246 24.4.3 Pneumatische Schwenk-Greifeinheit ................................................ 249 24.5 Arbeiten mit der SPS-Schnittstelle ................................................................... 253 24.5.1 Aufgabenstellung ............................................................................. 253 24.5.2 SPS-Schnittstelle .............................................................................. 253 24.5.3 Ablaufprogramm .............................................................................. 254 A. FTL Befehlsliste ................................................................................................ 256 B. Menübaum der FTL Befehle............................................................................... 261 C. Verwendete Begriffe ......................................................................................... 266 D. Index ................................................................................................................. 267 12 Festo GDCP-CMXR-SW-DE de Version 1.0 1. Einleitung 1. Einleitung Dieses Dokument beschreibt den Befehlssatz FTL (Festo Teach Language) der Festo CMXR Mehrachssteuerungen. Die Programmierung der CMXR-Steuerung erfolgt mit dem FTLEditor im zugehörigen PlugIn des Festo Configuration Tool (FCT) oder mit dem Handbediengerät CDSA-D1-VX. Steuerung CMXR-C1 FCT-PlugIn mit FTL-Editor Steuerung CMXR-C2 Handbediengerät CDSA-D1-VX FTL ist eine Programmiersprache mit einem Befehlsvorrat, der für die Erstellung von Anwenderprogrammen durch Maschinen-Benutzer konzipiert ist. Der vereinfachte Sprachaufbau ermöglicht das Erstellen von einfachen Maschinenabläufen, ohne dazu eine umfangreiche Programmierausbildung zu benötigen. 1.1 Gültigkeit Bedingt durch die unterschiedliche Rechenleistungen der CMXR Steuerungen, weichen die Befehlssätze der CMXR Steuerungen voneinander ab. Das Handbuch enthält den zum Zeitpunkt der Erstellung gültigen Stand der FTL Befehle. Durch unterschiedliche Versionen kann es jedoch zu Abweichungen kommen. Eine Übersicht über alle Befehle mit zugeordneter Versionierung und Steuerungsplattformen befindet sich im Anhang A. Festo GDCP-CMXR-SW-DE de Version 1.0 13 2. Sicherheitshinweise 2. Sicherheitshinweise 2.1 Gebrauch der Dokumentation Dieses Dokument ist für Bediener und Programmierer von Robotern gedacht, die mit dem Festo CMXR System arbeiten. Es gibt eine Einführung in die Bedienung und Programmierung. Eine entsprechende Schulung des Personals ist Voraussetzung. 2.2 Bestimmungsgemäßer Gebrauch Warnung Das Festo CMXR System ist nicht für sicherheitsrelevante Steuerungsaufgaben (z.B.: Stillsetzen im Notfall oder Überwachung reduzierter Geschwindigkeiten) vorgesehen. Das Festo CMXR System entspricht lt. EN-13849-1 nur Kategorie B und ist somit für die Realisierung von Sicherheitsfunktionen für den Personenschutz nicht ausreichend. Für sicherheitsrelevante Steuerungsaufgaben oder Personensicherheit müssen zusätzliche externe Schutzmaßnahmen ergriffen werden, die auch im Fehlerfall einen sicheren Betriebszustand des Gesamtsystems gewährleisten. Bei Schäden infolge von Nichtbeachtung der Warnhinweise in dieser Betriebsanleitung übernimmt Festo keine Haftung. Hinweis Vor der Inbetriebnahme sind die Sicherheitshinweise Kapitel 2.3 ff. vollständig durchzulesen. Wenn die Dokumentation in der vorliegenden Sprache nicht einwandfrei verstanden wird, bitte beim Lieferant anfragen und diesen informieren. Der einwandfreie und sichere Betrieb des Steuerungssystems setzt den sachgemäßen und fachgerechten Transport, die Lagerung, die Montage und die Installation sowie die sorgfältige Bedienung und die Instandhaltung voraus. 14 Festo GDCP-CMXR-SW-DE de Version 1.0 2. Sicherheitshinweise 2.3 Qualifiziertes Personal Hinweis Für den Umgang mit elektrischen Anlagen ist ausschließlich ausgebildetes und qualifiziertes Personal einzusetzen. 2.4 Sicherheitshinweise zu den Produkten Warnung GEFAHR ! Bei der Entsorgung von Batterien sind die Bestimmungen für Sondermüll zu beachten. Obwohl Batterien eine niedrige Spannung haben, können sie doch bei Kurzschluss genug Strom abgeben, um brennbare Materialien zu entzünden. Sie dürfen deshalb nicht gemeinsam mit leitfähigen Materialien (wie z.B. Eisenspäne, mit Öl verunreinigte Drahtwolle usw.) entsorgt werden. ESD Elektrostatisch gefährdete Bauelemente: Unsachgemäße Handhabung kann zu Beschädigungen von Bauelementen führen. Warnung GEFAHR ! Gefahrbringende Bewegungen! Lebensgefahr, schwere Körperverletzung oder Sachschaden durch unbeabsichtigte Bewegungen der Achsen! 2.5 Sicherheitshinweise zu diesem Handbuch Warnung GEFAHR ! Die Nichtbeachtung kann hohe Sachschäden und Personenschäden zur Folge haben. Vorsicht Die Nichtbeachtung kann hohe Sachschäden zur Folge haben. Festo GDCP-CMXR-SW-DE de Version 1.0 15 2. Sicherheitshinweise 2.6 Sicherheitsanweisungen für das beschriebene Produkt Warnung Gefahr! Lebensgefahr durch unzureichende NOT-AUS-Einrichtungen! NOT-AUS-Einrichtungen müssen in allen Betriebsarten der Anlage wirksam und erreichbar bleiben. Ein Entriegeln der NOT-AUSEinrichtung darf keinen unkontrollierten Wiederanlauf der Anlage bewirken! Erst NOT-AUS-Kette prüfen, dann einschalten! Warnung GEFAHR ! Gefahr für Personen und Sachen! Testen Sie jedes neue Programm, bevor Sie die Anlage in Betrieb nehmen! Warnung GEFAHR ! Nachrüstungen und Veränderungen können die Sicherheit des Systems beeinträchtigen! Die Folgen können schwere Personen-, Sach- oder Umweltschäden sein. Mögliche Nachrüstungen oder Veränderungen der Anlage mit Ausrüstungsteilen fremder Hersteller müssen daher von Festo freigegeben werden. Warnung GEFAHR ! Gefährliche elektrische Spannung! Wartungsarbeiten sind, wenn nicht anders beschrieben, grundsätzlich nur bei ausgeschalteter Anlage durchzuführen! Dabei muss die Anlage gegen unbefugtes oder unbeabsichtigtes Wiedereinschalten gesichert sein. Sind Mess- oder Prüfarbeiten an der Anlage erforderlich, müssen diese von Elektrofachkräften durchgeführt werden. Vorsicht Es dürfen nur von Festo zugelassene Ersatzteile verwendet werden. 16 Festo GDCP-CMXR-SW-DE de Version 1.0 3. Programmbearbeitung 3. Programmbearbeitung 3.1 Allgemein FTL steht für Festo Teach Language. FTL ist eine bewegungsorientierte Programmiersprache und dient zur Programmierung der CMXR Steuerungen. Als Programmiersprache für Robotik und Handhabungssysteme besitzt FTL einen mächtigen Sprachumfang, der jedoch leicht zu erlernen und leicht beherrschbar ist. Dies ermöglicht dem Anwender eine auf seine Applikation gerichtete Programmierung. Die FTL-Befehle basieren auf der englischen Sprache. 3.2 Interpreter FTL-Programme werden nicht kompiliert, sondern durch einen Interpreter bearbeitet. Dieser Interpreter liest zu Beginn die Programme strukturiert in den Speicher, um sie optimal abzuarbeiten. Dieser Vorgang benötigt je nach Programmlänge eine kurze Reaktionszeit. Aus diesem Grund empfiehlt es sich vor dem Start das Programm zu laden, um einen schnellen Programmstart zu erzielen. 3.3 Programmstart Um ein Programm zu starten, muss dieses im entsprechenden Projekt geladen werden. Das Laden kann entweder über das Handbediengerät oder durch eine externe Steuerung über eine Steuerungsschnittstelle durchgeführt werden. Hinweis Es kann immer nur ein Anwender-Projekt geladen sein. Das globale Systemprojekt ist zusätzlich immer geladen. Der Programmablauf beginnt nach dem Startsignal immer an der aktuellen Position des Programmzeigers. Hat der Programmzeiger die letzte Programmzeile des Ablaufprogramms erreicht, wird das Programm beendet, bleibt aber geladen. Sollten im Ablauf parallele Programme gestartet worden sein, so bleibt das Hauptprogramm aktiv, bis diese beendet sind. 3.4 Satzvorlauf Um eine schnelle Programmbearbeitung zu erreichen, rechnet der Interpreter eine Anzahl von Bewegungsbefehlen voraus. Die Vorausberechnung erfolgt im laufenden Betrieb simultan zur Programmausführung und wird im System abgehandelt. Die Größe des Satzvorlaufes, d. h. die Anzahl der Bewegungsbefehle, die vorausberechnet werden, ist im System hinterlegt. Festo GDCP-CMXR-SW-DE de Version 1.0 17 3. Programmbearbeitung Hinweis Der Satzvorlauf bezieht sich auf Bewegungsbefehle. Andere Anweisungen, die zwischen den Bewegungsbefehlen stehen, wie z. B. das Ändern von Dynamikwerten oder das Verarbeiten von Variablen, werden dadurch nicht beeinträchtigt. In diesem Satzvorlauf werden die FTL-Befehle decodiert und für die weitere Berechnung bereitgestellt. Weiterhin erfolgt in diesem Satzvorlauf auch die Bahnplanung der Bewegung, die aufgrund der eingestellten Dynamikwerte berechnet wird. Mit einigen Befehlen von FTL kann man den Satzvorlauf beeinflussen, d. h. er wird unter Umständen gestoppt. Dies kann z. B. bei einer Programmverzweigung der Fall sein, in der auf Eingangssignale der Peripherie entschieden wird. Hält der Satzvorlauf an, wird der gesamte im Voraus berechnete Befehlssatz abgearbeitet und die Kinematik stoppt die Bewegung. Dann wird z. B. die Entscheidung der Programmverzweigung berechnet und die folgenden Bewegungsbefehle ausgeführt. Hinweis Ein Stoppen des Satzvorlaufes durch einen entsprechenden Befehl hat unter Umständen ungewünschte Stopps auf der Bahn zur Folge. Ein Überschleifen der Bewegungen ist bei derartigen Befehlen nicht möglich. Satzhauptlauf Lin(Pos1) Lin(Pos2) Lin(Pos3) Lin(Pos4) Lin(Pos5) Lin(Pos6) Lin(Pos7) Lin(Pos8) Satzvorlauf Lin(Pos9) Die Abbildung zeigt einen Ausschnitt aus einem FTL-Programm. Der obere Pfeil markiert den aktuellen Befehl, der gerade ausgeführt wird. Der untere Pfeil markiert den aktiven Befehl der Satzvorausberechnung. Der Abstand der beiden Pfeile ist der Satzvorlauf. Weitere Informationen und Beispiele zum Satzvorlauf sind im Kapitel 24.3 Steuerung des Satzvorlaufs beschrieben. 18 Festo GDCP-CMXR-SW-DE de Version 1.0 3. Programmbearbeitung 3.5 Programmstruktur Alle FTL-Programme sind auf der Speicherkarte (Compact Flash Card) der CMXR Mehrachssteuerung im Verzeichnis "application\control\teachcontrol" (im weiteren Text Applikationsverzeichnis genannt) abgespeichert. Die Ablage der Programme erfolgt in einer Ordnerstruktur. Ein Projekt enthält die zugeordneten Bewegungsprogramme. Die Anzahl der Projekte und Programme ist durch die Größe der Speicherkarte limitiert. Aufbau der Programmstrukturen: 3.6 FTL-Projekte Ein FTL-Projekt wird als Unterverzeichnis im Applikationsverzeichnis angelegt. Der Verzeichnisname ist dabei der Projektname und hat die Extension „tt“. Beispiel für Projektnamen: Projekt „_global“ Projekt „cube“ Projekt „PickPlace“ Festo GDCP-CMXR-SW-DE de Version 1.0 19 3. Programmbearbeitung In einem Projekt werden FTL-Programme zusammengefasst. Alle Programme sind somit Elemente eines Projektes. Weitere Unterverzeichnisse in einem Projektverzeichnis sind nicht zulässig. Hinweis Die Projektstruktur und Verwaltung wird durch die grafische Software des Handbediengerätes und über den Editor der FCT-Software automatisch erzeugt und verwaltet. 3.6.1 Globales FTL-Projekt Neben allen FTL-Projekten gibt es ein globales FTL-Projekt, das den Namen „_global“ trägt. Dieser Name ist fix und darf nicht verändert werden. Das Projekt ist global für alle Projekte. Alle darin gespeicherten Daten und Programme sind aus allen anderen Projekten zugänglich. Falls Daten oder Programme in mehreren Projekten benutzt werden müssen, werden diese in diesem globalen Projekt abgelegt. Somit ist die Datenkonsistenz gewahrt. Das globale Projekt "_global" wird beim Hochlauf der CMXR automatisch geladen und aktiviert. 3.7 FTL-Programme Alle zu einem Projekt gehörenden FTL-Programme werden in dem zugeordneten Projektverzeichnis abgelegt. Ein Programm setzt sich aus dem Programmcode und den dazu gehörenden Daten zusammen. Diese werden in getrennten Dateien - unter dem gleichen Namen jedoch mit einer unterschiedlichen Datei-Erweiterung (file extension) - gespeichert: <Name>.tip Datei-Name für Programmcode <Name>.tid Datei-Name für Programmdaten Beispiel: Für ein Programm mit dem Namen „Load“ wird die Datei "Load.tip" angelegt. Der Dateiname der programmlokalen Daten lautet "Load.tid". Wird das Programm über das Handbediengerät CDSA oder über den Festo FTL-Editor (im Festo Configuration Tool) angelegt, erfolgt das Erzeugen der Datei für programmlokale Daten automatisch. Erfolgt eine Programmgenerierung über eine andere Software, so ist darauf zu achten, dass für jedes Programm die entsprechende Datendatei angelegt wird. 3.7.1 Projektglobale Programme Das systemglobale Projekt „_global“ kann neben Daten auch Programme beinhalten. Diese Programme können von allen Programmen in allen Projekten genutzt werden. Diese globalen Programme bieten einen entscheidenden Komfort. Programme, die von der eingesetzten Kinematik abhängen, können so losgelöst von den Applikationsprojekten definiert und abgelegt werden. Existieren bei einer Kinematik feste Positionen, wie z. B. eine Sicherheitsposition, so kann der Ablauf zum Fahren auf diese Position einmalig im globalen Projekt abgelegt werden. 20 Festo GDCP-CMXR-SW-DE de Version 1.0 3. Programmbearbeitung 3.8 FTL-Datendatei „<Name>.tid“ Im CMXR Steuerungssystem dienen Daten als Variable und zur Kommunikation. Die Projektstruktur bietet die Möglichkeit, Daten übersichtlich abzulegen und den Zugriff auf die Daten zu beschränken. Eine Datendatei wird durch die Datei-Erweiterung „tid“ gekennzeichnet und ist - wie die Programmdatei - textbasierend. Im System sind möglich: programmlokale Daten innerhalb der einzelnen Programme, projektglobale Daten für jedes Projekt und systemglobale Daten für alle Projekte. Durch diese Aufteilung kann ausgewählt werden, wer auf die Daten Zugriff hat. Die Kommunikation zwischen Programmen bzw. Projekten lässt sich so ebenfalls steuern. Mit projektglobalen Daten kann zwischen Programmen, mit systemglobalen Daten zwischen Projekten kommuniziert werden. 3.8.1 Programmlokale Daten Programmlokale Daten sind nur innerhalb des Programms bekannt. Andere Programme oder Projekte haben keinen Zugriff auf diese Daten. Hinweis Programmlokale Daten sind nur innerhalb des zugeordneten Programms bekannt und gültig. Andere Programme und Projekte haben darauf keinen Zugriff. Die folgende Abbildung zeigt die Programme „Fill“ und „Sort“. Jedes dieser Programme besitzt lokale Daten und Programmdaten, die in den jeweiligen Dateien abgelegt sind. 3.8.2 Projektglobale Daten Projektglobale Daten dienen zur Kommunikation zwischen den einzelnen Programmen innerhalb eines Projektes. Programme außerhalb des entsprechenden Projektes haben keinen Zugriff auf diese Daten. Projektglobalen Daten werden in einer eigenen Datei mit dem Namen "_globalvars.tid" gespeichert. Erfolgt eine Projektanlage über das Handbediengerät CDSA oder den FTL Programmiereditor, so wird diese projektglobale Datendatei automatisch angelegt. Bei einer Festo GDCP-CMXR-SW-DE de Version 1.0 21 3. Programmbearbeitung Projektgenerierung über eine andere Software, z. B. kundenseitige Programmiersoftware, ist darauf zu achten, dass diese Datendatei angelegt wird. Hinweis Erfolgt eine Programmgenerierung über eine fremde Software, so ist darauf zu achten, dass die Datei „_globalvars.tid“ im Projektverzeichnis angelegt wird. Die folgende Abbildung zeigt die Projekte „FillPalett“ und „FeedParts“. Jedes dieser Projekte verfügt über projektglobale Daten, die in der Datei „_globalvars.tid“ abgespeichert und im Projektverzeichnis abgelegt sind. 3.8.3 Systemglobale Daten Systemglobale Daten sind systemweit in alle Programme aus allen Projekten bekannt. Diese systemglobalen Daten sind dem globalen Projekt „_global“ zugeordnet und dort in der Datendatei „_globalvars.tid“ abgelegt. Hinweis Da alle Programme auf systemglobale Daten Zugriff haben, ist auf die sorgfältige Verwendung dieser Daten zu achten. Ein gleichzeitiger Zugriff von mehreren Programmen auf diese Daten ist sorgföltig zu gestalten und ggf. in der Applikation durch entsprechende Maßnahmen zu verriegeln. Folgende Abbildung zeigt das globale Projekt „_global“ im Verbund mit projektglobalen und lokalen Daten. Ferner sind im systemglobalen Bereich auch systemglobale Programme dargestellt. 22 Festo GDCP-CMXR-SW-DE de Version 1.0 3. Programmbearbeitung 3.8.4 Instanziierung von Variablen Variable werden innerhalb der Datendatei „<Name>.tid“ in folgender Form angelegt: Syntax <Variablenname> : <Variablentyp> := <Wert> Der Name der Variablen kann unter Berücksichtigung der Regeln unter Kapitel 4.3 Schlüsselwörter frei vergeben werden. Pro Zeile kann jeweils eine Variable erstellt werden. Beispiel: cpos1 : CARTPOS := (100, 50, 100, 0, 0, 0) cpos2 : CARTPOS := (600, 550, 100, 180, 0, 0) index : DINT := 17 Die möglichen Variablentypen werden in den folgenden Kapiteln beschrieben. Vorsicht Werte von Variablen, die im Programm zur Laufzeit verändert werden, werden nicht in die Datendatei auf der Speicherkarte geschrieben. Die Werte bleiben nur solange erhalten, wie das Projekt / Programm geladen ist. Nach Abladen des Projektes / Programms oder Ausfall der Versorgungsspannung gehen im Programm veränderte Daten verloren. Festo GDCP-CMXR-SW-DE de Version 1.0 23 3. Programmbearbeitung Hinweis Sollen Positionswerte dauerhaft auf der Speicherkarte gespeichert werden, so kann dies mit dem FTL-Befehl „SavePosition“ geschehen. 24 Festo GDCP-CMXR-SW-DE de Version 1.0 4. Sprachaufbau 4. Sprachaufbau 4.1 Formatierung FTL-Dateien sind lesbare Textdateien. Anweisungen bzw. Deklarationen werden durch Zeilenumbrüche getrennt. Es wird im Allgemeinen zwischen Groß- und Kleinschreibung unterschieden. 4.2 Bezeichner Bezeichner dienen zur Identifikation von Projekten, Programmen, Bausteinen, Variablen, Konstanten und Typen. Ein Bezeichner ist eine Folge von Buchstaben, Ziffern und dem Zeichensymbol "_". Hinweis Zulässig sind die Zeichen a…z, A…Z, 0…9 und _ (Unterstrich). Alle anderen Zeichen sind unzulässig. Bei Bezeichnern wird zwischen Groß- und Kleinschreibung unterschieden, d. h. es muss darauf geachtet werden, dass z. B. eine Variable in Bezug auf die Groß- und Kleinschreibung immer gleich geschrieben wird. Beispiel: Eine Variable mit dem Bezeichner „Index“ ist ungleich der Variablen mit dem Bezeichner „INDEX“. Dies sind 2 verschiedene Variablen. Hinweis Im Gegensatz zu Bezeichnern wird bei Programm- und Projektnamen nicht zwischen Groß- und Kleinschreibung unterschieden. 4.3 Schlüsselwörter Schlüsselwörter sind Teil der FTL-Sprache. Alle Schlüsselwörter in FTL werden groß geschrieben und dürfen nicht als Namen für Programme, Variablen oder Typen verwendet werden. Liste aller Schlüsselwörter : CALL IF THEN END_IF ELSIF GOTO LABEL WHILE DO END_WHILE LOOP END_LOOP RETURN RUN KILL OR XOR MOD AND NOT MAP MAPTO WAIT Festo GDCP-CMXR-SW-DE de Version 1.0 ELSE 25 4. Sprachaufbau BOOL DINT DWORD REAL STRING ARRAY Ebenso sind alle weiteren abgeleiteten Datentypen Schlüsselwörter. Liste aller Funktionen : SIN COS TAN COT LN ABS SQRT EXP ASIN ACOS ATAN ATAN2 ACOT SHR SHL ROR ROL STR CHR ORD LOW HIGH Zusätzlich gelten die genannten Einschränkungen für alle Befehlsnamen wie z. B. Lin, Vel, SetError usw. 4.4 Zahlenkonstante Es wird zwischen ganzen Zahlen und reellen Zahlen unterschieden. Ganze Zahlen können in Dezimal-, Dual- oder Hexadezimaldarstellung geschrieben werden. Beispiele für gültige ganze Zahlen: Dezimale Schreibweise 100 -100 Duale Schreibweise 2#1010 -2#1010 Hexadezimale Schreibweise 16#1ABF -16#1ABF Reelle Zahlen (Gleitkommawerte) können mit Dezimalpunkt oder in Exponentialschreibweise dargestellt werden. Werte mit Dezimalpunkt müssen mindestens eine Nachkommastelle besitzen. Beispiele für gültige reelle Zahlen: Dezimale Schreibweise: 1.01 178.473 Exponentielle Schreibweise: 1.99E4 1.99e+8 4.5 1e-8 Zeichenketten Zeichenketten, sogenannte Strings, werden durch das Zeichen " eingeleitet und abgeschlossen. Sie dürfen alle druckbaren Zeichen beinhalten. Die Länge einer Zeichenkette ist auf 255 Zeichen beschränkt. Gültig sind alle Zeichen des ASCII Zeichensatzes. Beispiel für eine gültige Zeichenkette: "CMXR-C1 Mehrachssteuerung" 4.6 Operatoren und Begrenzungszeichen Operatoren werden in Ausdrücken verwendet und beschreiben, wie Variablenwerte und Zahlenkonstanten miteinander verknüpft werden. 26 Festo GDCP-CMXR-SW-DE de Version 1.0 4. Sprachaufbau 4.6.1 Arithmetische Operatoren Operator Bedeutung + Addition - Subtraktion * Multiplikation / Division MOD Modulo Operation Tabelle 4.1 arithmetische Operatoren 4.6.2 Logische Operatoren Diese Operatoren können auf Wahrheitswerte und auf ganze Zahlen angewendet werden. Bei ganzen Zahlen arbeiten sie bitweise. Operator Bedeutung AND Und-Verknüpfung OR Oder-Verknüpfung XOR Exklusive Oder-Verknüpfung NOT Negation Tabelle 4.2 logische Operatoren 4.6.3 Vergleichsoperatoren Operator Bedeutung < kleiner <= kleiner oder gleich = gleich <> ungleich >= größer oder gleich > größer Tabelle 4.3 Vergleichsoperatoren Festo GDCP-CMXR-SW-DE de Version 1.0 27 4. Sprachaufbau 4.6.4 Sonstige Operatoren Operator Bedeutung . Punktoperator zum Zugriff auf Strukturelemente [] Indexklammern zum Zugriff auf Arrays () Klammern für z. B. Parameterlisten und zur Strukturierung der Ausführung bei Ausdrücken Tabelle 4.4 sonstige Operatoren 4.6.5 Begrenzungszeichen Operator Bedeutung := Wertzuweisung für Variable : Trennzeichen bei der Instanziierung von Variablen , Aufzählungszeichen in Parameterlisten bei Funktionsoder FTL-Befehlsaufrufen Tabelle 4.5 Begrenzungszeichen 28 Festo GDCP-CMXR-SW-DE de Version 1.0 5. Grunddatentypen 5. Grunddatentypen FTL unterstützt 5 Datentypen: Boolesche Daten Ganze Zahlen Bitmuster Gleitkommazahlen Zeichenketten Innerhalb dieser 5 Datentypen werden in FTL elementare Datentypen abgeleitet. Aufgrund der Bedeutung des Datentyps, erfolgt eine Zuordnung für einen bestimmten Wertebereich und entsprechende Operationen. Datentyp Interpretation Speichergröße Wertebereich BOOL Bit 8 Bit TRUE oder FALSE DINT Ganze Zahl 32 Bit -2.147.483.648 … +2.147.483.647 DWORD Bitmuster 32 Bit 32 Bit REAL Gleitkommazahl 32 Bit nach IEEE STRING Zeichenkette max. 255 Byte max. 255 Zeichen Tabelle 5.1 Grunddatentypen Je nach Datentyp sind unterschiedliche Operationen möglich. Datentyp Operationen BOOL Logische Operationen AND, OR, XOR, NOT DINT Arithmetikoperationen, Vergleichsoperationen DWORD Bitweise Operationen AND, OR, XOR, NOT, SHL, SHR, ROL, ROR, =, <> REAL Arithmetikoperationen, Vergleichsoperationen STRING Vergleichsoperationen, + Tabelle 5.2 mögliche Operationen Festo GDCP-CMXR-SW-DE de Version 1.0 29 5. Grunddatentypen Prinzipiell muss bei einer Zuweisung auf Datentypen der Wert vom gleichen Datentyp sein. FTL unterstützt jedoch teilweise auch die Zuweisung unterschiedlicher Datentypen. In diesem Fall wird eine automatische Typkonvertierung durchgeführt. Für bestimmte Datentypen müssen für die Zuweisung die Built-in Funktionen STR, CHR und ORD verwendet werden. von \ nach BOOL Ganze Zahlen Bitmuster REAL STRING BOOL ja --- --- --- STR Ganze Zahlen --- ja ja ja STR, CHR Bitmuster --- ja ja --- STR, CHR REAL --- ja --- ja STR STRING --- ORD ORD --- ja Tabelle 5.3 mögliche Konvertierungen Je nach Datentyp sind folgende Konvertierungen möglich: Funktion Operation STR Wandelt einen beliebigen Datentyp in einen String um. CHR Wandelt einen ASCII Wert in ein einzelnes Zeichen um. ORD Wandelt ein einzelnes Zeichnen in den ASCII Wert um. Tabelle 5.4 Built-in Funktionen 5.1 Boolescher Datentyp (BOOL) Der boolesche Datentyp hat die Wertigkeit TRUE und FALSE. Er wird vorwiegend für logische Operationen, auch in Verbindung mit Peripheriesignalen z. B. Sensoreingängen und Aktuator-Ausgängen verwendet. Beispiel: Variablen: pos1 : BOOL pos2 : BOOL pos3 : BOOL min1PosValid : BOOL allPosValid : BOOL Programmcode: allPosValid := NOT pos1 AND NOT pos2 AND NOT pos3 min1PosValid := pos1 XOR pos2 XOR pos3 30 Festo GDCP-CMXR-SW-DE de Version 1.0 5. Grunddatentypen 5.2 Ganzzahl-Typen, REAL-Datentyp, Bitmuster-Typen Die Programmiersprache FTL unterstützt ganzzahlige (auch Integer-Typen genannt), Gleitkomma- und Bitmuster-Datentypen. Je nach Fall, können diese Datentypen einander zugewiesen werden (siehe Kapitel 5 Grunddatentypen auf Seite 29). Bei solchen Zuweisungen führt das System die interne Typumwandlung automatisch durch. Je nach Art einer Typumwandlung kann es zu einem Verlust an Genauigkeit kommen. Z. B. bei einer Wandlung von REAL nach DINT, das System entfernt die Nachkommastellen. Beispiele für Typumwandlungen: Variablen: pressure : REAL index : DINT Programmcode: pressure := 1.53 index := pressure // Umwandlung REAL->DINT Die Variable “index” enthält nach der Konvertierung den Wert “1“. Hinweis Typumwandlungen sollen nur dann genutzt werden, wenn die Konsequenz in jeder Hinsicht klar ist (siehe Beispiel oben). 5.3 Klammern Mit Klammern werden Berechnungen entsprechend der Bearbeitungsreihenfolge gruppiert. Die Bearbeitung der Klammern erfolgt dabei von innen nach außen. Beispiel: : IF (Index < 10) AND (Index > 5) THEN : END_IF : Distance := (xRow + 10) * Index : Festo GDCP-CMXR-SW-DE de Version 1.0 31 5. Grunddatentypen 5.4 Zeichenketten (STRING) Zeichenketten werden mit dem Datentyp STRING beschrieben. Die Länge einer Zeichenkette ist auf 255 Zeichen begrenzt. Zeichenketten, auch Strings genannt, können einander zugewiesen werden und mit Hilfe des Operators + einfach aneinander gehängt werden. Beispiel: Variable: message : STRING part : STRING Programmcode: message := “cylinder “ part := “DNC “ message := message + part + “is extended“ 5.5 Strukturierte Datentypen Unter strukturierten Datentypen versteht man eine feste Anordnung von Grunddatentypen zu einem neuen Datentyp. Strukturierte Datentypen können auf der Anwenderebene nicht angelegt werden. Sie werden (nur) als Datentypen in FTL-Befehlen verwendet. Eine Anwendung ist z. B. die Darstellung von Positionen. Mit dem Datentyp "AXISPOS" wird eine Achsposition beschrieben, die aus 6 Variablen des Grunddatentyps REAL in einer bestimmter Reihenfolge besteht. Siehe Kapitel 9.1 Positionsbeschreibung auf Seite 62. 5.6 Arrays Arrays werden verwendet um gleiche Datentypen zu einer geordneten Einheit zusammenzufassen. Der Zugriff auf einzelne Elemente des Arrays erfolgt mit einem Index. Die Grenzen des Arrays werden überwacht. Dies bedeutet, soll eine Operation außerhalb der Arraygröße ausgeführt werden, wird eine entsprechende Meldung ausgelöst. Deklaration von Arrays: Syntax VAR <name> : ARRAY [ < Arraygröße> ] OF <Datentyp> := ( <Initialisierung>) END_VAR 32 Festo GDCP-CMXR-SW-DE de Version 1.0 5. Grunddatentypen Unter dem Parameter Arraygröße wird: Die Größe des Arrays, der Bereichsindex des Arrays angegeben, die Dimensionen des Arrays. Arraygröße Die Arraygröße wird unter Angabe einer Konstanten (ganze Zahl) angegeben. Eine Angabe der Arraygröße mit einer Variablen ist nicht möglich. // Array mit 10 Elementen Matrix1 : ARRAY [10] OF DINT // Array mit 12 Elementen Matrix2 : ARRAY [12] OF CARTPOS Bereichsindex Der Bereichsindex des Arrays beginnt in der Regel bei 0 bis zu der definierten Arraygröße minus 1. Wird z. B. ein Array mit 10 Elementen definiert, geht der Arrayindex von 0 bis 9. Mit dem Arrayindex wird der Zugriff auf das einzelne Arrayelement ausgeführt. Wenn ein spezieller Arrayindex benötigt wird, so kann dieser in der Deklaration des Arrays angegeben werden. Syntax VAR <name> : ARRAY [<start index> ... <end index> ] OF <Datentyp> := ( <Initialisierung>) END_VAR Folgendes Beispiel zeigt ein Array mit 10 Elementen, dessen Index von 3 bis 12 geht: Matrix3 : ARRAY [3...12] OF DINT Dimensionen Ein Array ist mindestens eindimensional, kann aber auch mehrdimensional ausgeprägt sein. Mehrdimensionale Arrays werden durch Angabe der Dimensionen, getrennt durch ein Komma, innerhalb der eckigen Klammern angegeben. Festo GDCP-CMXR-SW-DE de Version 1.0 33 5. Grunddatentypen Syntax VAR <name> : ARRAY [<size 1> , <size 2>, <size 3>, ... ] OF <Datentyp> := ( <Initialisierung>) END_VAR Folgende Beispiele zeigen die Deklaration von mehrdimensionalen Arrays: // Array mit 2 Dimensionen mit je 3 Elementen = 9 Elemente Matrix1 : ARRAY [3, 3] OF DINT // Array mit 3 Dimensionen mit 3 Elementen bzw. 2 Elementen = 18 Elemente Matrix2 : ARRAY [3, 3, 2] OF DINT Wenn erforderlich, kann auch bei mehrdimensionalen Arrays ein Bereichsindex angegeben werden. Folgendes Beispiel zeigt ein Array mit 3 x 3 Elementen und jeweils anderem Bereichsindex: Matrix3 : ARRAY [1..3, 5..7, 0..2] OF DINT 5.6.1 Initialisierung von Arrays Das System initialisiert die Arrays mit dem Wert 0. Wird eine andere Initialisierung gewünscht, so kann diese hinter dem Typ des Arrays innerhalb runden Klammern angegeben werden. Beispiel: Matrix1 : ARRAY [7] OF DINT := (0, 1, 2, 3, , , ) Matrix2 : ARRAY [3, 3] OF DINT := ((1, , 9), (3, , 7), (, , 6)) Jedes Feld des Arrays wird dabei mit einem Komma eingeleitet. Soll dieses Feld nicht initialisiert werden, so wird dieser nicht angegeben. Das Komma ist jedoch zwingend erforderlich, damit weitere Elemente korrekt initialisiert werden. 5.6.2 Bestimmen der Arraygrenzen mit LOW und HIGH Mit den Schlüsselwörtern LOW kann der unterste, mit HIGH der oberste Bereichsindex eines Arrays ermittelt werden. Syntax <variable : DINT> := LOW( <Arrayvariable> ) <variable : DINT> := HIGH( <Arrayvariable> ) 34 Festo GDCP-CMXR-SW-DE de Version 1.0 5. Grunddatentypen Den Funktionen LOW und HIGH wird eine Arrayvariable übergeben. Sollen die Grenzen eines eindimensionalen Arrays ermittelt werden so wird nur der Arraynamen übergeben. Bei mehrdimensionalen Arrays muss immer die Dimension angegeben werden, von der die Grenzen ausgegeben werden sollen. Matrix : ARRAY [5, 19, 10..34] OF REAL Die Arraybereichsgrenzen des Array sind: Erste Dimension 0 bis 4 o Aufruf von LOW ergibt 0 o Aufruf von HIGH ergibt 4 Zweite Dimension 0 bis 18 o Aufruf von LOW ergibt 0 o Aufruf von HIGH ergibt 18 Dritte Dimension 10 bis 34 o Aufruf von LOW ergibt 10 o Aufruf von HIGH ergibt 34 Hinweis Wird LOW oder HIGH eine Variable übergaben, die kein Array ist, so wird eine Fehlermeldung ausgegeben. Beispiele: Matrix1 : ARRAY [1..4] OF DINT Matrix2 : ARRAY [3,8] OF DINT Index : DINT // Index hat Wert 1 Index := LOW(Matrix1) // Index hat Wert 4 Index := HIGH(Matrix1) // Index hat Wert 0 Index := LOW(Matrix2) // Index hat Wert 2 Index := HIGH(Matrix2) // Index hat Wert 0 Index := LOW(Matrix2[0]) // Index hat Wert 7 Index := HIGH(Matrix2[0]) Festo GDCP-CMXR-SW-DE de Version 1.0 35 5. Grunddatentypen 5.7 Referenzvariablen (Mapping) Der Mapping-Mechanismus erlaubt es, Variablen als Referenzen auf einen bestimmten Typ zu definieren, die dann mit Objekten dieses Typs verbunden werden können. Man sagt dann, die Referenzvariable sei auf das Objekt gemappt, oder das Objekt sei der Referenzvariablen zugeordnet. Eine direkte Verwendung der Referenzvariablen bedeutet dann eigentlich eine Verwendung des zugeordneten Objekts, mit dem die Referenzvariable über den Mapping-Mechanismus verbunden ist. Wird eine Referenzvariable direkt verwendet, obwohl es noch kein zugeordnetes Objekt gibt, so wird ein Fehler ausgelöst. Referenzvariablen benötigen nur soviel Speicherplatz wie nötig ist, um den Verweis auf das zugeordnete Objekt abzulegen. Dieser Speicherbedarf ist unabhängig von der Art des zugeordneten Objekts. Folgende Grafik zeigt den Mapping-Mechanismus: Programmvariablem Referenzvariable Index_A Ref_Index Index_B Index_C Mappen von Ref_Index auf Index_C Wird im Programm die Referenzvariable Ref_Index verwendet, so arbeitet diese mit dem Speicherbereich und Inhalt der Variable Index_C. Beispiel: Die Anweisung Ref_Index := 10 beschreibt die Variable Index_C mit dem Wert 10. Hinweis Beim Lesen einer gemappten Variable wird die zugeordnete Variable gelesen, und beim Schreiben auf eine gemappte Variable wird auf die zugeordnete Variable geschrieben. 36 Festo GDCP-CMXR-SW-DE de Version 1.0 5. Grunddatentypen 5.7.1 Deklaration von Referenzvariablen, <MAPTO> Die Deklaration einer Referenzvariable kann mit jedem beliebigen Datentyp wie z. B. DINT oder REAL erfolgen. Die Deklaration erfolgt durch das Voranstellen des Schlüsselwortes MAPTO vor dem eigentlichen Datentyp. Eine Initialisierung der Referenzvariable ist nicht möglich. Syntax <variable> : MAPTO <Datentyp> Beispiel: Index : MAPTO DINT Level : MAPTO REAL Home : MAPTO CARTPOS In diesem Beispiel sind 3 Referenzvariablen deklariert, die unterschiedlichen Datentypen zugeordnet sind. 5.7.2 Verbinden von Referenzvariablen, <MAP> Referenzvariable werden mit dem Schlüsselwort MAP auf Variable verbunden. Dabei ist zu beachten, dass nur Variablen verbunden werden können, die denselben Datentyp der Referenzvariablen besitzen. Syntax <variable> : = MAP( <variable> ) Beispiel: MyIndex := MAP(Index) 5.7.3 Prüfen von Referenzvariablen, <IS_MAPPED> Mit der Funktion IS_MAPPED kann überprüft werden, ob eine Referenzvariable eine Verbindung zu einer Variable besitzt. Ist eine Referenzvariable nicht verbunden und sie wird im Programm verwendet, so wird ein Fehler ausgelöst. Syntax IS_MAPPED (<Referenzvariable>) : BOOL Festo GDCP-CMXR-SW-DE de Version 1.0 37 5. Grunddatentypen Rückgabewerte: TRUE Referenzvariable ist verbunden FALSE Referenzvariable ist nicht verbunden Eine Verwendung dieser Funktion ist z. B. die Verwendung von Referenzvariablen in einem Unterprogramm, wobei die Verbindung der Variablen außerhalb des Unterprogrammes erfolgt. Beispiel: IF IS_MAPPED(Level) THEN : : ELSIF SetError(“Not mapped”) END_IF 38 Festo GDCP-CMXR-SW-DE de Version 1.0 6. Variablendeklarationen 6. Variablendeklarationen Die Variablendeklarationen erfolgen in den zugehörigen Dateien mit der Datei-Endung “tid“. Darin wird der Name der Variable und der Datentyp festgelegt. Name und Datentyp werden mit einem Doppelpunkt voneinander getrennt. Syntax <Name> : <Typ> Beispiele gültiger Variablendeklarationen: offset : REAL flag : BOOL index : DINT name : STRING 6.1 Initialisierung Alle FTL Variablen werden automatisch initialisiert. Dabei werden Integer und Real Variable mit 0, Zeichenketten (Strings) mit einer leeren Zeichenkette “ “ und boolesche Variable mit FALSE initialisiert. Neben dieser automatischen Initialisierung gibt es auch die Möglichkeit, Variablen mit einem bestimmten Wert zu Initialisieren. Man spricht hier auch von einer expliziten Initialisierung. Der Initialwert wird dabei nach der Typangabe in Form einer Zuweisung in der Datendatei angegeben. Real Variablen können dabei auch mit Integerwerten initialisiert werden. Beispiele gültiger Initialisierungen: index : DINT := 1 pi : REAL := 3.1415 radius : REAL := 10 flag : BOOL := TRUE message : STRING := "Hello" Festo GDCP-CMXR-SW-DE de Version 1.0 39 7. Ausdrücke 7. Ausdrücke Ein Ausdruck beschreibt einen Wert, der einem bestimmten Datentyp zugeordnet ist. Ein Ausdruck kann Variablen und Funktionen enthalten. Die Bestandteile eines Ausdrucks werden durch Operatoren verknüpft. wert := SQRT(a) – 2*a*b + SQRT(b) 7.1 Ausführungsreihenfolge in Ausdrücken Operatoren in einem Ausdruck werden in einer bestimmten Reihenfolge bearbeitet: 1. ( ) (Klammern) 2. [] (Array-Index) 3. NOT (Negation) 4. * / MOD AND (Multiplikation, Division, Modulo, Logisch UND) 40 5. + - OR XOR (Addition, Subtraktion, Logisch ODER /EXOR) 6. < <= = <> >= > (Vergleichsoperationen) Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung 8. Programmsteuerung 8.1 Anweisungen FTL-Programme bestehen aus einer Aneinanderreihung von durch Zeilenumbrüche getrennten Anweisungen. FTL kennt folgende Anweisungen: 1. Wertzuweisung 2. Verzweigungen: IF, IF .. GOTO, GOTO .. LABEL, RETURN 3. Schleifen: WHILE, LOOP 4. Routinenbearbeitung: CALL, Befehls-Aufruf, RUN, KILL 5. Synchronisationsanweisung: WAIT 8.2 Wertzuweisung <:=> Eine Wertzuweisung besteht aus einer Variablenbezeichnung auf der linken Seite, dem Zuweisungsoperator := und einem Ausdruck auf der rechten Seite. Der Datentyp des Ausdrucks muss auf den Datentyp der Variable zuweisbar sein. Syntax <Variable > := <Ausdruck> Beispiele: i := 1 x := a + b * 2 8.3 Bedingungen Innerhalb von Anweisungen, Verzweigungen oder Schleifen können Bedingungen formuliert werden. Diese können boolesche Operanden (z. B. AND, OR) oder einen Vergleichsoperand (z. B. >, <=,=) beinhalten. Die Verknüpfung von mehreren Vergleichen wird durch entsprechende Klammerebenen strukturiert. Für die folgenden Beispiele werden folgende Variablen verwendet: Marker : BOOL Flag1 : BOOL Flag2 : BOOL Flag3 : BOOL Index : DINT Festo GDCP-CMXR-SW-DE de Version 1.0 41 8. Programmsteuerung Beispiele Bedingungen: Marker := Index < 10 Marker := Flag1 AND Flag2 OR Flag3 IF Index < 10 THEN : END_IF WHILE Index < 5 DO : END_WHILE WHILE NOT Flag1 AND Flag3 OR Flag2 DO : END_WHILE Beispiele Bedingungen mit Klammern: Marker := (Index < 10) AND (Index < 0) Marker := Flag1 AND (Index < 7) IF (Index < 10) AND (Index > 5) THEN : END_IF 8.4 Verzweigung <IF…THEN> Die IF-Anweisung ermöglicht Verzweigungen im Programmablauf, die von Bedingungen abhängen. Die Bedingung muss vom Datentyp BOOL sein und kann aus mehreren Operanden bestehen. Mit der Anweisung ELSIF lassen sich mehrere Bedingungen formulieren. Mit der Anweisung ELSE können Anweisungen definiert werden, die angesprungen werden, falls keine der Bedingungen zutrifft. Die IF-Anweisung wird mit der Anweisung END_IF abgeschlossen. 42 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Syntax IF <Bedingung> THEN <Anweisungen> ELSIF <Bedingung> THEN <Anweisungen> ELSE <Anweisungen> END_IF Die ELSEIF-Anweisung kann mehrfach vorkommen. Beispiel: Von einer Messanlage werden 2 Signale gesendet, die eine Qualitätsbeurteilung zulassen. partOk Signal für Gutteil partBad Signal für Ausschuss Im folgenden FTL-Beispiel wird im Falle eines Gutteiles und eines Ausschussteiles entsprechend verzweigt. Sind die Signale undefiniert d. h. beide Signale haben den Zustand TRUE oder FALSE, so wird auf die Position PosStart gefahren. IF partOk AND NOT partBad THEN // Gutteil Lin(pos12) Lin(pos13) ELSIF NOT partOk AND partBad THEN // Ausschussteil Lin(pos3) Lin(pos4) ELSE Lin(posStart) // keine definierten Signale END_IF 8.5 Sprungbefehle Oft müssen in FTL-Programmen Sprünge ausgeführt werden. Diese Sprünge können auf einer Entscheidung beruhen oder bedingungslos ausgeführt werden. Um einen Sprung durchzuführen benötigt man einen Ausgangspunkt und ein Sprungziel. Festo GDCP-CMXR-SW-DE de Version 1.0 43 8. Programmsteuerung Entscheidung über Sprung : IF teilOk GOTO lblHome Lin(pos15) Lin(pos16) LABEL lblHome Lin(pos5) Lin(pos6) Sprungziel : Hinweis Das Sprungziel muss sich innerhalb des aktiven Programms befinden. Ein Sprung in einen Anweisungsblock mit IF..THEN, WHILE oder LOOP ist nicht erlaubt. Jedoch darf aus einem solchen Anweisungsblock heraus gesprungen werden. 8.5.1 Sprungmarke <LABEL> Eine Sprungmarke muss als Ziel eines Sprunges deklariert werden. Die Sprungmarke besteht aus einem Namen, der frei vergeben werden kann. Die Sprungmarke ist eindeutig und darf nur einmal in einem Programm vorkommen. Damit das System eine Sprungmarke erkennt, wird das Schlüsselwort LABEL vorangestellt. Syntax LABEL <Sprungmarke> Die Sprungmarke kann mit Sprungbefehlen angesprungen werden, die im Folgenden beschrieben werden. Hinweis Bei der Programmierung mit dem CDSA muss zunächst das Sprungziel (LABEL) definiert werden. Erst anschließend kann die GOTO Anweisung programmiert werden. 8.5.2 Bedingter Sprung <IF…GOTO> Mit der IF…GOTO Anweisung werden bedingte Sprünge ausgeführt. Diese Anweisung benötigt wie die Programmverzweigung IF…THEN eine Bedingung, die ein Ergebnis vom Datentyp BOOL liefern muss. 44 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Syntax IF <Bedingung> GOTO <Sprungmarke> Ist die Bedingung erfüllt, d. h. das Ergebnis ist TRUE, dann wird der Sprung ausgeführt. Ist die Bedingung nicht erfüllt, d. h. das Ergebnis ist FALSE, so werden die Befehle in den nachfolgenden Programmzeilen ausgeführt. 8.5.3 Absoluter Sprung <GOTO> Im Gegensatz zur bedingten Sprunganweisung IF…GOTO, ist die GOTO Anweisung absolut. Dies bedeutet, es gibt keine Bedingungsanweisung. Syntax GOTO <Sprungmarke> Mit der GOTO Anweisung lassen sich Programmteile sehr leicht überspringen. Sie eignet sich auch dazu, um aus Programmschleifen zu springen. Hinweis Bei der Programmierung mit dem CDSA muss zunächst das Sprungziel (LABEL) definiert werden. Erst anschließend kann die GOTO Anweisung programmiert werden. 8.6 Schleifen Schleifen sind Programmanweisungen, die bedingt oder unbedingt einen definierten Programmteil wiederholen. Dadurch lassen sich je nach Aufgabe Programme sehr kurz fassen, z. B. eine Entnahme von Teilen aus einer Palette, deren Positionen sich aufgrund der bekannten Anordnung berechnen lassen. Vorsicht Durch die Programmierung von Endlosschleifen kann das Laufzeitverhalten der CMXR Steuerung beeinträchtigt werden. Innerhalb Endlosschleifen müssen Anweisungen wie Wait oder WaitTime stehen, damit eine Endlosschleife die CMXR Steuerung nicht blockiert. 8.6.1 WHILE-Anweisung <WHILE> Die WHILE-Anweisung dient zur Wiederholung einer Anweisungsfolge, solange eine Bedingung erfüllt ist. Das Ergebnis der Schleifenbedingung muss vom Datentyp BOOL sein. Die Schleife darf beliebig viele Anweisungen enthalten. Die WHILE-Anweisung wird mit dem Schlüsselwort END_WHILE abgeschlossen. Festo GDCP-CMXR-SW-DE de Version 1.0 45 8. Programmsteuerung Hinweis Wenn eine Schleife sehr oft durchlaufen wird und keine WAITAnweisungen enthält, kann sie die Ausführung anderer FTLProgramme behindern. Üblicherweise wird die Steuerung so konfiguriert sein, dass in diesem Fall eine Warnung ausgelöst und das unkooperative Programm kurzfristig ausgesetzt wird. Syntax WHILE <Bedingung> DO <Anweisungen> END_WHILE Beispiel : WHILE index < 5 DO Lin(pos1) Lin(pos2) Lin(pos3) index := index + 1 END_WHILE 8.6.2 LOOP-Anweisung <LOOP> Die LOOP-Anweisung dient zur Wiederholung einer Anweisungsfolge. Man kann direkt angeben, wie oft die Anweisungen durchlaufen werden sollen. Für jede LOOP-Anweisung wird automatisch eine interne Schleifenvariable angelegt, die beim Auflaufen auf die Schleife auf 1 initialisiert wird. Die Schleife wird solange durchlaufen, bis der Wert der internen Schleifenvariablen den Endwert überschreitet. Ist der Endwert kleiner als 1 wird die Schleife somit gar nicht durchlaufen, sondern übersprungen. Nach jedem Durchlauf wird der Wert der Schleifenvariable um eins erhöht und der Endwert neu berechnet. Die Schleife darf beliebig viele Anweisungen enthalten. Syntax LOOP <Anzahl> DO <Anweisungen> END_LOOP 46 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Beispiele: LOOP 10 DO // 10 Durchläufe index := index + 13 END_LOOP j := 0 ... LOOP j DO // wird übersprungen, da j = 0 index := index + 13 END_LOOP : 8.7 Unterprogramme In einem Programm können andere Programme aufgerufen werden. Diese Programme müssen sich im gleichen Projekt wie das aktive Programm befinden oder im globalen Projekt (_global, siehe Kapitel 3.6.1 Globales FTL-Projekt auf Seite 20) liegen. Diese aufgerufenen Programme werden als Unterprogramme bezeichnet. Hinweis Ein Unterprogramm benötigt keine spezielle Kennung. Bei der Erstellung wird dieses genau wie jedes andere Programm erzeugt und in einem Projekt abgespeichert. Die Klassifizierung eines Programms als Unterprogramm erfolgt lediglich durch den Aufruf aus einem Programm und nicht direkt aus dem Projekt. Abarbeitung: Während das Unterprogramm abgearbeitet wird, wartet das aufrufende Programm auf dessen Ende. Nach Ende des Unterprogramms erfolgt ein automatischer Rücksprung zum aufrufenden Programm, das fortgesetzt wird. Festo GDCP-CMXR-SW-DE de Version 1.0 47 8. Programmsteuerung Ablaufschema: Hauptprogramm Unterprogramm Sprungziel In diesem Beispiel ruft das Programm „feed“ ein Unterprogramm „movehome“ auf. Wenn das Programme „movehome“ die Abarbeitung beendet hat, wird das Programm „feed“ fortgesetzt. Vorteile: Die Programmgestaltung mit Unterprogrammen ermöglicht eine überschaubare und effiziente Programmierung. Der Programmcode für Teilaufgaben wird separat abgelegt und kann von mehreren Programmen genutzt werden. Die Pflege und die Konsistenz der Programme wird dadurch gesteigert. 8.7.1 Unterprogrammaufruf <CALL> Ein Unterprogrammaufruf erfolgt über den Befehl CALL. Eine Parameterübergabe an das Unterprogramm wird nicht unterstützt. Falls eine Datenübergabe notwendig ist, muss dies über globale Variable erfolgen. Diese Variablen werden vor dem Aufruf mit entsprechenden Werten versorgt und innerhalb des Unterprogramms verarbeitet. Rekursive Aufrufe von Programmen sind nicht erlaubt. Ein Programm darf sich daher nicht selbst aufrufen. Ferner ist ein Aufruf des aufrufenden Programms nicht möglich. Syntax CALL <Programmname> ( ) 48 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Beispiel: : variant := 17 // Variable für Programm Kleben directionRight := TRUE // Variable für Programm Kleben directionLeft := FALSE // Variable für Programm Kleben CALL Glueing() // Unterprogramm Kleben CALL MoveStart() // Unterprogramm fahre Startposition : 8.7.2 Programmrücksprung <RETURN> Prinzipiell wird ein Unterprogramm mit der letzten Anweisung beendet. Soll ein Unterprogramm vor der letzten Anweisung beendet werden, erfolgt dies mit dem Befehl RETURN. Das Unterprogramm wird dabei vorzeitig beendet und es wird in das aufrufende Programm zurückgesprungen, das fortgesetzt wird. Syntax RETURN Eine Rückgabe von Werten an das übergeordnete Programm ist nicht möglich. Sollte das nötig sein, können entsprechende globale Variablen benützt werden. Hinweis Wird der Befehl RETURN im Hauptprogramm ausgeführt, wird dieses gestoppt und beendet. Bei einem Aufruf von RETURN in einem parallelen Programm oder einem Unterprogramm wird dieses beendet. Das Hauptprogramm wird fortgesetzt. Beispiel: : CALL CheckPart() // Aufruf Unterprogramm CheckPart IF NOT partOk THEN partStatus := 10 // globale Variable für Rückgabewert RETURN // vorzeitiges Programmende END_IF Lin(pos3) : Festo GDCP-CMXR-SW-DE de Version 1.0 49 8. Programmsteuerung 8.8 Parallele Programme Ein Programm aus dem aktiven Projekt oder aus dem globalen Projekt kann auch als paralleler Prozess gestartet werden. Das Betriebssystem des CMXR sorgt dafür, dass diese Programme parallel abgearbeitet werden. Dies wird durch das interne Multitaskingsystem sichergestellt. Hinweis Fahrbefehle an eine Kinematik sind aus einem parallelen Programm nur möglich, wenn zuvor aus einem Hauptprogramm kein Fahrbefehl abgesetzt wurde. Erfolgt ein Fahrbefehl aus einem Haupt- und Parallelprogramm, erzeugt das System einen Fehler. Verwendung: Parallele Programme ermöglichen das Erstellen von Prozessen, die asynchron oder nur teilweise zum Hauptprogramm synchronisiert arbeiten. Ein Beispiel ist das Ansteuern einer Zuführ- oder Auswerfeinheit, die mit Ein-/ Ausgängen angesteuert wird. Mit logischen Befehlen und Verarbeitung der Ein-/Ausgänge, kann in diesem Fall der Ablauf beschrieben werden. Je nach Anforderung kann eine Synchronisierung zum Hauptprogramm über globale Variable erfolgen. Ablaufschema: Hauptprogramm Parallelprogramm Sprungziel In diesem Beispiel ruft das Programm „feed“ ein Parallelprogramm „calculate“ auf. Das aufgerufenen Programm „calculate“ wartet zunächst auf ein Signal und erhöht einen Zähler. Währenddessen wird das Hauptprogramm „feed“ weiter abgearbeitet. 50 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Hinweis Wird in einem parallelen Programm eine Endlosschleife programmiert, so ist dafür zu sorgen, dass diese die Programmausführung der anderen Programme nicht blockiert. Durch einen Wait oder einen WaitTime Befehl wird ein Verteilen der Rechenleistung auf die anderen Programme gewährleistet. 8.8.1 Paralleles Programm starten <RUN> Ein paralleles Programm wird mit dem Befehl RUN gestartet. Eine Parameterübergabe an das zu startende Programm ist nicht möglich. Sollten Daten übergeben werden, so können globale Variable dafür verwendet werden. Syntax RUN <Programmname> Ein bereits laufendes Programm kann nicht gleichzeitig als Parallelprogramm gestartet werden. 8.8.2 Paralleles Programm beenden <KILL> Ein aktives parallel laufendes Programm kann aus dem aufrufenden Programm über die Anweisung "KILL" beendet werden. Dabei wird zuerst das Programm und die Kinematik gestoppt, danach wird das Programm beendet. Syntax KILL <Programmname> Auch der Befehl RETURN hat im parallelen Programm zur Folge, dass das Programm beendet wird. Festo GDCP-CMXR-SW-DE de Version 1.0 51 8. Programmsteuerung 8.9 Beeinflussen des Satzvorlaufes Um Bewegungen effizient abzufahren und kritische Situationen wie z. B. das Überschreiten der max. Antriebsdynamik zu erkennen, muss die Bahn vorausberechnet werden. In manchen Situationen ist es jedoch notwendig, dass die Programmvorausberechnung mit der Ausführung synchronisiert wird. Zu diesem Zweck werden in der FTL Programmierung unterschiedliche Befehle angeboten, die die Vorausberechnung anhalten und somit einen Stopp der Bewegung erzeugen oder auf die Programmausführung zeitoptimal warten, um die Dynamik der Bewegung nicht zu beeinflussen. Die Beschreibung dieser Befehle erfolgt auf den folgenden Seiten. 8.9.1 WAIT – Anweisung mit Zeit <WaitTime> Die WAIT Anweisung mit Zeit-Angabe ermöglicht das Programmieren einer Wartezeit. Diese Wartezeit beeinflusst das Bewegungsverhalten. Sie erzwingt ein Stoppen der Satzvorausberechnung, was zu einem Stopp der Bewegung führt. Nachdem der vorherige Befehl ausgeführt wurde, beginnt die Wartezeit zu laufen. Nach Ablauf dieser Zeit wird das Programm fortgesetzt. Syntax WaitTime (<timeMS >: DINT) Die Angabe der Zeit erfolgt in Millisekunden und kann über einen Wert oder eine Variable angegeben werden. Hinweis Soll der Satzvorlauf mit dem Satzhauptlauf synchronisiert werden, so kann dies über die Anweisung WaitTime 0 erfolgen. Beispiel: Ein Handhabungssystem, bestückt mit einem Greifer, entnimmt Teile aus einer Palette. Um die Teile sicher zu greifen, muss eine gewisse Zeit abgewartet werden. Auszug aus dem Bewegungsprogramm: : Lin(pos1) // fahre über Greifposition Lin(pos2) // fahre auf Greiferposition Gripper.Set() // Greifer schließen WaitTime(70) // warte 70 msec Greifzeit Lin(pos1) // fahre über Greifposition : 52 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Bewegungsablauf : Bahngeschwindigkeit Wartezeit 70 msec pos1 8.9.2 pos2 Zeit pos1 WAIT- Anweisung mit Bedingung <WAIT> Die WAIT-Anweisung mit Bedingung ermöglicht das Abfragen von binären Zuständen. Dieser Zustand kann in Form einer einzelnen booleschen Variable, einer Kombination aus mehreren oder einer Abfrage bestehen. Die Bearbeitung der WAIT-Anweisung erfolgt im Satzvorlauf, d. h. in der Vorausberechnung der CMXR-Steuerung. Ist die Bedingung nicht erfüllt, so wird der Satzvorlauf (Vorausberechnung) solange gestoppt, bis die Bedingung der WAIT-Anweisung erfüllt ist. Satzhauptlauf Lin(pos1) Lin(pos1) Lin(pos2) Lin(pos2) Lin(pos3) Lin(pos3) Lin(pos4) Lin(pos4) Lin(pos5) Lin(pos5) Wait sensor Satzvorlauf Satzhauptlauf Satzvorlauf Wait sensor Lin(pos6) Lin(pos6) Lin(pos7) Lin(pos7) Lin(pos8) Lin(pos8) Lin(pos9) Lin(pos9) Bedingung für WAIT erfüllt, Satzvorlauf wird weiter berechnet. Bedingung für WAIT nicht erfüllt, Satzvorlauf bleibt stehen, bis Bedingung erfüllt ist. Ist die zeitliche Verzögerung so groß, dass sogar der Hauptlauf des Bewegungsprogramms die WAIT-Anweisung erreicht, so wird auch dieser gestoppt, was zu einem Stillstand der Festo GDCP-CMXR-SW-DE de Version 1.0 53 8. Programmsteuerung Bewegung führt. Die Abarbeitung und Vorausberechnung wird erst fortgesetzt, wenn die Bedingung der WAIT-Anweisung erfüllt ist. Hinweis Da die Abfrage der Bedingung im Satzvorlauf erfolgt, wird eine Änderung, die nach der Bearbeitung durch den Satzvorlauf erfolgt, nicht mehr registriert. Wird dies gewünscht, so kann mit dem Voranstellen des Befehls WaitTime (siehe Kapitel 8.9.1 WAIT – Anweisung mit Zeit auf Seite 52) eine Synchronisation mit dem Satzhauptlauf erzwungen werden. In der Bedingung der WAIT Anweisung dürfen die Grunddatentypen BOOL, REAL und DINT mit logischen Operatoren und Vergleichsoperatoren verwendet werden. Arithmetische und Bitoperatoren dürfen nicht verwendet werden. Syntax WAIT <Bedingung> Beispiel: Mit einer schiefen Ebene werden Teile einem Handhabungssystem zugeführt. Ein anwesendes Teil wird über einen digitalen Sensor erkannt und kann dann vom Handhabungssystem entnommen werden. Z X Pos2 Sauggreifer Pos3 Pos1 Pos4 Werkstück Sensor Ablage Der Sensor erkennt, ob sich ein Werkstück auf der Ablage befindet. Steht dieses bereit, wird es vom Handhabungssystem entnommen. 54 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Auszug aus dem Bewegungsprogramm: : Lin(pos2) // fahre über Teil Vacuum.Set() // Vakuum ein WAIT sensor // warte, bis Teil vorhanden Lin(pos1) // fahre auf Teil Lin(pos2) // fahre über Teil Lin(pos3) // fahre über Ablage Lin(pos4) // lege Teil ab WaitTime(0) // warte auf Satzhauptlauf Vacuum.Reset() // Vakuum aus Lin(pos3) // fahre über Ablage : Ist kein Werkstück in der Ablage, so wartet das Handhabungssystem über dem Werkstück, die Bewegung ist gestoppt. Meldet der Sensor „Werkstück vorhanden“, so wird das Programm fortgesetzt. Ist beim Anfahren bereits ein Werkstück vorhanden, so fährt das Handhabungssystem sofort auf das Werkstück, ohne dass die Bewegung unterbrochen wird. 8.9.3 WaitOnPath – Anweisung mit Zeit <WaitOnPath> Der FTL-Befehl WaitOnPath erzeugt eine Wartezeit, die sich nur auf die Bewegung auswirkt. Diese Wartezeit wird direkt in die Bahnplanung mit aufgenommen und die Achsen mit der programmierten Dynamik abgebremst. Nach dem Ablauf der Zeit wird die folgende Bahn fortgesetzt. Der Satzvorlauf des FTL Programms wird dabei nicht angehalten. Hinweis Das Befehl WaitOnPath eignet sich nicht um Anweisungen wie z. B. das Schalten eines Ausganges oder beschreiben einer Variable mit dem Programmhauptlauf zu synchronisieren. Syntax WaitOnPath ( <timeMS> : DINT ) Parameter Bedeutung Einheit time Wartezeit msec Tabelle 8.1 Parameter Befehl WaitOnPath Festo GDCP-CMXR-SW-DE de Version 1.0 55 8. Programmsteuerung Beispiel: Mit einem Stempel wird eine Markierung auf ein Werkstück gedrückt. Nach dem Erreichen der Druckposition, muss zur Farbübertragung eine Wartezeit von 150msec ausgeführt werden. Der Satzvorlauf darf jedoch nicht angehalten werden. : Lin(pos1) // fahre auf Sicherheit Lin(printPos) // fahre auf Druckposition WaitOnPath(150) // warte 150 msec Lin(pos1) // fahre auf Sicherheit : Bahngeschwindigkeit Wartezeit 150 msec pos1 8.9.4 printPos Zeit pos1 WaitOnPos – Anweisung mit Zeit <WaitOnPos> Der FTL-Befehl WaitOnPos hält den Satzvorlauf an, bis das aktuelle Segment zum angegebenen prozentualen Anteil abgearbeitet wurde. Danach wird das Programm weiter bearbeitet. Syntax WaitOnPos ( OPT <pos> : REAL ) Parameter Bedeutung Einheit Pos Prozentualer Wert für Bahnsegmentlänge Prozent Tabelle 8.2 Parameter Befehl WaitOnPos Ist ein Überschleifen aktiviert und die Distanz zum Zielpunkt zum Überschleifen ausreichend groß, so wird das Überschleifen ausgeführt. Der Parameter des prozentualen Anteils ist optional. Wird dieser nicht angegeben, so entspricht dies dem Wert 100%. Dies hat einen Stop auf der Bahn zur Folge. 56 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Im folgenden Beispiel werden Position angefahren und der Satzvorlauf solange angehalten, bis 80% des Bahnsegmentes abgefahren wurde. Danach wird im Beispiel die Variable Index wird auf 10 gesetzt. Lin(Pos1) Lin(Pos2) WaitOnPos(80) Index := 10 Pos1 80% Pos2 8.9.5 WaitOnMainRun – Warten auf Hauptlauf <WaitOnMainRun> Der FTL-Befehl WaitOnMainRun hält den Satzvorlauf solange an, bis der Hauptlauf diesen erreicht hat. Jedoch hat dies keine Auswirkung auf die Bahndynamik. Dies bedeutet ein Überschleifen auf eine folgende Position wird nicht beeinträchtigt. Syntax WaitOnMainRun ( ) Dieser Befehl ermöglicht ein spätest mögliches Beschreiben oder Auswerten von Signalen, ohne dass die Bewegung beeinträchtigt wird. Eine davor programmierte Position wird bedingt durch ein Überschleifen auf das nächste Segment nicht genau erreicht. Beispiel: Im folgenden Bewegungsablauf wird kurz vor dem Erreichen der Position pos2 der Befehl WaitOnMainRun ausgeführt und anschließend die Variable plc_InBool[3] , die zur SPS geht, beschrieben. : Lin(pos1) // fahre auf pos1 Lin(pos2) // fahre auf pos2 WaitOnMainRun() // warte auf Hauptlauf Festo GDCP-CMXR-SW-DE de Version 1.0 57 8. Programmsteuerung plc_InBool[3] := TRUE // Signal zur SPS Lin(pos3) // fahre auf pos3 : Das folgende Diagramm zeigt die zeitliche Darstellung der Ausführung von WaitOnMainRun: Bahngeschwindigkeit pos1 pos3 pos2 Hauptlauf Zeit Vorlauf Ausführung von WaitOnMainRun vor dem Erreichen der Position pos2 8.10 DO Anweisung Mit der DO Anweisung ist es möglich, bestimmte FTL-Befehle zwingend im Hauptlauf der Programmbearbeitung auszuführen. Die Anweisung besitzt folgende Syntax: Syntax <FTL-Befehl> DO <FTL-Anweisung> Die Ausführung derFTL- Anweisung nach DO wird im Hauptlauf der Programmbearbeitung ausgeführt. Die Vorausberechnung des Programms wird durch die DO Anweisung nicht beeinflusst. Nach einer DO Anweisung kann eine eingeschränkte Menge von FTL-Befehlen genutzt werden. Nicht erlaubt sind Befehle, die sich auf eine Kinematik beziehen wie z. B. Dynamikangabe oder eine Positionsfahrt. 58 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Hinweis Die Ausführung der DO Anweisung erfolgt, nachdem der FTL-Befehl davor im Hauptlauf ausgeführt wurde. Die Ausführung erfolgt bedingungslos. Eine Programmzeile darf nur eine DO Anweisung enthalten, hinter der genau eine FTL-Anweisung stehen darf. Mit der DO Anweisung können im Hauptlauf der FTL Programmbearbeitung z. B. Variablen beschrieben oder Ausgänge gesetzt werden. Die DO Anweisung kann in Verbindung mit allen Bewegungsbefehlen z. B. Ptp, Lin verwendet werden. Beispiel Setzen eines Ausgangs: Mit dem Erreichen von pos2 wird der Ausgang des Bausteines Vacuum gesetzt. : Lin(pos1) Lin(pos2) DO Vacuum.Set() Lin(pos3) : Beispiel Beschreiben von Variablen an die SPS: : Lin(pos1) SetVel(dynCart, 1000)) DO plc_Dint[3] := 5 Lin(pos2) : Festo GDCP-CMXR-SW-DE de Version 1.0 59 8. Programmsteuerung 8.11 Kommentare einfügen <//> Ein Kommentar wird mit der Zeichenfolge "//" eingeleitet. Er kann ab Zeilenanfang allein oder hinter einem FTL-Befehl stehen und endet am Zeilenende Syntax // <Beliebiger Text> Ein FTL-Befehl kann mit Kommentarzeichen "auskommentiert" werden. Dieser Befehl hat dann keine Auswirkung auf die Programmbearbeitung. Folgende Abbildung zeigt die Programmmaske des Handbediengerätes mit einem Kommentar und einer auskommentierten Programmanweisung: 8.12 Programmzeile deaktivieren <##> Mit der Zeichenfolge "##" werden Programmzeilen für die Programmbearbeitung deaktiviert, jedoch bleibt die Syntaxprüfung erhalten. Hinweis ## <Programmanweisung> Dies bedeutet: Ein deaktivierter FTL-Befehl wird im Programm nicht bearbeitet, d. h. die Inhalte haben keine Auswirkung. Die Inhalte der Programmanweisung unterliegen der Syntaxprüfung des Compilers. Wird z. B. eine verwendete Variable gelöscht, so wird beim Programmstart ein Fehler ausgegeben. 60 Festo GDCP-CMXR-SW-DE de Version 1.0 8. Programmsteuerung Hinweis Bei Programmanweisungen, die aus mehreren Zeilen bestehen, wie z. B. IF..THEN…ELSE, müssen alle zugehörigen Programmzeilen deaktiviert werden. Folgende Abbildung zeigt die Programmmaske des Handbediengerätes mit deaktivierten Programmanweisungen in den Zeilen 8 … 10: Festo GDCP-CMXR-SW-DE de Version 1.0 61 9. Bewegungsbefehle 9. Bewegungsbefehle Bewegungen einer Kinematik werden mit Bewegungsbefehlen ausgelöst. Diese beschreiben die Bewegung vom aktuellen Ort zu dem angegebenen Zielpunkt. Bei der Bewegung werden zuvor gesetzte Werte wie z. B. Geschwindigkeit, Beschleunigung oder Orientierung berücksichtigt. Bewegungen gibt es unterschiedlicher Art. Es gibt Bewegung mit einer Achsinterpolation (Point-To-Point-Bewegung) und Bewegungen in einem kartesischen Raum. Die kartesischen Bewegungen greifen dabei auf eine interne Transformation der Kinematik zurück. 9.1 Positionsbeschreibung Alle Positionen werden in sogenannten Positionsvariablen abgespeichert. Diese Positionsvariablen werden zur Positionsangabe bei den Bewegungsbefehlen benötigt. Eine direkte Angabe mit Konstanten ist nicht möglich. Alle Positionsvariablen werden in der zugehörigen Datendatei (siehe Kapitel 3.8 FTL-Datendatei auf Seite 21) abgespeichert. Es gibt die Möglichkeit, eine Position im Achskoordinatensystem oder in einem kartesischen Koordinatensystem anzugeben. Da diese Positionsangaben unterschiedlichen Ursprungs sind, gibt es dafür 2 Datentypen: 1. AXISPOS für die Angabe im Achskoordinatensystem, 2. CARTPOS für die Angabe im kartesischen Koordinatensystem Die Anzahl der Achsen ist beim CMXR auf 6 begrenzt. Diese Achsen können auf Kinematische und Hilfsachsen verteilt werden. Die Positionen aller Achsen werden in einer Positionsvariablen abgespeichert. Somit umfasst der Datentyp AXISPOS 9 Koordinatenwerte. Bedingt durch maximal 6 Freiheitsgrade umfasst der Datentyp CARTPOS ebenfalls 9 Koordinatenwerte, die sich jedoch in 3 Positionsangaben, 3 Orientierungsangaben und 3 Hilfsachsen unterteilen. In der Programmierumgebung des FCT-PlugIn ist die Anzahl der Koordinatenwerte auf die Anzahl der projektierten Achsen begrenzt, der Rest ist gesperrt. Hinweis Beide Datentypen AXISPOS und CARTPOS können für Bewegungsbefehle verwendet werden. Die CMXR Steuerung führt je nach Bedarf automatisch Wandlungen (Koordinatentransformationen) aus. Entsprechendes ist der Befehlsbeschreibung zu entnehmen. Bei den Datentypen AXISPOS und CARTPOS handelt es sich um strukturierte Datentypen (siehe Kapitel 5.5 Strukturierte Datentypen auf Seite 32). 9.1.1 Achsposition Eine Achsposition wird mit dem strukturierten Datentyp AXISPOS beschrieben (siehe Kapitel 5.5 Strukturierte Datentypen auf Seite 32). Dieser umfasst 9 Positionen von 9 einzelnen 62 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Achsen, deren Positionswert mit dem Datentyp REAL angegeben wird. Bedingt durch das ausgewählte Kinematikmodell kann dies eine Auswahl oder Mischung von linearen oder rotativen Achsen sein. Die Einheit einer Position wird somit in z. B. mm oder Grad angegeben. Aufbau: Bedingt durch die maximale Achsanzahl einer Kinematik von 9 Achsen, umfasst der Datentyp 9 Achspositionen. Diese einzelnen Positionswerte sind in 9 einzelnen REAL Variablen hinterlegt. Datentyp AXISPOS: a1 : REAL Achsposition Kinematikachse 1 a2 : REAL Achsposition Kinematikachse 2 a3 : REAL Achsposition Kinematikachse 3 a4 : REAL Achsposition Kinematikachse 4 a5 : REAL Achsposition Kinematikachse 5 a6 : REAL Achsposition Kinematikachse 6 a7 : REAL Achsposition Hilfsachse 1 a8 : REAL Achsposition Hilfsachse 2 a9 : REAL Achsposition Hilfsachse 3 Der Datentyp AXISPOS beschreibt den maximal möglichen Aufbau einer Achsposition. Sind Achsen nicht vorhanden, so ist eine Positionsangabe für diese Achsen irrelevant. In der Regel erfolgt für diese Achsen die Angabe des Positionswertes 0. Im FCT-Editor sind die Felder dieser Achsen gesperrt. Auf jeden einzelnen Wert eines Positionswertes vom Typ AXISPOS kann über den Namen der einzelnen Position zugegriffen werden. Beispiel: Variable: startPos : AXISPOS := (100, 50, 30, 0, 0, 0, 0, 0, 0) posA1 : REAL posA2 : REAL Programm: : Lin(startPos) // fahren auf startPos posA1 := startPos.a1 // umspeichern von Achswert 1 posA2 := startPos.a2 // umspeichern von Achswert 2 : Festo GDCP-CMXR-SW-DE de Version 1.0 63 9. Bewegungsbefehle Die Zuordnung einzelner Achsen auf die Positionsdatenstruktur AXISPOS erfolgt durch eine Nummerierung. Diese Nummerierung hat bereits in der Konfiguration der Kinematikachsen stattgefunden. Analog zu dieser Nummerierung erfolgt bei der Positionsangabe des Datentyps AXISPOS die Zuordnung zu den einzelnen Achsen. Beispiel: Kartesisches Raumportal mit 3 Linearachsen und einer Rotationsachse (Drehen des Greifers). In der Konfiguration erfolgte folgende Festlegung: Achse 1 = X-Achse Achse 2 = Y-Achse Achse 3 = Z-Achse Achse 4 = Drehachse Greifer Achse 5 bis 6 sind nicht vorhanden, keine Hilfsachsen. Analog zu dieser Nummerierung erfolgt die Zuordnung im Datentyp Axispos: a1 : REAL Position Achse 1 = X - Achse a2 : REAL Position Achse 2 = Y - Achse a3 : REAL Position Achse 3 = Z - Achse a4 : REAL Position Achse 4 = Drehachse Greifer a5 : REAL Position Achse 5, nicht vorhanden a6 : REAL Position Achse 6, nicht vorhanden a7 : REAL Position Hilfsachse 1, nicht vorhanden a8 : REAL Position Hilfsachse 2, nicht vorhanden a9 : REAL Position Hilfsachse 3, nicht vorhanden 64 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle 9.1.2 Kartesische Position Im Gegensatz zur Achsposition des Datentyps AXISPOS beschreibt der kartesische Positionstyp CARTPOS eine Position in einem kartesischen Koordinatensystem. Ein Körper besitzt maximal 6 Freiheitsgrade. Mit Hilfe dieser Werte kann man die Position und Orientierung des Körpers im Raum bestimmen. Diese 6 Freiheitsgrade werden mit 6 Angaben im Datentyp CARTPOS beschrieben. Zusätzlich erfolgt die Angabe der Position der 3 Hilfsachsen. Diese ist jedoch eine Angabe in einer Achsposition, da mit den Hilfsachsen nicht kartesisch verfahren werden kann. Sie werden gemeinsam mit den Kinematikachsen auf die Zielposition interpoliert, jedoch führen die Hilfsachsen eine PointTo-Point (Ptp) Interpolation aus. Aufbau: Datentyp CARTPOS x : REAL Verschiebung entlang der X-Achse y : REAL Verschiebung entlang der Y-Achse z : REAL Verschiebung entlang der Z-Achse a : REAL Orientierungsangabe, Drehung um die Z-Achse b : REAL Orientierungsangabe, Drehung um die verdrehte Y-Achse c : REAL Orientierungsangabe, Drehung um die verdrehte Z-Achse aux1 : REAL Achsposition Hilfsachse 1 aux2 : REAL Achsposition Hilfsachse 2 aux3 : REAL Achsposition Hilfsachse 3 Bedingt durch die ausgewählte Kinematik bzw. deren Freiheitsgrade, ist manche Angabe in einer kartesischen Position nicht möglich. Die einzelnen Positionsangaben im Datentyp CARTPOS sind nicht an die physikalischen Achsen der Kinematik gebunden, sondern an deren Freiheitsgrade. Die kartesische Position umfasst die Angaben für maximal 6 Freiheitsgrade. X, Y, Z sind die translatorischen Positionen, A, B und C beschreiben die Orientierungen der Position. Die Orientierung wird, wie im gesamten System, nach der Euler ZYZ Konvention angegeben. Der Datentyp CARTPOS ist wie der Datentyp AXISPOS strukturiert (siehe Kapitel 5.5 Strukturierte Datentypen auf Seite 32). Der Zugriff auf einzelne Positionswerte erfolgt über den Namen der einzelnen Werte des Datentyps. Beispiel: Variable: startPos : CARTPOS := (1050, 130, 30, 0, 0, 0, 0, 0, 0) newPos : CARTPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0) posX : REAL posY : REAL Festo GDCP-CMXR-SW-DE de Version 1.0 65 9. Bewegungsbefehle Programm: : Lin(startPos) // fahren auf StartPos newPos // kopieren von StartPos := startPos newPos.x := newPos.x + 10 // berechnen von X newPos.y := newPos.y + 35.7 // berechnen von Y Lin(newPos) // fahre auf berechnete Position : Die Wirkung der einzelnen kartesischen Positions- und Orientierungsangaben hängt von den Freiheitsgraden der Kinematik ab. Beispiel: Gegeben ist eine Parallelstab-Kinematik (Tripod) mit 3 Hauptachsen, ohne Handachsen. Mit den vorhandenen 3 Hauptachsen werden die 3 translatorischen Freiheitsgrade X, Y und Z abgedeckt. Da keine Handachsen vorhanden sind, ist keine Orientierung des Werkzeuges möglich. Eine Programmierung der Variablen a, b, c, aux1, aux2 oder aux3 in der Positionsangabe des Datentyps CARTPOS hat keine Auswirkungen. 66 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle 9.1.3 Teachen von Positionsvariable Einzelne Positionsvariable vom Typ AXISPOS und CARTPOS können mit Hilfe des Handbediengerätes oder der Emulationssoftware im Variablenmonitor geteacht werden. Um eine Positionsvariable zu teachen ist es notwendig, dass sich die Mehrachssteuerung CMXR in der Betriebsart HAND befindet und die zu teachende Variable markiert ist. 1. Variable anklicken, wird blau hinterlegt 2. Softkey Teach wird aktiviert Durch drücken des Softkeys wird die aktuelle Position in die angegebene Variable gespeichert. Dabei wird bei einer Variable vom Typ CARTPOS der kartesische Wert, bei einer Variable vom Typ AXISPOS die Achsposition gespeichert. Das Teachen erfolgt immer auf eine Positionsvariable. Hinweis Beim Teachen einer kartesischen Position vom Typ CARTPOS, wird der Wert wird immer im aktuellen ausgewählten Referenzsystem geteacht. Dieses wird auf der Positionsseite in der Auswahlbox angezeigt. Wird eine Achsposition vom Typ AXISPOS geteacht, so ist das ausgewählte Referenzsystem bedeutungslos. 9.2 Point-To-Point-Bewegung <Ptp> Die Point-To-Point-Bewegung (PTP) ist die schnellste Möglichkeit, die Werkzeugspitze (TCP) an die gewünschte Position zu bewegen. Die PTP-Bewegung ist ein synchroner Punkt-zu-Punkt-Fahrbefehl mit Zielposition. Bei diesem Befehl werden alle Achsen gleichzeitig gestartet und gelangen gleichzeitig an die programmierte Zielposition. Zur Bewegung werden die gerade aktiven Dynamikwerte verwendet, z. B. Geschwindigkeit und Beschleunigung. Die effektive Dynamik ergibt sich aus Kombination der Dynamiken aller beteiligten Achsen. Die langsamste Achse bestimmt die Dynamik. Die Bewegung des TCP ergibt sich in diesem Fall aus der Kombination der Einzelachsbewegung. Die Bewegung am TCP ist undefiniert. Festo GDCP-CMXR-SW-DE de Version 1.0 67 9. Bewegungsbefehle Vorsicht Da bei einer PTP-Bewegung keine Bahn eingehalten wird, sondern nur die Achsen auf das Ziel interpoliert werden, kann es zu nicht einschätzbaren Beschleunigungen und Geschwindigkeiten am Werkzeug (TCP) kommen. Die Bewegungen sind daher auf Verlust oder Beschädigung von Werkstück und/oder Werkzeug zu prüfen. Aufgrund der Achsinterpolation können bei einer PTPBewegung keine Werkzeugdaten berücksichtigt werden. Deshalb ist stets auf die eingesetzten Werkzeuge zu achten und diese vor Beschädigungen zu schützen. Um die Kollisionsgefahr zu minimieren, sollten alle PTPBewegungen mit einer reduzierten Geschwindigkeit getestet werden. Dazu kann z.B. der Override verwendet werden. Syntax Ptp ( <Pos> : AXISPOS oder CARTPOS) Parameter Bedeutung Einheit Pos Zielposition AXISPOS oder CARTPOS Tabelle 9.1 Parameter Befehl PTP Die Positionsangabe kann kartesisch oder im Achskoordinatensystem (bezogen auf jede einzelne Achse) sein. Die CMXR Mehrachssteuerung transformiert die Positionen entsprechend. Beispiel: Ein kartesisches Portal mit 3 Achsen X, Y, Z und einer Drehachse mit Greifer muss positioniert werden. 1 Y-Achse 2 Z-Achse 3 Drehachse mit Greifer 1 2 4 X-Achse 3 4 68 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Variable: pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0) pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0) Programm: : Ptp(pos1) Ptp(pos2) : Y Drehachse 180 Grad Drehachse 90 Grad Bahnverlauf an der Z-Achse Drehachse 0 Grad Ungefährer Bahnverlauf am TCP X Im Beispiel ist der Bahnverlauf der Z-Achse und der Werkzeugspitze (TCP) ersichtlich. Durch die senkrechte Anordnung der kartesischen Kinematik ist der Bahnverlauf an der ZAchse eine Gerade. Dadurch, dass das Werkzeug einen Versatz zur Z-Achse besitzt, kommt es bei dessen Bahnverlauf zu einem nicht vorhersehbaren Verhalten, da mit der synchronen Interpolation alle Achsen gemeinsam auf ihren Zielpunkt fahren, ohne Rücksicht auf den Verlauf der gefahrenen Bahn. Festo GDCP-CMXR-SW-DE de Version 1.0 69 9. Bewegungsbefehle 9.2.1 Teachen der Ptp Bewegung Der FTL-Befehl Ptp besitzt die Zielposition als Parameter, der mit Hilfe des Handbediengerätes oder der Emulationssoftware geteacht werden kann. In der Betriebsart HAND wird bei Erstellung des Befehls oder über den Softkey Ändern die Parametermaske des Befehls geöffnet. Durch das markieren der Zeile Position wird der Softkey aktiv und kann verwendet werden. 1. Parameterfeld anklicken, wird blau hinterlegt 2. Softkey Teach wird aktiviert Durch drücken des Softkeys wird die aktuelle Position in die angegebene Variable gespeichert. Das Teachen erfolgt immer auf eine Positionsvariable. Hinweis Beim Teachen einer kartesischen Position vom Typ CARTPOS, wird der Wert wird immer im aktuellen ausgewählten Referenzsystem geteacht. Dieses wird auf der Positionsseite in der Auswahlbox angezeigt. Wird eine Achsposition vom Typ AXISPOS geteacht, so ist das ausgewählte Referenzsystem bedeutungslos. 9.3 Relative Point-To-Point-Bewegung <PtpRel> Analog zum PTP-Befehl funktioniert der relative PTP-Befehl. Mit dem Unterschied, dass die angegebene Position relativ zur Startposition erfolgt. Die Positionsangabe wird zur Startposition addiert. Eine Anwendung wäre z. B. eine relative Positionierung innerhalb eines Rasters wie bei einer Palette. Syntax PtpRel ( <Dist> : AXISDIST oder CARTDIST) Parameter Bedeutung Einheit Dist Relative Entfernung, die gefahren werden soll AXISDIST oder CARTDIST Tabelle 9.2 Parameter Befehl PtpRel 70 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Die Distanzangabe kann kartesisch oder bezogen auf jede einzelne Achse sein. Die Mehrachssteuerung CMXR transformiert die Positionen entsprechend. Beispiel: In einer Handhabungsapplikation wird ein Teil an 4 Positionen jeweils an eine Messeinheit angefahren. Z-Achse pos1 300 pos3 pos2 225 150 1 2 3 4 110 100 207 850 XAchse Variable: : pos1 : CARTPOS := (100, 0, 300, 0, 0, 0, 0, 0, 0) pos2 : CARTPOS := (207, 0, 225, 0, 0, 0, 0, 0, 0) pos3 : CARTPOS := (850, 0, 300, 0, 0, 0, 0, 0, 0) distX : CARTDIST := (110, 0, 0, 0, 0, 0, 0, 0, 0) distZpos : CARTDIST := (0, 0, 150, 0, 0, 0, 0, 0, 0) distZneg : CARTDIST := (0, 0, -150, 0, 0, 0, 0, 0, 0) : Programm: : Ptp(pos1) Ptp(pos2) LOOP 3 DO PtpRel(distZneg) CALL Check() // Aufruf Pruefzyklus PtpRel(distZpos) Festo GDCP-CMXR-SW-DE de Version 1.0 71 9. Bewegungsbefehle PtpRel(distX) END_LOOP PtpRel(distZneg) CALL Check() // Aufruf Pruefzyklus PtpRel(distZpos) PtpRel(distX) Ptp(pos3) : Der Messzyklus für das Werkstück, sowie die Auswertung werden im Unterprogramm „Pruefe“ abgehandelt. Der Inhalt des Unterprogramms ist zur Vereinfachung nicht dargestellt. Vorsicht Kollisionsgefahr! Wird während einer Relativbewegung die Bewegung gestoppt und wieder gestartet, wird die programmierte Bewegungsdistanz vollständig abgefahren. 9.4 Bewegung einer Achse, <MoveAxisPtp>, <MoveAxisCart> Mit dem Befehl MoveAxisPtp und MoveAxisCart kann eine Achse der Kinematik mit einer PTP-Bewegung oder kartesischen Bewegung positioniert werden. Die Zielposition der Achse wird absolut angegeben. Syntax MoveAxisPtp (<Axis> : ENUM, <Pos> : REAL) MoveAxisCart (<CartComp> : ENUM, <Pos> : REAL) Parameter Bedeutung Einheit Axis Ausgewählte physikalische Enumeration mit der Wertigkeit Achse, die verfahren werden A1 bis A9 für Achse 1 bis 9 soll. Pos Absolute Zielposition Einheit der definierten Achse Tabelle 9.3 Parameter Befehl MoveAxisPtp Parameter 72 Bedeutung Einheit Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Parameter Bedeutung CartComp Ausgewählte kartesische Achse, Enumeration mit der Wertigkeit Pos Einheit die verfahren werden soll. XYZ;ABC Absolute kartesische Zielpositi- Einheit der definierten Achse on Tabelle 9.4 Parameter Befehl MoveAxisCart Da es sich hier um eine Einzelachse handelt, erfolgt die Bewegung unter Berücksichtigung etwaiger Begrenzungen, z. B. Override, mit voller Achsdynamik. Beispiel: Eine kartesische Kinematik besteht aus 4 Achsen: Achse 1 = X-Achse, Achse 2 = Y-Achse, Achse 3 = Z-Achse und Achse 4 = Drehachse des Werkzeuges. Im Beispiel muss ein Werkstück an einer Position aufgenommen und an einer anderen Position abgelegt werden. Dazu muss die Drehachse entsprechend positioniert werden. Z-Achse pos1 pos2 250 145 50 aufnahmeOben ablageOben aufnahmeUnten ablageUnten 300 350 450 575 XAchse Variable: : pos1 : CARTPOS := (300, 0, 250, 0, 0, 0, 0, 0, 0) takeAbove : CARTPOS := (350, 0, 145, 0, 0, 0, 0, 0, 0) pos2 : CARTPOS := (575, 0, 250, 0, 0, 0, 0, 0, 0) takePos : REAL := 96.5 : Festo GDCP-CMXR-SW-DE de Version 1.0 73 9. Bewegungsbefehle Programm mit PTP-Bewegungen: : Ptp(pos1) // anfahren Ptp(takeAbove) // Aufnahme oben MoveAxisPtp(A4, takePos) // Greifer drehen MoveAxisPtp(A3, 50) // nach unten Gripper.Set() // Greifer schließen MoveAxisPtp(A3, 145) // nach oben MoveAxisPtp(A1, 450) // Ablage oben MoveAxisPtp(A4, 180) // drehen auf Ablage MoveAxisPtp(A3, 50) // Ablage unten Gripper.Reset() // Greifer öffnen MoveAxisPtp(A3, 145) // Ablage oben Ptp(pos2) // abfahren : 9.4.1 Teachen der Position bei MoveAxisPtp und MoveAxisCart Die Position des Befehls MoveAxisPtp und MoveAxisCart können mit Hilfe des Handbediengerätes oder der Emulationssoftware geteacht werden. In der Betriebsart HAND wird bei Erstellung des Befehls oder über den Softkey Ändern die Parametermaske des Befehls geöffnet. Durch das markieren der Zeile Position wird der Softkey aktiv und kann verwendet werden. 1. Parameterfeld anklicken, wird blau hinterlegt 2. Softkey Teach wird aktiviert Vor dem Teachen, muss die gewünschte Achse des Parameters CartComp (Befehl MoveAxisCart) bzw. Axis (Befehl MoveAxisPtp) ausgewählt werden. Aufgrund dieser Auswahl wird durch das Teachen die Position ermittelt und in den Parameter Pos geschrieben. Ist dem Parameter Pos eine REAL Variable zugeordnet, so wird der Wert in diese Variable geschrieben. 74 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Auswahlbox einzelner Achsen beim Makro Auswahlbox kartesischer Achsen beim Makro MoveAxisPtp. Es werden nur die Achsen ange- MoveAxisCart. zeigt, die in der Konfiguration verfügbar sind. Hinweis Beim Teachen der kartesischen Position des Befehls MoveAxisCart, wird der Wert wird immer im aktuellen ausgewählten Referenzsystem geteacht. Dieses wird auf der Positionsseite in der Auswahlbox angezeigt. Beim Teachen der Achsposition des Befehls MoveAxisPtp ist das ausgewählte Referenzsystem, bedeutungslos. Festo GDCP-CMXR-SW-DE de Version 1.0 75 9. Bewegungsbefehle 9.5 Linearbewegung <Lin> Bei einer Linearbewegung berechnet die CMXR Mehrachssteuerung eine Gerade, die von der momentanen Position (Startposition) zur programmierten Position (Zielposition) führt. Diese Bewegung wird unter Berücksichtigung der gesetzten Bahnwerte wie z. B. Bahnbeschleunigung, Bahngeschwindigkeit, Orientierungen und Werkzeugdaten berechnet und ausgeführt. Wird in der Zielpositionsangabe eine Orientierungsänderung angegeben, so wird auf dieser Bahn kontinuierlich von der Anfangsorientierung am Startpunkt auf die Endorientierung verfahren. Die Linearbewegung ist eine kartesische Bewegung, d. h. die Bewegung wird mit Hilfe der intern implementierten Koordinatentransformation für die vorliegende Kinematik berechnet. Dabei wird stets die Position an der Werkzeugspitze (TCP) programmiert. Auch alle Dynamikwerte wie Bahnbeschleunigung und Bahngeschwindigkeit werden direkt am TCP erreicht. Dies hat den Vorteil, dass die Dynamikwerte am Werkzeug begrenzt und bekannt sind. Auf die Greifereinheit wirken somit reproduzierbare Kräfte. Syntax Lin ( <Pos> : AXISPOS oder CARTPOS) Parameter Bedeutung Einheit Pos Absolute Zielposition AXISPOS oder CARTPOS Tabelle 9.5 Parameter Befehl Lin Die Positionsangabe kann kartesisch oder bezogen auf jede einzelne Achse sein. Die CMXR Mehrachssteuerung transformiert die Positionen entsprechend. Beispiel: Ein kartesisches Portal mit 3 Achsen X, Y, Z und einer Drehachse am Greifer muss positioniert werden. Die Werkzeugspitze (TCP) ist mit einem Vektor auf den Mittelpunkt des Greifers definiert (siehe Kapitel 14 Werkzeuge auf Seite 127). Y - Achse Z - Achse X - Achse Drehachse mit Greifer Vektor auf den TCP 76 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Variable: : pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0) pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0) gripper : TCPTOOL := (-100, 0, 97, 0, 0, 0,) : Programm: : Tool(gripper) Lin(pos1) Lin(pos2) : Y Drehachse 180 Grad Drehachse 90 Grad Bahnverlauf am TCP Drehachse 0 Grad Ungefährer Bahnverlauf an der Z-Achse X Wie dargestellt, wird bei einer Linearbewegung der TCP (Werkzeugspitze) auf der Bahn geführt. Alle Geschwindigkeitsangaben beziehen sich dabei immer auf den TCP, somit ist der Bahnverlauf bestimmt. Nicht vorhersehbar ist jedoch der Verlauf der Bahn des Werkzeugflansches in der X-Y- Ebene. Dieser Bahnverlauf ergibt sich aus der Konstellation der Kinematik und des Vektors zum TCP und wird durch die interne Koordinatentransformation berechnet. Festo GDCP-CMXR-SW-DE de Version 1.0 77 9. Bewegungsbefehle 9.5.1 Teachen der Lin Bewegung Der Befehl Lin besitzt die Zielposition als Parameter, der mit Hilfe des Handbediengerätes oder der Emulationssoftware geteacht werden kann. In der Betriebsart HAND wird bei Erstellung des Befehls oder über den Softkey Ändern die Parametermaske des Befehls geöffnet. Durch das markieren der Zeile Position wird der Softkey aktiv und kann verwendet werden. 1. Parameterfeld anklicken, wird blau hinterlegt 2. Softkey Teach wird aktiviert Durch drücken des Softkeys wird die aktuelle Position in die angegebene Variable gespeichert. Das Teachen erfolgt immer auf eine Positionsvariable. Hinweis Beim Teachen einer kartesischen Position vom Typ CARTPOS, wird der Wert wird immer im aktuellen ausgewählten Referenzsystem geteacht. Dieses wird auf der Positionsseite in der Auswahlbox angezeigt. Wird eine Achsposition vom Typ AXISPOS geteacht, so ist das ausgewählte Referenzsystem bedeutungslos. 9.6 Relative Linearbewegung <LinRel> Analog zum Lin-Befehl funktioniert der relative Lin-Befehl. Hier wird die Positionsangabe zur Startposition addiert. Eine Anwendung wäre z. B. eine relative Positionierung innerhalb eines Rasters wie bei einer Palette. Syntax LinRel (<Dist> : AXISDIST oder CARTDIST) Parameter Bedeutung Einheit Dist Relative Zielposition AXISDIST oder CARTDIST Tabelle 9.6 Parameter Befehl LinRel 78 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Die Distanzangabe kann kartesisch oder bezogen auf jede einzelne Achse angegeben werden. Die CMXR Mehrachssteuerung transformiert die Positionen entsprechend. Beispiel: Eine Kontur enthält sich wiederholende Bahnstücke. Diese Bahnstücke lassen sich relativ beschreiben. Mit dem Einsatz einer Schleifenprogrammierung lässt sich eine solche Applikation komfortabel lösen. YAchse 57 pos1 112 pos3 100 pos2 45 98.5 387 1050 XAchse Variable: : pos1 : CARTPOS := (98.5, 100, 0, 0, 0, 0, 0, 0, 0) pos2 : CARTPOS := (387, 100, 0, 0, 0, 0, 0, 0, 0) distX : CARTDIST := (57, 0, 0, 0, 0, 0, 0, 0, 0) distYpos : CARTDIST := (0, 112, 0, 0, 0, 0, 0, 0, 0) distYneg : CARTDIST := (0, -112, 0, 0, 0, 0, 0, 0, 0) pos3 : CARTPOS := (1050, 45, 0, 0, 0, 0, 0, 0, 0) direction : BOOL : Programm: : Lin(pos1) Lin(pos2) direction := TRUE LOOP 5 DO IF direction = TRUE THEN LinRel(distYpos) Festo GDCP-CMXR-SW-DE de Version 1.0 79 9. Bewegungsbefehle ELSE LinRel(distYneg) END_IF LinRel(distX) direction := NOT direction END_LOOP LinRel(distYneg) Lin(pos3) : Mit der Variablen „direction“ wird die Richtung der relativen Bewegung der Y-Achse festgelegt. Auf diese Weise lässt sich die Bewegung mit einer Schleife programmieren. Vorsicht Kollisionsgefahr! Wird während einer Relativbewegung die Bewegung gestoppt und wieder gestartet, wird die programmierte Bewegungsdistanz vollständig abgefahren. 9.7 Zirkularbewegung mit Stützpunkt Die Kreisinterpolation unterscheidet sich von der Linearinterpolation nicht nur durch die geometrische Form, sondern auch dadurch, dass neben Start- und Endpunkt zusätzlich ein Stützpunkt angegeben werden muss, damit der Kreis eindeutig bestimmt ist. 9.7.1 Funktionsweise Die Kreisdefinition erfolgt mit einem Stützpunkt, der auf der Kreisbahn liegen muss, und dem Endpunkt der Kreisbahn. Bei der Kreisbahn wird zuerst der Stützpunkt, dann der Endpunkt angefahren. Der Radius der Kreisbahn ergibt sich aus einer internen Berechnung mit Startpunkt, Stützpunkt und Endpunkt der Kreisbahn. 80 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Folgende Abbildung zeigt eine Zirkularbewegung mit Verwendung eines Stützpunktes: Der Kreis wird immer so gefahren, dass sich der TCP vom Startpunkt über den Stützpunkt zum Endpunkt bewegt. Der Stützpunkt liegt per Definition immer zwischen dem Start- und Endpunkt. Einschränkungen: Eine Fehlermeldung erhält man, wenn zumindest zwei der den Kreis definierenden Positionen die gleiche Position haben, oder wenn alle Punkte auf einer Geraden liegen. In diesen Fällen lässt sich die Kreisbahn mathematisch nicht berechnen. Mit dieser Methode kann kein Vollkreis (360°) beschrieben werden. Deshalb muss ein Vollkreis aus 2 Halbkreisen zusammengesetzt werden. Die Orientierung des Stützpunktes wird zur Interpolation des Kreisbogens nicht berücksichtigt. Die Interpolation erfolgt ausschließlich zwischen Start- und Endpunkt. Ist es erforderlich, Orientierungen innerhalb eines Kreisbogens zu wechseln, so besteht die Möglichkeit, einen Kreisbogen in mehrere Teile zu zerlegen, um dann an den Start- und Endpunkten die Orientierungen vorzugeben. 9.7.2 Ebenendefinition Die Kreisbahn wird auf einer Ebene gefahren, die anhand der 3 Punkte Startpunkt, Stützpunkt und Endpunkt definiert wird. Durch diese Definition spannt sich die Ebene im Raum auf, auf der die Kreisbahn gefahren wird. Festo GDCP-CMXR-SW-DE de Version 1.0 81 9. Bewegungsbefehle Die Abbildung zeigt eine Kreisbahn mit ihren 3 Stützpunkten, die eine Ebene im Raum definieren, auf der die Kreisbahn liegt. Hinweis Die Kreisbahn liegt immer auf einer Ebene, eine Schraubeninterpolation, mit einer zusätzlichen Interpolation senkrecht zur Ebene ist nicht möglich. 82 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle 9.7.3 Zirkularbefehl mit Stützpunkt <CircIp> Der Zirkularbefehl mit Stützpunkt hat folgende Programmsyntax: Syntax CircIp ( <IpPos> : AXISPOS oder CARTPOS, <Pos> : AXISPOS oder CARTPOS) Parameter Bedeutung Einheit IpPos Stützpunkt auf dem Kreis AXISPOS oder CARTPOS Pos Endposition des Kreisbogens AXISPOS oder CARTPOS Tabelle 9.7 Parameter Befehl CircIp Die Positionsangaben können kartesisch oder bezogen auf jede einzelne Achse sein. Die CMXR Mehrachssteuerung transformiert die Positionen entsprechend. Warnung Der Kreisbefehl benötigt die Angabe des Stütz- und Endpunktes. Der Startpunkt wird durch den Endpunkt der vorherigen Bewegung gebildet. Wird dieser Punkt verschoben, kommt es zu einer Veränderung der Kreisbahn. Diese könnte ungewollt sein und könnte zu einer Kollision führen. Die Änderung des Startpunktes muss zu keiner Fehlermeldung führen, weil das Ergebnis rechnerisch korrekt ist. Festo GDCP-CMXR-SW-DE de Version 1.0 83 9. Bewegungsbefehle Beispiel: Mit einer Kinematik soll folgende Kontur abgefahren werden: Y-Achse Position pos1 500 Stützpunkt IpPos 400 300 Endpunkt EndPos Position pos2 X-Achse 455 950 1050 Die Z-Achse bleibt auf der Koordinate 0. Der Startpunkt des Kreisbogens wird über einen separaten Fahrbefehl z. B. Ptp oder Lin angefahren. Variablen: : pos1 : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0) pos2 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0) IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0) EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0) : Programm : : Lin(pos1) // Anfahren Startpunkt CircIp(IpPos, EndPos) // Kreisbewegung auf Endpunkt Lin(pos2) // Abfahren : 84 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle 9.7.4 Zirkularbefehl mit Stützpunkt, PTP-Anfahrt <PtpToCircIp> Im Gegensatz zum Zirkularbefehl CircIp besitzt dieser Befehl den Startpunkt des Kreisbogens in der Parameterliste. Dies hat den Vorteil, dass der Kreisbogen konsistent beschrieben wird. Der Startpunkt des Kreisbogens wird mit einem PTP-Befehl angefahren. Sonst ist das Verhalten gleich wie beim CircIp-Befehl. Da es sich beim Anfahren des Startpunktes um eine PTP-Bewegung und bei der Kreisinterpolation um eine kartesische Bewegung handelt, ist kein geometrisches Überschleifen und keine konstante Bahngeschwindigkeit möglich. Das Überschleifen wird anhand den Möglichkeiten einer PTP-Bewegung durchgeführt. Syntax PtpToCircIp ( <StartPos> : AXISPOS oder CARTPOS, <IpPos> : AXISPOS oder CARTPOS, <Pos> : AXISPOS oder CARTPOS) Parameter Bedeutung Einheit StartPos Startpunkt des Kreisbogens AXISPOS oder CARTPOS IpPos Stützpunkt des Kreisbogens AXISPOS oder CARTPOS Pos Endpunkt des Kreisbogens AXISPOS oder CARTPOS Tabelle 9.8 Parameter Befehl PtpToCircIp Die Positionsangaben können kartesisch oder bezogen auf jede einzelne Achse sein. Die CMXR Mehrachssteuerung transformiert die Positionen entsprechend. Festo GDCP-CMXR-SW-DE de Version 1.0 85 9. Bewegungsbefehle Beispiel: Mit einer Kinematik soll folgende Kontur abgefahren werden: Y-Achse Startposition StartPos 500 Stützpunkt IpPos 400 300 Endpunkt EndPos Position Pos1 X-Achse 455 950 1050 Die Bewegung erfolgt in der XY- Ebene, der Wert für die Z-Achse beträgt 0. Der Startpunkt des Kreisbogens wird mit einer PTP (Point-To-Point) Bewegung angefahren. Der Startpunkt wird dem Befehl PtpToCircIp übergeben. Variablen: : StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0) IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0) EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0) Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0) : Programm: : // PTP Anfahren, kartesische Kreisbewegung PtpToCircIp(StartPos, IpPos, EndPos) Lin(Pos1) // Abfahren : 86 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle 9.7.5 Zirkularbefehl mit Stützpunkt, Lin Anfahrt <LinToCircIp> Wie der Befehl PtpToCircIp beinhaltet der Befehl LinToCircIp den Startpunkt der Kreisbahn. Die Anfahrt der Kreisbahn erfolgt nun kartesisch. Dies bedeutet, dass die Bewegung auf den Startpunkt und die Kreisbahn im Falle des Überschleifens geometrisch erfolgen kann. Eine konstante Bahngeschwindigkeit ist ebenso möglich. Syntax LinToCircIp (<StartPos> : AXISPOS oder CARTPOS, <IpPos> : AXISPOS oder CARTPOS, <Pos> : AXISPOS oder CARTPOS) Parameter Bedeutung Einheit StartPos Startpunkt des Kreisbogens AXISPOS oder CARTPOS IpPos Stützpunkt des Kreisbogens AXISPOS oder CARTPOS Pos Endpunkt des Kreisbogens AXISPOS oder CARTPOS Tabelle 9.9 Parameter Befehl LinToCircIP Die Positionsangaben können kartesisch oder bezogen auf jede einzelne Achse sein. Die CMXR Mehrachssteuerung transformiert die Positionen entsprechend. Beispiel: Mit einer Kinematik soll folgende Kontur abgefahren werden: Y-Achse Startposition StartPos 500 Stützpunkt IpPos 400 300 Endpunkt EndPos Position Pos1 X-Achse 455 950 1050 Die Bewegung erfolgt in der XY- Ebene, der Wert für die Z-Achse beträgt 0. Der Startpunkt des Kreisbogens wird mit einer Linearbewegung angefahren. Der Startpunkt wird dem Befehl LinToCirc übergeben. Festo GDCP-CMXR-SW-DE de Version 1.0 87 9. Bewegungsbefehle Variablen: : StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0) IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0) EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0) Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0) : Programm: : // Lin Anfahren, kartesische Kreisbewegung LinToCircIp(StartPos, IpPos, EndPos) Lin(Pos1) // Abfahren : 9.7.6 Teachen der Zirkularbefehle Die Zirkularbefehle besitzen je nach Art 2 oder 3 Parameter. Diese können mit Hilfe des Handbediengerätes oder der Emulationssoftware geteacht werden. In der Betriebsart HAND wird bei Erstellung des Befehls oder über den Softkey Ändern die Parametermaske des Befehls geöffnet. Durch das markieren der Zeile Position wird der Softkey aktiv und kann verwendet werden. 1. Parameterfeld anklicken, wird blau hinterlegt 2. Softkey Teach wird aktiviert Durch drücken des Softkeys wird die aktuelle Position in die angegebene Variable gespeichert. Das Teachen erfolgt immer auf Positionsvariable. Zum Teachen weiterer Positionen muss die jeweilige Position erneut angeklickt und somit markiert werden. 88 Festo GDCP-CMXR-SW-DE de Version 1.0 9. Bewegungsbefehle Hinweis Beim Teachen einer kartesischen Position vom Typ CARTPOS, wird der Wert immer im aktuellen ausgewählten Referenzsystem geteacht. Dieses wird auf der Positionsseite in der Auswahlbox angezeigt. Wird eine Achsposition vom Typ AXISPOS geteacht, so ist das ausgewählte Referenzsystem bedeutungslos. 9.8 Stoppen der Bewegung <StopMove> Mit dem Befehl StopMove wird die Kinematik gestoppt und alle bereits berechneten Bahndaten werden verworfen. Der Befehl wirkt sich im Satzvorlauf aus. Das Stoppen der Kinematik erfolgt mit der maximalen Bremsrampe, die für das Stoppen der Kinematik definiert ist. Reduktionen der Dynamik durch einen Override wirken sich beim Stoppen nicht aus. Syntax StopMove() Eine Anwendung für diesen Stopp ist z. B. das Fahren auf ein Hindernis, das mit einem Sensor erkannt wird. Nach dem Erkennen des Zustandes wird über den Befehl StopMove die Bewegung gestoppt. In Kapitel 24.1 Stoppen von Bewegungen auf Seite 237 ist ein Beispiel mit Verwendung des StopMove Befehls beschrieben. Festo GDCP-CMXR-SW-DE de Version 1.0 89 9. Bewegungsbefehle 9.9 Stoppen des Programms <StopProgram> Der Befehl StopProgram hält das Programm an, das Programm geht in den Zustand gestoppt. Er entspricht der Stopp Taste auf dem Handbediengerät. Eine Weiterführung kann nur durch einen erneuten Start z. B. über das Handbediengerät oder von extern über eine SPS Steuerung ausgeführt werden. Der Befehl ist im Hauptlauf aktiv, dies bedeutet er wird durch den Satzvorlauf nicht ausgeführt. Eine Ausführung der vorherigen Befehle, die durch den Satzvorlauf berechnet werden, ist sichergestellt. Das Stoppen der Kinematik erfolgt mit der maximalen Bremsrampe, die für das Stoppen der Kinematik definiert ist. Reduktionen der Dynamik durch einen Override wirken sich beim Stoppen nicht aus. Syntax StopProgram() Beispiel: : Vel(dynCart, 1000) Lin(pos1) Lin(pos2) SetInfo(“insert workpiece and press start“) StopProgram() Lin(pos3) CALL Conture1 : 90 Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle 10. Dynamikbefehle Mit den Dynamikbefehlen können Geschwindigkeit, Beschleunigung und Ruck für die Bewegungen der Kinematik programmiert werden. Dabei gibt es die Möglichkeit, die Dynamik von Point-To-Point-Bewegungen (PTP) und kartesischen Bewegungen getrennt einzustellen. Eine Änderung der Dynamikwerte kann an jeder gewünschten Programmzeile erfolgen. Hinweis In der Konfiguration (Festo Configuration Tool) werden Initialwerte für die Dynamik angegeben. Diese Werte sind bei einem Programmstart als Initialwert aktiv. Wird im Programm keine Dynamik programmiert, so werden diese Initialwerte verwendet. Mit den folgenden Dynamikbefehlen können diese Werte innerhalb des Programms jederzeit überschrieben werden. Grafik mit Voreinstellung der Dynamikwerte im Festo Configuration Tool: Festo GDCP-CMXR-SW-DE de Version 1.0 91 10. Dynamikbefehle 10.1 Autom. Begrenzung der Dynamik, Dynamiklimiter Um eine Bahntreue einzuhalten, müssen die Solldynamikwerte mit den physikalisch möglichen Dynamikwerten verglichen werden, damit es zu keiner Überschreitung der maximal möglichen Werte der einzelnen Achsen kommt. Dabei handelt es sich um die Geschwindigkeit, Beschleunigung und den Ruck. Diese maximalen Werte sind in der Konfiguration der einzelnen Achsen hinterlegt. Die CMXR Steuerung verfügt über einen Begrenzer der Dynamikwerte, der Dynamiklimiter genannt wird. Dieser arbeitet in der Vorausberechnung des FTL Programms und prüft ständig die zu fahrende Dynamikwerte mit der maximal möglichen Dynamik der einzelnen Achsen ab. Hinweis Der Dynamiklimiter ist ständig aktiv und muss nicht aktiviert werden. Ein Eingreifen des Dynamiklimiters hängt ab von: - Größe der programmierten Dynamik - Konstellation der Bewegungsbahn, aus der die Dynamikwerte für die einzelnen Achsen resultieren. Wird aufgrund der programmierten Dynamik oder durch das Ändern der Bewegungsbahn das Maximum von mindestens einer Achse überschritten, so wird die Bahndynamik so reduziert, dass die betroffene Achse sich an ihren Grenzen bewegt. Die Bahn wird dabei nicht verlassen. Verlässt die Kinematik kritische Bewegungsbahnen und eine höhere Dynamik ist möglich, so wird dies erkannt und auf den programmierten Wert beschleunigt. Im folgenden Beispiel wird die Grenze einer Achse erreicht, so dass automatisch die Bahngeschwindigkeit reduziert und somit die Bahntreue gewährleistet wird. Nachdem die Achse den kritischen Bereich verlassen hat, wird wieder auf den programmierten Wert beschleunigt. Bahngeschwindigkeit Achsgrenze 92 Verringern der Bahngeschwindigkeit Grenze der einzelnen Achse erreicht Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle 10.2 Geschwindigkeiten <Vel> Mit dem Befehl Vel kann die Geschwindigkeit für eine kartesische und eine PTP-Bewegung angegeben werden. Die Steuerung reduziert die angegebenen Werte auf die maximal möglichen Achsgeschwindigkeiten der einzelnen beteiligten Achsen. Kommt es zu einer Begrenzung aufgrund der maximal möglichen Achsgeschwindigkeiten, so wird eine Meldung ausgegeben. Syntax Vel (<Mode> : ENUM, <Value> : REAL) Parameter Bedeutung Einheit Mode Art der Geschwindigkeit Enumeration: dynPtp, dynCart Value Geschwindigkeitswert Abhängig vom gewählten Mode Tabelle 10.1 Parameter Befehl Vel Enumeration Parameter Mode Bewegungsart Einheit dynPtp Point To Point % dynCart kartesisch mm/sec Tabelle 10.2 Einheiten Parameter Value Beispiel: Variable: : axis0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0) axis1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0) axis2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0) : Programm: : Vel(dynPtp, 30) // Geschwindigkeit für PTP auf 30 % Ptp(axis0) Vel(dynCart, 500) // Bahngeschwindigkeit auf 500 mm/sec Lin(axis1) speed := 85 Festo GDCP-CMXR-SW-DE de Version 1.0 93 10. Dynamikbefehle Vel(dynPtp, speed) // Geschwindigkeit für PTP auf 85 % Ptp(axis3) : 10.3 Beschleunigung <Acc> Einstellen der Beschleunigung und Verzögerung für PTP- und kartesische Bewegungen der Handachsen. Die nachfolgenden Befehle werden auf den angegebenen Wert reduziert. Die Steuerung reduziert die Beschleunigung bzw. Verzögerung bei Überschreitung der Achsgrenzwerte selbstständig. Syntax Acc ( <Mode> : ENUM, <ValueAcc> : REAL, OPT <ValueDec> : REAL) Parameter Bedeutung Einheit Mode Art der Beschleunigung Enumeration: dynPtp, dynCart ValueAcc Wert für die Beschleunigung Abhängig vom gewählten Mode ValueDec Wert für das Abbremsen, optionale Angabe Abhängig vom gewählten Mode Tabelle 10.3 Parameter Befehl Acc Enumeration Parameter Mode Bewegungsart Einheit dynPtp Point To Point % dynCart kartesisch mm/sec² Tabelle 10.4 Einheiten Parameter ValueAcc, ValueDec Hinweis Wird der optionale Parameter ValueDec (für die Bremsrampe) nicht angegeben, so wird für die Bremsrampe der Wert des Parameters ValueAcc (für die Beschleunigung) verwendet. Das Profil ist dann symmetrisch. Beispiel: Variable: : pos0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0) pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0) pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0) 94 Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle : Programm: : Ptp(pos0) Acc(dynPtp, 30, 30) // Beschleunigung für PTP auf 30 % Ptp(pos1) Acc(dynCart, 100) // Bahnbeschleunigung auf 100mm/sec² Lin(pos2) : 10.4 Ruck <Jerk> Einstellen des Rucks für PTP- und kartesischeBewegungen. Die nachfolgenden Befehle werden auf den angegebenen Wert reduziert. Die Steuerung reduziert den Ruck bei Überschreitung der Achsgrenzwerte selbstständig. Syntax Jerk ( <Mode> : ENUM, <Value> : REAL) Parameter Bedeutung Einheit Mode Art der Bewegung Enumeration: dynPtp, dynCart Value Wert des Rucks Abhängig vom gewählten Mode Tabelle 10.5 Parameter Befehl Jerk Enumeration Parameter Mode Bewegungsart Einheit dynPtp Point To Point % dynCart kartesisch mm/sec³ Tabelle 10.6 Einheiten Parameter Value Beispiel: Variable: : pos0 : AXISPOS := (-60, -60, 0, 0, 0 ,0, 0, 0, 0) pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0) pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0) Festo GDCP-CMXR-SW-DE de Version 1.0 95 10. Dynamikbefehle : Programm: : Ptp(pos0) Jerk(dynPtp, 50) // Ruck für PTP auf 50 % Ptp(pos1) Jerk(dynCart, 5000) // Ruck auf der Bahn auf 5000mm/sec³ Lin(pos2) : 96 Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle 10.5 Override Mit einem Override lassen sich die Dynamikwerte prozentual einstellen. Dabei lassen sich die Werte für Beschleunigung, Geschwindigkeit und Ruck einfach beeinflussen. Die programmierte Bahn wird nicht beeinflusst. Hinweis Soll nur die Geschwindigkeit reduziert werden, so sollte dies über die direkte Angabe des Geschwindigkeitswertes erfolgen. Eine Reduktion über den Override beeinflusst auch die Beschleunigung und den Ruck. Dies bewirkt, dass die Achsdynamik nicht voll ausgenutzt wird und die Bewegung in der Summe langsamer ist. Es gibt 2 verschiedene Overrides: Dynamik Override, beeinflusst die eingestellten Werte für Geschwindigkeit, Beschleunigung und Ruck. Override am Handbediengerät Wirkungsweise der Override Dynamik = programmierte Dynamik * Dynamik Override 10.5.1 Override am Handbediengerät <Ovr> Der Override entspricht der Einstellung am Handbediengerät CDSA-D1-VX über die Tasten V+, V-. Der Override wird in der Einheit Prozent angegeben, wobei 100 Prozent der maximalen Dynamik entspricht, die programmiert wurde. Eine Verringerung des Overrides bewirkt ein Verlangsamen der Dynamik, wobei die Bahn dadurch nicht verändert wird. Die Abbildung zeigt die Tasten V- und V+ zum Einstellen des Override am Handbediengerät CDSA-D1-VX. Der Override ist sehr hilfreich bei Inbetriebnahmen. Im Automatikbetrieb sollte dieser jedoch auf 100 % stehen, damit die volle Dynamik genützt werden kann. Entsprechende Dynamikanpassungen sind direkt mit den Befehlen für Geschwindigkeit und Beschleunigung vorzunehmen. Mit dem Befehl Ovr kann ein Overridewert direkt im Programm gesetzt werden. Dies hat dieselbe Auswirkung wie eine Änderung über die Tasten am Handbediengerät. Festo GDCP-CMXR-SW-DE de Version 1.0 97 10. Dynamikbefehle Syntax Ovr ( <Value> : REAL) Parameter Bedeutung Einheit Value Overridewert Prozent Tabelle 10.7 Parameter Befehl Ovr Hinweis Um die volle Dynamik der Kinematik zu nützen, sollte im Automatikbetrieb der Override stets auf 100 % stehen. Dynamikanpassungen sind über die entsprechenden Befehle direkt vorzunehmen. Wirkungsweise: Wird der Override am Handbediengerät geändert, so wirkt sich dieser sofort auf die Bewegung aus. Bedingt durch die Vorausberechnung des Programms kann eine sofortige Änderung des Override über den Befehl Ovr nicht ausgeführt werden. Das Verwenden von Ovr hält deshalb die Vorausberechnung an, dies führt zu einen Stop auf der Bahn. Ein überschleifen auf das nächste Bahnsegment ist nicht möglich. Beispiel: // setzen des Override auf 100% Ovr(100) Lin(pos1) Lin(pos2) // setzen des Override auf 60% Ovr(60) Lin(pos3) Lin(pos4) 98 Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle Bahngeschwindigkeit 100% 60% Zeit pos1 pos2 pos3 pos4 Ändern des Override mit Ovr hält die Bewegung an. 10.5.2 Dynamikoverride <DynOvr> Mit dem Befehl DynOvr werden die eingestellten oder programmierten Dynamikwerte beeinflusst. Er unterliegt dem Override, welcher am Handbediengerät eingestellt wird. Syntax DynOvr ( <Value> : REAL) Parameter Bedeutung Einheit Value Wert des dynamischen Overrides Prozent Tabelle 10.8 Parameter Befehl DynOvr Hinweis Die gefahrene Bahn wird durch den Override nicht verändert. Der programmierte Wert hat keine Auswirkungen auf die Vorausberechnung des Programmes. Festo GDCP-CMXR-SW-DE de Version 1.0 99 10. Dynamikbefehle 10.6 Beschleunigungsrampen Mit dem Befehl Ramp kann eine Rampenform zur Beschleunigung bzw. Verzögerung eingestellt werden. Zur Auswahl stehen vier Rampenformen, wobei nach dem Start die SinusQuadrat-Rampe aktiv ist. Abbildung der 4 Rampenformen: Trapez 1,2 Beschleunigung 1 0,8 0,6 0,4 0,2 0 0,000 0,333 0,667 1,000 Zeit Trapez-Rampe Die Trapez-Rampe bewirkt einen trapezförmigen Beschleunigungsverlauf. Der Ruck verläuft somit rechteckförmig. Mit der Trapez-Rampe können die schnellsten Ausführungszeiten der Bahn realisiert werden. Mit einem optionalen Parameter lässt sich die Rampenform beeinflussen. Dieser darf den Wert > 0 und <= 0,5 besitzen. Bei einem Wert von 0,5 ergibt sich ein Beschleunigungsdreieck, bei einem Wert z. B. 0,1 nähert sich die Rampenform einem Rechteckprofil. Beschleunigung Trapezrampenform bei Faktor ca. 0,1 Trapezrampenform bei Faktor 0,5 Zeit Wird der optionale Parameter nicht angegeben, wird er automatisch auf den Faktor 0.5 gestellt. Daraus ergibt sich das Beschleunigungsdreieck. 100 Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle Sinus-Rampe Die Sinus-Rampe hat den Vorteil, dass nicht nur die Beschleunigung, sondern auch der Ruck sinusförmig verläuft. Dies bewirkt einen weicheren Beschleunigungsverlauf als die Trapez-Rampe. Jedoch ist die Ausführungszeit zur Geschwindigkeitserreichung etwas höher. Sinus-Quadrat-Rampe Die Sinus-Quadrat-Rampe hat den weichsten Bahnverlauf, bewirkt aber auch die längste Ausführungszeit beim Fahren der Bahn. MinimumJerk-Rampe Die Minimumjerk-Rampe ist eine spezielle Rampenform, die einen Kompromiss zwischen Ausführungszeit und Weichheit der Bewegung darstellt. Der Beschleunigungsverlauf ähnelt einem Sinusprofil, der Ruckverlauf ist jedoch nicht sinusförmig sondern sägezahnartig. Dies bewirkt eine weiche Bewegung bei doch schneller Ausführungszeit. Hinweis Die Verwendung eines Rampentyps hängt von der eingesetzten Kinematik und von der Applikation ab. Nach einer Auswahl der Rampenform ist diese in der Bewegung zu testen. Als Initialwert ist Sinus-Quadrat-Ramp eingestellt. 10.6.1 Setzen von Rampenformen <Ramp> Mit dem Befehl Ramp kann eine Rampenform ausgewählt werden. Diese wird für den Bewegungsverlauf aller folgenden Bewegungsbefehle verwendet. Syntax Ramp( <Ramptype> : ENUM, OPT <Param> : REAL) Parameter Bedeutung Einheit Ramptype Rampentyp, wählt die Rampenform aus. Enumeration: TRAPEZOID SINE SINESQUARE MINJERK Param Parameter für Trapezrampen ----- Tabelle 10.9 Parameter Befehl Ramp Festo GDCP-CMXR-SW-DE de Version 1.0 101 10. Dynamikbefehle Beispiel: : Ramp(TRAPEZOID) // Auswahl Trapezrampe Lin(pos1) Lin(pos2) WaitTime(1000) Ramp(SINE) // Auswahl der Sinusrampe Lin(pos3) Lin(pos4) : 10.7 Konstante Bahngeschwindigkeit einschalten <VconstOn> Mit diesem Befehl wird die Überwachung der konstanten Bahngeschwindigkeit eingeschaltet. Diese wirkt sich nur auf kartesische Befehle wie z. B. LIN und CIRC aus. Bei PTPBewegungen hat dieser Befehl keine Auswirkungen. Syntax VconstOn (<Tolerance> : REAL, <StopOnViolation> : BOOL) Parameter Bedeutung Einheit Tolerance Prozentualer Wert für den zulässigen Einbruch der Prozentwert 0 % bis 100 % Bahngeschwindigkeit StopOnViolation Bei TRUE Auslösen eines Fehlers bei Verletzung der Schalter: TRUE oder FALSE Toleranz. Tabelle 10.10 Parameter Befehl VconstOn Hinweis Wird eine konstante Bahngeschwindigkeit benötigt, so ist darauf zu achten, dass für den Überschleifbereich ein geometrisches Überschleifen eingestellt ist (siehe Kapitel 11.4 Geometrisches Überschleifen auf Seite 110). Ein Überschleifen auf Basis der prozentualen Geschwindigkeit führt zu Veränderung der Bahngeschwindigkeit im Überschleifbereich. Die CMXR Mehrachssteuerung berechnet anhand der Bahn und den maximalen Dynamikwerten der Mechanik die mögliche Bahngeschwindigkeit. Die Grenze der möglichen Bahngeschwindigkeit wird durch die Dynamik der Mechanik bestimmt. Falls Bahnsegmente 102 Festo GDCP-CMXR-SW-DE de Version 1.0 10. Dynamikbefehle programmiert werden, die bedingt durch die Dynamikgrenzen nicht mit konstanter Bahngeschwindigkeit gefahren werden können, kommt es an diesen Stellen zu Einbrüchen der Bahngeschwindigkeit. Mit dem Parameter Tolerance kann ein prozentualer Wert für den zulässigen Einbruch der Bahngeschwindigkeit angegeben werden. Wird als Toleranzwert 100 % angegeben, so ist die Überwachung ausgeschaltet. Hinweis Die Überwachung der Bahngeschwindigkeit berücksichtigt nicht den eingestellten Override am Handbediengerät. D.h. wenn die Kinematik aufgrund eines begrenzenden Overrides nicht ihre volle Geschwindigkeit erreicht, wird die Überwachung aktiv und ein Fehler ausgelöst. Beispiel: Programm: : Lin(pos1) VconstOn(25, TRUE) Lin(pos2) Lin(pos3) VconstOff() : Festo GDCP-CMXR-SW-DE de Version 1.0 103 10. Dynamikbefehle 10.8 Konstante Bahngeschwindigkeit ausschalten <VconstOff> Mit diesem Befehl wird eine konstante Bahngeschwindigkeit ausgeschaltet. Syntax VconstOff ( ) Hinweis Ein Abbruch des Anwenderprogramms führt nicht automatisch zum Abschalten der Überwachung der Bahngeschwindigkeit. Bei einem Neustart des Anwenderprogramms muss zunächst immer die Überwachung abgeschaltet werden. 104 Festo GDCP-CMXR-SW-DE de Version 1.0 11. Überschleifbefehle 11. Überschleifbefehle Unter Überschleifen versteht man das Beschleunigen der Achsen zum Anfahren der nächsten Position, obwohl die vorherige Position noch nicht erreicht wurde. Oft ist es nicht notwendig, dass eine Position genau erreicht wird, sondern dass die Bewegung schnell und schonend, d. h. mit möglichst geringer Belastung für die Mechanik angefahren wird. Hier bietet die Überschleiffunktion die Möglichkeit, die Genauigkeit zum Erreichen eines Punktes sowie die Härte der Bewegung einzustellen. In der folgenden Abbildung ist die Funktionsweise der Überschleiffunktion dargestellt. Position 1 Position 2 Überschleifbereiche, Polynomkurven Bahn der Kinematik Das Bewegungsprogramm enthält eine Positionierung auf Position 1, dann auf Position 2. Durch die Überschleiffunktion, die über einen Programmbefehl eingestellt wird, werden die einzelnen Positionen nicht genau angefahren. Die Dynamikprofile zum Anfahren der einzelnen Positionen werden in den Überschleifbereichen überlagert, was zu einer Erhöhung der Dynamik führt. Hinweis Nach dem Laden eines Programms ist kein Überschleifen aktiv, d. h. es erfolgt ein genaues Anfahren der Positionen. Ein gewünschtes Überschleifen muss mit den entsprechenden Funktionen aktiviert werden. Das Überschleifen kann auf zwei Arten erfolgen: 1. Geschwindigkeitsüberschleifen anhand der Geschwindigkeit 2. Positionsüberschleifen anhand einer vorgegebenen Distanz Die Beschreibung dieser Arten erfolgt auf den folgenden Seiten. Festo GDCP-CMXR-SW-DE de Version 1.0 105 11. Überschleifbefehle Hinweis Die Bahn im Überschleifbereich wird durch eine Polynomkurve bestimmt, die sich aus mathematischen Berechnungen ergibt. Diese verwirklicht einen stetigen Anstieg der Dynamik und somit eine schonendes Verhalten für die Mechanik. Mit einem Verrunden über einen Radius kann dieses Verhalten nicht erzielt werden. Somit kann eine Verrundung von Bahnsegmenten mit dem Überschleifen nicht realisiert werden. 11.1 Nullsegmente Wird ein Nullsegment programmiert, d. h. die erneute Positionierung auf die bereits angefahrene Position , so kann nicht überschliffen werden. Dies führt zu einem Abbremsen mit anschließendem Beschleunigen auf der Bahn. Beispiel: Lin(pos1) Lin(pos2) // erneute Positionierung auf pos2 = kein Überschleifen möglich Lin(pos2) Lin(pos3) Da die Position pos2 wiederholt programmiert ist, kommt es an dieser Programmstelle zu einem Stopp auf der Bahn. 106 Festo GDCP-CMXR-SW-DE de Version 1.0 11. Überschleifbefehle 11.2 Grenzbereich Ist ein Abstand zwischen 2 Punkten kleiner als notwendig, um dazwischen die parametrierte Überschleifbahn zu fahren, reduziert die Steuerung den Überschleifbereich zwischen den Punkten automatisch, so dass der bestmögliche Überschleifwert gefahren werden kann. In der Abbildung sind die gestrichelten Kreise der Überschleifbereich, der sich aufgrund der Parametrierung ergibt. Die Kreise überlappen sich, da die Distanz zwischen der Position A und B nicht ausreicht um dieses Profil abzufahren. Die Steuerung berechnet nun automatisch den maximal möglichen Überschleifbereich, der durch die grauen Vollkreise dargestellt ist. Hinweis Das Überschleifen ist auf 50 % der Bahnsegmentlänge beschränkt. Ist der Überschleifbereich größer als maximal möglich, verkürzt die CMXR Mehrachssteuerung den Überschleifbereich automatisch auf 50 % der Bahnsegmentlänge. Hinweis Zu kleine Bahnsegmentlängen können zu ungewollten Dynamikeinbrüchen führen, falls der definierte Überschleifbereich reduziert wurde. Falls dies ungewünscht ist, müssen die Bahn oder der Überschleifbereich angepasst werden. Festo GDCP-CMXR-SW-DE de Version 1.0 107 11. Überschleifbefehle 11.3 Geschwindigkeitsüberschleifen Beim Geschwindigkeitsüberschleifen werden die Dynamikprofile der Bahn überlappt. Daraus resultiert eine Bewegung im Überschleifbereich auf die nächste Position. 11.3.1 Mit Prozentfaktor <OvlVel> Beim Geschwindigkeitsüberschleifen wird ein Grad des Überschleifens mit einem Prozentwert vorgegeben. Der Wertebereich beträgt 0 % bis 200 %. Syntax OvlVel (<Value> : REAL) Parameter Bedeutung Einheit Value Überschleifwert Prozent Tabelle 11.1 Parameter Befehl OvlVel Parameter: ProzentÜberschleifparameter in % 0% ohne Überschleifen 100 % optimale Nutzung der Achsbeschleunigungen 100..200 % ohne Zeitverlust, weichere Bewegung mit größerem Überschleifbereich Werte kleiner als 100 % bewirken kleinere Abweichungen zur Position, verlängern jedoch die Bewegungszeit, da die Geschwindigkeit reduziert werden muss. Bei einem Wert von 100 % werden alle Beschleunigungsreserven der Achsen ausgenützt, wobei eine möglichst geringe Abweichung von der Position berücksichtigt wird. Gibt man Werte zwischen 100 % und 200 % an, so werden die Positionabweichungen (Schleppfehler) erhöht, wobei die Achsbeschleunigungen im Gegensatz zu einer Einstellung von 100 % verringert werden. Folgende Abbildung zeigt die Geschwindigkeitsprofile bei einer Fahrt auf Position 1 und Position 2. Dabei sind verschiedene Werte für den Überschleifbereich definiert. 108 Festo GDCP-CMXR-SW-DE de Version 1.0 11. Überschleifbefehle 0% 50 % 100 % Grafik 1 zeigt ein Geschwindigkeitsprofil, bei dem keine Überlappung stattgefunden hat. Die Achsen bremsen auf der Bahn ab; somit wird die Position 1 und 2 genau erreicht. In der mittleren Grafik ist eine teilweise Überlappung dargestellt, in der unteren Grafik eine volle Überlappung (100 %) der Geschwindigkeitsprofile. Hinweis Im Überschleifbereich wird mit der vollen Achsdynamik gearbeitet. Dies bedeutet, dass das Bahnstück im Überschleifbereich kein Radius ist, sondern eine Polynomkurve, die sich aus den aktuellen Dynamikwerten der Achsen ableitet. Beispiel: : OvlVel(100) // Überschleifen mit 100 % Lin(pos1) Lin(pos2) OvlVel(75) // Überschleifen mit 75 % Lin(pos3) : Festo GDCP-CMXR-SW-DE de Version 1.0 109 11. Überschleifbefehle 11.4 Geometrisches Überschleifen Beim geometrischen Überschleifen werden die Abweichungen von der programmierten Endposition festgelegt. Im Gegensatz zum Geschwindigkeitsüberschleifen wird der Versatz geometrisch d. h. in Längen- oder Winkeleinheiten angegeben. Beim geometrischen Überschleifen wird zwischen einem Überschleifen der kartesischen Achsen X, Y und Z sowie der Orientierungsachsen unterschieden. Hinweis Das geometrische Überschleifen kann nur bei kartesischen Bewegungen benutzt werden. PTP-Bewegungen sind mit dieser Art des Überschleifens nicht möglich. Es eignet sich nicht zum Verrunden von Ecken, da die geometrische Form im Überschleifbereich kein Radius, sondern eine Polynomkurve ist. Ein Radius ist zum Überschleifen ungeeignet, da dies einen sprunghaften Anstieg der Beschleunigung zur Folge hat. 11.4.1 Überschleifen der Achsen X, Y und Z <OvlCart> Das Überschleifen von kartesischen Bewegungen mit einer geometrischen Bestimmung wird durch die Angabe eines Abstandes des TCP auf der Bahn bis zum Zielpunkt angegeben. Kugel mit Überschleifbereich Die Überschleifbewegung wird beim Eintritt in die Kugel gestartet und an dem Punkt, an dem die Kugel das nächste Bahnstück schneidet, beendet. Diese Kurve verläuft tangential zu den 2 betroffenen Bahnstücken. Die Grenze des Überschleifbereiches bildet die Hälfte des kürzesten der beteiligten Bahnsegmente. Die Bahn im Überschleifbereich ist kein Radius, sondern ein Polynom 5. Ordnung. Dieses Polynom erzeugt den maximal möglichen weichen Bahnverlauf, was mit einem Kreisbogen nicht möglich ist. Syntax OvlCart (<Distance> : REAL) 110 Festo GDCP-CMXR-SW-DE de Version 1.0 11. Überschleifbefehle Parameter Bedeutung Einheit Distance Überschleifbereich, Abstand zum Endpunkt eingestellte Längeneinheit Tabelle 11.2 Parameter Befehl OvlCart Hinweis Ein geometrisches Überschleifen wird sehr oft in Verbindung mit einer konstanten Bahngeschwindigkeit benötigt. Diese wird mit dem Befehl VconstOn eingestellt (siehe Kapitel 10.7 Konstante Bahngeschwindigkeit auf Seite 102). Beispiel: Eine Kontur soll mit konstanter Bahngeschwindigkeit und mit einem Überschleifbereich von 5 mm abgefahren werden. p1 p2 Überschleifbereich p3 p6 p4 p5 Vel(dynCart, 300) // Bahngeschwindigkeit auf 300 mm/sec VconstOn(25, TRUE) // einschalten konst. Bahngeschw. OvlCart(5) // Überschleifbereich einstellen Lin(p1) Lin(p2) Lin(p3) Lin(p4) Lin(p5) Lin(p6) Festo GDCP-CMXR-SW-DE de Version 1.0 111 12. Referenzsysteme (Nullpunktverschiebung) 12. Referenzsysteme (Nullpunktverschiebung) Referenzsysteme sind kartesische Koordinatensysteme mit 3 translatorischen und 3 rotatorischen Freiheitsgraden. Die Definition der Orientierung basiert auf der Euler ZYZ Konvention. Hinweis Da die Referenzsysteme von kartesischer Art sind, haben sie keine Auswirkungen auf den Nullpunkt einzelner Achsen im Achskoordinatensystem. Sie wirken sich nur auf das kartesische Koordinatensystem aus. Zum Start eines Programms ist das Welt-Koordinatensystem aktiv. 12.1 Bezug des Referenzsystems Ein Referenzsystem bezieht sich auf den kartesischen Nullpunkt eines schon definierten Koordinatensystems. Die definierten Werte des neuen Referenzsystems bewirken eine Verschiebung in den 6 Freiheitsgraden. Z Y Z X Verschiebung 1 Z Y Y X Nullpunkt desWeltKoordinatensystems X Verschiebung 2 Z Y X Additive Verschiebung auf Verschiebung 2 Wie in der Abbildung ersichtlich ist, lassen sich mehrere Referenzsysteme auf den kartesischen Nullpunkt eines anderen Referenzsystems definieren, wobei nur eine Referenz aktiv sein kann. Hinweis Eine Verkettung von Referenzsystemen ist mit Bedacht anzuwenden. Dieser Mechanismus kann unter Umständen zu einer effizienten Programmierung dienen. Jedoch ist die Transparenz beim Lesen des Programms schwierig und nicht bedachte Verschachtelungen können evtl. zu Kollisionen führen. 112 Festo GDCP-CMXR-SW-DE de Version 1.0 12. Referenzsysteme (Nullpunktverschiebung) Hinweis Die Verschiebung des Referenzsystems setzt sich aus einer Translation und einer Verdrehung (Orientierung) zusammen. Bei der Ausführung wird zuerst die Verschiebung, danach die Verdrehung ausgeführt. 12.2 Daten des Referenzsystems Die Daten eines Referenzsystems bestehen aus einer 3-dimensionalen Translation und einer 3-dimensionalen Orientierungsangabe. Die Definition der Orientierung erfolgt nach der Euler-ZYZ-Methode. Diese Daten werden in einer Variable angelegt, die aus einem strukturierten Datentyp besteht. Der Name des Referenzsystems ist frei wählbar. Die Anzahl der Referenzsysteme ist durch den Speicher begrenzt. Es gibt folgende Möglichkeiten, die Daten für ein Referenzsystem zu definieren: 1. direkte Angabe der Werte 2. Angabe über 3 kartesische Punkte Neben den Werten des Referenzsystems gibt es die Möglichkeit, einen Bezug auf ein anderes Referenzsystem herzustellen. In jedem der strukturierten Datentypen gibt es dazu die Möglichkeit, unter dem Parameter RefSys einen Bezug zu einem anderen Referenzsystem herzustellen. Unter dem Parameter RefSys können die Datentypen aller Möglichkeiten angegeben werden. Im Folgenden werden die Befehle zum Setzen eines Referenzsystems beschrieben. Festo GDCP-CMXR-SW-DE de Version 1.0 113 12. Referenzsysteme (Nullpunktverschiebung) 12.3 Referenzsystem mit direkten Werten <SetRefSys> Der Befehl SetRefSys aktiviert ein Referenzsystem, dessen Daten absolut in die Datenstruktur der übergebenen Variable eingetragen sind. Syntax SetRefSys(<refSys> : REFSYSDATA) Parameter Bedeutung Einheit refSys Referenzsystem, das durch Verschiebungswerte definiert ist. Längen und Winkeleinheiten Tabelle 12.1 Parameter Befehl SetRefSys Bei einer direkten Wertangabe werden die Werte direkt mit der übergebenen Variable bekannt gemacht. Ein Verändern bereits übergebener Daten ist nur über einen erneuten Aufruf möglich. Aufbau Datentyp REFSYSDATA: baseRs : REFSYS Bezug auf ein anderes Referenzsystem x : REAL Verschiebung entlang der X-Achse y : REAL Verschiebung entlang der Y-Achse z : REAL Verschiebung entlang der Z-Achse a : REAL Orientierung nach Euler, Drehung um die Z-Achse b : REAL Orientierung nach Euler, Drehung um die verdrehte Y-Achse c : REAL Orientierung nach Euler, Drehung um die verdrehte Z-Achse Unter dem Parameter baseRs kann man eine andere Referenz angeben, auf das sich das Referenzsystem additiv wirkt. Wenn ein Bezug zum Weltkoordinatensystem der Kinematik erfolgen soll, muss auf die Systemvariable world referenziert werden. Beispiel: Daten: refsysdata0 : REFSYSDATA := (MAP(world), 100, 150, 0, 0, 0, 0) Programm: SetRefSys(refsysdata0) 114 Festo GDCP-CMXR-SW-DE de Version 1.0 12. Referenzsysteme (Nullpunktverschiebung) 12.4 Referenzsystem mit 3 Punkten <SetRefSys3P> Mit dem folgenden Befehl SetRefSys3P wird ein Referenzsystem gesetzt, dessen Daten über 3 Positionen im Raum bestimmt werden. Syntax SetRefSys3P(<refSys> : REFSYS3P) Parameter Bedeutung Einheit refSys Referenzsystem, das durch 3 Positionen bestimmt ist Länge (mm) Tabelle 12.2 Parameter Befehl SetRefSys3P Verwendung: Diese Art der Beschreibung eines Referenzsystems bietet die Möglichkeit, über 3 Positionen geteacht zu werden. Diese 3 Positionen sind von kartesischer Art mit 6 Freiheitsgraden. Bedeutung der Positionen: Die erste Position bestimmt den Ursprung des Referenzsystems. Die zweite Position bestimmt einen Punkt, durch den die positive kartesische XAchse des Referenzsystems läuft. Die dritte Position bestimmt einen Punkt auf der XY-Ebene. Hinweis Die Orientierungen der Positionen sind nicht relevant. Für die Berechnungen werden nur die kartesischen Positionen benötigt. Aufbau Datentyp REFSYS3P: baseRs : REFSYS Bezug auf ein anderes Referenzsystem p0 : CARTPOS Ursprung des zu definierenden Referenzsystems px : CARTPOS Position entlang der X-Achse pxy : CARTPOS Position auf der X-Y Ebene Unter dem Parameter baseRs kann man eine andere Referenz angeben, auf die das Referenzsystem additiv wirkt. Wenn ein Bezug zum Weltkoordinatensystem der Kinematik erfolgen soll, muss auf die Systemvariable world referenziert werden. Beispiel: Daten: Festo GDCP-CMXR-SW-DE de Version 1.0 115 12. Referenzsysteme (Nullpunktverschiebung) refsys3p0 : REFSYS3P := (MAP(world), (100.0, 100.0, 0.0), (200.0, 100.0, 0.0), (200.0, 200.0, 0.0)) Programm: SetRefSys3P(refsys3p0) 12.4.1 Teachen des Referenzsystem SetRefSys3P Das Teachen des Referenzsystem SetRefSys3p bringt in der Applikation entscheidende Vorteile. Durch das Teachen wird der Nullpunkt z. B. einer Palette direkt geteacht. Etwaige Ungenauigkeit z. B. durch die Montage oder der Kinematik selbst werden dadurch kompensiert. Außerdem entfällt eine aufwendige Nullpunktbestimmung z. B. durch Messung und Berechnung im Raum. Um das Referenzsystem SetRefSys3P zu Teachen muss jedoch eine Reihenfolge eingehalten werden: Erster Punkt = Ursprung dritter Punkt = positive XY-Ebene zweiter Punkt = positive X-Achse dritter Punkt = positive XY-Ebene Vorsicht Der dritte Punkt bestimmt die positive XY Ebene. Je nach Lage des 3. Punkte kann dies ein Drehen des Koordinatensystems zur Folge haben z. B. drehen der Z-Achse um 180 Grad. Diese 3 Parameter können mit Hilfe des Handbediengerätes oder der Emulationssoftware geteacht werden kann. 116 Festo GDCP-CMXR-SW-DE de Version 1.0 12. Referenzsysteme (Nullpunktverschiebung) In der Betriebsart HAND wird bei Erstellung des Befehls oder über den Softkey Ändern die Parametermaske des Befehls geöffnet. Durch das markieren der Zeile Position wird der Softkey aktiv und kann verwendet werden. 1. Auswahl Referenzsystem, in diesem geteacht wird. 2. Parameterfeld anklicken, wird blau hinterlegt 3. Softkey Teach wird aktiviert Vor dem Teachen der Positionen muss jedoch beachtet werden, dass ein gültiger Bezug zum gewünschten Referenzsystem durch den Parameter baseRs ausgewählt wird. In diesem Referenzsystem werden die folgenden Positionen geteacht. Existiert das gewünschte Referenzsystem noch nicht, so muss dieses zuvor angelegt werden. Durch drücken des Softkeys wird die aktuelle kartesische Position in die angegebene Variable gespeichert. Das Teachen erfolgt immer auf eine Positionsvariable. Zum Teachen einer weiteren Position muss diese wiederholt durch anklicken markiert werden. Hinweis Das auf der Positionsseite angewählt Referenzsystem hat beim Befehl SetRefSys3P keine Bedeutung. Der Bezug zum Referenzsystem wird über den Parameter baseRs hergestellt. Festo GDCP-CMXR-SW-DE de Version 1.0 117 12. Referenzsysteme (Nullpunktverschiebung) 12.5 Referenzsystem Welt <SetRefSysWorld> Mit diesem Befehl wird das Referenzsystem Welt aktiviert, dessen Ursprung in der Kinematikkonfiguration hinterlegt ist. Syntax SetRefSysWorld() Wurde ein Referenzsystem mit dem Befehl SetRefSys oder SetRefsys3P gesetzt d. h. aktiviert und man möchte an bestimmter Programmstelle diese Referenzsysteme deaktivieren, so wird dafür der Befehl SetRefSysWorld verwendet. 12.6 Referenzsystem Dynamisch <SetRefSysDyn> > Als Erweiterung zu den statischen Referenzsystemen, gibt es den Befehl SetRefSysDyn um ein dynamisches (bewegtes) Referenzsystem zu definieren. Dieses bewegte Referenzsystem wird zur Realisierung der Trackingfunktion benötigt. Syntax SetRefSysDyn(<refSys> : CARTREFSYSVAR) Parameter Bedeutung Einheit refSys Referenzsystem, das durch die interne SPS mit Werte versogt Längen und Winkeleinheiten wird. Tabelle 12.3 Parameter Befehl SetRefSysDyn Hinweis Dieser Befehl arbeitet nur im Zusammenhang mit der integrierten SPS. Weitere Informationen über den Befehl und die damit verbundene Trackingfunktion sind der speziellen Dokumentation „FTL Programmierung Tracking“ zu entnehmen. 118 Festo GDCP-CMXR-SW-DE de Version 1.0 12. Referenzsysteme (Nullpunktverschiebung) 12.7 Beispiel Im folgenden Beispiel müssen 2 Paletten entleert und die Teile einer Maschine zugeführt werden. Y Sensor zum Erkennen, ob Platz frei ist Palette 1 Zuführung Maschine Palette 2 300 300 1500 X Beide Paletten besitzen den gleichen Inhalt und die gleichen Abmaße. Um hier den Programmieraufwand gering zu halten, wird für jede Palette ein eigenes Referenzsystem gesetzt und das Programm der Palette in einem Unterprogramm verfasst. Für das Referenzsystem der Palette 1 wird die Variable RefPal1 und für Palette 2 RefPal2 verwendet. Daten: : refPal1 : REFSYSDATA := (MAP(world), 0, 0, 0, 0, 0, 0) refPal2 : REFSYSDATA := (MAP(world), 0, 0, 0, 0, 0, 0) pos1 : CARTPOS := (100, 80, 70, 0, 0, 0, 0, 0, 0) : Programm: : refPal1.x := 300 // Verschiebung Palette 1 in X refPal1.y := 300 // Verschiebung Palette 1 in Y refPal2.x := 1500 // Verschiebung Palette 2 in X refPal2.y := 300 // Verschiebung Palette 2 in Y Lin(pos1) // fahren auf Sicherheit im Welt System SetRefSys(refPal1) // Verschiebung Palette 1 aktivieren Festo GDCP-CMXR-SW-DE de Version 1.0 119 12. Referenzsysteme (Nullpunktverschiebung) CALL Feed() // Aufruf Unterprogramm Teile zuführen SetRefSys(refPal2) // Verschiebung Palette 2 aktivieren CALL Feed() // Aufruf Unterprogramm Teile zuführen SetRefSysWorld() // aktiviere Welt System Lin(pos1) : 120 Festo GDCP-CMXR-SW-DE de Version 1.0 13. Referenzieren einer Kinematik 13. Referenzieren einer Kinematik 13.1 Referenzfahrt <RefAxis> Der Befehl RefAxis ermöglicht das Referenzieren von Achsen. Die Referenzfahrt wird dabei immer mit einer einzelnen Achse ausgeführt. Syntax RefAxis(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL) Parameter Bedeutung Einheit Axis Ausgewählte Achse, die referenziert wird. Enumeration A1, A2, bis A9 refData Datensatz der Referenzfahrt, z. B. wie referenziert wird. keine timeout Zeit für den Ablauf der Operation (danach kommt eine Fehler- Sekunden meldung, die Referenzierung wird abgebrochen). Tabelle 13.1 Parameter Befehl RefAxis Bei der Durchführung der Referenzfahrt ist darauf zu achten, dass die beteiligten Achsen freie Fahrt in ihren Bewegungen haben. Die Bewegung wird als Achsbewegung ausgeführt. Je nach Kinematiktyp kann es aufgrund der Achsanordnungen am Werkzeug zu unbekannten Bewegungen kommen. Hinweis Die Parameter refData und timeout sind optional. Werden diese nicht angegeben, wird die aktuelle Ist-Position als Referenzposition übernommen (DS 402 - Methode 35). Vorsicht Bei der Referenzfahrt ist auf freie Fahrt der betroffenen Achsen zu achten. Ferner sind bei diesen Bewegungen geeignete Dynamikwerte zu wählen, um die Referenzfahrt sinnvoll auszuführen. Hohe dynamische Werte sind hier nicht sinnvoll. Festo GDCP-CMXR-SW-DE de Version 1.0 121 13. Referenzieren einer Kinematik Das Referenzieren benötigt zum Ablauf einige Daten. Diese werden in einen Referenzdatensatz vom Typ REFDATA angegeben. Parameter Typ Bedeutung method DINT Referenzfahrmethode nach CANOpen DS 402 offset REAL Offset der Referenzposition [mm] velSwitch REAL Referenziergeschwindigkeit (Anfahren des Schalters) velZero REAL Kriechgeschwindigkeit (Suchen der Flanke) acc REAL Referenzfahrbeschleunigung Tabelle 13.2 Aufbau Datentyp REFDATA Hinweis Wird die Referenzfahrtmethode 99 angegeben, werden die Parameter der Referenzfahrt, wie sie mit dem Festo Configuration Tool (FCT) im Antrieb abgelegt wurden, verwendet. Die Referenzfahrt wird dann so ausgeführt, wie bei Inbetriebnahme der einzelnen Achse. Alle andere Parameter wie offset, velSwitch, zeroSwitch und acc haben in diesem Fall keine Bedeutung. Referenzfahrtmethode Die Methode der Referenzfahrt kann auf verschiedene Art geschehen, z. B. negativer Endschalter mit Nullimpulsauswertung, positiver Endschalter mit Nullimpulsauswertung oder Referenzfahrt auf einen Endschalter. Diese Methoden sind alle in der zugehörigen CANopen-Dokumentation des jeweiligen Antriebsreglers hinterlegt. Die folgende Tabelle zeigt die Referenziermethoden für CANopen-Geräte nach DS 402. 122 Wert Richtung Ziel Bezugspunkt für Null -18 positiv Anschlag Anschlag -17 negativ Anschlag Anschlag -2 positiv Anschlag Nullimpuls -1 negativ Anschlag Nullimpuls 1 negativ Endschalter Nullimpuls 2 positiv Endschalter Nullimpuls 7 positiv Referenzschalter Nullimpuls 11 negativ Referenzschalter Nullimpuls 17 negativ Endschalter Endschalter 18 positiv Endschalter Endschalter 23 positiv Referenzschalter Referenzschalter Festo GDCP-CMXR-SW-DE de Version 1.0 13. Referenzieren einer Kinematik Wert Richtung Ziel Bezugspunkt für Null 27 negativ Referenzschalter Referenzschalter 33 negativ Nullimpuls Nullimpuls 34 positiv Nullimpuls Nullimpuls 35 - Keine Fahrt Aktuelle Ist-Position 99 - - Ablauf wie in FCT Projekt des Motorcontrollers definiert Tabelle 13.3 Referenzfahrtmethoden Verschiebung der Referenzposition Über den Parameter offset kann eine Verschiebung des Nullpunktes gegenüber der Referenzposition festgelegt werden. Nach dem Referenzieren wird dieser Offsetwert auf den Referenznullpunkt addiert. Die Istwertanzeige der betroffenen Achse wird entsprechend aktualisiert. Referenziergeschwindigkeit, Kriechgeschwindigkeit, Beschleunigung Mit der Referenziergeschwindigkeit und der Beschleunigung wird die Dynamik der Achse beim Referenzieren festgelegt. Diese ist wirksam, vom Start der Referenzfahrt, bis zum Erreichen der Flanke des entsprechenden Schalters. Ist die Flanke erkannt, so wird auf die Kriechgeschwindigkeit umgeschaltet und die Referenzfahrt gemäß der ausgewählten Methode fertig gestellt. 13.2 Asynchrone Referenzfahrt <RefAxisAsync> Mit Hilfe dieses Befehls ist es möglich, mehrere Roboterachsen parallel zu referenzieren. Der Befehl wartet dabei nicht bis die Referenzfahrt abgeschlossen ist, sondern der Programmablauf wird nach Absetzen des Referenzierkommandos fortgesetzt. Um festzustellen, ob die Referenzierung abgeschlossen ist bzw. um den Status der Referenzierung auszulesen, existieren die Befehle WaitRefFinished und IsAxisReferenced. Syntax RefAxisAsync(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL) Festo GDCP-CMXR-SW-DE de Version 1.0 123 13. Referenzieren einer Kinematik Parameter Bedeutung Einheit Axis Ausgewählte Achse, die referenziert wird. Enumeration A1, A2, bis A9 refData Datensatz der Referenzfahrt, z. B. wie referenziert wird. keine timeout Zeit für den Ablauf der Operation (danach kommt eine Fehler- Sekunden meldung, die Referenzierung wird abgebrochen). Tabelle 13.4 Parameter Befehl RefAxisAsync Bei der Durchführung der Referenzfahrt ist darauf zu achten, dass die beteiligten Achsen freie Fahrt in ihren Bewegungen haben. Die Bewegung wird als Achsbewegung ausgeführt. Je nach Kinematik Typ kann es aufgrund der Achsanordnungen am Werkzeug zu unbekannten Bewegungen kommen. Hinweis Die Parameter refData und timeout sind optional. Werden diese nicht angegeben, wird die aktuelle Ist-Position als Referenzposition übernommen (DS 402 - Methode 35). Vorsicht Bei der Referenzfahrt ist auf freie Fahrt aller Achsen zu achten. Ferner sind bei diesen Bewegungen geeignete Dynamikwerte zu wählen, um die Referenzfahrt sinnvoll auszuführen. Hohe dynamische Werte sind hier nicht sinnvoll. Die Parameter und die sonstige Funktionsweise entspricht dem Befehl RefAxis. Hinweis Wird die Referenzfahrtmethode 99 angegeben, werden die Parameter der Referenzfahrt, wie sie mit dem Festo Configuration Tool (FCT) im Antrieb abgelegt wurden, verwendet. Die Referenzfahrt wird dann so ausgeführt, wie bei Inbetriebnahme der einzelnen Achse. Alle andere Parameter wie offset, velSwitch, zeroSwitch und acc haben in diesem Fall keine Bedeutung. 124 Festo GDCP-CMXR-SW-DE de Version 1.0 13. Referenzieren einer Kinematik 13.3 Warten auf Ende der Referenzfahrt <WaitRefFinished> Warten bis alle asynchron gestarteten Referenzfahrten abgeschlossen sind. Syntax WaitRefFinished( ) : BOOL Der Befehl wartet, bis die asynchronen Referenzfahrten beendet wurden (es wird auf den Hauptlauf gewartet) oder bis ein Fehler bei einer Referenzfahrt aufgetreten ist. Ist bei der Referenzfahrt kein Fehler aufgetreten, wird TRUE zurückgegeben, ansonsten FALSE. Programm: : RefAxisAsync(A1, refdata0) RefAxisAsync(A2, refdata0) RefAxisAsync(A3, refdata0) RefAxisAsync(A4) boolReference := WaitRefFinished() IF NOT boolReference THEN SetError("Error homing") END_IF Vorsicht Bei der Ausführung des Befehls RefAxisAsync ist die Verwendung des Befehls WaitRefFinished zwingend nötig, um die weitere Programmbearbeitung sicherzustellen. Wird nicht auf das Ende der Referenzfahrt gewartet, so können etwaige Befehle, bedingt durch die Vorausberechnung des Programms, Fehler erzeugen. Festo GDCP-CMXR-SW-DE de Version 1.0 125 13. Referenzieren einer Kinematik 13.4 Status einer Achse abfragen <IsAxisReferenced> Abfrage, ob eine Achse referenziert ist. Syntax IsAxisReferenced(axis : AXIS ) : BOOL Parameter Bedeutung Einheit Axis Ausgewählte Achse, die abgefragt werden Enumeration A1, soll. A2, bis A9 Tabelle 13.5 Parameter Befehl IsAxisReferenced Ist die angegebene Achse referenziert, wird TRUE zurückgegeben, ansonsten FALSE. 126 Festo GDCP-CMXR-SW-DE de Version 1.0 14. Werkzeuge 14. Werkzeuge Die CMXR Mehrachssteuerung bietet die Möglichkeit, die Längendaten eines Werkzeuges zu definieren. Diese Daten werden in Form eines 6-dimensionalen Vektors beschrieben. Somit kann dem Werkzeug neben den Abmaßen auch eine Orientierung mitgegeben werden. Diese Orientierung erfolgt nach der Euler ZYZ Konvention. Der Ursprung des Vektors ist dabei der Nullpunkt im Werkzeugflansch, das Ende bestimmt den Werkzeugendpunkt, der TCP (Tool Center Point) genannt wird. Mit den Werkzeugdaten wird das Werkzeugkoordinatensystem bestimmt. Koordinatensystem des 6- dimensionalen Vektors mit Ursprung am Flansch Werkzeugflansch X Y Z 14.1 Werkzeugdaten 14.1.1 Daten TCP-Vektor Die Werkzeugdaten sind im strukturierten Datentyp TCPTOOL abgelegt. Dieser enthält die Daten der 6 Freiheitsgrade. Aufbau: Datentyp TCPTOOL x : REAL Verschiebung entlang der X-Achse y : REAL Verschiebung entlang der Y-Achse z : REAL Verschiebung entlang der Z-Achse a : REAL Orientierungsangabe, Drehung um die Z-Achse b : REAL Orientierungsangabe, Drehung um die verdrehte Y-Achse c : REAL Orientierungsangabe, Drehung um die verdrehte Z-Achse Festo GDCP-CMXR-SW-DE de Version 1.0 127 14. Werkzeuge Die 3 translatorischen Werte X, Y und Z definieren den TCP im Raum, wenn alle Achsen in Ausgangslage stehen. Auf diese Weise wird das Werkzeugkoordinatensystem in den TCP verschoben. Dieses kann zusätzlich durch eine Orientierungsangabe (A-, B- und C-Parameter) in seiner Orientierung im Raum verdreht werden. Beispiel TCP-Daten: Ein kartesisches Portal besitzt am Ende der Z-Achse eine pneumatische Schwenkachse mit einem Vakuumgreifer. Das Werkzeug ist in Richtung der Z-Achse montiert. Die Orientierung des TCP ist unverändert zum ursprünglichen Werkzeugkoordinatensystem. X-Achse Z-Achse Werkzeuglänge Es ergeben sich folgende TCP-Daten: X= 0 Y= 0 Z= Werkzeuglänge A= 0 B= 0 C= 0 X Y Z Nun ist das Werkzeug, das über eine pneumatische Schwenkachse verfügt, im Raum um 30 Grad geneigt. Der TCP berechnet sich über den Winkel der Schwenkbewegung. Dabei ergeben sich folgende Daten: X-Achse Z-Achse X = Werkzeuglänge x sin(30°) Y=0 Z = Werkzeuglänge x cos(30°) Winkel 30° A=0 Versatz in Z X B=0 C=0 Versatz in X Y 128 Z Die Orientierung des Werkzeugkoordinatensystems ist unverändert. Wenn erforderlich, dann muss dieses über die Parameter A, B und C eingestellt werden. Festo GDCP-CMXR-SW-DE de Version 1.0 14. Werkzeuge Zusätzlich soll die Orientierung des Werkzeugkoordinatensystems in Richtung des gedrehten Werkzeuges zeigen. Zur Drehung wird die Euler-Konvention ZYZ angewandt. X-Achse Z-Achse Dabei ergeben sich folgende Daten: X = Werkzeuglänge x sin(30°) Y=0 Winkel Z = Werkzeuglänge x cos(30°) X Versatz in Z Y A=0 B = 30 Z Versatz in X C=0 Diese Werkzeugbeschreibungen werden in Variablen abgespeichert. Dabei können für ein Werkzeug beliebig viele TCP-Variable definiert werden, wobei nur ein Datensatz aktiv sein kann. Die verschiedenen Beschreibungen werden dann verwendet, wenn ein Werkzeug verschiedene Bezugspunkte besitzt und diese je nach Aufgabe im Betrieb gewechselt werden müssen. Da die Werkzeugdaten im Speicher als Variable abgelegt sind, ist die Anzahl durch die Speichergröße bestimmt. Für die richtige Zuordnung der TCP-Daten zum Werkzeug hat der Programmierer zu sorgen. Die CMXR Mehrachssteuerung kennt keinen Bezug der Werkzeugdaten zum physikalischen Werkzeug. Vorsicht Bei unpassenden oder falschen TCP-Daten besteht Kollisionsgefahr. Festo GDCP-CMXR-SW-DE de Version 1.0 129 14. Werkzeuge 14.2 Aktivieren von Werkzeugdaten <Tool> Mit folgendem Befehl können innerhalb eines FTL-Programms die Daten eines Tool Center Point (TCP) gesetzt werden. Dieser Tool-Befehl setzt neue TCP-Daten für die Kinematik. Somit wird der Arbeitspunkt der Kinematik verändert. Syntax Tool (<ToolData> : TCPTOOL) Die Daten für den TCP sind in der zu übergebenden Variable enthalten. Diese Daten werden im Satzvorlauf des FTL-Interpreters eingelesen und gehen ab dort in die weitere Bahnplanung der Bewegung ein. Bei allen folgenden Befehlen werden nun diese TCP-Daten berücksichtigt. Parameter Bedeutung Einheit ToolData Werkzeugdaten TCPTOOL Tabelle 14.1 Parameter Befehl Tool Der Aufruf des Befehls Tool bewirkt keine Verfahrbewegung, sondern nur ein Bekanntmachen der nun aktiven TCP-Daten. Im nächsten kartesischen Fahrbefehl werden diese Daten eingerechnet und in der Bewegungsausführung berücksichtigt. Wird im FTL-Programm ein Tool-Befehl übersprungen, bzw. am Handbediengerät der Satzzeiger zur Programmausführung so positioniert, dass der zugehörige Tool Befehl nicht ausgeführt werden kann, können Gefahren für Mensch und Maschine entstehen. Die folgende Werkzeugorientierung könnte unpassend zur Bewegung sein, wobei Kollisionsgefahr besteht. Warnung Beim Ändern des Tools ergibt sich ein Sprung in der kartesischen Bahn des TCP. Wird am Handbediengerät der Programmzeiger so gesetzt, dass ein Tool Befehl umgangen wird, so kann dies bei kartesischen Bewegungen zu ungewollten Reaktionen führen! 14.2.1 Auswirkung von TCP-Daten Die TCP-Daten werden im FTL-Programm über einen Befehl aktiviert und im Satzvorlauf des Interpreters eingelesen. Diese nun aktuellen TCP-Daten werden in die Bahnplanung der folgenden Bewegungsbefehle eingerechnet. Folgendes ist ein Beispiel, in dem das Verhalten von Werkzeugdaten mit der Anwendung einer pneumatischen Schwenkachse beschrieben wird. 130 Festo GDCP-CMXR-SW-DE de Version 1.0 14. Werkzeuge Beispiel: Ein Handhabungssystem besitzt am Werkzeugflansch eine pneumatische Schwenkachse. Mit Hilfe dieser Achse kann das Werkzeug auf eine feste Position geschwenkt werden. Durch diese Schwenkbewegung wird die Orientierung des Werkzeuges verändert. Damit nun die CMXR Mehrachssteuerung unter Berücksichtigung der Lage des TCP eine kartesische Bewegung im Raum berechnen kann, muss nach der Schwenkbewegung die neue Orientierung mitgeteilt werden. Bedingt durch die zwei möglichen Orientierungen des Werkzeuges, gibt es 2 TCPs und somit 2 Datensätze tool1 und tool2. Orientierung 1, Werkzeug senkrecht: Z Y X Drehachse Werkzeuglänge Sauggreifer TCP Die Werkzeuglänge des senkrechten Werkzeuges läuft entlang der Z- Achse des Werkzeugkoordinatensystems. Somit besitzt der TCP nur eine Translation in Richtung der Z-Achse, die Orientierungsangaben sind 0. Werkzeugdaten für tool1: X =0 Verschiebung entlang der X-Achse Y =0 Verschiebung entlang der Y-Achse Z = Werkzeuglänge Verschiebung entlang der Z-Achse A =0 Orientierung nach Euler, Drehung um die Z-Achse B =0 Orientierung nach Euler, Drehung um die verdrehte Y-Achse C =0 Orientierung nach Euler, Drehung um die verdrehte Z-Achse Festo GDCP-CMXR-SW-DE de Version 1.0 131 14. Werkzeuge Orientierung 2, Werkzeug geschwenkt: Z Y X Sauggreifer TCP Drehachse Werkzeuglänge Durch die Schwenkbewegung wandert der TCP zur Seite, das Werkzeug hat nun eine veränderte Orientierung. Bei der abgebildeten Kinematik handelt es sich um ein kartesisches System. Bei diesem ist die Lage des kartesischen Koordinatensystems der Grundachsen X, Y und Z deckungsgleich mit dem kartesischen Werkzeugkoordinatensystem. Wendet man nun zur Bestimmung der Orientierung die Rechte-Hand-Regel an, so ergibt sich eine Drehung des Werkzeuges um die Y-Achse in positiver Richtung. Werkzeugdaten für tool2: X = Länge x sin(30°) Verschiebung entlang der X-Achse Y =0 Verschiebung entlang der Y-Achse Z = Länge x cos(30°) Verschiebung entlang der Z-Achse A =0 Orientierung nach Euler, Drehung um die Z-Achse B = 30 Orientierung nach Euler, Drehung um die verdrehte Y-Achse C =0 Orientierung nach Euler, Drehung um die verdrehte Z-Achse Programmbeispiel: Unsere kartesische Kinematik soll nun mit senkrechtem Werkzeug von einer Position 1 auf eine Position 2 fahren. Danach wird das Werkzeug durch die Schwenkachse geschwenkt. Das geschwenkte Werkzeug muss nun die Position 2 anfahren. Anfahren von pos1 nach pos2: Tool(tool1) Lin(pos1) Lin(pos2) 132 Festo GDCP-CMXR-SW-DE de Version 1.0 14. Werkzeuge Z Z Y X pos1 Werkstück pos2 Bei den kartesischen Fahrbefehlen von pos1 auf pos2 berücksichtigt die Steuerung automatisch die aktiven Werkzeugdaten tool1. Schwenken der Schwenkachse: : Tool(tool1) Lin(pos1) Lin(pos2) CALL Rotate() // Aufruf Unterprogramm : Z Y X pos1 Werkstück pos2 Die Schwenkbewegung hat zur Folge, dass sich nun der Tool Center Point (TCP) nach oben bewegt. Aufgrund der pneumatischen Achse, kann die Steuerung keine automatischen Ausgleichsbewegungen durchführen. Um nun die Position 2 anzufahren, muss die neue Orientierung des Werkzeuges definiert werden. Festo GDCP-CMXR-SW-DE de Version 1.0 133 14. Werkzeuge Erneutes Anfahren von pos2 mit tool2: : Tool(tool1) Lin(pos1) Lin(pos2) CALL Rotate() // Aufruf Unterprogramm Tool(tool2) Lin(pos2) : Z Y Z X Ausgleichsbewegung Werkstück pos2 Das erneute Anfahren von Position 2 hat die Folge, dass der TCP mit seinen neuen Daten auf die Position 2 ausgerichtet wird. Je nach Fall, kann dabei eine Ausgleichsbewegung mit max. allen Achsen stattfinden. Hinweis Bei Verwendung einer elektrischen Schwenkachse die als Freiheitsgrad in die kartesische Kinematik eingearbeitert ist, wird im Gegensatz zur pneumatischen Schwenkachse keine Änderung der Werkzeugorientierung erforderlich. Bei der elektrischen Schwenkachse wird die gewünschte Orientierung innerhalb eines Fahrbefehls programmiert. Die CMXR Steuerung berechnet dann automatisch die Position der Achsen unter Berücksichtigung der programmierten Orientierung. 134 Festo GDCP-CMXR-SW-DE de Version 1.0 15. PROFIBUS-Schnittstelle 15. PROFIBUS-Schnittstelle Über die PROFIBUS-Schnittstelle kann die CMXR von einer übergeordneten Steuerung (SPS/IPC) gesteuert werden. Weiterhin können Daten in Form von Variablen geschrieben und gelesen werden. All diese Daten sind systemglobale Daten und stehen allen FTL- Programmen zur Verfügung. Die Kommunikation zur übergeordneten Steuerung verläuft zyklisch im Updatezyklus des PROFIBUS. Beim Neustart des Systems sind alle Werte auf Null gesetzt. Etwaige Daten, die für die Abarbeitung der Programme benötigt werden, müssen von der übergeordneten Steuerung vor dem Programmstart gesendet werden. Hinweis Werden in einem Programm konsistente Daten benötigt, ist vor deren Verarbeitung dafür zu sorgen, dass diese auf z. B. lokale Daten kopiert werden. Hinweis Die Schnittstellendaten sind nicht gepuffert und haben nach einem Neustart des Systems alle den Wert Null. Etwaige Daten, die zur Abarbeitung benötigt werden, sind vor dem Start zu schreiben. Festo GDCP-CMXR-SW-DE de Version 1.0 135 15. PROFIBUS-Schnittstelle Hinweise zur Signalverarbeitung Die in den folgenden Kapiteln behandelten FTL Variablen der SPS Schnittstelle werden wie andere Variable immer in der Vorausberechnung (Satzvorlauf) des FTL Programms berechnet. Müssen Variablen zur Laufzeit der aktiven Programmzeile (Hauptlauf) ausgeführt werden, so sind zusätzliche Maßnahmen erforderlich. Eine Möglichkeit ist die Verwendung der DO Anweisung. Die folgende Grafik erläutert die Unterschiede der Signalverarbeitung: Hauptlauf Vorlauf Lin(pos1) Lin(pos1) Lin(pos2) Lin(pos2) Lin(pos3) Lin(pos3) Lin(pos4) Lin(pos4) Lin(pos5) Lin(pos5) DO plc_Dint[1] := 1 plc_Dint[1] := 2 Lin(pos6) Lin(pos6) Lin(pos7) DO plc_DInt[3] := 2 Lin(pos7) Lin(pos8) Lin(pos8) Lin(pos9) Variable wird im Satzvorlauf bearbeitet. 15.1 Hauptlauf Vorlauf Lin(pos9) Lin(pos10) Verwendung der DO Anweisung, Variable wird im Hauptlauf bearbeitet. Boolesche Ein- und Ausgänge, plc_InBool, plc_OutBool Die Schnittstelle umfasst 16 digitale Ein- und Ausgangssignale, die im Weiteren immer aus Sicht des CMXR gesehen werden. Sie sind in Form einer booleschen Variable auf der Steuerung verfügbar. Diese booleschen Signale werden zyklisch mit der übergeordneten Steuerung ausgetauscht. Hinweis Die booleschen Variablen werden über den Zyklus des PROFIBUS automatisch zur übergeordneten Steuerung übertragen bzw. von dieser gelesen. Die booleschen Variablen sind in einem Array abgelegt, auf das über den Index 0 bis 15 zugegriffen werden kann. 136 Festo GDCP-CMXR-SW-DE de Version 1.0 15. PROFIBUS-Schnittstelle Syntax plc_InBool [ <Arrayindex> ] : BOOL plc_OutBool [ <Arrayindex> ] : BOOL In der Arrayvariablen plc_InBool sind alle Eingangssignale gespeichert. Die Arrayvariable plc_OutBool enthält alle Ausgangsdaten. Beispiel: : plc_OutBool[9] := FALSE // Bit 9 zur PLC auf FALSE IF plc_InBool[5] THEN // prüfen Bit 5 von PLC Lin(pos1) Lin(pos2) END_IF plc_OutBool[9] := TRUE // Bit 9 zur PLC auf TRUE : 15.2 Integer-Variablen 32 Bit, plc_Dint Die Schnittstelle bietet 256 Integervariablen vom Datentyp DINT, der 32 Bit umfasst. Diese Variablen unterliegen keinem zyklischen Datenaustausch und können von der externen Steuerung nach Bedarf geschrieben und gelesen werden. Hinweis Die Integervariablen werden nicht automatisch von der übergeordneten Steuerung gelesen bzw. an diese übermittelt. Wenn erforderlich, dann müssen diese von der übergeordneten Steuerung gesendet bzw. gelesen werden. Die Integervariablen sind in einem Array abgelegt, auf das über den Index 0 bis 255 zugegriffen werden kann. Syntax plc_Dint [ <Arrayindex> ] : DINT Beispiel: : Festo GDCP-CMXR-SW-DE de Version 1.0 137 15. PROFIBUS-Schnittstelle IF plc_Dint[3] = 13 THEN : : END_IF 15.3 Positionen, plc_AxisPos, plc_CartPos Die Schnittstelle unterstützt zwei Positionsdatentypen. Es können Achspositionen und kartesische Positionen von der externen Steuerung zur CMXR Mehrachssteuerung gesendet werden. Die maximale Anzahl der Positionen umfasst dabei 256 Achs- und 256 kartesische Positionen. Diese Variablen unterliegen keinem zyklischen Datenaustausch und können von der externen Steuerung nach Bedarf geschrieben und gelesen werden. Hinweis Die Positionsvariablen werden nicht automatisch von der übergeordneten Steuerung gelesen bzw. an diese übermittelt. Wenn erforderlich, dann müssen diese von der externen Steuerung gesendet bzw. gelesen werden. Die Positionsvariablen sind in Arrays abgelegt. Über den Index 0 bis 255 kann auf diese zugegriffen werden. Hinweis plc_AxisPos [ <Arrayindex> ] : AXISPOS plc_CartPos [ <Arrayindex> ] : CARTPOS Die Schnittstellenvariable plc_AxisPos enthält 256 Positionen vom Datentyp AXISPOS, die Variable plc_CartPos enthält 256 Positionen von Datentyp CARTPOS. Beispiel: : Ptp(plc_AxisPos[17]) Lin(plc_AxisPos[18]) Lin(plc_AxisPos[19]) Lin(plc_CartPos[1]) : 138 Festo GDCP-CMXR-SW-DE de Version 1.0 15. PROFIBUS-Schnittstelle 15.4 Referenzsysteme, plcRefSys Maximal 16 Referenzsysteme können über die externe Schnittstelle vorgegeben werden. Diese Variablen sind vom Datentyp REFSYSDATA und können mit dem Befehl SetRefSys verwendet werden. Diese Variablen unterliegen keinem zyklischen Datenaustausch und können von der externen Steuerung nach Bedarf geschrieben und gelesen werden. Hinweis Die Referenzsysteme werden nicht automatisch von der übergeordneten Steuerung gelesen bzw. an diese übermittelt. Wenn erforderlich, dann müssen diese von der externen Steuerung gesendet bzw. gelesen werden. Die Referenzsysteme sind in einem Array abgelegt, auf das über den Index 0 bis 15 zugegriffen werden kann. Syntax plc_RefSys [ <Arrayindex> ] : REFSYSDATA Der Datentyp REFSYSDATA bietet die Möglichkeit, ein Referenzsystem additiv auf ein anderes zu beziehen. Die Schnittstelle unterstützt dies ebenfalls, jedoch nur innerhalb der Schnittstelle selbst. D. h. es kann kein Bezug auf im System bestehende Referenzsysteme hergestellt werden. Der Bezug auf ein anderes Referenzsystem basiert auf einer Nummernvorgabe 0 bis 15 durch die externe Steuerung. Bei einer Vorgabe von -1 wird der Bezug zum Weltkoordinatensystem der Kinematik hergestellt. Hinweis Referenzsysteme, die über die externe Schnittstelle vorgegeben werden, können nur innerhalb der Referenzsysteme der Schnittstelle verlinkt werden. Ein Bezug auf ein Referenzsystem, das außerhalb der Schnittstelle definiert wurde, ist nicht möglich. Beispiel: : Lin(pos2) SetRefSys(plc_RefSys[3]) Lin(pos3) Lin(pos4) : Festo GDCP-CMXR-SW-DE de Version 1.0 139 15. PROFIBUS-Schnittstelle 15.5 Programmierter Halt <ProgHold> Dieser Befehl arbeitet in Verbindung mit dem Signal HALTENA der SPS Schnittstelle. Er eignet sich für Test- oder Inbetriebnahmezwecke und kann an beliebiger Programmzeile eingefügt werden, um dort auf Anforderung das Programm anzuhalten. Ist das Signal HALTENA auf der Schnittstelle aktiviert, d. h. es hat den Zustand TRUE, wird bei einem Aufruf des Befehls ProgHold das Bewegungsprogramm angehalten. Dabei wird nur das Programm angehalten, in dem sich der Befehl ProgHold befindet. Andere Programme z. B. parallele Programme, werden weiter abgearbeitet. Setzt die SPS das Signal HALTENA auf FALSE, so wird das angehaltene Programm fortgesetzt. Hinweis Werden mit dem Befehl ProgHold mehrere Programme angehalten (z. B. parallele Programme), so werden diese mit dem Signalzustand FALSE gemeinsam wieder anlaufen. Ein selektives Anlaufen der einzelnen angehaltenen Programme ist nicht möglich. Syntax ProgHold ( ) Zum Aufruf des Befehls sind keine Parameter notwendig. Beispiel: : OvlVel(100) // volles Überschleifen Lin(pos1) Lin(pos2) ProgHold() // programmierter Halt Lin(pos3) Lin(pos4) ProgHold() // programmierter Halt Lin(pos5) : Dieses Beispielprogramm fährt verschiedene Positionen an, wobei ein Geschwindigkeitsüberschleifen mit 100 % eingestellt ist. Wenn das Signal zum programmierten Halt gesetzt ist, wird an diesen Stellen angehalten. Dabei ergibt sich folgender Geschwindigkeitsverlauf: 140 Festo GDCP-CMXR-SW-DE de Version 1.0 15. PROFIBUS-Schnittstelle Verlauf mit programmiertem Halt: Geschwindigkeit Zeit zwischen Anhalten und Weiter laufen Zeit pos1 pos2 pos3 pos4 pos5 Verlauf ohne programmierten Halt: Geschwindigkeit Zeit pos1 pos2 pos3 Festo GDCP-CMXR-SW-DE de Version 1.0 pos4 pos5 141 16. FTL Schnittstelle zur internen SPS (nur für Mehrachscontroller mit CoDeSys) 16. FTL Schnittstelle zur internen SPS (nur für Mehrachscontroller mit CoDeSys) Um neben den Bewegungsprogrammen auch individuelle Prozessabläufe zu erstellen, besitzt die CMXR Steuerung eine integrierte CoDeSys SPS, die eine Programmierung nach IEC 61131-3 ermöglicht. In welchem Umfang dies unterstützt wird, ist der Leistungsbeschreibung im Systemhandbuch der jeweiligen CMXR Steuerung zu entnehmen. Dieses Kapitel beschreibt die Schnittstelle zwischen der Bewegungs- und Prozessteuerung aus Sicht der FTL Programmierung. Ausgeprägt ist diese Schnittstelle durch FTL Variablen, die von der CoDeSys SPS beschrieben und gelesen werden können. 16.1 FTL Systemvariablen Alle für die Schnittstelle notwendigen FTL Variablen sind bereits als Systemvariable hinterlegt und sofort verfügbar. Die Variablen sind als Grunddatentyp BOOL, DWORD, DINT und REAL sowie Positionsvariable der Typen AXISPOS und CARTPOS vorhanden. Alle Variablen sind als ARRAY mit einer Größe von 256 Elementen ausgeprägt. Um die Verwendung der Daten einfach zu gestalten, gibt es von jedem Datentyp ein Eingangs- und ein Ausgangsarray. Diese Namensgebung ist aus Sicht der FTL Programmierung: - Eingangsdaten sind Daten, die von der SPS beschrieben werden (Namenszusatz In), - Ausgangsdaten sind Daten, die von der SPS gelesen werden (Namenszusatz Out). Hinweis Daten, die von der SPS erwartet werden, sind den Eingangsdaten zu entnehmen. Daten, die an die SPS gesendet werden, sind stets in die Ausgangsdaten zu schreiben. Ein vertauschen der Datenbereiche führt zu fehlerhaften Programmzuständen. Folgende Tabelle zeigt den Umfang der vorhandenen FTL Schnittstellenvariable: Datentyp Eingangsdaten Ausgangsdaten BOOL plc_InBool : ARRAY[256] OF BOOL plc_OutBool : ARRAY[256] OF BOOL DINT plc_InDint : ARRAY[256] OF DINT plc_OutDint : ARRAY[256] OF DINT REAL plc_InReal : ARRAY[256] OF Real plc_OutReal : ARRAY[256] OF Real DWORD plc_InDword : ARRAY[256] OF DWORD plc_OutDword : ARRAY[256] OF DWORD AXISPOS plc_InAxisPos : ARRAY[256] OF AXISPOS plc_OutAxisPos : ARRAY[256] OF AXISPOS CARTPOS plc_InCartPos : ARRAY[256] OF CARTPOS plc_OutCartPos : ARRAY[256] OF CARTPOS Tabelle 16.1 Systemvariablen FTL Schnittstelle zur SPS 142 Festo GDCP-CMXR-SW-DE de Version 1.0 16. FTL Schnittstelle zur internen SPS (nur für Mehrachscontroller mit CoDeSys) 16.1.1 Beispiel mit Systemvariablen Ein FTL-Programm kann einen Teiletyp A und B bearbeiten. Diese werden über eine Vorgabe durch die SPS ausgewählt. Nach Fertigstellung sendet das FTL-Programm eine Rückmeldung an die SPS. Dazu werden die FTL-Schnittstellenvariablen wie folgt aufgeteilt: - plc_OutBool[0] Rückmeldung, wenn Programm fertig - plc_InBool[0] Startsignal für Programmablauf - plc_InBool[1] Auswahl Teiletyp A - plc_InBool[2] Auswahl Teiletyp B Damit der Programmablauf sicher funktioniert, muss die SPS sicherstellen, dass vor dem Startsignal die Teileauswahl über die beiden Signale plc_InBool[1] und plc_InBool[2] richtig anstehen. : OvlVel(100) // volles Überschleifen Lin(Home) plc_OutBool[0] := FALSE // Fertigmeldung = FALSE WAIT plc_InBool[0] // warte auf Startsignal IF plc_InBool[1] THEN // bearbeite Teil A CALL PartTypeA ELSIF plc_InBool[2] THEN // bearbeite Teil B CALL PartTypeB END_IF plc_OutBool[0] := TRUE // Fertigmeldung = TRUE Lin(Home) : Die WAIT Anweisung hält die Vorausberechnung des Programms solange an, bis das Signal plc_InBool[0] den Zustand TRUE besitzt. Hinweis Das FTL Programm wird stets vorausberechnet. Dies gilt auch für alle programmierten Schnittstellenvariable. Von der SPS ist deshalb zu sorgen, dass alle notwendigen Daten zum richtigen Zeitpunkt dem FTL Programm zur Verfügung stehen. Wenn notwendig, müssen Maßnahmen wie z. B. warten auf spezielle Daten und somit anhalten der Vorausberechnung implementiert werden. Festo GDCP-CMXR-SW-DE de Version 1.0 143 16. FTL Schnittstelle zur internen SPS (nur für Mehrachscontroller mit CoDeSys) 16.1.2 Beispiel mit Systemvariablen und MAP-Befehl Die Systemvariablen besitzen festgelegte Namen. Um nun für die Schnittstellensignale sinnvolle Namen, die man selbst definiert, zu vergeben, wird der MAP-Befehl eingesetzt. Mit dem MAP-Befehl werden Referenzen angelegt, die dann auf die eigentlichen Variable verbunden werden. Analog zum vorherigen Beispiel: FTL-Variable: // Deklaration und Verbinden der Signale mit den einzelnen Variablen CycleFinished : MAPTO BOOL := MAP(plc_OutBool[0]) StartFromPlc : MAPTO BOOL := MAP(plc_InBool[0]) JobPartA : MAPTO BOOL := MAP(plc_InBool[1]) JobPartB : MAPTO BOOL := MAP(plc_InBool[2]) FTL-Programm: : OvlVel(100) // volles Überschleifen Lin(Home) CycleFinished := FALSE // Fertigmeldung = FALSE WAIT StartFromPlc // warte auf Startsignal IF JobPartA THEN // bearbeite Teil A CALL PartTypeA ELSIF JobPartB THEN // bearbeite Teil B CALL PartTypeB END_IF CycleFinished := TRUE // Fertigmeldung = TRUE Lin(Home) : Hinweis Durch die Verwendung von Referenzvariablen und den MAP-Befehl werden die Programme lesbarer. 144 Festo GDCP-CMXR-SW-DE de Version 1.0 17. Meldesystem 17. Meldesystem Aus dem Bewegungsprogramm können Meldungen generiert werden. Es gibt folgende Meldungsarten: - Information - Warnung - Fehler Diese Meldungen werden in den Meldespeicher der Steuerung eingetragen und entsprechend archiviert. Zurückgesetzt (gelöscht) werden die Meldungen durch Quittieren am Handbediengerät oder Quittieren über eine externe Steuerung. Abbildung des Meldespeichers am Handbediengerät: 17.1 Meldetexte Die Programmierung in FTL (Festo Teach Language) ermöglicht das Absetzen von Informations-, Warn- und Fehlermeldungen aus dem Bewegungsprogramm. Die Meldungstexte werden vom Anwender selbst als Zeichenkette (STRING) frei definiert. Diese Zeichenkette kann auch variable Einträge in Form von maximal 2 Parametern (z. B. DINT, REAL, STRING, BOOL) enthalten. Die 2 optionalen Parameter werden über eine Angabe eines Prozentzeichens und einer Nummer im Meldetext platziert. %1 bedeutet 1. optionaler Parameter %2 bedeutet 2. optionaler Parameter Festo GDCP-CMXR-SW-DE de Version 1.0 145 17. Meldesystem Werden Typen wie Achspositionen angegeben, so wird lediglich der Variablenname in den String eingefügt. Strukturierte Datentypen können nicht in einem Meldetext dargestellt werden. Hinweis Bei der Übergabe der Variablentypen DINT, REAL und STRING wird der Inhalt der Variablen in den Meldetext eingefügt. Beim Variablentyp BOOL wird je nach Zustand der Text TRUE oder FALSE in den Meldetext eingefügt. Beispiel: In einem Programm werden zwei Variable angelegt und mit Werten vorbelegt. Diese Werte werden mit dem Befehl SetInfo ausgegeben. Variablen: param1 : DINT := 7 param2 : REAL := 3.48 Programmcode: SetInfo(“Sensor %1, pressure %2 bar“, param1, param2) Es wird folgender Infotext angezeigt:“Sensor 7, pressure 3,48 bar“. 146 Festo GDCP-CMXR-SW-DE de Version 1.0 17. Meldesystem 17.2 Information <SetInfo> Der Befehl SetInfo setzt eine Informationsmeldung in das Meldesystem ab. Syntax SetInfo( <text> : STRING, OPT <param1> : ANY, OPT <param2> : ANY) Parameter Bedeutung Einheit text Text der Infomeldung STRING param1 1. möglicher Parameter ANY Param2 2. möglicher Parameter ANY Tabelle 17.1 Parameter Befehl SetInfo Die Zusammensetzung des Meldetextes ist in Kapitel 17.1 Meldetext auf Seite 145 beschrieben. Eine Informationsmeldung wird mit dem Symbol achssteuerung gekennzeichnet. im Fehlerspeicher der CMXR Mehr- Hinweis Eine Informationsmeldung hat keine Auswirkung auf die Bewegung. Sie dient lediglich der Information. Beispiel: pressure := Sensor.Read(); // lesen eines Druckwertes cycle // Zyklus zählen := cycle + 1 SetInfo ("Cycle %1 finished, Value %2", cycle, pressure) Anzeige am Handbediengerät: Festo GDCP-CMXR-SW-DE de Version 1.0 147 17. Meldesystem 17.3 Warnung <SetWarning> Der Befehl SetWarning setzt eine Warnmeldung in das Meldesystem ab. Syntax SetWarning( <text> : STRING, OPT <param1> : ANY, OPT <param2> : ANY) Parameter Bedeutung Einheit text Text der Warnmeldung STRING param1 1. möglicher Parameter ANY Param2 2. möglicher Parameter ANY Tabelle 17.2 Parameter Befehl SetWarning Die Zusammensetzung des Meldetextes ist in Kapitel 17.1 Meldetext auf Seite 145 beschrieben. Eine Warnmeldung wird mit dem Symbol rung gekennzeichnet. im Fehlerspeicher der CMXR Mehrachssteue- Hinweis Eine Warnmeldung hat keine Auswirkung auf die Bewegung. Sie dient lediglich der Information. Beispiel: pressure := Sensor.Read(); // lesen eines Druckwertes cycle // Zyklus zählen := cycle + 1 SetWarning("Cycle %1 finished, Value %2",cycle, pressure) Anzeige am Handbediengerät: 148 Festo GDCP-CMXR-SW-DE de Version 1.0 17. Meldesystem 17.4 Fehlermeldung <SetError> Der Befehl SetError setzt eine Fehlermeldung in das Meldesystem ab. Dieser Befehl wirkt sich auf die Bearbeitung des Programms aus, es wird gestoppt. Etwaige Bewegungen werden angehalten, nach Quittierung der Fehlermeldung kann das Programm fortgesetzt werden. Dazu müssen die Motorcontroller freigegeben und das Programm erneut gestartet werden. Syntax SetError( <text> : STRING, OPT <param1> : ANY, OPT <param2> : ANY) Parameter Bedeutung Einheit Text Text der Fehlermeldung STRING param1 1. möglicher Parameter ANY Param2 2. möglicher Parameter ANY Tabelle 17.3 Parameter Befehl SetError Eine Fehlermeldung wird mit dem Symbol steuerung gekennzeichnet. im Fehlerspeicher der CMXR Mehrachs- Hinweis Die Ausgabe einer Fehlermeldung führt zu einer Unterbrechung der Bewegung. Die Kinematik kann erst nach Quittieren der Fehlermeldung weitergefahren werden. Beispiel: pressure := Sensor.Read(); // lesen eines Druckwertes cycle // Zyklus zählen := cycle + 1 SetError("Cycle %1 error, pressure %2", cycle, pressure) Anzeige am Handbediengerät: Festo GDCP-CMXR-SW-DE de Version 1.0 149 17. Meldesystem Bei einer Fehlermeldung wird der Fehlertext zusätzlich in der Kopfzeile am Handbediengerät angezeigt. Außerdem leuchtet die Error LED am Handbediengerät rot. 150 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18. Funktionen 18.1 Aktuelle Position lesen <ReadActualPos> Auslesen der aktuellen Position der Kinematik. Syntax ReadActualPos (<Pos> : POSITION) Die aktuelle Position des Roboters wird in die übergebene Variable geschrieben. Ist die übergebene Variable vom Typ CARTPOS, wird die Position als kartesischer Wert abgelegt. Wird eine Variable vom Typ AXISPOS übergeben, erfolgt die Positionsspeicherung in Achskoordinaten. Parameter Bedeutung Einheit Pos Zielvariable der gelesenen Position AXISPOS oder CARTPOS Tabelle 18.1 Parameter Befehl ReadActualPos Vorsicht Ein Positionswert, der in einer Variablen gespeichert wurde, bleibt nur solange erhalten, wie das Programm bzw. das Projekt geladen ist. Es erfolgt kein Sichern der Variablenwerte in die Datendatei auf der Speicherkarte. Nach dem Abwählen des Programms/Projektes sind die Werte verloren. Zum Sichern der Position kann der Befehl SavePosition verwendet werden. Beispiel: Das Beispielprogramm liest die aktuelle Position ein, fährt die programmierten Bewegungsbefehle ab und kehrt am Ende zur eingelesenen Position zurück. Variable: startPos : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0) axis0 : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0) axis1 : AXISPOS := (60, -120, 0, 0, 0, 0, 0, 0, 0) axis2 : AXISPOS := (-120, -120, -250, 0, 0, 0, 0, 0, 0) Festo GDCP-CMXR-SW-DE de Version 1.0 151 18. Funktionen Programm: ReadActualPos(startPos) PTP(axis0) PTP(axis1) PTP(axis2) PTP(startPos) 18.2 Zielposition lesen <ReadTargetPos> Auslesen der programmierten Zielposition der Kinematik. Syntax ReadTargetPos (<Pos> : POSITION) Die aktuell programmierte Zielposition des Roboters wird in die übergebene Variable geschrieben. Ist die übergebene Variable vom Typ CARTPOS, wird die Position als kartesischer Wert abgelegt. Wird eine Variable vom Typ AXISPOS übergeben, erfolgt die Positionsspeicherung in Achskoordinaten. Parameter Bedeutung Einheit Pos Zielvariable der gelesenen Position AXISPOS oder CARTPOS Tabelle 18.2 Parameter Befehl ReadTargetPos Vorsicht Ein Positionswert, der in einer Variablen gespeichert wurde, bleibt nur solange erhalten, wie das Programm bzw. das Projekt geladen ist. Es erfolgt kein Sichern der Werte in die Datendatei auf der Speicherkarte. Nach dem Abwählen des Programms, Projektes sind die Werte verloren. Zum Sichern der Position kann der Befehl SavePosition verwendet werden. 152 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18.3 Positionswert dauerhaft speichern <SavePosition> Das FTL-Befehl speichert einen Positionswert dauerhaft auf der Speicherkarte. Syntax SavePosition (<Pos> : POSITION) Mit dem Befehl SavePosition erfolgt ein Sichern der Werte aus der angegebenen Variable <Pos> in die Datendatei auf der Speicherkarte. Die Position kann somit bei einem Neustart der Steuerung wiederhergestellt werden. Parameter Bedeutung Einheit Pos zu speichernde Position AXISPOS oder CARTPOS Tabelle 18.3 Parameter Befehl SavePosition Vorsicht Ein häufiges Zurückschreiben von Positionen auf die Speicherkarte verkürzt deren Lebensdauer. Der Befehl SavePosition darf keinesfalls zyklisch aufgerufen werden. Es kann zum gelegentlichen Einrichten der Applikation verwendet werden. 18.4 Lesen der Systemzeit <Time> Lesen der Systemzeit in Sekunden seit dem 01.01.1970 um 00:00 Uhr. Syntax (<Zeitwert> : DINT) := Time ( ) Dieser Befehl liest die aktuelle Systemzeit der Steuerung aus und gibt ihn als DINT-Wert zurück. Beispiel: value := Time() // aktuelle Systemzeit lesen Festo GDCP-CMXR-SW-DE de Version 1.0 153 18. Funktionen 18.5 Umwandeln Zeit in Text <TimeToStr> Umwandeln einer Zeit in einen Text. Syntax (<Zeitstring> : STRING) := TimeToStr (OPT sysTime : DINT) Dieser Befehl kann eine Zeit (Parameter sysTime) in einen formatierten Text mit dem Format „DDD mon dd hh:mm:ss yyyy“ umwandeln. Ohne Parameter sysTime wird die aktuelle Systemzeit formatiert zurückgegeben. Der Parameter sysTime gibt die Zeit in Sekunden seit dem 01.01.1970 um 00:00 Uhr an. Parameter: Parameter Bedeutung Einheit sysTime Optionale Angabe, Zeitwert, der ge- Sekunden wandelt werden soll. Tabelle 18.4 Parameter Funktion TimeStr Beispiel: str_Time := TimeToStr() // aktuelle Systemzeit lesen Rückgabe: str_Time = „Mon Feb 13 11:23:44 2006“ 154 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18.6 Sinus <SIN>, <ASIN> Die Sinus-Funktion stellt den mathematischen Zusammenhang zwischen einem Winkel und den Seiten in einem rechtwinkligen Dreieck her. Für Sinus gilt: sin(alpha) = Gegenkathete / Hypotenuse sin(alpha) = a / c Die Angabe des Winkels erfolgt in der Einheit Grad. Syntax (<Sinuswert> : REAL) := SIN(<Winkel> : REAL) Verwendung: Die Sinus-Funktion dient zur Berechnung von unbekannten Strecken in einem rechtwinkligen Dreieck. Ist der Winkel bekannt und entweder die Gegenkathete oder die Hypotenuse, so lässt sich die unbekannte Strecke berechnen. Soll jedoch der Winkel berechnet werden, so stellt die CMXR die Funktion des Arcus Sinus bereit. Diese Funktion berechnet aus der Gegenkathete und der Hypotenuse den eingeschlossenen Winkel, z. B. Alpha. Syntax (<Winkel in Grad> : REAL) := ASIN(<Sinuswert>) Die Angabe des Winkels erfolgt in Grad. Festo GDCP-CMXR-SW-DE de Version 1.0 155 18. Funktionen Beispiel: a := 30 // Gegenkathete alpha := 23.5 // Winkel Alpha c := a / SIN(alpha) // Berechnung der Hypotenuse a : = 45.89 // Gegenkathete c := 145.67 // Hypotenuse value := a / c alpha := ASIN(value) 18.7 // Berechnung des Winkels Cosinus <COS>, <ACOS> Die Cosinus-Funktion stellt den mathematischen Zusammenhang zwischen einem Winkel und den Seiten in einem rechtwinkligen Dreieck her. Für Cosinus gilt: cos(alpha) = Ankathete / Hypotenuse cos(alpha) = b / c Die Angabe des Winkels erfolgt in der Einheit Grad. Syntax (<Cosinuswert> : REAL) := COS( <Winkel>) Verwendung: Die Cosinus-Funktion dient zur Berechnung von unbekannten Strecken in einem rechtwinkligen Dreieck. Ist der Winkel bekannt und entweder die Ankathete oder die Hypotenuse, so lässt sich die unbekannte Strecke berechnen. Soll jedoch der Winkel berechnet werden, so stellt die CMXR die Funktion des Arcus Cosinus bereit. Diese Funktion berechnet aus der Ankathete und der Hypotenuse den eingeschlossenen Winkel z. B. Alpha. 156 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen Syntax (<Winkel in Grad> : REAL) := ACOS(<Cosinuswert>) Die Rückgabe des Winkels erfolgt in Grad. Beispiel: b := 30 // Ankathete alpha := 23.5 // Winkel Alpha c := b / COS(alpha) // Berechnung der Hypotenuse b := 45.89 // Ankathete c := 145.67 // Hypotenuse value := b / c alpha := ACOS(value) // Berechnung des Winkels Festo GDCP-CMXR-SW-DE de Version 1.0 157 18. Funktionen 18.8 Tangens <TAN>, <ATAN> Die Tangens-Funktion stellt den mathematischen Zusammenhang zwischen einem Winkel und den Seiten in einem rechtwinkligen Dreieck her. Für Tangens gilt: tan(alpha) = Gegenkathete / Ankathete tan(alpha) = a / b Die Angabe des Winkels erfolgt in der Einheit Grad. Syntax (<Tangenswert> : REAL) := TAN( <Winkel>) Verwendung: Die Tangens-Funktion dient zur Berechung von unbekannten Stecken in einem rechtwinkligen Dreieck. Ist der Winkel bekannt und auch entweder die Ankathete oder die Gegenkathete, so lässt sich die unbekannte Strecke berechnen. Soll jedoch der Winkel berechnet werden, so stellt die CMXR die Funktion des Arcus Tangens bereit. Diese Funktion berechnet aus der Ankathete und der Gegenkathete den eingeschlossenen Winkel z. B. Alpha. Syntax (<Winkel in Grad> : REAL) := ATAN(<Tangenswert>) Die Rückgabe des Winkels erfolgt in Grad. Beispiel: a := 30 // Gegenkathete alpha := 23.5 // Winkel Alpha b // Berechnung der Ankathete 158 := a / TAN(alpha) Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen a := 45.89 // Gegenkathete b := 145.67 // Ankathete value := a / b alpha := ATAN(value) // Berechnung des eingeschlossenen Winkels 18.9 Cotangens <COT>, <ACOT> Die Cotangens-Funktion stellt den mathematischen Zusammenhang zwischen einem Winkel und den Seiten in einem rechtwinkligen Dreieck her. Für Cotangens gilt: Cotan(alpha) = Ankathete / Gegenkathete cotan(alpha) = b / a Die Angabe des Winkels erfolgt in der Einheit Grad. Syntax (<Cotangenswert> : REAL) := COT(<Winkel>) Verwendung: Die Cotangens-Funktion dient zur Berechnung von unbekannten Strecken in einem rechtwinkligen Dreieck. Ist der Winkel bekannt und auch entweder die Ankathete oder die Gegenkathete, so lässt sich die unbekannte Strecke berechnen. Soll jedoch der Winkel berechnet werden, so stellt die CMXR die Funktion des Arcus Cotangens bereit. Diese Funktion berechnet aus der Ankathete und der Gegenkathete den eingeschlossenen Winkel z. B. Alpha. Syntax (<Winkel in Grad> : REAL) := ACOT(<Cotangenswert>) Die Rückgabe des Winkels erfolgt in Grad. Festo GDCP-CMXR-SW-DE de Version 1.0 159 18. Funktionen Beispiel: a := 30 // Gegenkathete alpha := 23.5 // Winkel Alpha b := a // Berechnung der Ankathete a := 45.89 // Gegenkathete b := 145.67 // Ankathete * COT(alpha) value := b / a alpha := ACOT(value) // Berechnung eingeschlossener Winkel 18.10 Tangens2 <ATAN2> Berechnet Arcustangens mit der Wertebereichsvergrößerung von + π bis –π. Syntax (<Argument> : REAL) := ATAN2 (<y> : REAL, <x> : REAL) 18.11 Logarithmus <LN> Die Logarithmusfunktion berechnet den natürlichen Logarithmus des übergebenen Argumentes. Syntax (<natürlicher Logarithmus> : REAL) := LN (<Wert> : REAL) 18.12 Exponent <EXP> Die Exponentialfunktion berechnet den Wert e(x). Syntax (<Ergebnis> : REAL) := EXP (<Wert>:REAL) 160 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18.13 Absolutwert <ABS> Die Funktion Absolutwert liefert den absoluten Betrag des übergebenen REAL-Wertes. Der Rückgabewert ist somit immer positiv. Negative Zahlen werden als Betrag (mit positivem Vorzeichen) zurückgegeben. Syntax (<Absolutwert> : REAL) := ABS (<Wert> : REAL) Beispiel Level := 452.98 Level := ABS(Level) // Level hat den absoluten Wert von 452.98 Level := -1056.61 Level := ABS(Level) // Level hat den absoluten Wert von 1056.61 18.14 Quadratwurzel <SQRT> Die Wurzelfunktion ermittelt den Wert der Quadratwurzel eines Ausdrucks. Syntax (<Wurzelwert> : REAL) := SQRT (<Wert> : REAL) Beispiel: Berechnung der Länge c in einem rechtwinkligen Dreieck. Nach dem Satz des Pythagoras gilt: C² = A² + B² oder C = √(A² + B²) Programmbeispiel: a := 152.67 // Länge der Kathete A b := 63.12 // Länge der Kathete B value := a * a + b * b c := SQRT(value) // Berechnung der Hypotenuse Festo GDCP-CMXR-SW-DE de Version 1.0 161 18. Funktionen 18.15 Bitweise schieben <SHR>, <SHL> Mit den Funktionen SHR und SHL können Daten vom Typ DWORD bitweise nach rechts (Funktion SHR) und bitweise nach links (Funktion SHL) geschoben werden. Bits, die auf der einen Seite aus der Variable „herausfallen“, gehen verloren. Auf der anderen Seite werden Bits mit dem Wert "0" aufgefüllt. Syntax (<Variable> :DWORD) := SHR (<Wert : DWORD>, <count> : DINT) (<Variable> :DWORD) := SHL (<Wert : DWORD>, <count> : DINT) Beispiel: Mit der Anweisung Mask := SHL(Mask, 3) wird der Inhalt der Variable Mask um 3 Bit nach links geschoben. Auf der rechten Seite werden 3 Bit mit dem Wert "0" eingeschoben. Inhalt der Variable: 1001 1111 0000 1100 1111 1111 1001 1100 Es ergibt sich das Bitmuster: 1111 1000 0110 0111 1111 1100 1110 0000 Mit der Anweisung Mask := SHR(Mask, 3) wird der Inhalt der Variable Mask um 3 Bit nach rechts geschoben. Auf der linken Seite werden 3 Bit mit dem Wert 0 eingeschoben. Inhalt der Variable: 1001 1111 0000 1100 1111 1111 1001 1100 Es ergibt sich das Bitmuster: 0001 0011 1110 0001 1001 1111 1111 0011 162 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18.16 Bitweise rotieren <ROR>, <ROL> Mit den Funktionen ROR und ROL können Daten vom Typ DWORD bitweise nach rechts (Funktion ROR) und bitweise nach links (Funktion ROL) rotiert werden. Beim Rotieren des Bitmusters wird das heraus fallende Bit auf der anderen Seite wieder eingefügt. Syntax (<Variable> : DWORD) := ROR (<Wert : DWORD>, <count> : DINT) (<Variable> : DWORD) := ROL (<Wert : DWORD>, <count> : DINT) Beispiel: Mit der Anweisung Mask := ROL(Mask, 4) wird der Inhalt der Variable Mask um 4 Bit nach links rotiert. Auf der rechten Seite werden die 4 Bits wieder eingefügt. Inhalt der Variable: 1011 1111 0110 1001 0011 000 1001 1010 Es ergibt sich das Bitmuster: 1111 0110 1001 0011 000 1001 1010 1011 Mit der Anweisung Mask := ROR(Mask, 4) wird der Inhalt der Variable Mask um 4 Bit nach rechts rotiert. Auf der linken Seite werden die 4 Bits wieder eingefügt. Inhalt der Variable: 1011 1111 0110 1001 0011 000 1001 1010 Es ergibt sich das Bitmuster: 1010 1011 1111 0110 1001 0011 000 1001 Festo GDCP-CMXR-SW-DE de Version 1.0 163 18. Funktionen 18.17 Wert nach String wandeln <STR> Wandelt einen beliebigen Datentyp in einen String um. Syntax (<Variable> : STRING) := STR (<Wert> : ANY) Beispiel: Mit der Anweisung STR wird der Wert der Variable Real1 in einen String gewandelt. Real1 := 25.5 String1 := STR(Real1) String1 hat nun den Wert „25.500000“. 18.18 ASCII Wert in Zeichen wandeln <CHR> Wandelt einen ASCII Wert in ein einzelnes Zeichen um. Syntax (<Variable> : STRING) := CHR (<Wert> : DINT / DWORD) Beispiel: Mit der folgenden Anweisung enthält die Variable String1 den Wert „a“. String1 := CHR(97) 18.19 Zeichen in ASCII Wert wandeln <ORD> Wandelt ein einzelnes Zeichnen in den ASCII Wert um. Syntax (<Variable> : DINT / DWORD) := ORD (<Wert> : STRING) Beispiel: Mit der folgenden Anweisung enthält die Variable Dint1 den Wert 65. Dint1 := ORD(“A“) 164 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18.20 Bit in einer WORD Variable setzen <SetBit> Die Funktion SetBit setzt innerhalb einer DWORD Variable ein gewähltes Bit auf den Wert TRUE. Besitzt das Bit bereits den Wert TRUE, so hat dies keine weiteren Auswirkungen. Der veränderte Wert steht im Rückgabewert zur weiteren Bearbeitung zur Verfügung. Syntax SetBit ( <val> : DWORD, <bitNr> : DINT): DWORD Methode Beschreibung val Wert, der verändert werden soll bitNr Bitnummer in Parameter Val, die gesetzt wird Tabelle 18.5 Variable Funktion SetBit Die Bitnummer wird über den Parameter bitNr angegeben. Der dafür zulässige Wertebereich ist von 0 bis 31 um die Bits der WORD Variable (32 Bit) zu referenzieren. Das niederwertigste Bit (LSB) wird mit der Bitnummer = 0 angesprochen. Rückgabewert Ausgabe des bearbeiteten Bitmuster der Variable val. Fehlerbehandlung Wird im Parameter bitNr ein unzulässiger Wert übergeben, so wird ein Fehler ausgelöst. Beispiel: // Variable auf 0 setzen mask := 16#0000 // das dritte Bit auf TRUE setzen mask := SetBit(mask, 2) // mask besitzt den Wert 2#0000 0100 Festo GDCP-CMXR-SW-DE de Version 1.0 165 18. Funktionen 18.21 Bit in einer WORD Variable löschen <ResetBit> Die Funktion ResetBit setzt innerhalb einer DWORD Variable ein gewähltes Bit auf den Wert FALSE. Besitzt das Bit bereits den Wert FALSE, so hat dies keine weiteren Auswirkungen. Der veränderte Wert steht im Rückgabewert zur weiteren Bearbeitung zur Verfügung. Syntax ResetBit ( <val> : DWORD, <bitNr> : DINT): DWORD Methode Beschreibung val Wert, der verändert werden soll bitNr Bitnummer in Parameter Val, die zurück gesetzt wird Tabelle 18.6 Variable Funktion ResetBit Die Bitnummer wird über den Parameter bitNr angegeben. Der dafür zulässige Wertebereich ist von 0 bis 31 um die Bits der WORD Variable (32 Bit) zu referenzieren. Das niederwertigste Bit (LSB) wird mit der Bitnummer = 0 angesprochen. Rückgabewert Ausgabe des bearbeiteten Bitmuster der Variable val. Fehlerbehandlung Wird im Parameter bitNr ein unzulässiger Wert übergeben, so wird ein Fehler ausgelöst. Beispiel: // Variable auf 2#0000 1111 setzen mask := 16#000F // das erste Bit auf FALSE setzen mask := ResetBit(mask, 0) // mask besitzt den Wert 2#0000 1110 166 Festo GDCP-CMXR-SW-DE de Version 1.0 18. Funktionen 18.22 Bit in einer WORD Variable prüfen <CheckBit> Die Funktion CheckBit prüft das unter der Bitnummer angegebene Bit und gibt dessen Wert im Rückgabewert zurück. Syntax CheckBit ( <val> : DWORD, <bitNr> : DINT): BOOL Methode Beschreibung val Wert, der geprüftt werden soll bitNr Bitnummer in Parameter Val, die geprüft wird Tabelle 18.7 Variable Funktion CheckBit Die Bitnummer wird über den Parameter bitNr angegeben. Der dafür zulässige Wertebereich ist von 0 bis 31 um die Bits der WORD Variable (32 Bit) zu referenzieren. Das niederwertigste Bit (LSB) wird mit der Bitnummer = 0 angesprochen. Rückgabewert TRUE Das Bit ist gesetzt. FALSE Das Bit ist nicht gesetzt. Fehlerbehandlung Wird im Parameter bitNr ein unzulässiger Wert übergeben, so wird ein Fehler ausgelöst. Beispiel IF CheckBit(mask, 1) THEN // Zustand TRUE SetInfo(„Bit 1 ist gesetzt“) ELSE // Zustand FALSE SetInfo(„Bit 1 ist nicht gesetzt“) END_IF Festo GDCP-CMXR-SW-DE de Version 1.0 167 19. Bausteine 19. Bausteine Die FTL Sprache verfügt über die Möglichkeit, Bausteine zu verwenden. Bausteine besitzen neben Daten auch Bestandteile in Form von Programmcode, um eine bestimmte Funktionalität zu erzielen. Um mit einem Baustein in FTL zu kommunizieren, besitzt dieser Ein- und Ausgangsdaten. Grafische Darstellung eines Bausteins: Baustein: Analogwert Eingangsdaten des Bausteins Interner Programmcode Ausgangsdaten des Bausteins Die Anzahl der Ein- / Ausgangsdaten eines Bausteins, sind in FTL in einem Datentyp hinterlegt. Um nun einen Baustein in der Applikation zu benützen, muss dieser deklariert werden. Bei einem Baustein spricht man von einer Instanziierung. Dabei wird unter dem frei wählbaren Bausteinnamen (Bezeichner) eine Kopie der Bausteinhülle angelegt. Die Bausteinhülle umfasst dabei die Ein- und Ausgangsdaten sowie interne Programmdaten. Der eigentliche Programmcode existiert nur einmal. Betriebssystem Bausteintyp Analogwert FTL-Programm Druck : Typ Analogwert Gewicht : Typ Analogwert Bausteininstanzen im Applikationsprogramm Deklaration einer Bausteininstanz <Instanzname> : <Instanztyp> ( Parameter ) 168 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Gleich wie Variablen, werden die Instanzen in der zugehörigen Datendatei abgespeichert. Beispiel einer Instanz Sensor : AIN(…) Je nach Bausteintyp werden diesem bei der Deklaration Daten mitgegeben z. B. der Name eines Hardwaresignals. Die Dokumentation der Bausteine ist den folgenden Kapiteln zu entnehmen. 19.1 Funktionen Um auf Daten eines Bausteines zuzugreifen oder Funktionalitäten in Anspruch zu nehmen, werden Bausteinfunktionen angeboten. Der Zugriff auf die Funktionen des Bausteins erfolgt über den Instanznamen und den Punkt-Operator. Zugriff auf Bausteinfunktionen <Instanzname> . <Funktionsname> Im Beispiel wird auf die Bausteinfunktion Read der Instanz Sensor zugegriffen: merker := Sensor.Read() Bei manchen Funktionen können Parameter übergeben werden. Näheres ist in den folgenden Kapiteln der einzelnen Bausteine beschrieben. 19.2 Variable Neben Funktionen können Bausteine auch Variable enthalten. Mit diesen Bausteinvariablen kann auf Daten des Bausteins zugegriffen werden. Der Zugriff auf die Variablen des Bausteins erfolgt über den Instanznamen und den Punkt-Operator. Zugriff auf Bausteinvariable <Instanzname> . <Variablenname> Der Zugriff auf die Daten kann bei bestimmten Bausteinen über Variable und Funktionen erfolgen, sie liefern das gleiche Ergebnis. Beide Zugriffsarten haben unterschiedliche Laufzeiten. Näheres ist im Kapitel der einzelnen Bausteine beschrieben. Im Beispiel wird auf die Bausteinvariable State der Instanz Sensor zugegriffen: IF Sensor.state THEN Lin(pos1) ELSE Festo GDCP-CMXR-SW-DE de Version 1.0 169 19. Bausteine Lin(pos2) END_IF Empfehlung: Wenn der Zugriff über eine Variable erfolgen kann, sollte diese Variante bevorzugt werden, sie benötigt weniger Laufzeit. 19.3 Laufzeitverhalten Das FTL-Programm läuft nicht zyklisch, sondern wird sequentiell Anweisung für Anweisung abgearbeitet. Dieses Verhalten ist jedoch für einige Applikationen nicht ausreichend. Soll z. B. eine Prüfung parallel zum aktiven Bewegungsprogramm vorgenommen werden, ob es an einem Eingang einen Flankenwechsel gegeben hat, so müsste dies aufwendig in einem parallelen Programm gemacht werden. Um nun ein Bearbeiten eines Bausteins optimal und komfortabel zu gestalten, laufen einige Bausteine im Betriebssystem zyklisch. Der Anwender kann dann mit den Methoden oder Variablen auf die Ergebnisse des Bausteins zugreifen. 19.3.1 Parameter ovlEnable Einige Methoden der folgenden Bausteine besitzen einen optionalen Parameter ovlEnable. Dieser Parameter regelt den Abfragezeitpunkt des digitalen Eingangssignals. Der Parameter ist vom Typ BOOL, ihm kann der Zustand TRUE oder FALSE übergeben werden. Zustand FALSE Der Satzvorlauf wird an dieser Stelle gestoppt. Erreicht der Satzhauptlauf diese Programmanweisung, dann wird das Signal ausgelesen bzw. ausgeführt. Die Bewegung wird gestoppt und nach dem Befehl wieder beschleunigt. Ein Überschleifen auf folgende Bewegungen ist nicht möglich. Zustand TRUE Wird dem Parameter ovlEnable der Zustand TRUE übergeben, so wird zum spätesten Zeitpunkt das Signal ausgelesen bzw. ausgeführt, bei dem die Bewegung noch fortgeführt werden kann. Die Bewegung wird nicht gestoppt, sondern kontinuierlich fortgeführt. Ein Überschleifen auf folgende Bewegungen ist möglich. Hinweis Wird der Parameter nicht angegeben, so wird FALSE angenommen. 170 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine 19.4 Digitaler Eingangsbaustein DIN Der Baustein DIN dient zur Abfrage und Verwaltung eines digitalen Eingangs. 19.4.1 Instanziierung Zur Instanziierung des digitalen Eingangsbausteins wird der Hardwarebezug zum digitalen Eingang benötigt. Dieser wird über den Parameter <input> bei der Instanziierung angegeben. Syntax <Instanzname> .DIN( <Timeout> : DINT, <RisingEdge> : BOOL, <Input> : MAPTO DINPORT) Es können weitere Parameter angegeben werden, um z. B. Voreinstellungen zu treffen. Dies ist jedoch zur Instanziierung nicht notwendig und kann im Programm erfolgen. Beispiel: Ein Sensor wird als Bausteininstanz angelegt: Instanziierung in der Datendatei Sensor : DIN := (-1, FALSE, MAP(Input1)) Instanziierung mit dem FTL-Editor Die Instanziierung erfolgt im Dialog zum Anlagen von Variablen durch Auswahl des <Typ:> (DIN) und Eingabe des <Bezeichner:> (Sensor). In der Zeile <MAPTO DINPORT> wird der reale Bezug zu einen konfigurierten Digitalen Eingang hergestellt. Festo GDCP-CMXR-SW-DE de Version 1.0 171 19. Bausteine Instanziierung mit dem Handbediengerät Die Instanziierung des digitalen Eingangsbausteins mit dem Handbediengerät erfolgt in der Variablenmaske durch Auswahl des Datentyps DIN. Der Eintrag wird automatisch im Datenfile gespeichert. Der digitale Eingangsbaustein besitzt folgende Variablen: Variable Typ Bedeutung Zustand beim Anlegen Timeout REAL Timeout zum Warten bei den Befehlen Wait und WaitN. -1 -1 = kein Timeout (unendlich warten) 0 = sofortige Überprüfung >0 = Timeout in Millisekunden RisingEdge BOOL Zustand der steigenden Flanke FALSE Input DINPORT Verweis auf den Hardwareeingang --- Tabelle 19.1 Variablen digitaler Eingangsbaustein Timeout Mit dem Parameter Timeout kann eine Wartezeit definiert werden. Die Methode des Bausteins wartet die eingestellte Zeit, auf den angeforderten Signalzustand. Steht der Wert auf -1, so erfolgt ein unendliches Warten. Wird ein Wert > 0 angegeben, so wird max. diese Zeit abgewartet. Ist die Wartezeit abgelaufen, ohne dass der gewünschte Signalzustand eingetreten ist, wird der Programmablauf fortgesetzt. Eine Fehlermeldung muss vom Ablaufprogramm selbst erzeugt werden. Wird als Wert 0 angegeben, so erfolgt eine sofortige Prüfung. Falls das Signal nicht den gewünschten Wert besitzt, muss vom Ablaufprogramm eine Fehlermeldung generiert werden. Weitere Informationen und ein Beispiel zum erzeugen der Fehlermeldung sind im Kapitel 24.2 Arbeiten mit Ein- und Ausgangsbausteinen beschrieben. 172 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine RisingEdge Obwohl der Baustein nicht aufgerufen wird, speichert er den Zustand einer steigenden Flanke. Dieser Zustand kann im Programm ausgewertet werden. Input Die Variable Input beschreibt den Verweis auf den Hardwareeingang des Bausteins. 19.4.2 Methoden Der Baustein verfügt über mehrere Methoden: Methode Beschreibung Wait warten, bis Eingang Zustand TRUE besitzt WaitN warten, bis Eingang Zustand FALSE besitzt Read Zustand des Eingangs lesen RisingEdge Zustand steigende Flanke lesen ResetRisingEdge Zustand steigende Flanke rücksetzen Tabelle 19.2 Methoden digitaler Eingangsbaustein DIN Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und kann dort ausgewählt werden. Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „Digitale Eingänge“ ausgewählt werden. Die Abbildung zeigt die Auswahl der Methoden des Bausteins DIN am Handbediengerät. Festo GDCP-CMXR-SW-DE de Version 1.0 173 19. Bausteine 19.4.3 Auf Zustand warten, Methode Wait / WaitN Mit den Methoden Wait und WaitN kann im FTL-Programm gewartet werden, bis der Eingang den Wert TRUE oder FALSE besitzt. Der eventuell gesetzte Timeout wird dabei berücksichtigt. Syntax <Instanzname>.Wait (OPT ovlEnable : BOOL) <Instanzname>.WaitN (OPT ovlEnable : BOOL) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Beispiel: Ptp(pos0) sensor.Wait() // warten Signal TRUE, Bewegung gestoppt Ptp(pos1) sensor.WaitN(TRUE) // warten Signal FALSE, kein Stop Ptp(pos2) 19.4.4 Zustand Lesen Methode Read Mit der Methode Read kann der aktuelle Zustand des Einganges gelesen werden. Als Rückgabewert wird der Zustand TRUE oder FALSE zurückgegeben. Synatx <Instanzname>.Read (OPT ovlEnable: BOOL) : BOOL Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Beispiel: value := sensor.Read() 19.4.5 Steigende Flanke Methode RisingEdge Mit der Methode RisingEdge kann abgefragt werden, ob es am Eingang eine steigende Flanke gab, die gespeichert wurde. Der Rückgabewert ist auch dann TRUE, wenn der Eingang inzwischen den Zustand FALSE besitzt. Der Zustand der Flanke wird unabhängig vom Zyklus des FTL-Programms ermittelt und läuft in einem eigenen Zyklus ab. 174 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Syntax <Instanzname>.RisingEdge (OPT ovlEnable: BOOL) : BOOL Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Beispiel: value := sensor.RisingEdge() 19.4.6 Flanke rücksetzen Methode ResetRisingEdge Diese Methode setzt den internen Merker der steigenden Flanke zurück. Dies ist dann erforderlich, wenn mit der Methode RisingEdge eine steigende Flanke abgeprüft werden soll. Syntax <Instanzname>.ResetRisingEdge() Hinweis Ist der Wert des digitalen Eingangs zum Zeitpunkt der Ausführung dieses Befehls gesetzt, so wird der Flankenerkennungszustand zurückgesetzt und nicht neuerlich gesetzt. Erst nachdem abermals eine positive Flanke (Zustandsänderung des Eingangs von 0 auf 1) auf dem Eingang aufgetreten ist, wird der Flankenerkennungszustand wieder gesetzt. Beispiel: sensor.ResetRisingEdge() value := sensor.RisingEgde() 19.5 Digitaler Ausgangsbaustein DOUT Der Baustein DOUT dient zur Abfrage und Verwaltung eines digitalen Ausganges. 19.5.1 Instanziierung Zur Instanziierung des digitalen Ausgangsbausteins wird der Hardwarebezug zum digitalen Ausgang benötigt. Dieser wird über den Parameter <output> bei der Instanziierung angegeben. Syntax <Instanzname> .DOUT( <Timeout> : DINT, <RisingEdge> : BOOL, <Output> : MAPTO DOUTPORT) Festo GDCP-CMXR-SW-DE de Version 1.0 175 19. Bausteine Es können weitere Parameter angegeben werden, um z. B. Voreinstellungen zu treffen. Dies ist jedoch zur Instanziierung nicht notwendig und kann im Programm erfolgen. Beispiel: Ein Zylinder wird als Bausteininstanz angelegt: Instanziierung in der Datendatei cylinder : DOUT := (-1,FALSE, MAP(Output3)) Instanziierung mit dem FTL-Editor Die Instantiierung erfolgt im Dialog zum Anlagen von Variablen durch Auswahl des <Typ:> (DOUT) und Eingabe des <Bezeichner:> (Cylinder). In der Zeile <MAPTO DOUTPORT> wird der reale Bezug zu einen konfigurierten Digitalen Ausgang hergestellt. Instanziierung mit dem Handbediengerät Die Instanziierung des digitalen Ausgangsbausteins mit dem Handbediengerät erfolgt in der Variablenmaske durch Auswahl des Datentyps DOUT. Mit der Instanziierung am Handbediengerät wird der Eintrag im Datenfile automatisch gespeichert. 176 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine 19.5.2 Variable Der digitale Ausgangsbaustein besitzt folgende Variablen: Variable Typ Bedeutung Zustand beim Anlegen Timeout REAL Timeout zum Warten bei den Befehlen Wait und WaitN. -1 -1 = kein Timeout (unendlich warten) 0 = sofortige Überprüfung >0 = Timeout in Millisekunden RisingEdge BOOL Zustand der steigenden Flanke FALSE Output DOUTPORT Verweis auf den Hardwareausgang --- Tabelle 19.3 Variablen digitaler Ausgangsbaustein Timeout Mit dem Parameter Timeout kann eine Wartezeit definiert werden. Die Methode des Bausteins wartet die eingestellte Zeit, auf den angeforderten Signalzustand. Steht der Wert auf -1, so erfolgt ein unendliches Warten. Wird ein Wert > 0 angegeben, so wird max. diese Zeit abgewartet. Ist die Wartezeit abgelaufen, ohne dass der gewünschte Signalzustand eingetreten ist, wird der Programmablauf fortgesetzt. Eine Fehlermeldung muss vom Ablaufprogramm selbst erzeugt werden. Wird als Wert 0 angegeben, so erfolgt eine sofortige Prüfung. Falls das Signal nicht den gewünschten Wert besitzt, muss vom Ablaufprogramm eine Fehlermeldung generiert werden. Weitere Informationen und ein Beispiel zum erzeugen der Fehlermeldung sind im Kapitel 24.2 Arbeiten mit Ein- und Ausgangsbausteinen beschrieben. RisingEdge Obwohl der Baustein nicht aufgerufen wird, speichert er den Zustand einer steigenden Flanke. Dieser Zustand kann im Programm ausgewertet werden. Output Die Variable Output beschreibt den Verweis auf den Hardwareausgang des Bausteins. Festo GDCP-CMXR-SW-DE de Version 1.0 177 19. Bausteine 19.5.3 Methoden Der Baustein verfügt über mehrere Methoden: Methode Beschreibung Wait Warten, bis Ausgang den Wert TRUE besitzt WaitN Warten, bis Ausgang den Wert FALSE besitzt Read Ausgangswert lesen RisingEdge Zustand steigende Flanke lesen ResetRisingEdge Zustand steigende Flanke rücksetzen Set Ausgang setzen, Zustand TRUE Reset Ausgang rücksetzen, Zustand FALSE Write Ausgang auf angegebenen Wert setzen Tabelle 19.4 Methoden digitaler Ausgangsbaustein DOUT Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „Digitale Ausgänge“ ausgewählt werden. Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und können dort ausgewählt werden. Die Abbildung zeigt die Auswahl von Methoden des Bausteins DOUT am Handbediengerät. 178 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine 19.5.4 Auf Zustand warten, Methode Wait / WaitN Mit den Methoden Wait und WaitN kann im FTL-Programm gewartet werden, bis der Ausgang den Wert TRUE oder FALSE besitzt. Der eventuell gesetzte Timeout wird dabei berücksichtigt. Syntax <Instanzname>.Wait (OPT ovlEnable : BOOL) <Instanzname>.WaitN (OPT ovlEnable : BOOL) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Beispiel: Ptp(pos0) cylinder.Wait() // warten Ausgang TRUE, Bewegung gestoppt Ptp(pos1) cyinder.WaitN(TRUE) // warten Ausgang FALSE, kein Stop Ptp(pos2) 19.5.5 Zustand Lesen Methode Read Mit der Methode Read kann der aktuelle Zustand des Ausganges gelesen werden. Als Rückgabewert wird der Zustand TRUE oder FALSE zurückgegeben. Syntax <Instanzname>.Read ( OPT ovlEnable: BOOL) : BOOL Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Beispiel: value := cylinder.Read() 19.5.6 Steigende Flanke, Methode RisingEdge Mit der Methode RisingEdge kann abgefragt werden, ob es am Ausgang eine steigende Flanke gab, die gespeichert wurde. Der Rückgabewert ist auch dann TRUE, wenn der Ausgang inzwischen den Zustand FALSE besitzt. Der Zustand der Flanke wird unabhängig vom Zyklus des FTL-Programms ermittelt und läuft in einem eigenen Zyklus ab. Syntax <Instanzname>.RisingEdge (OPT ovlEnable: BOOL) : BOOL Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Festo GDCP-CMXR-SW-DE de Version 1.0 179 19. Bausteine Beispiel: value := cylinder.RisingEdge() 19.5.7 Flanke rücksetzen, ResetRisingEdge Diese Methode setzt den internen Merker der steigenden Flanke zurück. Dies ist dann erforderlich, wenn mit der Methode RisingEdge eine steigende Flanke abgeprüft werden soll. Syntax <Instanzname>.ResetRisingEdge() Hinweis Ist der Wert des digitalen Ausgangs zum Zeitpunkt der Ausführung dieses Befehls gesetzt, so wird der Flankenerkennungszustand zurückgesetzt und nicht neuerlich gesetzt. Erst nachdem abermals eine positive Flanke (Zustandsänderung des Ausgangs von 0 auf 1) auf dem Ausgang aufgetreten ist, wird der Flankenerkennungszustand wieder gesetzt. Beispiel: cylinder.ResetRisingEdge() value := cylinder.RisingEgde() 19.5.8 Setzen und rücksetzen, Methode Set / Reset Mit den Methoden Set wird ein Ausgang gesetzt (Zustand TRUE) und mit Reset zurückgesetzt (Zustand FALSE). Syntax <Instanzname>.Set ( ) <Instanzname>.Reset ( ) Set und Reset werden im Hauptlauf ausgeführt. Das Überschleifen wird durch den Baustein NICHT beeinflusst. Beispiel: Lin(pos1) Lin(pos2) cylinder.Set() // setzt Ausgang cylinder auf TRUE Lin(pos3) 180 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine cylinder.Reset() // setzt Ausgang cylinder auf FALSE Lin(pos4) 19.5.9 Setzen des Ausgangs, Methode Write Mit der Methode Write kann der Zustand eines Ausgangs beschrieben werden. Der gewünschte Zustand TRUE oder FALSE wird dabei als Parameter übergeben. Die Funktionsweise von Write ist die gleiche wie bei den Methoden Set und Reset. Syntax <Instanzname>.Write (Value: BOOL) Die Methode Write wird im Hauptlauf ausgeführt. Das Überschleifen wird durch den Baustein NICHT beeinflusst. Beispiel: cylinder.Write(TRUE) // setzt Ausgang cylinder auf TRUE state := FALSE cylinder.Write(state) // setzt Ausgang cylinder auf FALSE 19.5.10 Setzen des Ausgangs auf bestimmte Dauer, Methode Pulse Die Methode Pulse setzt einen Ausgang für eine bestimmte Dauer auf TRUE. Die Ausführung von Pulse erfolgt im Hauptlauf und beeinflusst das Überschleifen nicht. Syntax <Instanzname>.Pulse (timeMs :DINT; OPT pauseAtInterrupt: BOOL) Parameter Typ Bedeutung timeMs DINT Zeit für die Impulslänge in msec pauseAtInterrupt BOOL Anhalten der Impulszeit, wenn Programm gestoppt Tabelle 19.5 Parameter Methode Pulse Die Methode Pulse steuert einen digitalen Ausgang mit einem Puls bestimmter Länge an. Die Länge des Pulses wird dabei in Millisekunden angegeben werden. Dabei wird zu Beginn des Pulses der Ausgang immer auf TRUE gesetzt und am Ende immer auf FALSE gesetzt. Besitzt der Ausgang jedoch schon den Zustand TRUE, so wird dieser nach Ablauf der Impulszeit zurückgesetzt. Festo GDCP-CMXR-SW-DE de Version 1.0 181 19. Bausteine Mit dem optionalen Parameter „pauseAtInterrupt“ kann angegeben werden, wie die Reaktion im Falle eines Stopp des FTL Programm erfolgt. Wir dieser Parameter nicht angegeben, so wird intern der Zustand FALSE gesetzt. pauseAtInterruppt = TRUE: Mit TRUE wird der Impulszeit angehalten und der Ausgang auf den Wert FALSE gesetzt. Wird das FTL Programm fortgesetzt, so wie der Ausgang für die restliche verbleibende Zeit erneut auf TRUE gesetzt. Nach Ablauf der Impulszeit erfolgt ein Setzen auf den Zustand FALSE. pauseAtInterruppt = FALSE: Ist der optionale Parameter nicht oder FALSE angegeben, so wird der Impuls nach Start bis zum Ende ausgeführt. Ein Stopp des FTL Programm hat keine Auswirkungen. Hinweis Wird ein gestopptes FTL Programm entladen, so wird Impulsfunktion automatisch beendet und der Ausgang FALSE gesetzt. Beispiel: // setzt Ausgang cylinder für 200msec auf TRUE cylinder.Pulse(200) 19.6 Analoger Eingangsbaustein AIN Der Baustein AIN dient zur Abfrage und Verwaltung eines analogen Einganges. 19.6.1 Instanziierung Zur Instanziierung des analogen Eingangsbausteins wird der Hardwarebezug zum analogen Eingang benötigt. Dieser wird über den Parameter Input bei der Instanziierung angegeben. Syntax <Instanzname> .AIN( <Timeout> : DINT, <port> : MAPTO AINPORT) Der Parameter input ist der Name, mit dem der Hardwareeingang bezeichnet ist. Diese Zuweisung stellt einen Bezug des Bausteins zur Handware her. Es können weitere Parameter angegeben werden, um z. B. Voreinstellungen zu treffen. Dies ist jedoch zur Instanziierung nicht notwendig und kann im Programm erfolgen. Beispiel: Ein Sensor wird als Bausteininstanz angelegt: 182 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Instanziierung in der Datendatei temperature : AIN := (-1, MAP(Sensor1)) Instanziierung mit dem FTL-Editor Die Instanziierung erfolgt im Dialog zum Anlagen von Variablen durch Auswahl des <Typ:> (AIN) und Eingabe des <Bezeichner:> (ainTemperature). In der Zeile <MAPTO AINPORT> wird der reale Bezug zu einen konfigurierten Analogen Eingang hergestellt. Instanziierung mit dem Handbediengerät Die Instanziierung des analogen Eingangsbausteins mit dem Handbediengerät erfolgt in der Variablenmaske durch Auswahl des Datentyps AIN. Mit der Instanziierung am Handbediengerät wird der Eintrag im Datenfile automatisch gespeichert. Festo GDCP-CMXR-SW-DE de Version 1.0 183 19. Bausteine 19.6.2 Variable Der analoge Eingangsbaustein besitzt folgende Variablen: Variable Typ Bedeutung Zustand beim Anlegen Timeout REAL Timeout zum Warten bei den Befehlen WaitLss, WaitGrt, -1 WaitIns und Waitouts. -1 = kein Timeout (unendlich warten) 0 = sofortige Überprüfung >0 = Timeout in Millisekunden Input AINPORT Verweis auf den Hardwareeingang --- Tabelle 19.6 Variablen analoger Eingangsbaustein Timeout Mit dem Parameter Timeout kann eine Wartezeit definiert werden. Die Methode des Bausteins wartet die eingestellte Zeit, auf den angeforderten Signalzustand. Steht der Wert auf -1, so erfolgt ein unendliches Warten. Wird ein Wert > 0 angegeben, so wird max. diese Zeit abgewartet. Ist die Wartezeit abgelaufen, ohne dass der gewünschte Signalzustand eingetreten ist, wird der Programmablauf fortgesetzt. Eine Fehlermeldung muss vom Ablaufprogramm selbst erzeugt werden. Wird als Wert 0 angegeben, so erfolgt eine sofortige Prüfung. Falls das Signal nicht den gewünschten Wert besitzt, muss vom Ablaufprogramm eine Fehlermeldung generiert werden. Weitere Informationen und ein Beispiel zum erzeugen der Fehlermeldung sind im Kapitel 24.2 Arbeiten mit Ein- und Ausgangsbausteinen beschrieben. Input Die Variable Input beschreibt den Verweis auf den Hardwareeingang des Bausteins. 19.6.3 Methoden Der Baustein verfügt über mehrere Methoden: Methode Beschreibung WaitLss Warten, bis Eingangswert kleiner als angegeben WaitGrt Warten bis Eingangswert größer als angegeben WaitIns Warten, bis Eingangswert innerhalb der angegebenen Grenze WaitOuts Waten, bis Eingangswert außerhalb der angegebenen Grenze Read Eingangswert lesen Tabelle 19.7 Methoden analoger Eingangsbaustein 184 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und können dort ausgewählt werden. Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „Analoge Eingänge“ ausgewählt werden. Die Abbildung zeigt die Auswahl von Methoden des Bausteins AIN am Handbediengerät. 19.6.4 Warten bis Wert kleiner/größer, Methode WaitLss , WaitGrt Die Methoden WaitLss und WaitGrt ermöglichen ein Abfragen eines analogen Einganges auf einen Zustand größer oder kleiner des angegebenen Wertes. Der Parameter Timeout des Bausteins wird dabei berücksichtigt. Syntax <Instanzname>.WaitLss(value : REAL, OPT ovlEnable : BOOL) <Instanzname>.WaitGrt(value : REAL, OPT ovlEnable : BOOL) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Parameter Typ Bedeutung value REAL Grenzwert Tabelle 19.8 Parameter Methoden WaitLss, WaitGrt Beispiel: Lin(pos1) temperature.WaitLss(65.0, TRUE) Lin(pos2) Festo GDCP-CMXR-SW-DE de Version 1.0 185 19. Bausteine 19.6.5 Warten bis Wert im/aus Bereich, Methode WaitIns, WaitOuts Mit den Methoden WaitIns und WaitOuts kann gewartet werden, bis sich der analoge Eingangswert innerhalb oder außerhalb des angegebenen Wertebereiches befindet. Der Parameter Timeout des Bausteins wird dabei berücksichtigt. Syntax <Instanzname>.WaitIns( minValue : REAL, maxValue : REAL, OPT ovlEnable : BOOL) <Instanzname>.WaitOuts( minValue : REAL, maxValue : REAL, OPT ovlEnable : BOOL) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Parameter Typ Bedeutung minValue REAL Unterer Grenzwert maxValue REAL Oberer Grenzwert Tabelle 19.9 Parameter Methoden WaitIns, WaitOuts Beispiel Lin(pos1) // warten bis Temperatur innerhalb der Grenzen temperature.WaitIns(50.0, 55.0, TRUE) Lin(pos2) 19.6.6 Abfragen des Wertes, Methode Read Die Methode Read liest den aktuellen Wert des analogen Einganges ein. Syntax <Instanzname>.Read(OPT ovlEnable) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. 186 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Beispiel Lin(pos1) // lesen der Temperatur ohne Stopp auf der Bahn value := temperature.Read(TRUE) Lin(pos2) 19.7 Analoger Ausgangsbaustein AOUT Der Baustein AOUT dient zur Abfrage und Verwaltung eines analogen Ausganges. 19.7.1 Instanziierung Zur Instanziierung des analogen Ausgangsbausteins wird der Hardwarebezug zum analogen Ausgang benötigt. Dieser wird über den Parameter <port> bei der Instanziierung angegeben. Syntax <Instanzname> .AOUT( <Timeout> : DINT, <port> : MAPTO AOUTPORT)) Es können weitere Parameter angegeben werden, um z. B. Voreinstellungen zu treffen. Dies ist jedoch zur Instanziierung nicht notwendig und kann im Programm erfolgen. Beispiel: Eine Mengenvorgabe wird als Bausteininstanz angelegt: Instanziierung in der Datendatei quantity : AOUT := (-1, MAP(SetValue)) Instanziierung mit dem FTL-Editor Die Instanziierung erfolgt im Dialog zum Anlagen von Variablen durch Auswahl des <Typ:> (AOUT) und Eingabe des <Bezeichner:> (aoutQuantity). In der Zeile <MAPTO AOUTPORT> wird der reale Bezug zu einen konfigurierten Analogen Ausgang hergestellt. Festo GDCP-CMXR-SW-DE de Version 1.0 187 19. Bausteine Instanziierung mit dem Handbediengerät Die Instanziierung des analogen Ausgangsbausteins mit dem Handbediengerät erfolgt in der Variablenmaske durch Auswahl des Datentyps AOUT. Mit der Instanziierung am Handbediengerät wird der Eintrag im Datenfile automatisch gespeichert. 19.7.2 Variable Der analoge Ausgangsbaustein besitzt folgende Variablen: Variable Typ Bedeutung Zustand beim Anlegen Timeout REAL Timeout zum Warten bei den Befehlen WaitLss, WaitGrt, -1 WaitIns und Waitouts. -1 = kein Timeout (unendlich warten) 0 = sofortige Überprüfung >0 = Timeout in Millisekunden Output AOUTPORT Verweis auf den Hardwareausgang --- Tabelle 19.10 Variablen analoger Ausgangsbaustein Timeout Mit dem Parameter Timeout kann eine Wartezeit definiert werden. Die Methode des Bausteins wartet die eingestellte Zeit, auf den angeforderten Signalzustand. Steht der Wert auf -1, so erfolgt ein unendliches Warten. Wird ein Wert > 0 angegeben, so wird max. diese Zeit abgewartet. Ist die Wartezeit abgelaufen, ohne dass der gewünschte Signalzustand eingetreten ist, wird der Programmablauf fortgesetzt. Eine Fehlermeldung muss vom Ablaufprogramm selbst erzeugt werden. 188 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Wird als Wert 0 angegeben, so erfolgt eine sofortige Prüfung. Falls das Signal nicht den gewünschten Wert besitzt, muss vom Ablaufprogramm eine Fehlermeldung generiert werden. Weitere Informationen und ein Beispiel zum erzeugen der Fehlermeldung sind im Kapitel 24.2 Arbeiten mit Ein- und Ausgangsbausteinen beschrieben. Output Die Variable Output beschreibt den Verweis auf den Hardwareausgang des Bausteins. 19.7.3 Methoden Der Baustein verfügt über mehrere Methoden: Methode Beschreibung Write Schreibt einen Wert auf den analogen Ausgang WaitLss Warten, bis Ausgangswert kleiner als angegeben WaitGrt Warten bis Ausgangswert größer als angegeben WaitIns Warten, bis Ausgangswert innerhalb der angegebenen Grenze WaitOuts Waten, bis Ausgangswert außerhalb der angegebenen Grenze Read Ausgangswert lesen Tabelle 19.11 Methoden analoger Ausgangsbaustein Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und können dort ausgewählt werden. Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „Analoge Ausgänge“ ausgewählt werden. Die Abbildung zeigt die Auswahl von Methoden des Bausteins AOUT am Handbediengerät. Festo GDCP-CMXR-SW-DE de Version 1.0 189 19. Bausteine 19.7.4 Schreiben des Ausgangswertes, Methode Write Mit der Methode Write wird ein analoger Ausgang geschrieben. Der gewünschte Sollwert wird in den Parameter value übergeben. Syntax <Instanzname>.Write(value :REAL) Parameter Typ Bedeutung value REAL Sollwert für den analogen Ausgang Tabelle 19.12 Parameter Methode Write Beispiel: quantity.Write(110.0) value := 1.3 quantity.Write(value) // setzt den Ausgang auf 110.0 // setzt den Ausgang auf 1.3 19.7.5 Warten bis Wert größer/kleiner, Methode WaitLss, WaitGrt Die Methoden WaitLss und WaitGrt ermöglichen ein Abfragen eines analogen Ausgangs auf einen Zustand größer oder kleiner des angegebenen Wertes. Der Parameter Timeout des Bausteins wird dabei berücksichtigt. Syntax <Instanzname>.WaitLss(value : REAL, OPT ovlEnable : BOOL) <Instanzname>.WaitGrt(value : REAL, OPT ovlEnable : BOOL) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Parameter Typ Bedeutung value REAL Grenzwert Tabelle 19.13 Parameter Methoden WaitLss, WaitGrt Beispiel: Lin(pos1) // warten, bis weniger als 110.0 quantity.WaitLss(110.0, TRUE) Lin(pos2) 190 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine 19.7.6 Warten bis Wert im/aus Bereich, Methode WaitIns, WaitOuts Mit den Methoden WaitIns und WaitOuts kann gewartet werden, bis sich der analoge Ausgangswert innerhalb oder außerhalb des angegebenen Wertebereiches befindet. Der Parameter Timeout des Bausteins wird dabei berücksichtigt. Syntax <Instanzname>.WaitIns(minValue : REAL, maxValue : REAL, OPT ovlEnable : BOOL) <Instanzname>.WaitOuts(minValue : REAL, maxValue : REAL, OPT ovlEnable : BOOL) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Parameter Typ Bedeutung minValue REAL Unterer Grenzwert maxValue REAL Oberer Grenzwert Tabelle 19.14 Parameter Methoden WaitIns, WaitOuts Beispiel Lin(pos1) // warten bis Menge innerhalb der Grenzen quantity.WaitIns(100.0, 110.0, TRUE) Lin(pos2) 19.7.7 Ausgangswert lesen, Methode Read Die Methode Read liest den aktuellen Wert des analogen Ausganges ein. Syntax <Instanzname>.Read(OPT ovlEnable) Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Beispiel Lin(pos1) // lesen der Menge ohne Stopp auf der Bahn value := quantity.Read(TRUE) Lin(pos2) Festo GDCP-CMXR-SW-DE de Version 1.0 191 19. Bausteine 19.8 Uhrenbaustein CLOCK Der Uhrenbaustein (Timer) kann zur einfachen Zeitmessung im Programmablauf verwendet werden. Die Zeiten werden in Millisekunden gemessen. 19.8.1 Instanziierung Zur Instanziierung des Uhrenbausteins CLOCK wird der Name des Bausteins benötigt. Der Baustein besitzt keine Variablen. Instanziierung <Instanzname> : CLOCK Instanziierung in der Datendatei: Timer : CLOCK Instanziierung mit dem FTL-Editor Die Instanziierung erfolgt im Dialog zum Anlagen von Variablen durch Auswahl des <Typ:> (CLOCK) und Eingabe des <Bezeichner:> (clkTimer). Instanziierung mit dem Handbediengerät Die Instanziierung des Uhrenbausteins mit dem Handbediengerät erfolgt in der Variablenmaske durch Auswahl des Datentyps CLOCK. 192 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Mit der Instanziierung am Handbediengerät wird der Eintrag im Datenfile automatisch geschrieben. 19.8.2 Methoden Der Uhrenbaustein verfügt über folgende Methoden: Methode Beschreibung Reset Rücksetzen der Uhr Start Starten der Uhr Stop Stoppen der Uhr Read Auslesen der gestoppten Zeit in msec ToStr Umwandeln der Zeit in einen String Tabelle 19.15 Methoden Uhrenbaustein Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und können dort ausgewählt werden. Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „Timerbausteine“ ausgewählt werden. Die Abbildung zeigt die Auswahl der Methoden des Bausteins CLOCK am Handbediengerät. Festo GDCP-CMXR-SW-DE de Version 1.0 193 19. Bausteine 19.8.3 Starten der Uhr, Methode Start Mit der Methode Start wird der Timer gestartet. Der Startzeitpunkt wird im Baustein intern gespeichert. Erfolgt ein Start auf einen bereits gestoppten Timer, so wird der gestoppte Timer erneut gestartet, die Zeit läuft weiter. Der Timer kann nur über den Reset Befehl neu gestartet werden. Syntax <Instanzname>.Start ( ) Beispiel: Timer.Start() // Uhr wird gestartet 19.8.4 Stoppen der Uhr, Methode Stop Die Methode Stop stoppt eine gestartete Zeitmessung. Die abgelaufene Zeit wird im Baustein intern berechnet und zum Auslesen bereitgestellt. Syntax <Instanzname>.Stop ( ) Beispiel: Timer.Stop() // Uhr wird angehalten 19.8.5 Rücksetzen der Uhr, Methode Reset Der Aufruf der Methode Reset stellt den Timer zurück. Wird ein Reset auf einen laufenden Timer ausgeführt, so wird dieser auf 0 gesetzt und läuft weiter. Syntax <Instanzname>.Reset ( ) Beispiel: Timer.Reset() // Uhr wird rückgestellt 19.8.6 Auslesen der Uhr, Methode Read Mit der Methode Read kann der aktuelle Zeitwert in Millisekunden (msec) ausgelesen werden. 194 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Syntax <Instanzname>.Read(OPT ovlEnable : BOOL) : DINT Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Rückgabewert: Gemessene Zeit in Millisekunden (msec) Beispiel: Daten: value : DINT Programm: : Lin(pos1) value := Timer.Read() // auslesen mit Bahnstopp Lin(pos2) value := Timer.Read(TRUE) // auslesen im Satzhauptlauf Lin(pos3) : 19.8.7 Zeitwert in String konvertieren, Methode ToStr Ein Aufruf der Methode ToStr konvertiert den aktuellen Zeitwert in einen String, der den Aufbau <Tage> <Stunden>:<Minuten>:<Sekunden>:<Millisekunden> besitzt. Syntax <Instanzname>.ToStr(OPT ovlEnable : BOOL) : STRING Beschreibung des Parameters ovlEnable siehe Kapitel 19.3.1 auf Seite 170. Rückgabewert: String mit der formatierten Zeitinformation tt hh:mm:dd.ms. Beispiel: Daten: time : STRING Festo GDCP-CMXR-SW-DE de Version 1.0 195 19. Bausteine Programm: Lin(pos1) time := Timer.ToStr() // auslesen mit Bahnstopp Lin(pos2) time := Timer.ToStr(TRUE) // auslesen im Satzhauptlauf Lin(pos3) 19.9 Encoder-Baustein ENCODER Der Encoder-Baustein kann im Programm verwendet werden, um die maximal zwei angeschlossenen Inkrementalgeber auszulesen. 19.9.1 Instanziierung Zur Instanziierung des Encoder-Bausteins wird der Hardwarebezug zum Eingang benötigt. Dieser wird über den Parameter <port> bei der Instanziierung angegeben. Syntax <Instanzname> .ENCODER( <Timeout> : DINT, <port> : MAPTO ENCPORT)) Es können weitere Parameter angegeben werden, um z. B. Voreinstellungen zu treffen. Dies ist jedoch zur Instanziierung nicht notwendig und kann im Programm erfolgen. Beispiel: Ein Encoder wird als Bausteininstanz angelegt: Instanziierung in der Datendatei enc0 : ENCODER := (-1, MAP(Encoder_0)) 196 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Instanziierung mit dem FTL-Editor Die Instantiierung erfolgt im Dialog zum Anlegen von Variablen durch Auswahl des <Typ:> (ENCODER) und Eingabe des <Bezeichner:> (encTrack). In der Zeile <MAPTO ENCPORT> wird der reale Bezug zu einen konfigurierten Encoder-Eingang hergestellt. Instanziierung mit dem Handbediengerät Die Instanziierung des Encoderbausteins mit dem Handbediengerät erfolgt in der Variablenmaske durch Auswahl des Datentyps ENCODER. Mit der Instanziierung am Handbediengerät wird der Eintrag im Datenfile automatisch gespeichert. Festo GDCP-CMXR-SW-DE de Version 1.0 197 19. Bausteine 19.9.2 Variable Der Encoder-Baustein besitzt folgende Variablen: Variable Typ Bedeutung Zustand beim Anlegen timeout REAL Timeout zum Warten. -1 port ENCPORT Verweis auf den Hardwareeingang --- Tabelle 19.16 Variablen Encoder-Baustein Timeout – (derzeit in diesem Baustein ohne Funktion) Mit dem Parameter Timeout kann eine Wartezeit definiert werden. Die Methode des Bausteins wartet die eingestellte Zeit, auf den angeforderten Signalzustand. Derzeit besitzt der Encoder-Baustein keine Methoden, die den Timeout berücksichtigen. Port Die Variable Port beschreibt den Verweis auf den Hardwareeingang. 19.9.3 Methoden Der Encoder-Baustein verfügt über folgende Methoden: Methode Beschreibung Set Inkrementalgeberwert manuell setzen Read Inkrementalgeberwert auslesen Tabelle 19.17 Methoden Encoder-Baustein Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und können dort ausgewählt werden. Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „Inkrementalgeber“ ausgewählt werden. Die Abbildung zeigt die Auswahl der Methoden des Encoder-Bausteins am Handbediengerät. 19.9.4 Encoder setzen, Methode Set Mit der Methode Set kann ein Inkrementalgeberwert vom Anwenderprogramm gesetzt werden. 198 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Syntax: <ENCODER>.Set ( OPT <count> : DINT, OPT <mode> : SETCOUNTMODE) Parameter Typ Bedeutung count DINT Wert auf den der Inkremetalgeber gesetzt werden soll (Inkremente) mode SETCOUNTMODE Parameter zum Einstellen des Übernahmezeitpunkts Tabelle 19.18 Parameter Methode Set Der Baustein setzt den Wert hauptlaufsynchron, stoppt den Vorlauf aber nicht. Im Parameter mode kann der Zeitpunkt des Setzens definiert werden. mode Bedeutung DIRECT Wert wird im nächsten IO-System-Zyklus übernommen ZEROPULSE Wert wird beim nächsten Nullimpuls des Gebers übernommen Tabelle 19.19 Modes der Methode Set Beispiel: enc0.Set(1000, DIRECT) 19.9.5 Encoder lesen Methode Read Mit der Methode Read kann der aktuelle Inkrementalgeberwert vom Anwenderprogramm gelesen werden. Syntax: <ENCODER>.Read ( OPT <ovlEnable> : BOOL) : DINT Parameter Typ Bedeutung ovlEnable BOOL Parameter zum Einstellen des Abfragezeitpunkts Tabelle 19.20 Parameter Methode Read Die Methode gibt den inkrementellen Wert des Encoders zurück. Dieser wird nicht mit dem Umrechnungsfaktor verrechnet. Soll der normierte Wert gelesen werden, so muss direkt auf den Port des Encoder-Eingangs mit dem Element Value zugegriffen werden. Festo GDCP-CMXR-SW-DE de Version 1.0 199 19. Bausteine Beispiel normierten Wert lesen: value := enc0.port.value Beispiel inkrementellen Wert lesen: value := enc0.Read() 19.10 CANopen Baustein COPDEVICE Der CANopen-Baustein kann im Programm verwendet werden um Geräte anzusprechen, die per Peripherie-CAN-Bus mit der CMXR verbunden sind. Vorsicht Am Peripherie-CAN-Bus können CANopen-Geräte angesteuert werden. Diese Geräte unterliegen jedoch nicht dem NOT-AUSVerhalten der Kinematik. Es erfolgt kein kontrolliertes Abbremsen von Hilfsantrieben. Wird der Peripherie-CAN-Bus aus einem parallelen Programm bedient, so wird dieser im Falle eines NOT-AUS nicht gestoppt! Hinweis Wie einzelne Geräte angesprochen werden müssen, die per CANBus mit der CMXR verbunden sind, ist der jeweiligen Herstellerdokumentation des Busteilnehmers zu entnehmen. 19.10.1 Instanziierung Die Instanziierung des CANopen-Bausteins erfolgt aufgrund der IO-Konfiguration der Steuerung automatisch und ist manuell nicht möglich. Der Zugriff auf angeschlossene CANopen-Geräte erfolgt über einen eindeutigen Namen, welcher über die Konfigurationssoftware FCT vorgegeben wird. Der im FCT angegebene Name kann dabei nicht direkt verwendet werden, sondern es erfolgt eine Namenserweiterung mit der Endung „_copd“. Dies gilt sowohl für Antriebe, welche am DriveBus angeschlossen sind, als auch für CANopen-Geräte am Peripherie-CAN-Bus. Beispiel: Die Achse 1 der Kinematik wird im FCT in der DriveBus-Konfiguration als Axis1 bezeichnet. Der Zugriff erfolgt über Axis1_copd.BausteinMethode( ). CANopen-Konfiguration: [IO.ONBOARD.SLOTCAN:0.FX200A:0.CAN:0.COPDEVICE:1] name="Axis1" 200 // Name des COP-Device Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine Programmcode: Axis1_copd.WriteSDO(16#6060,0,7,eight_bits) 19.10.2 Methoden Der CANopen-Baustein verfügt über folgende Methoden: Methode Beschreibung WriteSDO SDO schreiben ReadSDOUnsigned SDO lesen ohne Vorzeichen ReadSDOSigned SDO lesen mit Vorzeichen Tabelle 19.21 Methoden CANopen Baustein Im FTL-Editor werden die verfügbaren Methoden nach Eingabe des Punktes automatisch in einer Liste angezeigt und können dort ausgewählt werden. Über das Handbediengerät können diese Methoden über den Menübaum aus der Rubrik „CANopen Geräte“ ausgewählt werden. Die Abbildung zeigt die Auswahl der Methoden des CANopen-Bausteins am Handbediengerät. 19.10.3 SDO schreiben, Methode WriteSDO Mit der Methode WriteSDO können Datenpakete auf den CAN-Bus geschrieben werden. Syntax: <COPDEVICE>.WriteSDO ( <index> : DINT, <subindex> : DINT, <data> : DINT, <type> : SdoDataType ) : BOOL Festo GDCP-CMXR-SW-DE de Version 1.0 201 19. Bausteine Parameter Typ Bedeutung index DINT Index des SDO subindex DINT Subindex des SDO data DINT Daten, die geschrieben werden type SdoDataType Datentyp (Enum) eight_bits (8 Bit) sixteen_bits (16 Bit) thirtytwo_bit (32 Bit) Tabelle 19.22 Parameter Methode WriteSDO Wird das Paket erfolgreich geschrieben, wird TRUE zurückgegeben, ansonsten FALSE. Beispiel: oData := 12000 Axis3_copd.WriteSDO(16#6085, 0, oData, thirtytwo_bits) 19.10.4 SDO lesen, Methode ReadSDOSigned Mit der Methode ReadSDOSigned können Datenpakete mit Vorzeichen vom CAN-Bus gelesen werden. Syntax: <COPDEVICE>.ReadSDOSigned (<index> : DINT, <subindex> : DINT, <data> : DINT) : BOOL Parameter Typ Bedeutung index DINT Index des SDO subindex DINT Subindex des SDO data DINT Daten, die gelesen werden Tabelle 19.23 Parameter Methode ReadSDOSigned Wird das Paket erfolgreich gelesen, wird TRUE zurückgegeben, ansonsten FALSE. Beispiel: dint_iData : DINT := 0 Programm: Axis3_copd.ReadSDOSigned(16#6098, 0, dint_iData) SetInfo("Gelesene Referenzfahrtmethode: %1", dint_iData) : 202 Festo GDCP-CMXR-SW-DE de Version 1.0 19. Bausteine 19.10.5 SDO lesen, Methode ReadSDOUnsigned Mit der Methode ReadSDOUnsigned können Datenpakete auf dem CAN-Bus gelesen werden. Die Methode erkennt automatisch wie lang die vom CAN-Bus gelesenen Daten sind. Diese werden vorzeichenlos als 32 Bit Wert zurückgegeben. Syntax: <COPDEVICE>.ReadSDOUnigned (<index> : DINT, <subindex> : DINT, <data> : DWORD) : BOOL Parameter Typ Bedeutung index DINT Index des SDO subindex DINT Subindex des SDO data DWORD Daten, die gelesen werden Tabelle 19.24 Parameter Methode ReadSDOUnsigned Wird das Paket erfolgreich gelesen, wird TRUE zurückgegeben, ansonsten FALSE. Festo GDCP-CMXR-SW-DE de Version 1.0 203 20. Peripheriesignale 20. Peripheriesignale 20.1 Arbeiten mit digitalen Ein- und Ausgängen Digitale Signale werden über die Konfiguration festgelegt. In dieser wird für jedes Hardwaresignal ein eigener Name definiert. Diese Namen können im Bewegungsprogramm für Abfragen oder zum Ansteuern verwendet werden. Jedes digitale Signal ist in Form eines strukturierten Datentyps abgebildet. Dieser enthält die Daten: State : BOOL Status des Signals TRUE oder FALSE Error Informationen über einen Fehler des Signals : BOOL Der Zugriff auf diese Daten geschieht über den Hardwarenamen und den Punktoperator. Beispiel: Ein Sensoreingangssignal hat die Bezeichnung „GripperOpen“. Der Zugriff auf den Zustand des Sensors lautet: GripperOpen.State Dieser Ausdruck ist vom Datentyp BOOL und kann wie eine boolesche Variable im Programm verwendet werden. 20.2 Arbeiten mit analogen Ein- und Ausgängen Analoge Signale werden über die Konfiguration festgelegt. In dieser wird für jedes Hardware-Signal ein eigener Name definiert. Der Name kann im Bewegungsprogramm wie eine Variable verwendet werden und somit kann z.B. ein Analogwert für eine Berechnung verwendet werden. Jedes analoge Signal ist in Form eines strukturierten Datentyps abgebildet. Dieser enthält die Daten: Value : REAL Wert des Signals Error Informationen über einen Fehler des Signals : BOOL Der Zugriff auf diese Daten geschieht über den Hardwarenamen und den Punktoperator. 204 Festo GDCP-CMXR-SW-DE de Version 1.0 20. Peripheriesignale Beispiel: Ein Analogeingangssignal hat die Bezeichnung „Level“. Der Zugriff auf den Zustand des Sensors lautet: Level.Value Dieser Ausdruck ist vom Datentyp REAL und kann wie eine Variable im Programm verwendet werden. Festo GDCP-CMXR-SW-DE de Version 1.0 205 21. Programmierung von Ereignissen 21. Programmierung von Ereignissen Die FTL-Sprache bietet die Möglichkeit, auf Ereignisse – wie z. B. Start und Stopp eines Programmes - zu reagieren. Dazu wird bei Eintreten dieses Ereignisses ein FTL-Programm mit einem fest vereinbarten Namen gestartet und bearbeitet. Hinweis Die Latenzzeit zum Start von Ereignisprogrammen liegt bei ca. 5 bis 20 msec und ist nicht deterministisch. Weiterführende Ereignisse sind durch Programmierung in der integrierten SPS auszuführen. Alle Ereignisprogramme (auch Eventprogramme) müssen im globalen Projekt "GLOBAL" abgelegt werden. Sie müssen nicht "geladen" werden. Sie haben fest vereinbarte Namen. 21.1 Unterstützte Ereignisse Folgende Tabelle zeigt eine Übersicht über die möglichen Ereignisse: Ereignisname = Programmname Ausführung des Eventprogramms onstartup einmalig nach Steuerungshochlauf onprogstart Programm starten onproginterrupt aktives Programm unterbrechen onprogcontinue unterbrochenes Programm fortsetzen onprogend Programmende onf1keypressed Taste F1 am Handbediengerät CDSA gedrückt onf1keyreleased Taste F1 am Handbediengerät CDSA losgelassen onf2keypressed Taste F2 am Handbediengerät CDSA gedrückt onf2keyreleased Taste F2 am Handbediengerät CDSA losgelassen Tabelle 21.1 Übersicht FTL Ereignisse Die in der Tabelle genannten Ereignis- / Programmnamen sind strikt einzuhalten. Im folgenden Bild sind die 3 Ereignisse - onkeyf1pressed, - onprogstart, - onstartup im Projekt "GLOBAL" angelegt. Nur auf diese Ereignisse kann reagiert werden. 206 Festo GDCP-CMXR-SW-DE de Version 1.0 21. Programmierung von Ereignissen Achtung Werden die Namenskonventionen nicht eingehalten, ist die Ausführung der Ereignisprogrammes nicht möglich. Es kann auch keine Diagnosemeldung ausgegeben werden. Die Ereignisse sind somit bei jeder Inbetriebnahme separat zu testen. Hinweis Programmnamen werden - bedingt durch das Dateisystem des CMXR - immer klein geschrieben. Hinweis Wird während der Ausführung eines Ereignissprogramms ein Fehler ausgelöst, so führt dies zu einem Stopp und einem Verwerfen dieses Programms. Das Programm kann nicht erneut ausgeführt werden. Hinweis Variable, die in Ereignisprogrammen verwendet werden, müssen ebenfalls im globalen Projekt "GLOBAL" deklariert sein. Die Nutzung von geeigneten Systemvariablen ist ebenfalls zulässig 21.2 Verwendung des FTL-Befehlssatzes Innerhalb der Ereignisprogramme ist eine eingeschränkte Menge der FTL-Befehle nutzbar. Ausdrücklich nicht zugelassen sind folgende Befehle: - Fahrbefehle z. B. Ptp, Lin, - Befehle, die Fahrbefehle beeinflussen, z. B. Tool, SetRefSys, - Befehle, die Kinematikdaten beeinflussen, z. B. Vel, Acc, - Endlosschleifen, Festo GDCP-CMXR-SW-DE de Version 1.0 207 21. Programmierung von Ereignissen - Unterprogramme und Parallelprogramme. Achtung Innerhalb der Ereignisprogramme sind Fahrbefehle sowie andere Befehle, die Fahrbefehle oder Kinematikdaten beeinflussen, nicht erlaubt. Bei der Verwendung unzulässiger Befehle wird ein entsprechender Fehler ausgegeben und das Ereigniss abgebrochen. 21.3 Zeitüberwachung Bei allen Ereignisprogrammen wird die Laufzeit überwacht. Bei Überschreiten einer fest hinterlegten Zeit von 1 Sekunde wird ein Fehler ausgegeben und das aktive Ereignisprogramm abgebrochen. 21.4 Ereignis Steuerungshochlauf, <onstartup> Nach dem Hochlauf der Mehrachssteuerung CMXR wird das Eventprogramm "onstartup" einmalig ausgeführt. Eine Anwendung für dieses Ereignis ist z. B. das automatische Laden eines FTL Programms. Beispiel : // laden des Programms main aus dem Projekt sorting LoadProgram("sorting", "main") : 208 Festo GDCP-CMXR-SW-DE de Version 1.0 21. Programmierung von Ereignissen 21.5 Ereignisse der Programmsteuerung Mit Hilfe von "Programmereignissen" kann z. B. auf das Starten und Stoppen von FTL Programmen reagiert werden. Ein Anwendungsfall ist z. B. das Schließen/Öffnen eines Applikators bei einem Programmstopp und erneutem Start. In der folgenden Tabelle sind alle verfügbaren Ereignisse für die Programmsteuerung aufgeführt. Ereignisnamen Häufigkeit Aufruf Aufruf des Events bei onprogstart einmalig Beim Starten des FTL-Programms. onproginterrupt bei Bedarf Beim Stoppen des FTL-Programms z. B. über Stopptaste am Handbediengerät oder SPS-Schnittstelle. onprogcontinue bei Bedarf Beim erneuten Start eines gestoppten Programms. onprogend einmalig Wenn das Programm beendet wird. Tabelle 21.2 Übersicht Ereignisse Programmsteuerung 21.5.1 Laufzeitverhalten während des Betriebs Bedingt durch die verschiedenen Ereignisse ergeben sich entsprechende Reaktionszeiten im FTL-Programm sowie in den jeweiligen Ereignisprogrammen. Folgende Abbildung zeigt die zeitliche Abarbeitung der einzelnen Programmereignisse: Programmstopp, Programmstart Achsen bremsen ab Erneuter Pro- Programmende grammstart Evtl. Repositionieren des Roboter auf die Bahn onprogstart Zeit Programm Programm onprogcontinue onproginterrupt onprogend Wurde nach einer Programmunterbrechung die Kinematik z. B. im manuellen Betrieb verfahren, so wird vor dem Ereignis "onprogcontinue" der Repositioniervorgang zurück auf die Bahn ausgeführt. Festo GDCP-CMXR-SW-DE de Version 1.0 209 21. Programmierung von Ereignissen Achtung Das Abarbeiten der Ereignisprogramme "onproginterrupt" und "onprogend" geschieht erst nach dem Erreichen der Programmzustände. Dazu gehört auch das Stoppen der Achsen. Die Events "onprogstart" und "onprogcontinue" werden vor der Programmausführung aufgerufen. Bei der Verwendung dieser Ereignisse ist deshalb stets diese zeitliche Fixierung zu beachten. 21.5.2 Überlappung von Programmereignissen Die Überlappung von Programmereignissen, d. h. es passiert ein Ereignis während das aktuelle Ereignisprogramm noch nicht beendet wurde, ist verriegelt. Gestartete Ereignisse werden immer zu Ende geführt, bevor ein weiteres Ereignis aktiv wird. Achtung Um eventuell nachfolgende Ereignisse zeitlich nicht zu blockieren, darf in einem Ereignisprogramm nur das notwendigste programmiert werden. Die folgende Grafik stellt einen Programmstart innerhalb des noch aktiven Programmereignis "onproginterrupt" dar: Programmstopp, Achsen bremsen ab Programmstart Programmende Erneuter Programmstart Zeitlicher Versatz des Starts Programm onprogstart Zeit Programm onprogcontinue onproginterrupt onprogend Der erneute Programmstart wird solange verzögert, bis das Programmereignis "onproginterrupt" abgearbeitet ist. 210 Festo GDCP-CMXR-SW-DE de Version 1.0 21. Programmierung von Ereignissen 21.5.3 Verwendung verschiedener Projekte/Programme Auch beim Betrieb unterschiedlicher Projekte und Programme werden dieselben Ereignisprogramme aufgerufen. Müssen die Anweisungen innerhalb des Ereignisprogramms in Abhängigkeit zu einem gestarteten Programm stehen, muss dies explizit programmiert werden. Dies kann über die Verwendung von globalen Variablen stehen. Hinweis Beim Starten unterschiedlicher Programme ist unbedingt die oben angegebene Reihenfolge bei der Ausführung der Ereignisprogramme und der verursachenden Normalprogramme zu beachten! Programm "onprogstart" // Variable zur Kennung auf 0 setzen ProgCode := 0 : FTL Programm handling // Variable zur Kennung auf 1 setzen ProgCode := 1 : FTL Programm feeding // Variable zur Kennung auf 2 setzen ProgCode := 2 : Programme "onproginterrupt"," onprogcontinue" oder "onprogend" // Programmkennung pruefen IF(ProgCode = 1) THEN // Programm handling : ELSIF(ProgCode = 2) THEN // Programm feeding : END_IF Festo GDCP-CMXR-SW-DE de Version 1.0 211 21. Programmierung von Ereignissen 21.5.4 Beispiel: Ansteuern eines Applikators beim Kleben In einem FTL Programm wird ein Applikator für verschiedene Klebebahnen je nach Fall einund ausgeschaltet. Um im Fall eines Programmstopps den Applikator zu schließen und bei einem Neustart wieder zu öffnen, können die Ereignisfunktionen eingesetzt werden. Der Applikator wird dabei mit einem digitalen Ausgang angesteuert, der über den instanziierten Baustein Glue angesprochen wird. Wenn das FTL Programm angehalten wird, wird im Ereignis "onproginterrupt" der derzeitige Zustand des digitalen Ausgangs in der Variable GlueOpened abgespeichert und der Applikator geschlossen. Programm "onproginterrupt" // Zustand Applikation merken GlueOpened := Glue.State // Applikator schließen Glue.Reset() Wird das gestoppte FTL Programm wieder gestartet, wird das Ereignisprogramm "onprogcontinue" ausgeführt. In diesem wird der Zustand der Variable GlueOpened geprüft und ggf. der Applikator wieder geöffnet. Programm "onprogcontinue" // prüfen ob Applikator geöffnet war IF(GlueOpened)THEN // Applikator öffnen Glue.Set() END_IF // Variable zum Merken des Zustandes löschen GlueWasOpen := FALSE Zur Sicherheit kann mit dem Ereignis "onprogend" der Applikator geschlossen werden. Programm "onprogend" // Applikator schließen Glue.Reset() // Variable zum Merken des Zustandes löschen GlueWasOpen := FALSE 212 Festo GDCP-CMXR-SW-DE de Version 1.0 21. Programmierung von Ereignissen Achtung Das Ein- und Ausschalten des Applikators erfolgt nicht synchron zur Bahnbewegung. An der Unterbrechungsstelle kann es deshalb zu Qualitätseinbußen in Form von z. B. Über- oder Unterbeschichtung kommen. 21.6 Ereignisse für Tasten F1 und F2 Das Handbediengerät CDSA verfügt über 2 Funktionstasten mit der Bezeichnung F1 und F2, diese befinden sich auf der linken Seite der unteren Funktionstastenleiste. Mit Hilfe den Programmevents - onf1keypressed, - onf1keyreleased, - onf2keypressed, - onf2keyreleased können diese beiden Tasten in der Applikation benutzt werden. Tasten F1 und F2 Eine Anwendung für diese Tasten könnte das Öffnen und Schließen eines Greifers im manuellen Betrieb sein. Beispiel: Im manuellen Betrieb soll mit der Taste F1 ein Greifer geöffnet, bei einem weiteren Tastendruck geschlossen werden. Da der Greifer auch in einem FTL Programm verwendet wird, muss der Zustand im Fall eines Programmstopps berücksichtigt werden. Ferner muss bei einem erneuten Programmstart der Zustand des Greifers wieder hergestellt werden. Programmunterbrechung: Bei Programmunterbrechung wird der Zustand des Greifers in einer Variable abgespeichert, um den Zustand des Greifers bei einem etwaigen erneuten Programmstart wieder herzustellen. Festo GDCP-CMXR-SW-DE de Version 1.0 213 21. Programmierung von Ereignissen Programm "onproginterrupt" // Zustand Greifer merken GripperOpen := OpenGripper.State Bei Fortsetzen des Programms (erneuter Startbefehl) wird der Greifer in den Zustand bei Programmunterbrechung gebracht. Programm "onprogcontinue" // prüfen ob Greifer geöffnet war IF(GripperOpen)THEN // Greifer öffnen OpenGripper.Set() ELSE // Greifer schließen OpenGripper.Reset() END_IF Im manuellen Betrieb wird der Greifer über die Taste F1 mit einem Tastendruck wechselseitig geöffnet oder geschlossen. Dazu muss mit dem Befehl GetManualModeActive die aktive Betriebsart abgefragt werden. Programm "onf1keypressed" // prüfen ob manuelle Betriebsart IF(GetManualModeActive())THEN // prüfen ob Greifer geöffnet IF(OpenGripper.State)THEN // Greifer schließen OpenGripper.Reset() ELSE // Greifer öffnen OpenGripper.Set() END_IF END_IF 214 Festo GDCP-CMXR-SW-DE de Version 1.0 21. Programmierung von Ereignissen 21.7 Spezielle FTL-Befehle für Anwendung mit Ereignissen Die folgenden Befehle sind für die Verwendung innerhalb der Ereignisse gedacht. 21.7.1 Abfrage der aktiven Betriebsart, <GetAutoModeActive, GetManualModeActive> Mit diesem Befehl kann abgefragt werden, ob die Betriebsart Automatik bzw. Hand aktiv ist. Syntax GetAutoModeActive( ): BOOL GetManualModeActive( ): BOOL Rückgabewerte: FALSE Betriebsart nicht aktiv TRUE Betriebsart aktiv 21.7.2 FTL-Programm laden, <LoadProgram> Über den Befehl "LoadProgram" wird ein FTL-Programm von der Speicherkarte in den Arbeitsspeicher geladen und steht dort zur Ausführung bereit. Mit der Ausführung werden alle anderen bereits geladenen Programme beendet und aus dem Speicher entladen. Das Eventprogramm selbst wird dabei nicht beendet und zu Ende ausgeführt. Syntax LoadProgram ( <project>:STRING, <program>:STRING):BOOL Methode Beschreibung project Projektname, aus dem das Programm stammt program Name des Programms, das geladen wird. Tabelle 21.3 Befehl "LoadProgram" Aufruf aus einem laufenden Programm Festo GDCP-CMXR-SW-DE de Version 1.0 215 21. Programmierung von Ereignissen Rückgabewert TRUE Programm wurde geladen FALSE Programm konnte nicht geladen werden Fehlerbehandlung Konnte das Programm aufgrund eines Fehlers nicht geladen werden, z. B. es ist nicht vorhanden, wird eine entsprechende Meldung generiert und ausgegeben. Achtung Wird der Befehl "LoadProgram" außerhalb eines Eventprogramms ausgeführt, führt dies zum Stopp und Entladen des Programmes. Alle folgenden Programmzeilen werden somit nicht mehr ausgeführt. 216 Festo GDCP-CMXR-SW-DE de Version 1.0 21. Programmierung von Ereignissen 21.8 Meldetexte der Ereignisprogramme Alle Meldungen durch die Ereignisprogramme gehören zur Komponente 50. Es können folgende Meldungen ausgelöst werden: Hinweis Die Meldungsklasse Fehler bewirkt immer ein Stopp aller FTL Programme und somit einen Stillstand der Kinematikachsen. Meldungsnummer 1260 Meldungsklasse Fehler Meldetext Ungültiges Projekt bei Befehl 'LoadProgram'. <Projekt-/Programmname mit Zeilennummer> Auswirkung Befehl LoadProgram kann nicht ausgeführt werden. Ursache Das im Befehl 'LoadProgram' angegebene Projekt existiert nicht oder ist ungültig. Maßnahme Parameter des Makros LoadProgram überprüfen, Projekt/Programm auf CF Card bereitstellen, Programm auf Fehler überprüfen. Meldungsnummer 1261 Meldungsklasse Fehler Meldetext Ungültiges Programm bei Befehl 'LoadProgram'. <Projekt-/Programmname mit Zeilennummer> Auswirkung Befehl 'LoadProgram' kann nicht ausgeführt werden. Ursache Das im Befehl 'LoadProgram' angegebene Program existiert nicht oder ist ungültig. Maßnahme Parameter des Makros LoadProgram überprüfen, Projekt/Programm auf CF Card bereitstellen, Programm auf Fehler überprüfen. Meldungsnummer 1262 Meldungsklasse Fehler Meldetext Roboter Befehl in Event: <Ereignisname> ist nicht erlaubt. <Projekt/Programmname mit Zeilennummer> Auswirkung Programmereignis wird abgebrochen. Ursache Es ist nicht erlaubt Befehle, die die Kinematik beeinflussen z. B. Fahrbefehle, Dynamikdaten in Ereignisprogrammen zu verwenden. Maßnahme Nicht erlaubte Befehle aus dem Ereignisprogramm entfernen. Festo GDCP-CMXR-SW-DE de Version 1.0 217 21. Programmierung von Ereignissen Meldungsnummer 1263 Meldungsklasse Fehler Meldetext Event: <Name des Ereignisses> hat das Timeout von: <Zeitwert> msec überschritten. Auswirkung Programmereignis wird abgebrochen. Ursache Das Programmereignis benötigt zu viel Zeit. Es wurden evtl. zu viele Befehle programmiert, ein wartender Befehl (WaitTime) oder eine Endlosschleife programmiert. Maßnahme 218 Über prüfen des Programmes, entfernen unzulässiger Befehle. Festo GDCP-CMXR-SW-DE de Version 1.0 22. Einfache Schaltpunkte 22. Einfache Schaltpunkte Schaltpunkte sind Positionen auf einem Bewegungspfad oder auf einer Position selbst, an denen eine Aktion ausgeführt wird. Diese Aktionen werden in Abhängigkeit der Bewegungsbahn ausgeführt. Anwendungsfälle dazu könnten z. B. sein: - Öffnen und Schließen eines Applikator z. B. zum Kleben oder Beschichten - Änderung eines Volumenstromes eines zugeführten Mediums z. B. Dichtmittel - Ansteuern von intelligenten Sensoren z. B. Kamerasystem 22.1 Einfacher Schaltpunkt mit Bewegungsbefehl, <DO> Ein einfacher Schaltpunkt kann über die DO Anweisung (siehe Kapitel 8.10 DO Anweisung) in Verbindung mit einem Bewegungsbefehl erstellt werden. Dabei wird vor der DO Anweisung ein Bewegungsbefehl gestellt. Dazu können alle Bewegungsbefehle wie PTP oder kartesische Bewegungen linear und zirkular angewendet werden. Syntax <Bewegungsbefehl> DO < Anweisung > Mit der DO Anweisung können einfache Schaltvorgänge ausgeführt werden, die im Hauptlauf der FTL Bearbeitung ausgeführt werden. Eine Kompensation etwaiger Schaltzeiten ist hier nicht möglich. Es erfolgt keine Kopplung an die Bahngeschwindigkeit. Dies bedeutet, dass sich durch eine Änderung der Bahndynamik das Schaltverhalten, bezogen auf die Bahn, ändern kann. Die Ausführung der Anweisung erfolgt bedingungslos. Beispiel Auf der folgenden Kontur muss ein digitaler Ausgang auf den geraden Strecken eingeschaltet und in den Kreisbogen ausgeschaltet werden. Pos1 Pos2 Ipos1 Ipos2 Pos4 Pos3 Festo GDCP-CMXR-SW-DE de Version 1.0 219 22. Einfache Schaltpunkte : Lin(Pos1) DO Applicator.Set() Lin(Pos2) DO Applicator.Reset() CircIp(Ipos1,Pos3) DO Applicator.Set() Lin(Pos4) DO Applicator.Reset() CircIp(Ipos2,Pos1) : 22.2 Einfacher Schaltpunkt, <OnPosition> Neben der DO Anweisung kann mit dem Makro OnPosition ebenfalls eine vereinfachte Schaltaktion programmiert werden. Jedoch erfolgt hier keine Verknüpfung mit einem Bewegungsbefehl. Das Makro OnPosition wartet ab, bis die zuletzt programmierte Position erreicht wurde und führt dann die DO Anweisung aus. Syntax OnPosition() DO < Anweisung > Beispiel: Im folgenden Beispiel wird ein Unterprogramm aufgerufen, in dem Bewegungsbefehle stehen. Nachdem die letzte Position erreicht wurde, führt das Makro OnPosition die DO Anweisung aus und setzt die Variable SequenceReady auf TRUE. : Lin(Pos1) Lin(Pos2) CALL Sort OnPosition() DO SequenceReady := TRUE Lin(Home) DO Applicator.Reset() : 22.3 Verhalten im Überschleifbereich Ist das Überschleifen aktiviert, so kann die DO Anweisung nicht beim Erreichen des Programmierten Punktes ausgeführt werden, da dieser bedingt durch das Überschleifen nicht erreicht wird. In diesem Fall wird der Schaltpunkt auf die Bahn des Überschleifbereiches projiziert und ausgeführt. Dadurch können sich Ungenauigkeiten ergeben, deren Abmaß nicht bekannt sind und durch ein Inbetriebnahme ermittelt werden müssen. 220 Festo GDCP-CMXR-SW-DE de Version 1.0 22. Einfache Schaltpunkte Hinweis Münden die Bewegungssegmente tangential ineinander, so hat das Überschleifen keine Auswirkung auf das Ausführen der DO Anweisung. Do Anweisung wird hier ausgeführt. 1 1 P1´ 1 1 1 1 1 1 22.4 P2 P1 P0 Laufzeitverhalten der DO Anweisung Bei der Verwendung der DO Anweisung ist zu beachten, dass diese eine Art parallelen Ablauf repräsentiert. Die eigentliche Linearität des FTL Programms, dass dieses von oben nach unten ausgeführt wird, geht dadurch verloren. Bei der Verwendung der DO Anweisung ist zu beachten, dass die FTL Programme stets vorausberechnet werden. Folgendes Beispiel zeigt einen Programmablauf, der nicht das gewünschte Ergebnis erzeugt: : Started := FALSE Lin(Home) Lin(Pos2) DO Started := TRUE IF Started THEN : ELSE : END_IF : Bedingt durch die Vorausberechnung des FTL Programms, wird die IF Anweisung immer in den ELSE Zweig ausführen. Festo GDCP-CMXR-SW-DE de Version 1.0 221 23. Bahnschaltpunkte 23. Bahnschaltpunkte Bahnschaltpunkte werden auf der beschriebenen Bahn berechnet. Dabei kann es sich um PTP, Linear- und/oder Kreisbewegungen handeln. Für die Programmierung der Bahnschaltpunkte wird das jeweilige Makro in Verbindung mit der DO Anweisung eingesetzt. Syntax < Schaltpunktmakro > DO < Anweisung > Eine Programmzeile kann nur eine DO Anweisung besitzen, hinter diese maximal eine Anweisung stehen darf. Bahnschaltpunkte gibt es in mehreren Ausführungen, die von einfachen Schaltvorgängen bis zur Kompensation von Schaltzeiten gehen. Diese Varianten sind auf den nächsten Seiten beschrieben. Achtung Bahnschaltpunkte werden durch die Vorausberechnung des Programms berechnet. Um diese korrekt auszuführen, ist stets ein Override von 100% notwendig (siehe Kapitel 23.7.4 Einfluss des Overrides). Ein veränderter Override hat eine fehlerhafte Ausführung zur Folge. 23.1 Bahnsegment Als Bahnsegment wird die Stecke zwischen einem Start- und Zielpunkt bezeichnet. Auf einem solchen Bahnsegment werden die Bahnschaltpunkte ausgeführt. Zur Ausführung gibt es verschiedene Arten, die auf den folgenden Seiten beschrieben werden. Je nach Ausführungsart der Bahnschaltpunkte, lassen sich diese auf diesem Segment anhand einer Position oder einer Zeit verschieben. Folgende Grafik erläutert die Definition des Segmentes: P3 P1 Bahnsegment zwischen P1 und P2 P2 Segmentende Segmentanfang Schaltpunkt 222 Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte Hinweis Je Bahnsegment können max. 8 Schaltpunkte programmiert werden. Wird diese Grenze überschritten, so wird eine Fehlermeldung ausgegeben und das Programm gestoppt. 23.2 Verhalten im Überschleifbereich Bedingt durch Parameter wie Überschleifwerte, Positions- oder Zeitoffset des Schaltpunktes, kann die Position eines Schaltpunktes im Überschleifbereich liegen. Die Berechnung des Schaltpunktes findet auf den Bahnsegmenten statt, die ohne Überschleifen berechnet wurden. Nun wird im Überschleifbereich dieser Punkt auf die Bahnkurve das Überschleifbereiches projiziert. Je nach Größe des Überschleifbereich kommt es zu Ungenauigkeiten der programmieten Werte. Hinweis Können diese Ungenauigkeiten im Überschleifbereich nicht akzeptiert werden, so ist sicherzustellen, dass Schaltpunkte außerhalb diesem Bereich liegen. Dies kann z. B. durch das Einfügen von Kreissegmenten, die tangential münden, geschehen. P3 projizierter und ausgeführter Schaltpunkt P2 P1 programmierter Schaltpunkt, aus P2 verschoben Festo GDCP-CMXR-SW-DE de Version 1.0 223 23. Bahnschaltpunkte 23.3 Schaltpunkt mit prozentualer Verschiebung, <OnParameter> Mit dem Schaltpunktmakro OnParameter kann der Schaltpunkt prozentual auf dem folgenden Bahnsegment verschoben werden. Die Position des Schaltpunktes errechnet sich dabei über die Segmentlänge, die sich aus den programmierten Punkten ergibt, sowie den angegebenen Prozentwert. Syntax OnParameter( <percent> : REAL OPT <timeMs> : DINT) DO < Anweisung > Parameter Bedeutung Einheit percent Prozentwert für die Schaltpunktberech- Prozent 0..100% nung. timeMs Zeitversatz des Schaltpunktes msec Tabelle 23.1 Parameter Befehl OnParameter Der Befehl OnParameter kann auf PTP und kartesische Bewegungen sowie alle Befehle mit Orientierungsänderung angewendet werden. Die Programmierung von OnParameter findet immer zwischen 2 Bewegungsbefehlen statt, die das Bahnsegment beschreiben. Neben der prozentualen Verschiebung des Schaltpunktes, kann dieser auch mit einem Zeitoffset verschoben werden. Die Auswirkung des Zeitoffsets (Parameter timeMs) wird im Kapitel 23.6 Optionaler Zeitoffset auf Seite 231 behandelt. Beispiel: Eine Bahn wird abgefahren und nach einem Weg von 70% der Segmentlänge zwischen Position P0 und P1 soll ein Greifer geöffnet werden. : Lin(P0) Do Anweisung wird hier ausgeführt. 1 1 P2 OnParam(70) DO Gripper.Set() Lin(P1) 1 1 P0 : 1 1 1 1 224 0% 1 1 70% 1 1 P1 100% Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte 23.4 Schaltpunkt beliebig auf der Bahn, <OnDistance> Mit dem Schaltpunktmakro OnDistance kann ein Schaltpunkt definiert werden, der sich im folgenden Bahnsegment befindet. Dieser Schaltpunkt kann, bezogen auf den Anfang oder das Ende des Segmentes mit einem Offset verschoben werden. Optional kann auch eine Zeit angegeben werden, um den Schaltpunkt zeitlich zu verschieben z. B. zur Kompensation von Schaltzeiten. Syntax OnDistance( <type> : DISTANCETYPE, <offset> : REAL, OPT <timeMs> : DINT ) DO < Anweisung > Parameter Bedeutung Einheit type Enumerationswert zur Unterscheidung Abstand - vom Beginn oder Ende der Bewegung. Als Auswahl stehen die Werte FROMBEGIN und FROMEND zur Verfügung. offset Positionsoffset bezogen auf den Beginn oder mm Ende, wie in Parameter type angegeben, timeMs Zeitoffset zum Verschieben des Schaltpunktes msec Tabelle 23.2 Parameter Befehl OnDistance Hinweis Der Befehl OnDistance kann nur in Verbindung mit kartesischen Bewegungen (z. B. Lin und CircIP) genützt werden. Eine Verwendung mit PTP Bewegungen ist nicht möglich. Bei Verwendung vor PTP Fahrbefehlen wird eine Warnung ausgegeben. Die Auswirkung des Zeitoffsets (Parameter timeMs) wird im Kapitel 23.6 Optionaler Zeitoffset auf Seite 231 behandelt. Festo GDCP-CMXR-SW-DE de Version 1.0 225 23. Bahnschaltpunkte type Der Parameter type legt fest, ob sich der Schaltpunkt auf das Ende oder den Anfang des Segmentes bezieht. OnDistance (FROMBEGIN, 0) schaltet am Segmentanfang: Segmentanfang = Schaltpunkt P1 P3 P2 Segmentende OnDistance (FROMEND, 0) schaltet am Segmentende: Segmentanfang P1 P2 P3 Segmentende = Schaltpunkt offset Die Verschiebung des Schaltpunktes erfolgt immer auf dem betroffenen Bahnsegment. Dabei kann über den Parameter type festgelegt werden, ob sich dieser Offset auf den Anfang oder das Ende des Segmentes bezieht. Wird ein Bezug auf den Segmentanfang gewählt, so erstreckt sich der Offset auf dem Segment in Richtung Segmentende. Bei einem Bezug aug das Segmentende wird der Offset in Richtung des Segmentanfang verrechnet. Hinweis Der Parameter offset ist positiv vorzugeben. Wird ein negativer Wert vorgegeben, so wird eine entsprechende Meldung ausgegeben. 226 Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte Beispiel Schaltpunkt mit Abstand vom Segmentende: : Lin(P1) OnDistance(FROMBEGIN, 30) DO <Anweisung> Lin(P2) Lin(P3) : Segmentanfang Schaltpunkt P1 P3 P2 Segmentende Offset = 30mm Beispiel Schaltpunkt mit Abstand vom Segmentende: : Lin(P1) OnDistance(FROMEND, 30) DO <Anweisung> Lin(P2) Lin(P3) : Segmentanfang Schaltpunkt P1 P2 P3 Segmentende Offset = 30mm Festo GDCP-CMXR-SW-DE de Version 1.0 227 23. Bahnschaltpunkte 23.5 Schaltpunkt auf einer Schaltebene, <OnPlane> Das Schaltpunktmakro ermöglicht die Ausführung einer Anweisung beim Durchfahren einer programmierbaren Ebene im Raum. Die Schaltebene muss im Segment des folgenden kartesischen Fahrbefehls durchfahren werden. Die Ebene liegt in parametrierbarem Abstand parallel zu einer Referenzsystemebene des aktuellen Referenzsystems. Syntax OnPlane( <plane> : PLANETYPE, <pos> : REAL, OPT <timeMs> : REAL ) DO < Anweisung > Parameter Bedeutung Einheit plane Auswahl der Ebene XYPLANE, YZPLANE, - XZPLANE. pos Parallelverschiebung der Ebene gegenüber dem mm Nullpunkt des aktiven Referenzsystems. timeMs Zeitversatz des programmierten Schaltpunktes Tabelle 23.3 Parameter Befehl OnPlane Die Auswirkung des Zeitoffsets (Parameter timeMs) wird im Kapitel 23.6 Optionaler Zeitoffset auf Seite 231 behandelt. Hinweis Die Wahl der Schaltebene XY, YZ oder XZ über den Parameter plane wird im aktiven Referenzsystem definiert. Beim Wechsel in ein anderes Referenzsystem ist zu beachten, dass sich die Lage der Ebenen verändern können. Hinweis Die Schaltebene kann nur durch kartesische Bewegungen ausgelöst werden. Wird diese durch eine PTP Bewegung durchfahren, wird eine Warnung ausgegeben, denn der Schaltpunkt kann bei einer PTP Bewegung nicht berechnet werden. 228 Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte Beispiel: Im folgenden Beispiel wird eine Ebene parallel zur XZ Ebene des aktiven Referenzsystems definiert. Da sich die Ebene im Nullpunkt des Referenzsystems befindet, muss diese mit dem Parameter pos entsprechend parallel verschoben werden. 1 1 P2 X 1 1 100 mm Z 1 1 P0 P1´ 1 1 1 1 XZ Ebene P1 Y : // Hinfahrt Lin(P0) OnPlane(XZPLANE, 100) DO mySignal := TRUE Lin(P1) Lin(P2) // Rueckfahrt Lin(P1) OnPlane(XZPLANE, 100) DO mySignal := FALSE Lin(P0) : Festo GDCP-CMXR-SW-DE de Version 1.0 229 23. Bahnschaltpunkte 23.5.1 Teachen der Position zur Schaltebene Um die Arbeit einfach zu gestalten, kann die Position zur Schaltebene neben der Eingabe des Wertes auch geteacht werden. Dies wird mit Hilfe des Handbediengerätes oder der Emulationssoftware ausgeführt. In der Betriebsart HAND wird bei Erstellung des Makros oder über den Softkey Ändern die Parametermaske des Makros geöffnet. Durch das markieren der Zeile Position wird der Softkey aktiv und kann verwendet werden. 1. Parameterfeld anklicken, wird blau hinterlegt 2. Softkey Teach wird aktiviert Das Teachen der Position ist anhängig von der durch den Parameter plane ausgewählten Ebene. Folgende kartesischen Werte werden geteacht: Ausgewählte Ebene, Parameter plane kartesische Achse, die geteacht wird XYPlane Z XZPlane Y YZPlane X Tabelle 23.4 Teach-In Parameter plane Durch drücken des Softkey wird das Teachen ausgeführt. Dabei dies der kartesische Wert der jeweiligen Achse (siehe Tabelle) ermittelt und auf den Parameter pos geschrieben. Ist diesem Parameter eine Variable zugeordnet, so wird der Wert in diese Variable geschrieben. Hinweis Der Wert wird immer im aktuellen ausgewählten Referenzsystem geteacht. Dieses wird auf der Positionsseite in der Auswahlbox angezeigt. 230 Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte 23.6 Optionaler Zeitoffset Bei den beschriebenen Schaltpunktmakros OnParameter, OnDistance und OnPlane kann optional ein Zeitoffset angegeben werden. Mit diesem Zeitoffset können Schaltaktionen zeitlich auf dem Bahnsegment verschoben werden. Ein positiver Zeitwert verschiebt die Schaltaktion in die Zukunft, ein negativer Zeitwert löst die Schaltaktion früher aus. Für einen negativen Offset sind max. 300 msec, für einen positive Offset 1 sec zulässig. Hinweis Wird der optionale Zeitoffset nicht angegeben, so wird dieser mit dem Wert 0 initialisiert. Die Angabe des Zeitwertes erfolgt msec. Beispiel mit negativer Zeitoffset: : negativer Zeitoffset Lin(P1) OnDistance(FROMEND, 0, -55) DO Lamp.Set() P2 P1 Lin(P2) : Schaltpunkt Offset Beispiel negative Zeitoffset über das Segment: : negativer Zeitoffset Lin(P1) OnDistance(FROMEND, 0, -250) DO Lamp.Set() P2 P1 Lin(P2) : Schaltpunkt Offset Beispiel mit positivem Zeitoffset: : positiver Zeitoffset Lin(P1) OnDistance(FROMEND, 0, 250) DO Lamp.Set() P2 P1 Lin(P2) : Festo GDCP-CMXR-SW-DE de Version 1.0 Offset Schaltpunkt 231 23. Bahnschaltpunkte Hinweis Der maximale negative Zeitoffset ist begrenzt und beträgt maximal 300 msec, der maximale positive Wert 1 sec. Bei unzulässigen Werten wird eine Warnmeldung ausgegeben, dass dieser Bahnschaltpunkt einen nicht gültigen Zeitwert besitzt. 23.6.1 Systemreaktion bei unzulässigem Zeitwert Werden bei der Angabe des Zeitwertes die maximal zulässige Werte verletzt, so wird eine Warnmeldung ausgegeben. Innerhalb dieser Meldung wird das Schaltpunktmakro mit Angabe des Programmes und der betroffenen Programmzeile ausgegeben. 232 Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte 23.7 Randbedingungen 23.7.1 Einzelschritt Betrieb Wird im manuellen Betrieb am Handbediengerät der Schrittbetrieb zur Programmausführung ausgewählt, so werden die programmierten Bahnschaltpunkte nicht ausgeführt. Aufgrund dem Stoppen nach jeder Programmzeile ist eine Berechnung und Ausführung der Bahnschaltpunkte nicht möglich. Hinweis Die Auswahl des Einzelschrittbetriebes erfolgt über die Taste , die sich im Fenster der Programmansicht befindet. Innerhalb der Programmansicht wird der aktive Zustand in der Kopfzeile des Programms angezeigt. 23.7.2 Wartebefehle, die den Hauptlauf beeinflussen In Programmteilen, in denen die Bahnschaltpunkte verwendet werden, dürfen keine Wartebefehle wie z. B. WaitTime, WaitOnPos, WaitOnPath, WaitOnMainRun verwendet werden. Diese Befehle beeinflussen die Vorausberechnung des Programmes und somit die Berechung der Bahnschaltpunkte. Bei Verwendung dieser Befehle wird eine entsprechende Meldung angezeigt. 23.7.3 Setzen der Satzzeigers Wird der Satzzeiger (blauer Pfeil) auf ein Bahnschaltmakro vom Typ OnDistance, OnParameter oder OnPlane gesetzt, so wird dieses bei einem Programmstart nicht ausgeführt. Eine Ausführung kann erst erfolgen, nachdem der Startpunkt des ersten vollständigen Bahnsegment erreicht ist und die Bewegung in Richtung des Zielpunktes aktiv ist. Hinweis Programmierte Bahnschaltpunkte vor einem ersten Bahnsegment sind wirkungslos. Eine Ausführung kann erst innerhalb einem gestarteten Bahnsegment erfolgen. Das System erzeugt eine Warnmeldung, dass diese Schaltpunkte nicht ausgeführt werden können. Wird das im folgenden Bild dargestellte Programm gestartet, so kann der programmierte Schaltpunkt, auf dem der Programmzeiger steht, nicht ausgeführt werden. Festo GDCP-CMXR-SW-DE de Version 1.0 233 23. Bahnschaltpunkte Schaltpunkt kann nicht ausgeführt werden 23.7.4 Einfluss des Overrides Mit dem Override kann die aktuelle Geschwindigkeit der Kinematik prozentual reduziert werden. Diese Änderung wirkt sich sofort auf die aktuelle Bewegung aus und beeinflusst diese entsprechend. Um eine sichere Ausführung der Bahnschaltpunkte zu gewähleisten, muss der Override während der Ausführung einen konstanten Wert besitzen. Eine Änderung des Overrides während der Ausführung der Bahnschaltpunkte kann zu Ungenauigkeiten führen. Wird gewünscht, dass das Programm stets mit einem bestimmten Override, z. B. 100%, ausgeführt wird, so kann das Makro Ovr (siehe Kapitel 10.5.1 Override am Handbediengerät <Ovr>) eingefügt werden. Der Override wird somit über das FTL Programm einmalig gesetzt. Eine manuelle Änderung ist jederzeit möglich. Beispiel: : // setzen des Override auf 100% Ovr(100) Lin(HomePos) Lin(pos1) // Schaltpunkt OnDist(FROMEND, Offset, -55) DO Gripper.Set() Lin(pos2) Lin(pos3) : 234 Festo GDCP-CMXR-SW-DE de Version 1.0 23. Bahnschaltpunkte 23.7.5 Arbeiten im Handbetrieb mit reduzierter Geschwindigkeit Die Bahnschaltpunkte können auch im Handbetrieb mit reduzierter Geschwindigkeit ausgeführt und getestet werden. Die Programmausführung muss jedoch im kontinuierlichen Betrieb erfolgen, eine Ausführung im Einzelschrittbetrieb ist nicht möglich (siehe Kapitel 23.7.1 Einzelschritt Betrieb). Die reduzierte Geschwindigkeit wird als Maximalwert für die programmierte Bahngeschwindigkeit verwendet. Diese wird für die Berechnung der bei der Ausführung von Bahnschaltpunkten herangezogen. Somit hat die reduzierte Bahngeschwindigkeit keinen Einfluss auf die Schaltgenauigkeit der Bahnschaltpunkte. Wird das Geschwindigkeitsüberschleifen (Makro OvlVel) verwendet, ändert sich jedoch das Überschleifverhalten, da dies in Abhängigkeit der Bahngeschwindigkeit dynamisch berechnet wird. Befinden sich Bahnschaltpunkte im Überschleifbereich, so kann sich eine Differenz der Schaltpunktposition im Vergleich zum Automatikbetrieb ergeben. Die Verwendung des geometrischen Überschleifens (Makro OvlCart) wird durch die reduzierte Bahngeschwindigkeit nicht beeinflusst. Achtung Liegt ein Bahnschaltpunkt im Überschleifbereich, so können sich aufgrund der reduzierten Bahngeschwindigkeit in der Schaltposition Differenzen zum Automatikbetrieb (volle Geschwindigkeit) ergeben. Das Schaltverhalten ist somit stets Automatikbetrieb zu testen und zu optimieren. 23.7.6 Unterbrechung des Programmes Ein aktives Programm kann durch einen Stopp über die Stopptaste am Handbediengerät oder über eine SPS gestoppt und somit unterbrochen werden. Bei einem erneuten Start wird das Programm fortgesetzt und etwaige folgende Bahnschaltpunkte ausgeführt. Erfolgt dieser Start und/oder Stopp während der Ausführung eines Bahnschaltpunktes, so kann dies zu Ungenauigkeiten im Schaltverhalten führen. Achtung Wird das Programm gestoppt und Bahnschaltpunkte befinden sich bereits in der Berechnung, so wird die Ausführung und somit die Genauigkeit bei einem erneuten Programmstart beeinträchtigt. Dies kann zur Qualitätseinbußen führen. Festo GDCP-CMXR-SW-DE de Version 1.0 235 23. Bahnschaltpunkte 23.8 Nicht ausgeführte Schaltpunkte Am Ende jedes Segmentes, wird überprüft ob alle programmierten Schaltpunkte ausgeführt wurden. Kommt es vor, dass Schaltpunkte nicht ausgeführt wurden, z. B. eine definierte Ebene wurde nicht durchfahren, so wird für jeden nicht ausgeführten Trigger eine Warnmeldung ausgegeben. Diese Meldung enthält folgende Informationen: - Name des Schaltpunktmakro aus dem FTL Programm - Projekt- und Programmname - Zeilennummer 236 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele 24. Beispiele In den folgenden Kapiteln sind Beispiele abgebildet, die die Verwendung der Programmiersprache darstellen. Warnung Alle Beispiele dienen zur Darstellung der Verwendung der Programmiersprache. Es besteht kein Anspruch auf Richtigkeit, Vollständigkeit und Verwendung der Beispiele als lauffähige Applikation. Werden Programmteile aus den Beispielen in eine Applikation eingebaut, so sind diese bezüglich dem Verwendungszweck zu prüfen und die Funktion mit einer entsprechenden Inbetriebnahme sicher zu stellen. Die Nichtbeachtung kann Sachschäden und Personenschäden zur Folge haben. 24.1 Stoppen von Bewegungen Ein Handhabungsroboter muss von einem Stapel Blech eine Tafel entnehmen und auf einer Rollenbahn ablegen. Die genaue Höhe des Stapels ist unbekannt. Das Greifersystem ist jedoch mit einem Sensor ausgestattet, der eine Abfrage erlaubt, ob das Greiferwerkzeug auf ein Hindernis aufgefahren ist. Dieser Sensor wird dazu genutzt, die obere Blechtafel zu detektieren. Um zu erkennen, dass ein Blechstapel abgearbeitet ist, ist zusätzlich ein Sensor (zum Erkennen leerer Stapel) angebracht. y x z Greifersystem mit Auffahrerkennung Eingang: inCollision Rollenbahn Blechstapel Sensor zum Erkennen leerer Stapel Eingang: inStackNotEmpty Festo GDCP-CMXR-SW-DE de Version 1.0 237 24. Beispiele Das Bewegungsprogramm hat folgende Positionen: Beschreibung Name der Positionsvariable Entnahmeposition am Blechstapel takePosStack Sicherheitsposition über dem Blechstapel safetyPosStack Sicherheitsposition über der Rollenbahn safetyDepositPos Ablageposition auf der Rollenbahn depositPos Veränderbare Vorposition über Blechstapel prePosition Tabelle 24.1 Positionsübersicht Für diese Anwendung können weitere Positionen eingesetzt werden. Das Beispiel beschränkt sich jedoch auf die angegebenen. safetyDepositPos safetyPosStack depositPos takePosStack Da Aufgrund der variierenden Stapelhöhe die Höhe der Entnahmeposition unbekannt ist, wird diese unter den Stapel gelegt. 238 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele Bewegungsprogramm: : Vel(dynCart, 200) // langsame Geschwindigkeit prePosition := safetyPosStack WHILE TRUE DO Lin(safetyPosStack) WAIT inStackNotEmpty.State // prüfen, ob Teile auf Stapel Lin(prePosition) Vel(dynCart, 200) // langsame Geschwindigkeit Lin(takePosStack) WAIT inCollision.State // warte Sensorsignal aufgefahren StopMove() // stoppen der Bewegung // ermitteln der Istposition über dem Stapel ReadActualPos(prePosition) // Sicherheitsabstand über dem Stapel berechnen prePosition.z := prePosition.z - 10 gripper.Set() // Greifer schließen Vel(dynCart, 1000) // schnelle Geschwindigkeit Lin(safetyPosStack) Lin(safetyDepositPos) Lin(depositPos) gripper.Reset() // Greifer Öffnen Lin(safetyDepositPos) END_WHILE : Funktionsweise Die Kinematik fährt so lange auf die Entnahmeposition, bis sich der Greifer auf der Blechtafel befindet und der Sensor zur Auffahrerkennung das entsprechende Signal liefert. Dies wird mit einer langsamen Geschwindigkeit durchgeführt, um das System vor Schaden zu bewahren. Um im nächsten Zyklus eine möglichst nahe Position über dem Stapel zu erreichen, wird die tatsächliche Position über dem Stapel gespeichert. Diese Position wird mit einem Sicherheitsabstand ergänzt. Somit kann im nächsten Zyklus mit einer schnellen Geschwindigkeit über den Stapel gefahren werden. Anschließend wird bis zum Teilekontakt auf eine langsame Geschwindigkeit umgeschaltet. Festo GDCP-CMXR-SW-DE de Version 1.0 239 24. Beispiele 24.2 Arbeiten mit Ein- und Ausgangsbausteinen Bei der Instanziierung von Ein- bzw. Ausgangsbausteinen kann ein Timeout definiert werden. Wird zum Beispiel die Funktion Wait des Bausteins im Ablauf verwendet, muss ein eventuell aufgetretener Timeout vom Anwenderprogramm ausgewertet werden. Bewegungsprogramm: : inSensor.Wait() IF inSensor.Read() = FALSE THEN //Ablauf unterbrechen SetError(“Timeout over“) RETURN END_IF //Ablauf fortsetzten Lin(pos) : Hinweis Die Ausgabe einer Fehlermeldung führt zu einer Unterbrechung der Bewegung. Erst nach dem Quittieren der Fehlermeldung kann der Ablauf fortgesetzt werden. 240 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele 24.3 Steuerung des Satzvorlaufs Im Folgenden werden anhand von Beispielen verschiedene Möglichkeiten erläutert, wie die Berechnung des Satzvorlaufs beeinflusst werden kann. 1. Warten auf digitales Eingangssignal Im Programmablauf wird mit dem Befehl WAIT auf ein digitales Eingangssignal gewartet. Ist der Zustand des digitalen Eingangs FALSE, wird der Satzvorlauf gestoppt. Wird der Zustand TRUE, dann wird die Berechnung fortgesetzt. Dies zeigt die folgende Abbildung. Satzhauptlauf Satzvorlauf Lin(Pos1) Satzhauptlauf Lin(Pos1) Lin(Pos2) Lin(Pos2) Lin(Pos3) Lin(Pos3) Lin(Pos4) Lin(Pos4) WAIT Sensor.State WAIT Sensor.State Lin(Pos5) Lin(Pos5) Lin(Pos6) Lin(Pos6) Lin(Pos7) Lin(Pos7) Lin(Pos8) Lin(Pos9) Satzvorlauf Lin(Pos8) Lin(Pos9) 2. Schleifenzähler Ein Programmteil wird mit einer Zählschleife 10 mal wiederholt. Die Zyklen werden mit einem Schleifenzähler gezählt. Der Satzvorlauf interpretiert das Ablaufprogramm und erhöht dabei den Schleifenzähler. Dies führt dazu, dass der Satzvorlauf sehr schnell das Programmende erreicht und somit der Schleifenzähler den Wert 10 erreicht. Der Satzhauptlauf hat in dieser Zeit erst die Anweisung Lin(Pos1) erreicht. Soll der Schleifenzähler den tatsächlichen Zyklus anzeigen, dann muss der Satzvorlauf mit einer WaitTime-Anweisung unterbrochen werden. Der Schleifenzähler wird nun immer beim Erreichen der Pos3 erhöht. Dies zeigt die folgende Abbildung. Festo GDCP-CMXR-SW-DE de Version 1.0 241 24. Beispiele Satzhauptlauf count := 0 count := 0 Lin(Pos1) Lin(Pos1) Lin(Pos2) Lin(Pos2) LOOP 10 DO LOOP 10 DO Lin(Pos3) Lin(Pos3) count:=count + 1 Lin(Pos4) END_LOOP Satzvorlauf Satzhauptlauf Lin(Pos5) Satzvorlauf WaitTime (1) count:=count + 1 Lin(Pos4) END_LOOP Lin(Pos5) 24.4 Arbeiten mit Greifern In der Handhabungstechnik kommen eine Vielzahl verschiedener Greifer zum Einsatz. Jeder Greifvorgang benötigt Zeit, um den Greifer zu schließen bzw. zu öffnen. Diese Zeit kann die Taktzeit wesentlich beeinflussen. Hinweis Greifzeiten führen zu einer Erhöhung der Taktzeit und sind deshalb stets zu berücksichtigen. Je nach Greifertyp erfordert dies auch eine Wartezeit im FTL-Programm um das Öffnen oder Schließen des Greifers sicherzustellen. Hinweis Wartezeiten für den Zustand Geschlossen oder Geöffnet bei pneumatischen Greifern sind immer vom eingestellten Druck abhängig. Ändert sich der Druck, so sind auch die Zeiten anzupassen. Sind am Greifersystem Sensoren für die Endlagen angebracht, so kann in der Regel auf Wartezeiten verzichtet werden. In den folgenden Kapiteln ist die Integration unterschiedlicher Greifertypen in die CMXR Welt dargestellt. 242 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele 24.4.1 Vakuumgreifer Vakuumgreifer sind Greifertypen, mit denen sehr schnelle Greifzyklen ausgeführt werden können. Sie benötigen ein Vakuum, dass z. B. durch eine Venturidüse erzeugt werden kann. Bei der Aufnahme des Werkstückes muss das Vakuum anstehen. Wird das Werkstück abgelegt, muss neben dem Ausschalten des Vakuums ein Abblasimpuls ausgeführt werden, um das im Greifer aufgebaute Vakuum zu beseitigen. Vakuumerzeuger wie der VN-..-H-...-A führen nach dem Abschalten des Vakuums den Abblasimpuls automatisch aus. Bei anderen Typen muss dieser Abblasimpuls durch ein zusätzliches digitales Signal angesteuert werden. Vakuumgreifer ESG Vakuumerzeuger VN-..-H-...-A mit eingebautem Ablassimpuls Beispiel: Ein Werkstück soll von einer Position pos2 auf die Position pos4 umgesetzt werden. pos1 pos2 pos3 pos4 Als Vakuumerzeuger wird eine Venturidüse eingesetzt. Diese wird über einen digitalen Ausgang der CMXR angesteuert. Dazu wird ein digitaler Ausgangsbaustein angelegt. Festo GDCP-CMXR-SW-DE de Version 1.0 243 24. Beispiele Variablen: vacuum : DOUT := (...) // digitaler Ausgangsbaustein Programm: Vel(dynCart, 1500) // Bahngeschwindigkeit = 1500 mm/sec Acc(dynCart, 5000) // Bahnbeschleunigung = 5000 mm/sec² OvlVel(75) // Geschwindigkeitsüberschleifen mit 75% Lin(pos1) vacuum.Set() // Vakuum sofort einschalten Lin(pos2) // Aufnahmeposition WaitTime(10) // 10 msec Wartezeit fuer Greifzeit Lin(pos1) Lin(pos3) // ueber Ablageposition Lin(pos4) // Ablageposition vacuum.Reset() // Vakuum am unteren Punkt ausschalten WaitTime (20) // 20 msec Wartezeit fuer Greifzeit Lin(pos3) Funktionsweise: Da es am Greifer keine Rückmeldungen gibt, ist es erforderlich, beim Schließen und Öffnen eine Wartezeit einzubauen. Diese ist mit Hilfe der Inbetriebnahme zu ermitteln und zu optimieren. Die Bewegungen werden mit einem Geschwindigkeitsüberschleifen von 75% abgefahren. Eine Ausnahme bildet hierzu die Aufnahme pos2 und Ablageposition pos4. Der nachfolgende Befehl WaitTime unterbindet ein Überschleifen, da die Satzvorrausberechnung an dieser Stelle angehalten wird und nach Ablauf der Zeit fortgesetzt wird. 244 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele Bewegungsprofil: pos1 pos3 Überschleifbereich pos4 pos2 zeitliches Verhalten: Geschwindigkeit pos2 pos4 Zeit pos1 pos1 pos3 pos3 Wartezeit Festo GDCP-CMXR-SW-DE de Version 1.0 245 24. Beispiele 24.4.2 Pneumatische Parallelgreifer Parallelgreifer besitzen Greiferbacken, die parallel geschlossen werden. Die Greiferbacken können dabei individuell auf die Applikation angepasst werden. Üblicherweise werden Parallelgreifer zum Öffnen und Schließen mit zwei separaten Ausgängen angesteuert. Optional können an den Greifer Sensoren integriert werden um die Rückmeldungen über die Endlagen (geöffnet oder geschlossen) zu bekommen. Beispiel: Ein Werkstück soll von einer Position pos2 auf die Position pos4 umgesetzt werden. pos1 pos2 pos3 pos4 Zum Einsatz kommt ein Parallelgreifer, der über Endlagen-Sensorik verfügt. Dabei ergeben sich folgende digitale Signale, die in Form von Bausteinen in der FTL-Programmierung eingebaut werden. 246 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele Variablen: outGripperOpen : DOUT := (...) // digitaler Ausgangsbaustein outGripperClose : DOUT := (...) // digitaler Ausgangsbaustein inGripperOpen : DIN := (...) // digitaler Eingangsbaustein inGripperClosed : DIN := (...) // digitaler Eingangsbaustein Programm: Vel(dynCart, 1500) // Bahngeschwindigkeit = 1500 mm/sec Acc(dynCart, 5000) // Bahnbeschleunigung = 5000 mm/sec² OvlVel(75) // Geschwindigkeitsüberschleifen mit 75% Lin(pos1) outGripperClose.Reset() outGripperOpen.Set() // Greifer oeffnen inGripperOpen.Wait(TRUE) // warte bis geoeffnet Lin(pos2) // Aufnahmeposition outGripperOpen.Reset() outGripperClose.Set() inGripperClosed.Wait() // Greifer schliessen // warte bis geschlossen Lin(pos1) Lin(pos3) Lin(pos4) // Ablageposition outGripperClose.Reset() outGripperOpen.Set() // Greifer oeffnen inGripperOpen.Wait() // warte bis geoeffnet Lin(pos3) Funktionsweise: Bei vorhandenen Sensoren für die Rückmeldung der Greiferendlagen sind keine Wartezeiten nötigt. Die Bewegungen werden mit einem Geschwindigkeitsüberschleifen von 75% abgefahren. Durch das Warten auf die Endlagenrückmeldungen mit der Bausteinmethode Wait, wird ein Überschleifen an den Aufnahme- und Ablagepositionen unterbunden. Die Satzvorausberechnung wird an dieser Stelle angehalten und nach Schalten des digitalen Eingangssignales fortgesetzt. Festo GDCP-CMXR-SW-DE de Version 1.0 247 24. Beispiele Bewegungsprofil: pos1 pos3 Überschleifbereich pos4 pos2 zeitliches Verhalten: Geschwindigkeit pos2 pos4 Zeit pos1 pos1 Wartezeit bis Rückmeldung Greifer geschlossen 248 pos3 pos3 Wartezeit bis Rückmeldung Greifer geöffnet Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele 24.4.3 Pneumatische Schwenk-Greifeinheit Die pneumatische Schwenk-Greifeinheit HGDS von Festo vereint einen Parallelgreifer mit einem Schwenkantrieb zu einer Einheit. Schwenk-Greifeinheit HGDS mit Parallelgreifer Die HGDS bietet die Möglichkeit, Sensoren für die Erkennung der Endlagen des Greifers und des Schwenkantriebs einzubauen. Die Sensoren werden benötigt um die Applikation sicher zu steuern. Beispiel: Ein Werkstück soll von einer Position pos2 auf die Position pos4 mit einer Drehung von 90 Grad umgesetzt werden. pos1 pos3 Drehung um 90 Grad pos2 pos4 Zum Einsatz kommt die HGDS Einheit, die über die entsprechenden Sensoren verfügt, um die Endlagen zu erkennen. Dabei ergeben sich folgende digitale Signale, die in Form von Bausteinen in der FTL-Programmierung eingebaut werden. Festo GDCP-CMXR-SW-DE de Version 1.0 249 24. Beispiele Variablen: outGripperOpen : DOUT := (...) // digitaler Ausgangsbaustein outGripperClose : DOUT := (...) // digitaler Ausgangsbaustein outPos0Degree : DOUT := (...) // digitaler Ausgangsbaustein outPos90Degree : DOUT := (...) // digitaler Ausgangsbaustein inGripperOpen : DIN := (...) // digitaler Eingangsbaustein inGripperClose : DIN := (...) // digitaler Eingangsbaustein inPos0Degree : DIN := (...) // digitaler Eingangsbaustein inPos90Degree : DIN := (...) // digitaler Eingangsbaustein Programm: Vel(dynCart, 1500) // Bahngeschwindigkeit = 1500 mm/sec Acc(dynCart, 5000) // Bahnbeschleunigung = 5000 mm/sec² OvlVel(75) // Geschwindigkeitsüberschleifen mit 75% Lin(pos1) // fahre über Teil outGripperClose.Reset() // Greifer auf outGripperOpen.Set() outPos0Degree.Set() // auf 0 Grad drehen outPos90Degree.Reset() inGripperOpen.Wait() // warten bis Greifer offen inPos0Degree.Wait() // warten bis auf 0 Grad Lin(pos2) // Aufnahmeposition outGripperOpen.Reset() outGripperClose.Set() // Greifer schließen inGripperClose.Wait() // warten bis Greifer geschlossen Lin(pos1) outPos0Degree.Reset() // auf 90 Grad drehen outPos90Degree.Set() Lin(pos3) inPos90Degree.Wait(TRUE) // warten 90 Grad mit Ueberschleifen Lin(pos4) // Ablageposition outGripperClose.Reset() // Greifer auf outGripperOpen.Set() inGripperOpen.Wait() // warten bis Greifer offen Lin(pos3) 250 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele Funktionsweise Mit integrierten Sensoren sind für die Rückmeldungen der Greif- und Drehbewegungen keine Wartezeiten notwendig. Die Abfrage der Drehbewegung auf 90 Grad wird mit der Möglichkeit des Überschleifens ausgeführt. Dies bedeutet, wenn die Rückmeldung der Drehung auf 90 Grad beim Fahren auf pos4 nicht vorhanden ist, wird die Bewegung gestoppt und gewartet bis die Rückmeldung ansteht. Liegt die Rückmeldung bereits an, so wird direkt eine Überschleifbewegung auf pos4 ausgeführt. Bewegungsprofil: Die Rückmeldung der Drehbewegung auf 90 Grad wird vor dem Erreichen der Position pos3 erkannt. Es wird eine Überschleifbewegung auf pos4 ausgeführt. pos1 pos3 Überschleifbereich pos4 pos2 Die Rückmeldung der Drehbewegung auf 90 Grad ist vor dem Erreichen der Position pos3 nicht eingetroffen. Es wird an der Position pos3 auf die Rückmeldung gewertet und keine Überschleifbewegung auf pos4 ausgeführt. pos1 pos3 Überschleifbereich pos2 Festo GDCP-CMXR-SW-DE de Version 1.0 pos4 251 24. Beispiele Zeitliches Verhalten: Rückmeldung der Drehung auf 90 Grad ist vor dem Erreichen der Position pos3 vorhanden. Es wird eine Überschleifbewegung auf Position pos4 ausgeführt. Rückmeldung Drehung 90 Grad Geschwindigkeit pos2 pos4 Zeit pos1 pos1 pos3 Wartezeit bis Rückmeldung Greifer geschlossen pos3 Wartezeit bis Rückmeldung Greifer geöffnet Rückmeldung der Drehung auf 90 Grad ist nicht an Position pos3 vorhanden. Es wird auf diese gewartet. Geschwindigkeit pos2 pos3 pos4 Zeit pos1 pos1 Wartezeit bis Rückmeldung Greifer geschlossen pos3 Wartezeit bis Rückmeldung Greifer geöffnet Wartezeit bis Rückmeldung Drehung 90 Grad 252 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele 24.5 Arbeiten mit der SPS-Schnittstelle 24.5.1 Aufgabenstellung Im folgenden Beispiel werden Teile von der Position „pickPos“ abgeholt und auf die Position „ablagePos“ transportiert. Dabei ist die Abholposition dynamisch. Die genauen Koordinaten werden in jedem Zyklus von einem Kamerasystem berechnet und über die PROFIBUS-SPS-Schnittstelle an die Steuerung gesendet. Für den Ablauf werden aus der Start- und Endposition zwei dynamische Zwischenpositionen berechnet. Diese werden im Ablauf als Stützpunkte benutzt. Werden von der SPS nicht rechtzeitig Daten geliefert, so wird der Zyklus auf der Position „wartePos“ angehalten, bis die SPS bereit ist. ueberPickPos wartePos pickPos ueberAblagePos ablagePos 24.5.2 SPS-Schnittstelle Der Datenaustausch zwischen der CMXR Steuerung und der SPS wird mit zwei Synchronisierungsbits realisiert. Im ersten Schritt wird von der SPS signalisiert, dass Daten gesendet wurden. Sobald die Daten von der CMXR übernommen wurden, wird dies an die SPS gemeldet. Anschließend werden beide Schnittstellensignale zurückgesetzt. Der Ablauf ist im folgenden Ablaufdiagramm dargestellt. Signal von der SPS Daten bereit plc_inboolreg[0] Signal an die SPS Daten gelesen plc_outboolreg[0] Position übernehmen Neue Position wurde übertragen Festo GDCP-CMXR-SW-DE de Version 1.0 Position wurde übernommen Übertragung Ende 253 24. Beispiele 24.5.3 Ablaufprogramm Variablen: waitPos : CARTPOS := (...) pickPos : CARTPOS := (...) depositPos : CARTPOS := (...) abovePickPos : CARTPOS := (...) aboveDepositPos : CARTPOS := (...) gripper : DOUT := (...) Programm: // Initialisierung Acc(dynCart, 4000) Vel(dynCart, 100) Lin(waitPos) WHILE TRUE DO // Handshake WAIT plc_inboolreg[0] // SPS signalisiert eine neue Position pickPos := plc_cposreg[0] abovePickPos.x := plc_cposreg[0].x abovePickPos.y := plc_cposreg[0].y plc_outboolreg[0] := TRUE // Bestätigt die Übernahme WAIT NOT plc_inboolreg[0] // Warten auf Reaktion der SPS plc_outboolreg[0] := FALSE // Anfahren der Aufnahmeposition Lin(abovePickPos) Lin(pickPos) // Greifen gripper.Set() WaitTime(200) // Anfahren der Ablageposition Lin(abovePickPos) Lin(aboveDepositPos) 254 Festo GDCP-CMXR-SW-DE de Version 1.0 24. Beispiele Lin(depositPos) // Ablegen gripper.Reset() WaitTime(200) // Anfahren der Warteposition Lin(aboveDepositPos) Lin(waitPos) END_WHILE Festo GDCP-CMXR-SW-DE de Version 1.0 255 A. FTL Befehlsliste A. FTL Befehlsliste Folgende Tabelle stellt die Verfügbarkeit der FTL Makros in einzelnen Systemen, verbunden mit der zugehörigen Betriebssystemversion dar. CMXR – C1 FTL Befehle CMXR-C2 Version 1.06 Version 1.25 Version 1.0 BOOL √ √ √ REAL √ √ √ DINT √ √ √ DWORD √ √ √ STRING √ √ √ ( ) - √ √ ARRAY - √ √ LOW - √ √ HIGH - √ √ MAPTO - √ √ MAP - √ √ IS_MAPPED - √ √ IF … THEN, ELSIF…. THEN, ELSE √ √ √ LABEL √ √ √ IF … GOTO √ √ √ GOTO √ √ √ WHILE …. DO √ √ √ LOOP √ √ √ CALL √ √ √ RUN √ √ √ RETURN √ √ √ KILL √ √ √ WaitTime √ √ √ WAIT √ √ √ WaitOnPath - √ √ WaitOnPos - √ √ WaitOnMainRun - - √ Ptp √ √ √ PtpRel √ √ √ Datentypen Funktionen, Anweisungen Programmsteuerung, Schleifen Bewegungsbefehle 256 Festo GDCP-CMXR-SW-DE de Version 1.0 A. FTL Befehlsliste MoveAxisPtp √ √ √ Lin √ √ √ LinRel √ √ √ MoveAxisCart √ √ √ CircIp √ √ √ PtpToCircIp √ √ √ LinToCircIP √ √ √ StopMove √ √ √ StopProgram √ √ √ Vel √ √ √ Acc √ √ √ Jerk √ √ √ Ovr √ √ √ DynOvr √ √ √ Ramp √ √ √ VconstOn √ √ √ VconstOff √ √ √ OvlVel √ √ √ OvlCart √ √ √ SetRefSys √ √ √ SetRefSys3P √ √ √ SetRefSysWorld √ √ √ SetRefSysDyn - - √ RefAxis √ √ √ RefAxisAsync √ √ √ WaitRefFinished √ √ √ IsAxisReferenced √ √ √ √ √ √ plc_InBool : ARRAY[16] OF BOOL √ √ - plc_OutBool : ARRAY[16] OF BOOL √ √ - plc_Dint : ARRAY[256] OF DINT √ √ - plc_AxisPos : ARRAY[256] OF AXISPOS √ √ - plc_CartPos : ARRAY[256] OF CARTPOS √ √ - plc_RefSys : ARRAY[16] OF REFSYSDATA √ √ - Dynamikbefehle Überschleifbefehle Referenzsysteme Referenzfahrt Werkzeuge Tool Profibusschnittstelle, Systemvariablen, Funktionen Festo GDCP-CMXR-SW-DE de Version 1.0 257 A. FTL Befehlsliste ProgHold √ √ √ plc_InBool : ARRAY[256] OF BOOL - - √ plc_OutBool : ARRAY[256] OF BOOL - - √ plc_InDword : ARRAY[256] OF DWORD - - √ plc_OutDword : ARRAY[256] OF DWORD - - √ plc_InDint : ARRAY[256] OF DINT - - √ plc_OutDint : ARRAY[256] OF DINT - - √ plc_InReal : ARRAY[256] OF Real - - √ plc_OutReal : ARRAY[256] OF Real - - √ plc_InAxisPos : ARRAY[256] OF AXISPOS - - √ plc_OutAxisPos : ARRAY[256] OF AXISPOS - - √ plc_InCartPos : ARRAY[256] OF CARTPOS - - √ plc_OutCartPos : ARRAY[256] OF CARTPOS - - √ SetInfo √ √ √ SetWarning √ √ √ SetError √ √ √ ReadActualPos √ √ √ ReadTargetPos √ √ √ SavePosition √ √ √ Time √ √ √ TimeToStr √ √ √ SIN, ASIN √ √ √ COS, ACOS √ √ √ TAN, ATAN √ √ √ COT, ACOT √ √ √ ATAN2 √ √ √ LN √ √ √ EXP √ √ √ ABS √ √ √ SQRT √ √ √ SHR, SHL √ √ √ ROR, ROL √ √ √ STR √ √ √ CHR √ √ √ ORD √ √ √ SetBit - - √ ResetBit - - √ Variablenschnittstelle zur internen SPS (CoDeSys) Meldesystem Funktionen 258 Festo GDCP-CMXR-SW-DE de Version 1.0 A. FTL Befehlsliste CheckBit - - √ √ √ √ Wait, WaitN √ √ √ Read √ √ √ RisingEdge √ √ √ ResetRisingEdge √ √ √ digitaler Ausgang, DOUT √ √ √ Wait, WaitN √ √ √ Read √ √ √ RisingEdge √ √ √ ResetRisingEdge √ √ √ Set, Reset √ √ √ Write √ √ √ Pulse - √ √ √ √ √ WaitLss, WaitGrt √ √ √ WaitIns, WaitOuts √ √ √ Read √ √ √ √ √ √ Write √ √ √ WaitLss, WaitGrt √ √ √ WaitIns, WaitOuts √ √ √ Read √ √ √ √ √ √ Start √ √ √ Stop √ √ √ Reset √ √ √ Read √ √ √ ToStr √ √ √ Encoder, ENCODER √ √ √ Set √ √ √ Read √ √ √ √ √ √ WriteSDO √ √ √ ReadSDOSigned √ √ √ ReadSDOUnsigned √ √ √ onstartup - - √ onprogload - - √ Bausteine und Methoden digitaler Eingang, DIN analoger Eingang, AIN Analoger Ausgang, AOUT Timer, CLOCK CANOpen, COPDEVICE Ereignisse Festo GDCP-CMXR-SW-DE de Version 1.0 259 A. FTL Befehlsliste onproginterrupt - - √ onprogcontinue - - √ onprogend - - √ onf1keypressed - - √ onf1keyreleased - - √ onf2keypressed - - √ onf2keyreleased - - √ GetAutoModeActive - - √ GetManualModeActive - - √ LoadProgram - - √ DO - √ √ OnPosition - - √ OnParameter - - √ OnDistance - - √ OnPlane - - √ Schaltpunkte 260 Festo GDCP-CMXR-SW-DE de Version 1.0 B. Menübaum der FTL Befehle B. Menübaum der FTL Befehle Um die Programmierung zu erleichtern, wird am Handbediengerät CDSA und im FTL Programmiereditor ein Menübaum angezeigt, der alle verfügbaren FTL Befehle enthält. Im folgenden werden alle Befehle des Befehlsumfangs „FTL Programmierung Basis“ dargestellt. Darstellung des Menübaums am Handbediengerät CDSA: SPS-Schnittstelle ProgHold Funktionen ABS ACOS ACOT ASIN ATAN ATAN2 COS COT CheckBit EXP LN Positionsfunktionen o ReadActualPos o ReadTargetPos Festo GDCP-CMXR-SW-DE de Version 1.0 261 B. Menübaum der FTL Befehle o SavePosition ResetBit SIN SQRT SetBit TAN Time TimeToStr Referenzieren IsAxisReferenced RefAxis RefAxisAsync WaitRefFinished Bewegungsbefehle CircIp Lin LinRel LinToCircIp MoveAxisCart MoveAxisPtp Ptp PtpRel PtpToCircIp StopMove Dynamikbefehle Acc DynOvr Jerk OvlCart OvlVel OvlWrist Ovr Ramp VconstOff 262 Festo GDCP-CMXR-SW-DE de Version 1.0 B. Menübaum der FTL Befehle VconstOn Vel Anweisungen … := … CALL… // ELSE ELSIF … THEN GOTO… IF … GOTO IF … THEN … END_IF KILL… LABEL… LOOP … DO … END_LOOP RETURN RUN… StopProgram WAIT… WHILE … DO … END_WHILE WaitOnMainRun WaitOnPath WaitOnPos WaitTime Roboterbefehle Referenzsysteme o SetRefSys o SetRefSys3P o SetRefSysDyn o SetRefSysWorld Tool Systemfunktionen Zeitmessung o CLOCK.Read o CLOCK.Reset Festo GDCP-CMXR-SW-DE de Version 1.0 263 B. Menübaum der FTL Befehle o CLOCK.Start o CLOCK.Stop o CLOCK.ToStr Bitmanipulation o CHR o ORD o ROL o ROR o SHL o SHR o STR Meldesystem SetError SetInfo SetWarning E/A Bausteine Analoge Eingänge o AIN.Read o AIN.WaitGrt o AIN.WaitIns o AIN.WaitLss o AIN.WaitOuts Analoge Ausgänge o AOUT.Read o AOUT.WaitGrt o AOUT.WaitIns o AOUT.WaitLss o AOUT.WaitOuts o AOUT.Write CANopen Geräte o COPDEVICE.ReadSDOSigned o COPDEVICE.ReadSDOUnsigned o COPDEVICE.WriteSDO Digitale Eingänge 264 Festo GDCP-CMXR-SW-DE de Version 1.0 B. Menübaum der FTL Befehle o DIN.Read o DIN.ResetRisingEdge o DIN.RisingEdge o DIN.Wait o DIN.WaitN Digitale Ausgänge o DOUT.Pulse o DOUT.Read o DOUT.Reset o DOUT.ResetRisingEdge o DOUT.RisingEdge o DOUT.Set o DOUT.Wait o DOUT.WaitN o DOUT.Write Inkrementalgeber o ENCODER.Read o ENCODER.Set Technologiefunktionen Objektverfolgung o CONVEYOR.Begin o CONVEYOR.End o CONVEYOR.Done o CONVEYOR.Wait o CONVEYOR.WaitReachable Bahnschaltpunkte o OnDistance o OnParamter o OnPlane Festo GDCP-CMXR-SW-DE de Version 1.0 265 C. Verwendete Begriffe C. Verwendete Begriffe Folgende Tabelle enthält in diesem Dokument verwendete Begriffe: Begriff Bedeutung C CDSA Festo Typcode für das Handbediengerät CF card Compact Flash Card, wird bei CMXR als Speichermedium eingesetzt. CMXR-C1 Festo Typcode für das CMXR Basismodell C1 CMXR-C2 Festo Typcode für das CMXR Modell der oberen Leistungsklasse CoDeSys Name der integrierten SPS Steuerung, die nach IEC 61131-3 programmierbar ist und gemeinsam mit der Robotik auf einem Prozessor läuft. F FCT Festo Configuration Tool, Basissoftware zur Konfiguration der CMXR Steuerungen sowie weitere Festo Produkte z. B. elektrische Antriebe. FCT-Plugin Softwaremodul für die FCT Basissoftware. Für einzelne Festo Produkte können PlugIns installiertwerden. Diese sind im Downloadbereich der Festo Homepage www.festo.com erhältlich. FTL Festo Teach Language, textuelle Programmiersprache der Bewegungsprogramme T Tracking 266 Verfolgen von bewegten Objekten z. B. Teile auf einem Förderband. Festo GDCP-CMXR-SW-DE de Version 1.0 D. Index D. Index # D ##........................................................ 60 Datentypen ......................................... 29 deaktivierter Programmsatz ................ 60 DIN ................................................... 171 DO ...................................................... 58 DOUT ................................................ 175 DynOvr................................................ 99 / // ........................................................ 60 _ _global.tt ............................................. 20 A ABS ................................................... 161 Acc ...................................................... 94 Achsposition........................................ 62 ACOS ................................................. 156 ACOT ................................................. 159 AIN .................................................... 182 AOUT ................................................. 187 Array ................................................... 32 ASIN .................................................. 155 ATAN ................................................. 158 ATAN2 ............................................... 160 AXISPOS .............................................. 62 B Beispiel Arbeiten mit der SPS Schnittstelle .. 253 Arbeiten mit Ein- und Ausgangsbausteinen ................... 240 Arbeiten mit Greifern ...................... 242 Steuerung des Satzvorlauf.............. 241 Stoppen von Bewegungen .............. 237 WAIT mit digitalem Eingang .............. 54 E ENCODER .......................................... 196 Error.................................................. 204 EXP ................................................... 160 F FTL ........................................... 13, 17, 20 G GOTO .................................................. 45 I IF…GOTO ............................................. 44 IF…THEN ............................................. 42 IS_MAPPED ......................................... 37 IsReferenced ..................................... 126 J Jerk ..................................................... 95 K Kartesische Position............................ 65 KILL ..................................................... 51 Kommentar ......................................... 60 C L CALL .................................................... 48 CARTPOS ............................................. 62 CheckBit ............................................ 167 CHR ................................................... 164 CircIp ................................................... 83 CLOCK ............................................... 192 COPDEVICE ........................................ 200 COS ................................................... 156 COT ................................................... 159 LABEL ................................................. 44 Lin....................................................... 76 LinRel.................................................. 78 LinToCircIp .......................................... 87 LN ..................................................... 160 LOOP .................................................. 46 LOW, HIGH .......................................... 34 Festo GDCP-CMXR-SW-DE de Version 1.0 M MAP .................................................... 37 MAPTO ................................................ 37 MoveAxisCart ...................................... 72 267 D. Index MoveAxisPtp ....................................... 72 N Nullsegment ...................................... 106 O ORD ................................................... 164 OvlCart .............................................. 110 OvlVel................................................ 108 Ovr .............................................. 97, 234 P plc_AxisPos ....................................... 138 plc_CartPos ....................................... 138 plc_RefSys ......................................... 139 plc_VarDint........................................ 137 Profibusschnittstelle .......................... 135 ProgHold ........................................... 140 Ptp ...................................................... 67 PtpRel ................................................. 70 PtpToCircIp .......................................... 85 R Ramp ................................................. 101 Read .................................................. 199 ReadActualPos .................................. 151 ReadSDOSigned ................................ 202 ReadSDOUnsigned ............................ 203 ReadTargetPos .................................. 152 RefAxis .............................................. 121 RefAxisAsync ..................................... 123 ResetBit............................................. 166 RETURN ............................................... 49 ROL ................................................... 163 ROR ................................................... 163 RUN ..................................................... 51 S Satzvorlauf ............................ 52, 53, 241 SavePosition ..................................... 153 Schlüsselwörter ................................... 25 Set .................................................... 198 SetBit ................................................ 165 SetError ............................................. 149 268 SetInfo .............................................. 147 SetRefSys ......................................... 114 SetRefSys3P ..................................... 115 SetRefSysDyn ................................... 118 SetRefSysWorld ................................ 118 SetWarning ....................................... 148 SHL ................................................... 162 SHR................................................... 162 SIN .................................................... 155 SQRT................................................. 161 State ................................................. 204 StopMove ........................................... 89 StopProg ............................................. 90 STR ................................................... 164 T TAN ................................................... 158 TCP ................................................... 127 tid ................................................. 20, 21 Time.................................................. 153 TimeToStr ......................................... 154 tip ....................................................... 20 Tool .................................................. 130 Typumwandlungen ............................. 31 V Value ................................................ 204 VconstOff .......................................... 104 VconstOn .......................................... 102 Vel ...................................................... 93 W WAIT ................................................... 53 WaitOnMainRun .................................. 57 WaitOnPath......................................... 55 WaitOnPos .......................................... 56 WaitRefFinished ................................ 125 WaitTime............................................. 52 Wartezeit ............................................ 52 Werkzeuge ........................................ 127 WHILE ................................................. 45 WriteSDO .......................................... 201 Festo GDCP-CMXR-SW-DE de Version 1.0