Robotersteuerung SRC-300/320 - Epson
Robotersteuerung SRC-300/320 - Epson
Robotersteuerung SRC-300/320 - Epson
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
<strong>Robotersteuerung</strong><br />
Rev. 2 EM971R502F<br />
EPSON<br />
<strong>SRC</strong> – <strong>300</strong>/<strong>320</strong>
EPSON<br />
ROBOTERSTEUERUNG<br />
<strong>SRC</strong> – <strong>300</strong>/<strong>320</strong><br />
Bedienungshandbuch<br />
EPSON Deutschland GmbH<br />
Industrial Robots-Division<br />
SEIKO EPSON CORPORATION<br />
i
GARANTIE<br />
ii<br />
Die Roboter und die dazugehörigen Optionen werden erst nach strengsten Qualitätskontrollen,<br />
Tests und Prüfungen gemäß unserer hohen Leistungsstandards an unsere Kunden ausgeliefert.<br />
Treten bei normalem Betrieb, innerhalb von 12 Monaten nach Lieferung, Störungen auf, wird eine<br />
kostenfreie Reparatur garantiert.<br />
Davon ausgenommen sind jedoch die folgenden Fälle:<br />
1. Schäden oder Fehlfunktionen, verursacht durch falsche Bedienung.<br />
2. Schäden oder Fehlfunktionen, verursacht durch Demontagen.<br />
3. Schäden oder Fehlfunktionen, verursacht durch unerlaubte Modifikationen oder<br />
Reparaturen.<br />
4. Schäden oder Fehlfunktionen, die durch extreme, roboterunabhängige Ursachen<br />
entstanden sind, wie z.B. Brand- oder Wasserschäden.<br />
Die Garantie beginnt ab Auslieferung, also ab Lager Düsseldorf.<br />
Die vorliegenden Garantiebestimmungen gelten jedoch nicht in allen Ländern in vollem Umfang.<br />
Zusätzliche Informationen zum Haftungsumfang erhalten Sie bei Ihrem SEIKO EPSON Partner,<br />
bei dem Sie das Robotersystem erworben haben.
SERVICE CENTER<br />
Bei Reparaturen, Inspektionen oder Justageeinstellungen nehmen Sie bitte Kontakt zum nächsten<br />
Roboter Service Center auf.<br />
Halten Sie folgende Informationen bereit:<br />
• Roboter Typ,<br />
• Seriennummer,<br />
• M.Code,<br />
• Software Version und<br />
• eine Beschreibung des Roboterproblems.<br />
SERVICE CENTER USA<br />
HERSTELLER<br />
SEIKO EPSON CORPORATION<br />
Robots & FA. Systems Department<br />
Okaya Plant No. 2<br />
1-16-15, Daiei-cho<br />
Okaya-shi, Nagano-ken, 394<br />
Japan<br />
EPSON Deutschland GmbH<br />
Industrial Robots-Division<br />
Zülpicher Straße 6<br />
D-40549 Düsseldorf<br />
Tel: 0211 5603-204<br />
Fax: 0211 5603-319<br />
Seiko Instruments Inc USA<br />
Factory Automation Division<br />
2990 West Lomita Blvd<br />
Torrance, CA 90505<br />
Tel: (310) 517-7842<br />
Fax: (310) 517-8158<br />
TEL: 81-266-23-0020<br />
81-266-24-2001<br />
FAX: 81-266-24-2017<br />
iii
Vor Inbetriebnahme der <strong>Robotersteuerung</strong> lesen Sie bitte die folgenden Sicherheitshinweise aus diesem<br />
und allen weiteren Handbüchern.<br />
Das Kapitel „Sicherheit“ in diesem Handbuch erklärt minimale Sicherheitsvorkehrungen, die ein<br />
Bediener beachten muß, wenn er den Roboter einrichten und benutzen will. Bitte lesen Sie das<br />
Handbuch genau bevor Sie mit den Einstellungen beginnen und führen Sie die entsprechenden<br />
Sicherheitsvorkehrungen durch.<br />
Bewahren Sie diese Handbücher anschließend an einem für alle Betreiber zugänglichen Ort auf.<br />
iv<br />
Sicherheitshinweis<br />
� WARNUNG<br />
• Betreiben Sie den Roboter erst nach vollständiger Installation auf einer dafür konstruierten Grundplatte<br />
mit allen erforderlichen Sicherheitsabschrankungen, etc. Eine Inbetriebnahme auf der Transportpalette,<br />
auch zu Testzwecken, ist nicht zulässig und extrem gefährlich!<br />
• Stellen Sie sicher, daß beim An- oder Abklemmen von Kabelverbindungen zwischen der Eingabekonsole<br />
und der Steuerung der Netzschalter des Gerätes ausgeschaltet und verriegelt ist. Nichtbeachtung führt zu<br />
elektrischen, wie auch mechanischen Fehlfunktionen.<br />
• Stellen Sie während des Normalbetriebes sicher, daß nur unterwiesene Personen Zugriff auf die<br />
Eingabekonsole erhalten. Falsche Handhabung oder Bedienung kann zu Fehlfunktionen, Zerstörungen<br />
oder gefährlichen Unfällen führen<br />
• Der Aufenthalt im Gefahrenbereich des Roboters ist nicht zulässig!<br />
• Benutzen Sie ausschließlich Originalzubehörteile. Dies gilt besonders für alle sicherheitsrelevanten Teile,<br />
wie Programmierkabel, Programmiersoftware und optional benutzte Handbediengeräte.<br />
• Vor Inbetriebnahme des Roboters ist die Funktion aller NOT-AUS-Systeme und des E.STOP CANCEL-<br />
Tasters zu prüfen. Dieser Taster dient zur kurzzeitigen Überbrückung des NOT-AUS-Schalters der<br />
TEACH-Schnittstelle. Durch Betätigung dieses Tasters ist es möglich, während des Roborterbetriebes das<br />
SPEL-Editor-Kabel gegen den Dummystecker auszutauschen, ohne daß die Steuerung in den NOT-AUS-<br />
Status umschaltet. Benutzen Sie den Roboter nicht, wenn die E. STOP CANCEL LED leuchtet, nachdem<br />
alle NOT-AUS-Schalter entriegelt und die NOT-AUS-Meldung zurückgesetzt wurde und somit kein NOT-<br />
AUS-Signal an der Steuerung anliegt. Benutzen Sie den Roboter ebenfalls nicht, wenn die LED nicht<br />
leuchtet, während Sie den E. STOP CANCEL-Taster drücken. Dieses Signal bedeutet, daß eine<br />
Fehlfunktion im NOT-AUS-Kreis der vorderen (TEACH) Schnittstelle vorliegt.
VORWORT<br />
Dieses Handbuch spezifiziert die grundlegenden Einzelheiten, die zur korrekten Bedienung der<br />
Steuerung benötigt werden. Bitte arbeiten Sie das Handbuch, wie auch die folgenden Handbücher<br />
ründlich durch, bevor Sie die Komponenten benutzen.<br />
HANDBÜCHER<br />
1. Manipulator-Handbuch<br />
Handbuch zum Manipulator. Dieses Handbuch liegt Ihnen vor. Hier wird die Installation und<br />
der Anschluß von Peripheriegeräten erläutert.<br />
2. Handbuch zur <strong>Robotersteuerung</strong><br />
Handbuch zur Steuerung des Roboters. Dieses Handbuch liegt Ihnen vor. Hier werden<br />
Installation, Schaltereinstellungen, und der Anschluß an Peripheriegeräte beschrieben.<br />
3. Referenzhandbuch<br />
Handbuch, in dem die Befehle der Roboterprogrammiersprache SPEL III beschrieben werden.<br />
4. Wartungshandbuch<br />
Das Handbuch beschreibt das Verfahren zur Wartung des Roboters. Hier werden bspw.<br />
Methoden zur Problembehebung, Reparaturanleitungen, etc. beschrieben.<br />
5. Handbuch zur Bedieneinheit (optional)<br />
Handbuch zur Bedieneinheit. Hier wird die Bedienung beschrieben.<br />
6. Handbuch zum Programmentwicklungs- Tool<br />
In diesem Handbuch zur Programmentwicklung werden die Befehle der<br />
Entwicklungsumgebung und –methoden des SPEL Editor (optional) oder SPEL für Windows<br />
(optional) beschrieben.<br />
Wir bieten zwei Arten von Software: den SPEL Editor für MS-DOS und SPEL für Windows<br />
für Microsoft Windows. Ferner bieten wir als Option zum SPEL für Windows: Vision Guide,<br />
das integrierte Roboter Vision System (Bildverarbeitungssystem), an.<br />
7. Handbuch zum Handprogrammiergerät<br />
Hier werden die Anwendungsmöglichkeiten des Handprogrammiergerätes (Teaching<br />
Pendant) erläutert, etc.<br />
v
Eingabeformate der Befehle<br />
Formatierungsregeln für die Eingabebefehle<br />
Einfache Zeichenfolge: Geben Sie die Zeichenfolge wie dargestellt ein.<br />
vi<br />
Beispiel: MOTOR EIN<br />
[ ] (eckige Klammern): Benutzen Sie dies zur Dateneingabe<br />
Beispiel: EIN [Ausgabe Bitnummer]<br />
| | (vertikale Striche): Benutzen Sie dies zur Eingabe der Einstellungsmöglichkeiten<br />
Beispiel: MOTOR<br />
|EIN|<br />
|AUS|<br />
{ } (Klammern): Benutzen Sie dies zur Eingabe nicht benötigter Einstellungen (Schalter<br />
etc.). Die Funktion variiert je nachdem, ob die Einstellung genutzt wird<br />
oder nicht.<br />
Beispiel: DIR {/W}<br />
{ }n (Klammern + n): Benutzen Sie dies um einzugeben, daß die in den Klammern stehenden<br />
Werte n-Mal wiederholt werden sollen (geben Sie eine Zahl für n ein).<br />
Geben Sie nur „n“ ein, heißt das, daß die Werte wiederholt werden können.<br />
~ (Tilde): Hiermit zeigen Sie, daß ein Befehl noch in die nächste Zeile weiterführt<br />
oder daß er noch zur vorhergehenden Zeile gehört.<br />
Für „SPEL für Windows“-Benutzer<br />
Wir empfehlen nicht, „SPEL für Windows“ für Windows mit dem „SPEL-Editor“ einzusetzen. Benutzen<br />
Sie „SPEL für Windows“ mit dem „SPEL-Editor“, schlagen Sie unter „7. Benutzung des<br />
Handprogrammiergeräts und des SPEL-Editors“ im „SPEL für Windows“ Handbuch nach.
Alle Rechte vorbehalten. Kein Teil dieses Handbuchs darf in irgendeiner Form (Druck, Fotokopie,<br />
Mikrofilm oder ein anderes Verfahren) ohne die schriftliche Genehmigung der SEIKO EPSON<br />
Corporation reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder<br />
verbreitet werden. Im Hinblick auf die Nutzung der im Handbuch enthaltenen Informationen wird<br />
keinerlei Patenthaftung übernommen.<br />
Das Handbuch wurde mit der gebotenen Sorgfalt erarbeitet, SEIKO EPSON übernimmt jedoch keinerlei<br />
Patenthaftung für etwaige Fehler oder Auslassungen. Außerdem wird keine Haftung übernommen für<br />
Schäden, die sich durch Verwendung der im Handbuch enthaltenen Informationen ergeben.<br />
Weder SEIKO EPSON Corporation noch ihre Tochtergesellschaften haften gegenüber dem Käufer<br />
dieses Produkts oder Dritter für Schäden, Verluste, Kosten oder Ausgaben, die von dem Käufer oder<br />
Dritten aufgrund von Unfall, Mißbrauch des Produkts oder unerlaubter Änderungen, Reparaturen oder<br />
Neuerungen verursacht wurden.<br />
SEIKO EPSON haftet nicht für Schäden oder Störungen, die sich durch Einsatz von Optionen oder<br />
Fremdzubehör ergeben, die keine original EPSON-Produkte sind, oder keine ausdrückliche Zulassung<br />
der Firma SEIKO EPSON als „EPSON Approved Products“ haben.<br />
Warenzeichen<br />
Copyright © 1999 by EPSON Deutschland GmbH, Düsseldorf.<br />
vii
Inhaltsverzeichnis<br />
Sicherheit.................................................................................................................... 5<br />
1. Grundfunktionen.............................................................................................................6<br />
1.1 Niedrige und hohe Spannung.............................................................................................................. 6<br />
1.2 Sicherheitsabschrankungen................................................................................................................. 7<br />
1.3 NOT-AUS........................................................................................................................................... 8<br />
1.4 Zustimmtaster (nur für <strong>SRC</strong>-<strong>320</strong>)........................................................................................................ 8<br />
2. Sicherheitshinweise ........................................................................................................9<br />
2.1 Allgemeines........................................................................................................................................ 9<br />
2.2 Allgemeine Konstruktionsanforderungen .......................................................................................... 10<br />
Einführung ................................................................................................................ 11<br />
1. Vorbereitung .................................................................................................................12<br />
1.1 Komponenten des Roboters............................................................................................................... 12<br />
Optionen............................................................................................................................................. 12<br />
1.2 Vorsichtsmaßnahmen bei der Installation.......................................................................................... 13<br />
Überprüfen des M. CODE und der Kabellänge.................................................................................... 13<br />
Transportsicherung ............................................................................................................................. 13<br />
1.3 Programmiereinheit .......................................................................................................................... 13<br />
Vorbereitungen zum Gebrauch der Programmiereinheit...................................................................... 13<br />
1.4 Modi................................................................................................................................................. 14<br />
Steuerungsmodi .................................................................................................................................. 14<br />
TEACH-Modus................................................................................................................................... 14<br />
AUTO-Modus..................................................................................................................................... 16<br />
1.5 Fehlermeldung.................................................................................................................................. 17<br />
LCD Kontrollanzeige der Steuerung ................................................................................................... 17<br />
Ausgabe an OPU-<strong>300</strong> und REMOTE1-Steckverbindung ..................................................................... 18<br />
Ausgabe an Programmiereinheit ......................................................................................................... 18<br />
2. Grundlegende Bedienung.............................................................................................19<br />
2.1 Ablaufplan........................................................................................................................................ 19<br />
2.2 Überprüfung des Startzustandes ........................................................................................................ 20<br />
2.3 Einstellen der Datensicherung........................................................................................................... 21<br />
Initialisierung des Bewegungsbereiches............................................................................................... 21<br />
2.4 Einschalten der Motorspannungszufuhr ............................................................................................ 22<br />
Der Betriebszustand des Motors .......................................................................................................... 22<br />
2.5 Kalibrierung ..................................................................................................................................... 23<br />
2.6 Einstellen der Home-(Standby-)Position............................................................................................ 24<br />
Definieren der Home-(Standby-)Position............................................................................................. 24<br />
Armbewegungsreihenfolge bei Einstellung der Home-(Standby-)Position............................................ 24<br />
2.7 Teaching und Programmieren........................................................................................................... 25<br />
Teaching............................................................................................................................................. 25<br />
Beispiele für Einrichtmethoden........................................................................................................... 26<br />
Beispielprogrammierung..................................................................................................................... 28<br />
2.8 Ausführen eines Programms ............................................................................................................. 29<br />
Kompilieren........................................................................................................................................ 29<br />
Ausführen des Programms mit dem PC............................................................................................... 29<br />
Ausführen des Programms mit der Bedieneinheit................................................................................ 30<br />
Ausführen des Programms über REMOTE3........................................................................................ 30<br />
2.9 Auswahl des Programms zum Ändern von Zeilen ............................................................................. 31<br />
Auswahl des Programms per REMOTE-Eingang ................................................................................ 31<br />
Verwendung des CHAIN-Befehls........................................................................................................ 32<br />
2.10 Handhabung von Dateien................................................................................................................ 32<br />
3. JOG-Betrieb..................................................................................................................33<br />
3.1 Das verwendete Koordinatensystem im JOG-Verfahren .................................................................... 33<br />
JOG-Verfahren im Basis-Koordinatensystem ...................................................................................... 34<br />
JOG-Verfahren im Tool-Koordinatensystem ....................................................................................... 35<br />
JOG-Verfahren im Joint-Koordinatensystem....................................................................................... 35
2<br />
3.2 JOG-Bewegung................................................................................................................................. 36<br />
Grundlagen............................................................................................................... 37<br />
1. Bewegungsgeschwindigkeit..........................................................................................38<br />
1.1 Beschleunigungs-/Verzögerungsgeschwindigkeit .............................................................................. 38<br />
1.2 Hochgeschwindigkeit im Teach-Modus............................................................................................. 39<br />
Blockierung durch die Sicherheitsabschrankung ................................................................................. 39<br />
Blockierung durch den POWER-(LP)-Befehl ...................................................................................... 39<br />
Blockierung durch den TSPEED-Befehl.............................................................................................. 40<br />
1.3 Beschleunigungs-/Verzögerungssteuerung der 3. Achse mit dem JUMP-Befehl ................................ 41<br />
1.4 Transport von Objekten, die das Nominalgewicht überschreiten........................................................ 42<br />
2. Programmierung ...........................................................................................................43<br />
2.1 Grundlegende Bestandteile eines Programms.................................................................................... 43<br />
Funktionsname ................................................................................................................................... 44<br />
Kommentare ....................................................................................................................................... 44<br />
Mehrfachanweisung............................................................................................................................ 44<br />
Sprungmarken .................................................................................................................................... 45<br />
2.2 Konstanten........................................................................................................................................ 46<br />
Numerische Konstanten ...................................................................................................................... 46<br />
Zeichenketten...................................................................................................................................... 46<br />
2.3 Variablen.......................................................................................................................................... 47<br />
Spezifische Anzahl von Variablen....................................................................................................... 47<br />
Numerische Variablen......................................................................................................................... 47<br />
Zeichenketten-Variablen ..................................................................................................................... 48<br />
Bereichsvariablen................................................................................................................................ 49<br />
Auflisten der Variablennamen............................................................................................................. 49<br />
Backup-Variablen ............................................................................................................................... 50<br />
Hinweis zur Verwendung von Variablen ............................................................................................. 51<br />
2.4 Operationen ...................................................................................................................................... 52<br />
Mathematische Operationen................................................................................................................ 52<br />
Logische Operatoren ........................................................................................................................... 52<br />
Relationale Operatoren........................................................................................................................ 53<br />
Zeichenketten-Operatoren................................................................................................................... 53<br />
Rangfolge der Operatoren ................................................................................................................... 53<br />
Operationen mit ganzen und reellen Zahlen........................................................................................ 53<br />
Rückgabewerte.................................................................................................................................... 54<br />
Fälle, in denen Operationen und Funktionen benutzt werden können .................................................. 54<br />
2.5 Steueranweisungen des Programms................................................................................................... 55<br />
FOR...NEXT....................................................................................................................................... 55<br />
GOTO................................................................................................................................................. 55<br />
IF THEN ELSE................................................................................................................................... 55<br />
GOSUB...RETURN............................................................................................................................. 56<br />
GOTO, FOR...NEXT, GOSUB...RETURN, IF...THEN...ELSE........................................................... 56<br />
CALL ................................................................................................................................................. 57<br />
* ZEROFLG(0)................................................................................................................................... 57<br />
SELECT...CASE...SEND.................................................................................................................... 57<br />
WHILE[Bedingung]...WEND ............................................................................................................. 58<br />
TRAP.................................................................................................................................................. 58<br />
NESTING........................................................................................................................................... 59<br />
2.6 Pseudobefehl..................................................................................................................................... 60<br />
3. Dateien .........................................................................................................................61<br />
3.1 Haupt- und Dateispeicher.................................................................................................................. 61<br />
Speicherbereich im Hauptspeicher....................................................................................................... 61<br />
Bereich zur Programmausführung....................................................................................................... 62<br />
Dateispeicher ...................................................................................................................................... 62<br />
3.2 Dateinamen ...................................................................................................................................... 63<br />
Die Bestandteile eines Dateinamens.................................................................................................... 63<br />
Erzeugen eines Dateinamens............................................................................................................... 63
Erweiterung ........................................................................................................................................ 63<br />
Spezielle Dateinamen.......................................................................................................................... 64<br />
3.3 Dateien, die während der Ausführung geladen werden...................................................................... 64<br />
4. Verzeichnis ...................................................................................................................65<br />
4.1 Verzeichnis....................................................................................................................................... 65<br />
Hauptverzeichnis ................................................................................................................................ 65<br />
Unterverzeichnis................................................................................................................................. 65<br />
Erzeugen eines Unterverzeichnisses .................................................................................................... 65<br />
Löschen eines Unterverzeichnisses...................................................................................................... 66<br />
Baumstrukturierte Verzeichnisse......................................................................................................... 66<br />
Stammverzeichnis (Mutterverzeichnis), Unterverzeichnis (Kinderverzeichnis) ................................... 66<br />
Aktuelles Verzeichnis ......................................................................................................................... 66<br />
Festlegen eines Pfades......................................................................................................................... 67<br />
Umgebungsvariablen........................................................................................................................... 68<br />
Anwendungen........................................................................................................... 69<br />
1. Multitasking...................................................................................................................70<br />
1.1 Was ist Multitasking......................................................................................................................... 70<br />
Vorteile des Multitaskings................................................................................................................... 70<br />
Multitasking in SPEL III..................................................................................................................... 71<br />
Tasks während der Ausführung des WAIT-Befehls, des INPUT-Befehls und des Bewegungs-Befehls . 72<br />
WAIT-Befehl und IF-Satz................................................................................................................... 72<br />
Zeitprogrammierung für den Wechsel der Tasks ................................................................................. 73<br />
1.2 Ineinandergreifen von Tasks ............................................................................................................. 74<br />
Störungen der Steuerung..................................................................................................................... 74<br />
Nur ein Gerät wird von Vielfach-Tasks benutzt................................................................................... 75<br />
2. Programmiertechniken........................................................................................................................ 77<br />
2.1 Schreiben eines umfangreichen Programms (Effizienter Einsatz von CHAIN/LINK) ........................ 77<br />
Einsatzmöglichkeiten des CHAIN-Befehls .......................................................................................... 77<br />
Einsatzmöglichkeiten des CHAIN-Befehls .......................................................................................... 78<br />
2.2 Bewegung zu mehreren gleichweit voneinander entfernten Punkten.................................................. 79<br />
Definieren von Paletten....................................................................................................................... 79<br />
Positionsbestimmung innerhalb der Palette ......................................................................................... 80<br />
2.3 Techniken zum Verkürzen der Zykluszeit ......................................................................................... 81<br />
Benutzen einer Bogenbewegung.......................................................................................................... 81<br />
Freies Einstellen des Zeitverhaltens bei Abschluß der Positionierung .................................................. 81<br />
Parallele Prozesse................................................................................................................................ 81<br />
Bedingter Stop während der Bewegung............................................................................................... 82<br />
Montageanwendung mit langsamer Geschwindigkeit.......................................................................... 82<br />
Vereinigte Befehle .............................................................................................................................. 82<br />
2.4 Benutzen von Positionsdaten............................................................................................................. 83<br />
3. Fehlerbeseitigung (Debuggen) .....................................................................................84<br />
3.1 Fehlerbeseitigung im Multitasking.................................................................................................... 84<br />
Komfortable Befehle zur Fehlerbeseitigung......................................................................................... 84<br />
XQT-Befehl ........................................................................................................................................ 84<br />
TSTAT-Befehl.................................................................................................................................... 84<br />
TON/TOFF-Befehl.............................................................................................................................. 85<br />
PRINT-Befehl..................................................................................................................................... 85<br />
4. Stapelverarbeitung .......................................................................................................86<br />
4.1 Befehle zur Stapelverarbeitung.......................................................................................................... 86<br />
4.2 Stapeldatei ........................................................................................................................................ 88<br />
Herstellen einer Stapeldatei................................................................................................................. 88<br />
5. Automatische Programmausführung bei Einschalten der Spannungsversorgung........89<br />
5.1 Die AUTO.BAT-Datei ...................................................................................................................... 89<br />
5.2 Das IPL-Programm........................................................................................................................... 89<br />
6. Systemkonfigurationsdatei............................................................................................90<br />
6.1 CNFG.SYS-Datei.............................................................................................................................. 90<br />
6.2 Editieren von Dateien ....................................................................................................................... 91<br />
3
4<br />
7. RS-232C.......................................................................................................................93<br />
7.1 Übersicht über die RS-323C.............................................................................................................. 93<br />
Konfiguration ..................................................................................................................................... 93<br />
Konfiguration für SPEL III ................................................................................................................. 93<br />
Computerkonfiguration....................................................................................................................... 96<br />
TTY Protokoll und XON/XOFF Steuerung ......................................................................................... 97<br />
BASIC-Protokoll................................................................................................................................. 98<br />
Übertragungssteuerung per CS-Pin ................................................................................................... 100<br />
RS-232C Schnittstelle ....................................................................................................................... 101<br />
7.2 Die Kommunikation zwischen den Robotern................................................................................... 104<br />
Konfigurationseinstellungen ............................................................................................................. 104<br />
Kommunikationsbezogene Befehle.................................................................................................... 104<br />
Spezielle Anwendungsmethoden für kommunikationsbezogene Befehle............................................ 104<br />
7.3 Kommunikation zwischen Robotern und Anwendereinrichtungen................................................... 109<br />
Datenformat...................................................................................................................................... 109<br />
Programm für die Kommunikation mit dem Anwendereinrichtung ................................................... 111<br />
7.4 Die Kommunikation zwischen Hauptrechner und Roboter............................................................... 114<br />
Die Konsole ...................................................................................................................................... 114<br />
<strong>Robotersteuerung</strong>sprogramm............................................................................................................. 115<br />
7.5 Erweiterte Funktionen..................................................................................................................... 126<br />
SPEL III: Erweiterte Funktionsaufrufe .............................................................................................. 126<br />
ASCII-Codetabelle............................................................................................................................ 128<br />
7.6 Übertragungsfehler ......................................................................................................................... 129<br />
Übertragungsfehlercodes................................................................................................................... 129
SICHERHEIT<br />
5
1. Grundfunktionen<br />
6<br />
In diesem Kapitel erklären wir die Hauptsicherheitsfunktionen unserer Roboter. Diese Erklärungen<br />
beinhalten das Grundwissen, das benötigt wird um ein Robotersystem einzurichten.<br />
Die Erklärungen in diesem Kapitel sind einfach und kurz gehalten, um Ihnen einen Überblick über die<br />
Sicherheit zu verschaffen. Bitte nutzen Sie für Details das Handbuch zur Steuerung und andere relevante<br />
Handbücher und richten Sie ein Sicherheitssystem ein, nachdem Sie die Merkmale unserer Roboter<br />
wirklich verstanden haben.<br />
1.1 Niedrige und hohe Spannung<br />
Der Roboter hat zwei Motorspannungsmodi: Low Power (LP)- und High Power (HP)-Modus (niedrige<br />
und hohe Spannung.<br />
Im LP-Modus ist die Geschwindigkeit der Bewegung und die des Drehmoments des Motors verringert.<br />
Umgekehrt kann der Motor im HP-Modus in der programmierten Geschwindigkeit und mit einem<br />
bestimmten Drehmoment betrieben werden.<br />
Die Möglichkeit der geringen Geschwindigkeit wurde geschaffen, damit es möglich ist Gefahren<br />
vorzubeugen, falls der Roboter aus irgendeinem Grund Fehlfunktionen aufweist. Das reduzierte<br />
Drehmoment wurde geschaffen, um einen Bediener, wenn er von dem Roboter getroffen werden sollte,<br />
vor ernsthaften Verletzungen zu schützen. Jeder Roboter hat seine eigenen, vorgegebenen, maximalen<br />
Werte für verringerte Geschwindigkeit und reduziertes Drehmoment. Benutzer können diese Werte<br />
nicht verändern.<br />
Aus Gründen der Sicherheit ist die Anfangseinstellung der Roboter immer der LP-Modus. Der Roboter<br />
geht nicht zur Hochspannungseinstellung über, bis der spezielle Befehl dazu eingegeben wurde.<br />
Die Motorspannungseinstellungen werden gespeichert. Trotzdem schaltet die Motorsteuerung sofort in<br />
einen Niedrigspannungsstatus, der identisch zum LP-Modus ist, wenn die Sicherheitsabschrankung<br />
geöffnet wird.(Die Motorspannung geht in den HP-Modus zurück, sobald die Sicherheitsabschrankung<br />
wieder geschlossen ist.) Der Roboter wird ebenfalls automatisch in den Niedrigspanungsmodus<br />
zurückversetzt, wenn der Bedienungsmodus (TEACH/AUTO) geändert oder die Steuerung<br />
zurückgesetzt wird.<br />
LP-Modus HP-Modus<br />
Sicherheitsabschrankung offen Niedrige Spannung Niedrige Spannung<br />
Sicherheitsabschrankung geöffnet Niedrige Spannung Hohe Spannung<br />
Viele Schutz- und Überwachungskreisläufe in der Steuerung verhindern, daß der Roboter außer<br />
Kontrolle gerät und die verringerte Geschwindigkeit und das reduzierte Drehmoment überschreitet,<br />
sogar wenn nur ein einziger Fehler im LP-Modus auftritt.
1.2 Sicherheitsabschrankungen<br />
Der REMOTE1-Anschluß der Steuerung hat einen Eingangsstromkreis der mit dem<br />
Schließmechanismus der Sicherheitsabschrankung verbunden ist. Der Eingang der<br />
Sicherheitsabschrankung arbeitet wie folgt:<br />
Im AUTO-Modus:<br />
Sicherheitsabschrankung geschlossen: Automatischer Betrieb ist möglich<br />
Sicherheitsabschrankung geöffnet: Der Roboter stoppt sofort und geht in den LP-Modus über. Der<br />
Roboter kann nicht neu gestartet werden bis die<br />
Sicherheitsabschrankung wieder geschlossen ist und ein<br />
START-Signal eingegeben wird.<br />
Im TEACH-Modus:<br />
Sicherheitsabschrankung geschlossen: Der Roboter kann selbst im HP-Modus ein Programm<br />
verifizieren.<br />
Sicherheitsabschrankung geöffnet: Der Roboter hält sofort, kann aber danach nur im LP-Modus<br />
für den TEACH-Betrieb genutzt werden.<br />
Schlagen Sie auch (6) – e) im Abschnitt 2.3 des Handbuchs und „4. REMOTE1“ des<br />
Steuerungshandbuches nach.<br />
Nur für <strong>SRC</strong>-<strong>320</strong><br />
Der Schaltkreis der Sicherheitsabschrankung ist dual-redundant. Eine offene Sicherheitsabschrankung<br />
wird immer als Fehler erkannt, auch wenn nur einer der Schaltkreise ausfällt. Falls ein Ausfall erfolgt,<br />
wird ein Fehler angezeigt.<br />
Deshalb empfehlen wir dringend eine dual-redundante Verdrahtung für die Sicherheitstürschaltkreise.<br />
Wenn von dem Schaltkreis der Sicherheitsabschrankung eine offene Sicherheitsabschrankung entdeckt<br />
wird, wird das Signal geschlossen. Selbst, wenn danach die Sicherheitsabschrankung geschlossen wird,<br />
wird sie nicht als geschlossen erkannt, bis das Freigabesignal eingegeben wird. Diese<br />
Sicherheitsmaßnahme wurde eingeführt, damit eine Verwechslung der Zustände der<br />
Sicherheitsabschrankung vermieden wird. Eine Verwechslung könnte auftreten, wenn z.B. Bediener und<br />
Roboter Zustände der Sicherheitsabschrankung unterschiedlich erkennen, bspw. der Bediener glaubt die<br />
Türe ist offen während der Roboter einen geschlossenen Zustand wahrnimmt.<br />
(z.B.: Dies könnte passieren, wenn Falscheinstellungen unterschiedliche Zustände der<br />
Sicherheitsabschrankung und des Öffners bewirken, oder wenn die Türe geschlossen wird, obwohl der<br />
Bediener sie nicht schließen wollte, etc.)<br />
7
1.3 NOT-AUS<br />
8<br />
Die <strong>Robotersteuerung</strong> ist mit NOT-AUS Eingaben ausgestattet. Wenn der im Normalfall geschlossene<br />
NOT-AUS-Schalter gedrückt wird, wird die Spannungszufuhr zum Motor unterbrochen und der Roboter<br />
wird mittels einer Bremse angehalten.<br />
Der Bewegungsbereich des Roboters vor dem Stop und der genaue Punkt an dem der Roboter nach<br />
einem NOT-AUS hält können nicht spezifiziert werden. In den meisten Fällen wird der Roboter nicht<br />
über den Aufnahmepunkt, der vor dem Einsatz des NOT-AUS Schalters spezifiziert wurde,<br />
hinausgehen; eine Überschreitung dieses Punktes ist aber möglich. Dies ist abhängig von dem Gewicht<br />
der Ladung des Roboters und seiner Bewegungsgeschwindigkeit. Deshalb muß zusätzliche Ausstattung<br />
in einer entsprechenden Entfernung zum Roboter installiert werden.<br />
Ein NOT-AUS Ausgangsterminal, das mit dem NOT-AUS des Roboters verbunden ist, ist optional<br />
erhältlich. Bediener können es benutzen, um weitere Komponenten zu steuern.<br />
1.4 Zustimmtaster (nur für <strong>SRC</strong>-<strong>320</strong>)<br />
Ein Zustimmtaster wurde für Personen eingerichtet, die innerhalb der Sicherheitsabschrankung arbeiten.<br />
Im TEACH-Modus arbeitet der Roboter nur, wenn der Taster gedrückt wird und hält an, wenn der<br />
Taster losgelassen wird. Die Roboterbetrieb kann nicht durch einfaches Drücken des Tasters wieder<br />
begonnen werden.<br />
Der Zustimmtaster ist an der Seite des Handprogrammiergerätes TP-<strong>320</strong> angebracht. Um den Roboter<br />
mit dem Handprogrammiergerät zu betreiben, muß der Zustimmtaster ununterbrochen gedrückt werden,<br />
egal ob die Sicherheitsabschrankung geöffnet oder geschlossen ist.<br />
Um von außerhalb der Sicherheitsabschrankung ein Programm zu entwickeln wird ein PC benutzt. Die<br />
Software zur Unterstützung der Programmierung (SPEL Editor, SPEL für Windows) hat eine Teach-<br />
Funktion. Verbinden Sie ein PC-Kabel, das mit einem Zustimmtaster ausgestattet ist (optional<br />
erhältlich), wenn Sie diese Funktion benutzen. Verwenden Sie den PC niemals innerhalb der<br />
Sicherheitsabschrankung, wenn das PC-Kabel nicht mit einem Zustimmtaster ausgestattet ist,.
2. Sicherheitshinweise<br />
2.1 Allgemeines<br />
Dieses Kapitel beschreibt die grundlegenden Vorsichtsmaßnahmen, die getroffen werden müssen, um<br />
den gefahrlosen Betrieb des Roboters und des Robotersystems sicherzustellen.<br />
Bitte lesen Sie das Kapitel sorgfältig und denken Sie zuerst an die Sicherheit, wenn Sie den Roboter<br />
betreiben. Spezielle Toleranzwerte, Nutzungsbedingungen und andere Punkte, die zur Sicherheit<br />
notwendig sind werden im Steuerungs- und Manipulatorhandbuch erläutert.<br />
Die hier behandelten Punkte basieren auf ISO 10218 (Manipulator-Industrieroboter – Sicherheit), aber<br />
die Sicherheitsmaßstäbe sind genauer geworden und einige Zusätze sind erfolgt.<br />
Einige der Sicherheitsstandards von Robotern und Robotersystemen sind unten aufgelistet. Bitte führen<br />
Sie nicht nur die in diesem Kapitel aufgeführten, sondern alle relevanten Sicherheitsmaßnahmen durch.<br />
(Beachten Sie: dies ist nur ein Teil der benötigten Sicherheitsstandards).<br />
EN775 Europäischer Standard; Manipulator-Industrierobotor – Sicherheit<br />
ANSI/RIA R15.06 Amerikanischer nationaler Standard; Industrieroboter und Robotersysteme<br />
– Sicherheitsanforderungen.<br />
IEC204-1 (EN60204-1) Maschinensicherheit – Elektrische Ausstattung der Maschinen Teil1.<br />
Spezifikationen für generelle Anforderungen<br />
EN292-1, -2 Sicherheit der Maschinen – Basiskonzepte, allgemeine<br />
Konstruktionsvorschriften<br />
x Teil1. Basisterminologie, Methoden<br />
x Teil2. Technische Richtlinien und Spezifikationen<br />
EN418 NOT-AUS Zubehör, funktionale Aspekte – Konstruktionsvorschriften<br />
prEN953 Allgemeine Anforderungen an Entwurf und Konstruktion von<br />
Sicherheitsabschrankungen<br />
9
2.2 Allgemeine Konstruktionsanforderungen<br />
10<br />
Die Roboter und die dazugehörigen Optionen werden vom Hersteller/Lieferanten entsprechend der<br />
Vorgaben in diesem und dem nächsten Abschnitt entworfen und konstruiert.<br />
(1) Sicherheit bei Fehlern<br />
Die Roboter und die dazugehörigen Optionen werden so geplant, konstruiert und implementiert, daß<br />
sich ein vorhersehbarer Fehler einer einzelnen Komponente nicht auf andere Bestandteile auswirkt.<br />
Sollte ein Fehler auftreten wird das System in einem sicheren Zustand verlassen.<br />
(2) elektrische Einrichtungen<br />
Die Installation der elektrischen Einrichtungen wird gemäß IEC204-1 [(EN60204-1):<br />
Maschinensicherheit – Elektrische Ausstattung der Maschinen Teil1. Spezifikationen für generelle<br />
Anforderungen] vorgenommen.<br />
(3) Spannungszufuhr<br />
Die Einrichtung der Spannungszufuhr und der Erdung wird gemäß den Spezifikationen im Handbuch<br />
zur Steuerung vorgenommen.<br />
(4) Isolierung der Stromquellen<br />
Jedes Robotersystem verfügt über Apparate zum Isolieren seiner Stromquellen. Diese Apparate sind so<br />
angebracht, daß niemand einer Gefahr ausgesetzt wird und sie verfügen über die Fähigkeit einer<br />
Verriegelung.<br />
(5) Umgebungsbedingungen<br />
Die Umgebungsbedingungen werden gemäß den Spezifikationen im Handbuch zur Steuerung<br />
vorgenommen.
EINFÜHRUNG<br />
11
1. Vorbereitung<br />
1.1 Komponenten des Roboters<br />
Optionen<br />
12<br />
Die Hauptbestandteile unserer Roboter finden Sie in der folgenden Abbildung:<br />
���� HINWEIS<br />
SPEL Editor<br />
Alle Komponenten außer der Steuerung und dem Manipulator sind optional<br />
erhältlich.<br />
Programmentwicklungs-Tool unter MS-DOS.<br />
SPEL für Windows<br />
Programmentwicklungs-Tool unter MS-Windows.<br />
Bedieneinheit (OPU-<strong>300</strong>)<br />
Eine multifunktionale Bedieneinheit für unsere Roboter mit einer großen LCD-Anzeige.<br />
Handprogrammiergerät (TP-<strong>320</strong>/TP-<strong>320</strong>J)<br />
Die Programmierung kann mit Hilfe des Handprogrammiergeräts erfolgen.
1.2 Vorsichtsmaßnahmen bei der Installation<br />
Lesen Sie zuerst die Abschnitte über die Vorsichtsmaßnahmen in den Steuerungs- und Manipulator-<br />
Handbüchern. Einige ergänzende Vorsichtsmaßnahmen werden nachfolgend aufgeführt:<br />
Überprüfen des M. CODE und der Kabellänge<br />
Jede Steuerung ist auf einen bestimmten Manipulator eingestellt und angepaßt. Es kann daher zu<br />
Maschinenschäden oder anderen Problemen kommen, wenn ein falscher Steuerungstyp angeschlossen<br />
ist.<br />
Prüfen Sie daher vor der Installation, daß der M.CODE der Steuerung mit dem M.CODE des<br />
Manipulators übereinstimmt. Den M.CODE finden Sie auf dem gelben Aufkleber auf der Rückseite des<br />
Manipulators, wie auch auf der Rückseite der Steuerung. Stellen Sie sicher, daß die Länge des<br />
Stromversorgungskabels, wie auch des Signalkabels mit der angegebenen Länge auf dem gelben<br />
Aufkleber übereinstimmt.<br />
����VORSICHT!<br />
Transportsicherung<br />
Prüfen Sie vor der Installation, daß der M.CODE der Steuerung mit dem M.CODE<br />
des Manipulators übereinstimmt.<br />
M. CODE Aufkleber<br />
Der Roboterarm wird mit einer speziellen Transportsicherung ausgeliefert. Entfernen Sie diese<br />
Transportsicherung solange nicht, bis der Manipulator auf seinem Sockel befestigt ist. Stellen Sie sicher,<br />
daß die Transportsicherung entfernt wurde, bevor Sie die Spannungszufuhr einschalten. Weitere<br />
Informationen zur Transportsicherung finden Sie im Manipulator-Handbuch.<br />
1.3 Programmiereinheit<br />
Die Programmiereinheit wird zum Einrichten von Punkten und Erzeugen von Programmen verwendet,<br />
und um den Roboter zu betreiben.<br />
Im allgemeinen wird dafür ein Computer mit der Programmiersoftware (SPEL Editor oder SPEL für<br />
Windows) verwendet.<br />
Vorbereitungen zum Gebrauch der Programmiereinheit<br />
Die Vorbereitungen zur Nutzung der Programmiereinheit werden in Kapitel „1.3 Vorbereitungen“ im<br />
SPEL Editor Handbuch oder „Setup“ im SPEL für Windows Handbuch erklärt.<br />
13
1.4 Modi<br />
Steuerungsmodi<br />
14<br />
Die Programmiereinheit verfügt über zwei Modi: TEACH-(Einricht-)-Modus und AUTO-Modus. Bevor<br />
Sie den Roboter starten, müssen Sie auswählen, in welchem Modus er betrieben werden soll. Beachten<br />
Sie, daß das Betriebsverfahren von dem ausgewählten Modus abhängig ist.<br />
Es gibt zwei Methoden, zwischen den Modi zu wechseln:<br />
(a) Modusschalter an der Bedieneinheit<br />
Stellen Sie den Modusschalter auf den gewünschten Modus.<br />
(b) Signalsendung zum REMOTE2-Stecker (wenn die Bedieneinheit nicht verwendet wird)<br />
Senden Sie ein Modussignal, daß dem gewünschten Modus entspricht, an den Pin auf dem<br />
REMOTE2-Stecker. Weitere Informationen zur Modusumschaltung finden Sie im Handbuch zur<br />
Steuerung in dem Kapitel „Benutzung ohne Bedieneinheit“.<br />
Die Funktionsweisen der beiden Modi werden nachfolgend beschrieben:<br />
TEACH-Modus<br />
Dieser Modus wird zum Einrichten, Programmieren und Debuggen verwendet, wenn die Steuerung mit<br />
einem Programmiergerät, z.B. einem Personal Computer oder Handprogrammiergerät, verbunden ist.<br />
Unabhängig welches Programmiergerät angeschlossen ist, arbeitet der Modus durch Senden von<br />
Befehlen an die TEACH-Schnittstelle des Roboters. PC-seitig wird das TEACH-Kabel an die RS-232C<br />
Schnittstelle angeschlossen.<br />
Bitte konfigurieren Sie zur Benutzung der TEACH-Schnittstelle die RS-232C-Schnittstelle Ihres<br />
Personal Computers wie folgt:<br />
Die Konsole im TEACH-Modus<br />
9600 bps, 8 Bit, Even, 2 Stop Bits<br />
Das Gerät, das die Befehle an den Roboter sendet, wird Konsole genannt. Im TEACH-Modus ist die<br />
Konsole dem Gerät zugewiesen, das an der TEACH-Schnittstelle auf der Vorderseite der Steuerung<br />
angeschlossen ist. Außerdem können Sie den Personal Computer an die RS-232C-Schnittstelle (#20),<br />
auf der Rückseite der Steuerung, anschließen. (Nur für SPEL für Windows.)<br />
���� HINWEIS Die RS-232C-Schnittstelle (#21) kann nicht die Konsole sein.<br />
Warnung<br />
In dem Fall, daß der SSW3-1 des Softwareschalters auf ON steht, muß der PC an<br />
die RS-232C-Schnittstelle (#20) angeschlossen werden. Wenn der PC an der<br />
TEACH-Schnittstelle angeschlossen ist, funktioniert der Taster<br />
in SPEL für Windows nicht.
• TEACH-Schnittstelle<br />
Das ist die Standardeinstellung. Das Handprogrammiergerät oder der PC ist an der TEACH-<br />
Schnittstelle auf der Vorderseite der Steuerung angeschlossen.<br />
• RS-232C-Schnittstelle (#20)<br />
Das Handprogrammiergerät kann an die TEACH-Schnittstelle auf der Vorderseite der Steuerung<br />
angeschlossen werden, und gleichzeitig können Sie den PC mit SPEL für Windows an die RS-232C-<br />
Schnittstelle (#20) auf der Rückseite der Steuerung anschließen.<br />
Durch Wechseln der Konsole können Sie die Einrichtarbeiten vornehmen und parallel Programme<br />
erstellen oder debuggen, ohne das Kabel zu wechseln. Diese Funktion wird nur von SPEL für Windows<br />
und dem Handprogrammiergerät TP-<strong>320</strong>/TP-<strong>320</strong>J unterstützt.<br />
Wenn Sie die RS-232C-Schnittstelle (#20) benutzen, stellen Sie vorher den Softwareschalter SSW3-1<br />
auf ON. Wenn Sie die Spannungszufuhr für die Steuerung einschalten, nachdem Sie den<br />
Softwareschalter umgestellt haben, ist die RS-232C-Schnittstelle (#20) die Konsole. Sie können die<br />
Konsole wie folgt ändern:<br />
1. Wenn Sie die Konsole von Handprogrammiergerät auf PC umstellen wollen, drücken Sie den<br />
Freigabe-Schalter auf dem Handprogrammiergerät.<br />
2. Wenn Sie die Konsole von PC auf Handprogrammiergerät umstellen wollen, benutzen Sie den<br />
Taster in dem Menü in SPEL für Windows.<br />
Warnung<br />
Führen Sie keine Einrichtungen aus, wenn der PC an der RS-232C-Schnittstelle<br />
(#20) angeschlossen ist, da der NOT-AUS-Schalter nicht als solcher funktioniert,<br />
wenn ein PC-Kabel an der RS-232C-Schnittstelle (#20) angeschlossen ist. Daher<br />
ist es sehr gefährlich, den Roboter in diesem Zustand zu bewegen.<br />
Wenn Sie ein Programm debuggen, während der PC an die RS-232C-<br />
Schnittstelle (#20) angeschlossen ist und der Roboter sich bewegt, ist es<br />
zwingend notwendig, das Handprogrammiergerät oder die Bedieneinheit OPU-<br />
<strong>300</strong> in der Hand zu halten, um ggf. den NOT-AUS-Schalter drücken zu können.<br />
Das Handprogrammiergerät oder die Bedieneinheit müssen dafür an der<br />
TEACH-Schnittstelle angeschlossen sein.<br />
Der Spannungsversorgungszustand des Motors im TEACH-Modus<br />
Im TEACH-Modus ist es möglich, daß derjenige, der den TEACH-Vorgang ausführt, nahe an den<br />
Roboter herankommt. Der Roboter wird normalerweise im TEACH-Modus im LOW-POWER-Status<br />
betrieben, um die Sicherheit des Bedieners zu gewährleisten. Um den Roboter im TEACH-Modus im<br />
HIGH-POWER-Status betreiben zu können, muß die Sicherheitsabschrankung geschlossen und der<br />
LOW-POWER-Status durch Eingeben des Befehls LP OFF ausgeschaltet werden. Auch wenn der Befehl<br />
LP OFF eingegeben wurde, aber die Sicherheitsabschrankung geöffnet ist, ändert sich der<br />
Spannungsversorgungszustand des Motors nicht. Der Spannungsversorgungszustand des Motors ändert<br />
sich auch dann nicht, wenn die Sicherheitsabschrankung geschlossen ist, aber der Befehl LP OFF nicht<br />
eingegeben wurde.<br />
Der Roboter kann im TEACH-Modus mit niedriger Geschwindigkeit betrieben werden, auch wenn die<br />
Sicherheitsabschrankung geöffnet ist, um das Einrichten zu ermöglichen.<br />
15
AUTO-Modus<br />
16<br />
Dieser Modus wird zum Betrieb der Roboter verwendet. Die Befehle zum Starten oder Unterbrechen<br />
eines Programms können mit Hilfe der Bedieneinheit OPU-<strong>300</strong>, der REMOTE3 Steckverbindung oder<br />
der RS-232C Schnittstelle an den Roboter gesendet werden.<br />
Die Konsole im AUTO-Modus<br />
Das Gerät, das die Befehle an den Roboter sendet, wird Konsole genannt und wird mit Hilfe des Befehls<br />
„CONSOLE“ festgelegt. Es gibt drei verschiedene Möglichkeiten, die Konsole im AUTO-Modus zu<br />
spezifizieren.<br />
• Unter Verwendung der OPU-<strong>300</strong> (REMOTE2) als Konsole:<br />
Dieses Gerät ist mit einem Druckknopf zum Starten und Unterbrechen von Programmen<br />
ausgerüstet. Außerdem verfügt es über eine Anzeige zum Darstellen der Menüs und<br />
Fehlermeldungen.<br />
• Unter Verwendung der REMOTE3 als Konsole:<br />
Roboter können mit Hilfe der REMOTE3 über einen Sequencer oder eine herkömmliche<br />
Bedieneinheit gesteuert werden (So kann der Roboter gestartet, angehalten, unterbrochen oder<br />
kalibriert werden.)<br />
• Unter Verwendung von S.NET (RS-232C #20, #21):<br />
Die RS-232C stellt eine Kommunikationsschnittstelle bereit, um Befehle von einem Computer an<br />
den Roboter zu senden. Sie ermöglicht außerdem das Senden verschiedener Daten (Daten zur<br />
Produktionssteuerung, etc.) vom Roboter an den Computer, damit der Computer diese Daten<br />
bearbeiten kann. Nähere Informationen erhalten Sie in Kapitel 7.4.<br />
Der Spannungsversorgungszustand des Motors im AUTO-Modus<br />
Im AUTO-Modus ist es unmöglich, den Roboter mit geöffneter Sicherheitsabschrankung zu betreiben,<br />
da dies bedeuten würde, daß sich jemand in der Nähe des Roboters aufhält. Wenn Sie versuchen, den<br />
Roboter mit geöffneter Sicherheitsabschrankung zu betreiben, wechselt der Roboter sofort in den<br />
Pausezustand und kann nicht mehr betrieben werden. Um den Pausezustand wieder aufzuheben, müssen<br />
Sie die Sicherheitsabschrankung schließen und ein Startsignal senden.<br />
Weitere Informationen über den Spannungsversorgungszustand des Motors im AUTO-Modus erhalten<br />
Sie in der Übergangstabelle des Handbuches zur Steuerung. Die Spannungsversorgungszustände des<br />
Motors im AUTO-Modus sind bei den Steuerungen <strong>SRC</strong>-<strong>300</strong> und <strong>SRC</strong>-<strong>320</strong> unterschiedlich.
1.5 Fehlermeldung<br />
Wenn in der <strong>Robotersteuerung</strong> ein Fehler auftritt, erscheint eine entsprechende Fehlermeldung (wie<br />
nachfolgend dargestellt). Gleichzeitig erscheint eine Fehlermeldung an der OPU-<strong>300</strong> und der<br />
Programmiereinheit (PC).<br />
LCD Kontrollanzeige der Steuerung<br />
1. 7-Segment Anzeige<br />
Die oben dargestellten Inhalte werden alternativ angezeigt.<br />
Die Fehler- und die Achsnummern werden mit einem Bindestrich (-) dargestellt.<br />
2. andere Anzeigen<br />
NOT-AUS<br />
FEHLER<br />
S.ERR<br />
SICHERHEITSAB-<br />
SCHRANKUNG<br />
Leuchtet auf, wenn ein NOT-AUS-Zustand auftritt. Die LED leuchtet<br />
solange auf, bis der Roboter zurückgesetzt wird, auch wenn die Ursache des<br />
NOT-AUS beseitigt wurde.<br />
Leuchtet auf, wenn ein Fehler auftritt. Leuchtet nicht bei einem NOT-AUS<br />
oder Systemfehler.<br />
Leuchtet auf, wenn die Haupt-CPU aufgrund eines Hardwarefehlers nicht<br />
funktioniert. In diesem Fall wird der Fehler nicht oder nicht korrekt in der<br />
7-Segment Anzeige dargestellt.<br />
Leuchtet auf, wenn die Sicherheitsabschrankung geöffnet ist.<br />
17
Ausgabe an OPU-<strong>300</strong> und REMOTE1-Steckverbindung<br />
18<br />
1. LCD (OPU-<strong>300</strong>)<br />
Wenn ein Fehler auftritt, werden Fehler-, Zeilen- und Tasknummer sowie die Fehlerbeschreibung<br />
angezeigt.<br />
2. Ausgabe an OPU-<strong>300</strong> LCD und REMOTE1<br />
NOT-AUS Leuchtet auf, wenn ein NOT-AUS-Zustand auftritt.<br />
FEHLER<br />
Leuchtet auf, wenn ein Fehler auftritt. Leuchtet nicht bei einem NOT-AUS<br />
oder Systemfehler.<br />
Leuchtet auf, wenn die Haupt-CPU aufgrund eines Hardwarefehlers nicht<br />
S.ERR<br />
funktioniert. In diesem Fall wird der Fehler nicht oder nicht korrekt in der<br />
7-Segment Anzeige dargestellt.<br />
SICHERHEITSAB-<br />
SCHRANKUNG<br />
Leuchtet auf, wenn die Sicherheitsabschrankung geöffnet ist.<br />
Ausgabe an Programmiereinheit<br />
Wenn ein Fehler aufgrund eines eingegebenen Befehls auftritt, wird die Meldung wie folgt ausgegeben:<br />
Wenn ein Fehler auftritt, während ein Programm abläuft, wird die Meldung wie folgt ausgegeben:
2. Grundlegende Bedienung<br />
In diesem Kapitel beschreiben wir die grundlegenden Vorgehensweisen zum Betrieb des Roboters und<br />
geben Beispiele zum Einrichten und Programmieren des Roboters.<br />
2.1 Ablaufplan<br />
Die grundlegende Vorgehensweise zum Betrieb des Roboters ist in folgendem Ablaufplan dargestellt:<br />
Jeder einzelne Ablaufschritt wird nachfolgend beschrieben.<br />
19
2.2 Überprüfung des Startzustandes<br />
20<br />
(1) Stellen Sie sicher, daß die Transportsicherung des Armes entfernt wurde.<br />
(2) Schalten Sie die Spannungsversorgung der Steuerung ein.<br />
Stellen Sie sicher, daß auf den LED-Anzeigen auf der Vorderseite der Steuerung oder der<br />
Bedieneinheit keine ungewöhnliche Meldungen angezeigt werden. Der korrekte<br />
(3)<br />
Startzustand ist folgender:<br />
* Die Zeilennummer/Status auf der Kontrollanzeige ist „0“.<br />
���� HINWEIS<br />
(4)<br />
Bei Verwendung eines Manipulators vom Typ BNA oder BNA-CL kann der<br />
Fehler 119 auftreten, wenn die Spannungszufuhr eingeschaltet wird. Das bedeutet,<br />
daß die Positionsdaten beim Ab- und Einschaltvorgang voneinander abweichen.<br />
Wenn Sie den Arm manuell bewegt haben, nachdem die Spannungszufuhr<br />
ausgeschaltet, oder die Spannungszufuhr während des Betriebes unterbrochen<br />
wurde, ist dies kein Problem. Führen Sie den RESET-Befehl aus, um die Maschine<br />
zurückzusetzen.<br />
Wenn der Roboterarm mit Peripheriegeräten o. ä. kollidiert oder wenn es nach<br />
dem Austausch des Motors oder des Untersetzungsgetriebes zu einem<br />
Zusammenstoß mit anderen Geräten, etc. kommt, müssen die Achsen neu<br />
kalibriert werden. Weitere Informationen über das Kalibrieren entnehmen Sie bitte<br />
dem Kapitel 3.12 „Kalibrierung“.<br />
• Die LED-Anzeigen auf der Steuerung und der OPU-<strong>300</strong> müssen wie folgt aufleuchten:<br />
Steuerung<br />
OPU-<strong>300</strong><br />
LEDs EIN/AUS Zustand<br />
E.STOP<br />
S.ERR<br />
SICHERHEITSABSCHRANKUNG Blinkt<br />
Leuchtet nicht<br />
MODUS-Anzeige (TEACH/AUTO) Eine Lampe leuchtet<br />
RESET Leuchtet<br />
MOTOR POWER<br />
NOT-AUS<br />
FEHLER<br />
SYSTEM FEHLER<br />
PAUSE<br />
START<br />
SICHERHEITSABSCHRANKUNG<br />
HOME<br />
Leuchtet nicht<br />
Blinkt<br />
Wenn Sie die Spannungszufuhr einschalten und der Startzustand weicht von den oben<br />
genannten Möglichkeiten ab, beseitigen Sie die Fehlerursache.
2.3 Einstellen der Datensicherung<br />
���� HINWEIS<br />
Die Steuerung enthält wichtige Systemdaten. Stellen Sie sicher, daß es von den<br />
Originalsystemdaten eine Sicherungskopie gibt.<br />
Wie Sie die verschiedenen Systemdaten sichern:<br />
• SPEL Editor: Führen Sie im Befehlsmodus den Befehl MKVER aus.<br />
• SPEL für Windows: Führen Sie den Befehl [Tools]-[Wartung] aus, und klicken Sie auf die<br />
Schaltfläche MKVER im Menü „Wartung“.<br />
Durch o.g. Schritte werden die verschiedenen Einstellungsdaten im internen Dateispeicher der<br />
Steuerung als Datei gespeichert. Der Befehl SETVER kann genutzt werden, um die im Dateispeicher<br />
gespeicherten Daten zurückzusetzen. Zusätzlich können die im Dateispeicher gespeicherten Daten auf<br />
eine Diskette gespeichert werden. Weitere Informationen zu den Befehlen erhalten Sie in den<br />
Handbüchern zum SPEL Editor und SPEL für Windows.<br />
Das Gerät, das Programmiereinheit genannt wird, wird verwendet, um Punkte einzurichten und<br />
Programme zur Bedienung des Roboters zu erstellen. Im Normalfall wird zum Programmieren ein PC<br />
verwendet.<br />
Initialisierung des Bewegungsbereiches<br />
Der Bewegungsbereich wird mit Hilfe des Befehls RANGE eingestellt. Der Bewegungsbereich kann<br />
weder durch Ausschalten der Spannungszufuhr noch durch die Ausführung des Befehls VERINIT<br />
geändert werden. Wenn Sie die Standardwerte wiederherstellen wollen, müssen Sie die gespeicherten<br />
Originaldaten wieder einladen.<br />
Der Befehl RANGE ist ein wichtiger Befehl, um den Roboter gefahrlos zu bewegen. Weitere<br />
Informationen erhalten Sie im Kapitel 8.3 des Manipulator-Handbuches.<br />
21
2.4 Einschalten der Motorspannungszufuhr<br />
22<br />
Der Motor wird nicht alleine durch Einschalten der Spannungszufuhr in Betrieb gesetzt. Um ihn zu<br />
betreiben, ist es wichtig, daß er eingeschaltet ist. Um ihn einzuschalten, befolgen Sie eine der folgenden<br />
Methoden:<br />
(a) Von der Programmiereinheit:<br />
• SPEL Editor: Führen Sie im Befehlsmodus den Befehl MOTOR ON aus.<br />
• SPEL für Windows: Führen Sie den Befehl [Tools]-[<strong>Robotersteuerung</strong>] aus, und klicken<br />
Sie auf die Schaltfläche MOTOR ON im Menü „<strong>Robotersteuerung</strong>“.<br />
(b) Von der Bedieneinheit OPU-<strong>300</strong> (Weitere Informationen erhalten Sie im Handbuch zur<br />
Bedieneinheit.)<br />
(c) Von dem Handprogrammiergerät TP-<strong>320</strong>/TP-<strong>320</strong>J (Weitere Informationen erhalten Sie im<br />
entsprechenden Handbuch.)<br />
(d) Anlegen des Power-On-Signals an die REMOTE3-Schnittstelle (Siehe Handbuch zur Steuerung.)<br />
(e) Führen Sie den Befehl MOTOR ON im Programm aus.<br />
Der Betriebszustand des Motors<br />
Der Betriebszustand des Motors wird wie nachfolgend dargestellt umgeschaltet:
2.5 Kalibrierung<br />
Die Kalibrierung muß nach dem Einschalten der Motoren ausgeführt werden, es sei denn, es handelt<br />
sich um Manipulatoren vom Typ BNA oder BNA-CL. Um sie auszuführen, befolgen Sie eine der<br />
folgenden Methoden:<br />
(a) Von der Programmiereinheit:<br />
• SPEL Editor: Führen Sie im Befehlsmodus den Befehl MCAL aus.<br />
• SPEL für Windows: Führen Sie den Befehl [Tools]-[<strong>Robotersteuerung</strong>] aus, und klicken<br />
Sie auf die Schaltfläche MCAL im Menü „<strong>Robotersteuerung</strong>“.<br />
(b) Von der Bedieneinheit OPU-<strong>300</strong> (Weitere Informationen erhalten Sie im Handbuch zur<br />
Bedieneinheit.)<br />
(c) Von dem Handprogrammiergerät TP-<strong>320</strong>/TP-<strong>320</strong>J (Weitere Informationen erhalten Sie im<br />
entsprechenden Handbuch.)<br />
(d) Anlegen des MCAL-Signals an die REMOTE3-Schnittstelle als E/A-1.(Siehe Handbuch zur<br />
Steuerung.)<br />
(e) Führen Sie den Befehl MCAL im Programm aus.<br />
Wenn Sie den Befehl MCAL ausführen, während sich der Arm in der Nähe der Begrenzung des<br />
Bewegungsbereiches befindet, ist es u.U. möglich, daß der Arm den Bewegungsbereich überschreitet.<br />
Eine Kalibrierung ist dann nicht möglich. Sollte dies dennoch passieren, führen Sie den Befehl MOTOR<br />
OFF aus, schalten Sie die Steuerung aus, und bewegen Sie danach den Arm per Hand in die Mitte des<br />
Bewegungsbereiches zurück. Starten Sie dann den Ablauf erneut. (Siehe auch Kap. 9.1 „Kalibrierung“<br />
im Manipulatorhandbuch.)<br />
23
2.6 Einstellen der Home-(Standby-)Position<br />
24<br />
Die Ursprungsposition kann auf eine optionale Position eingestellt werden. Der Arm wird mit Hilfe des<br />
Befehls HOME bewegt. Stellen Sie die Home-(Standby-)Position, falls notwendig, ein.<br />
Mit Hilfe des Befehls HOME in SPEL III Ver. 3. bewegen Sie den Roboter in die Home-(Standby-)<br />
Position.<br />
Bitte beachten Sie, daß bei Auslieferung des Systems keine Home-(Standby-)Position definiert ist. Wenn<br />
Sie also den HOME Befehl ausführen, ohne zuvor die Home-(Standby-)Position zu definieren, erscheint<br />
der Fehler 143.<br />
Die HOME LCD an der OPU-<strong>300</strong> und der HOME-Ausgang an REMOTE2 leuchten, während der<br />
HOME-Befehl ausgeführt wird.<br />
Definieren der Home-(Standby-)Position<br />
Die Definition der Home-(Standby-)Position wird ausgeführt, indem Sie die Pulswerte der Position, die<br />
Sie als Home-(Standby-)Position festlegen möchten, mit Hilfe des Befehls HOMESET eingeben.<br />
Weitere Informationen über das Verhältnis Bewegungsbereich und Pulsbereiche erhalten Sie in Kap. 8<br />
„Der Bewegungsbereich und die Roboterkoordinaten“ im Manipulatorhandbuch.<br />
• SPEL Editor:<br />
(a) Wenn Sie den Pulswert für die zu definierende Homeposition kennen, geben Sie<br />
den entsprechenden Pulswert mit Hilfe des Befehls HOMESET ein.<br />
HOMESET 0,0,0,0<br />
(b) Wenn der Pulswert nicht bekannt ist, können Sie ihn mit Hilfe der PLS Funktion<br />
einfach definieren. Gehen Sie wie folgt vor:<br />
• SPEL für Windows:<br />
1 Führen Sie den Befehl SFREE aus.<br />
2 Bewegen Sie den Arm manuell zu der Position, die Sie als Homeposition<br />
definieren wollen.<br />
3 Geben Sie folgenden Befehl ein:<br />
HOMESET PLS(1),PLS(2),PLS(3),PLS(4)<br />
Führen Sie den Befehl [Project]-[Roboterpaprameter] aus, und geben Sie den<br />
Pulswert der Homeposition über das [HOMESET]-Bedienfeld im Menü<br />
„Roboterparameter“ ein.<br />
Armbewegungsreihenfolge bei Einstellung der Home-(Standby-)Position<br />
Der Befehl HORDR definiert die Reihenfolge der Achsenbewegung bei Ausführung des HOME-Befehls.<br />
Bei Auslieferung des Systems sind die HORDR-Werte wie folgt eingestellt. Nachdem die 3. Achse in<br />
Home-(Standby-)Position neu positioniert wurde, werden alle anderen Achsen gleichzeitig positioniert.<br />
HORDR &B0010, &B1101,0,0<br />
Wenn die Standard-Positionierungsreihenfolge für Ihre Anwendung unzureichend ist, können Sie die<br />
Werte mit Hilfe des Befehls HORDR ändern.<br />
• SPEL Editor:<br />
• SPEL für Windows:<br />
Geben Sie die Werte mit Hilfe des Befehls HORDR ein.<br />
Geben Sie die Werte im Menü [Project] im Dialogfenster [Robot Parameters] mit<br />
Hilfe des [HORDR]-Bedienfeldes ein.
2.7 Teaching und Programmieren<br />
Teaching<br />
Um einen Roboter zu betreiben, ist es wichtig, eine Zielposition einzurichten. Dieser Vorgang wird<br />
„Teaching“ („Einrichten“) genannt. Es gibt drei verschiedene Einrichtmethoden:<br />
REMOTE Teaching<br />
Direktes Teaching<br />
MDI Teaching (Manuelle Dateneingabe)<br />
Teaching per JOG Tasten. Detaillierte Informationen<br />
erhalten Sie in Kapitel 3.<br />
Teaching mittels Positionierung des Roboterarms direkt<br />
durch den Anwender. Detaillierte Informationen<br />
erhalten Sie auf der nächsten Seite.<br />
Teaching durch Eingabe numerischer Positionsdaten.<br />
Detaillierte Informationen erhalten Sie im Abschnitt<br />
über den Befehl „Pn=Positionsdefinition“ im SPEL III<br />
Referenzhandbuch.<br />
Für das Teaching wird ein PC oder ein Handprogrammiergerät (TP-<strong>320</strong>/TP-<strong>320</strong>J) verwendet.<br />
Wenn Sie ein Handprogrammiergerät einsetzen, erhalten Sie weiterführende Informationen im<br />
Handbuch über das Handprogrammiergerät.<br />
Wenn Sie einen PC mit SPEL Editor einsetzen, erhalten Sie weiterführende Informationen im Kapitel 6<br />
des SPEL Editor-Handbuches.<br />
Wenn Sie einen PC mit SPEL für Windows einsetzen, erhalten Sie weiterführende Informationen im<br />
Abschnitt [JOG und Teach] des [TOOLS]-Menüs des SPEL für Windows-Handbuches.<br />
25
Beispiele für Einrichtmethoden<br />
26<br />
1. Direktes Teaching<br />
Mit Hilfe des Befehls SFREE werden die Motoren ausgeschaltet, und der Arm kann per Hand bewegt<br />
werden. Bewegen Sie die Arme in eine Zielposition, und speichern Sie diese. Schalten Sie dann mit<br />
Hilfe des Befehls SLOCK die Motorspannung ein.<br />
• Mit SPEL Editor:<br />
1 Schalten Sie die Steuerung ein, und führen Sie den Befehl MOTOR ON im<br />
Programmiermodus des SPEL Editors aus.<br />
>MOTOR ON<br />
2 Führen Sie den Befehl MCAL im Programmiermodus des SPEL Editors aus.<br />
(Überspringen Sie diesen Schritt, wenn Sie einen Roboter vom Typ BNA oder BNA-CL<br />
einsetzen.)<br />
>MCAL<br />
3 Führen Sie den Befehl SFREE aus. Alle Achsen werden freigeschaltet.<br />
>SFREE<br />
4 Bewegen Sie die Arme per Hand in die gewünschten Positionen. Wenn die 3. Achse mit<br />
einer elektromagnetischen Bremse ausgestattet ist, bewirkt das Ausschalten des Motors,<br />
daß die Bremse greift und die 3. Achse gesperrt ist. Um die 3. Achse bewegen zu können,<br />
halten Sie den Bremsfreigabetaster gedrückt.<br />
5 Richten Sie die aktuelle Position als P1 ein.<br />
>P1=P*<br />
6 Bewegen Sie die Arme per Hand in die nächsten gewünschten Positionen.<br />
7 Richten Sie die aktuelle Position als P2 ein.<br />
>P2=P*<br />
8 Durch obige Schritte haben Sie die Positionen eingerichtet. Schalten Sie die Motoren mit<br />
SLOCK wieder ein.<br />
>SLOCK<br />
9 Bewegen Sie den Roboter zur Überprüfung mit Hilfe von JUMP zu P1. Stellen Sie vorher<br />
sicher, daß sich kein Hindernis in der Nähe der Zielposition befindet.<br />
>JUMP P1<br />
10 Bewegen Sie den Roboter mit Hilfe von JUMP zu P2.<br />
>JUMP P2
• Mit SPEL für Windows:<br />
1 Schalten Sie die Steuerung und die Motoren ein. Wenn Sie den Befehl [Tools]-<br />
[<strong>Robotersteuerung</strong>s-Bedienfeld] ausführen, wird das <strong>Robotersteuerung</strong>s-Bedienfeld<br />
angezeigt. Wählen Sie den Manipulator als Punktgerät. Klicken Sie auf die Schaltfläche<br />
. Eine Meldung erscheint. Folgen Sie den dargestellten Anweisungen.<br />
2 Klicken Sie auf die Schaltfläche . Wenn die Kalibrierung beendet ist, klicken Sie<br />
auf die Schaltfläche . (Überspringen Sie diesen Schritt, wenn Sie einen<br />
Roboter vom Typ BNA oder BNA-CL einsetzen.)<br />
3 Wenn Sie den Befehl [Tools]-[Jog und Teach] ausführen, wird das [Jog und Teach]- Menü<br />
angezeigt. Schalten Sie die Motoren aller Achsen mit Hilfe der [Achsen frei]-Schaltfläche<br />
aus.<br />
4 Bewegen Sie die Arme per Hand in die gewünschten Positionen. Wenn die 3. Achse mit<br />
einer elektromagnetischen Bremse ausgestattet ist, bewirkt das Ausschalten des Motors,<br />
daß die Bremse greift und die 3. Achse gesperrt ist. Um die 3. Achse bewegen zu können,<br />
halten Sie den Bremsfreigabetaster gedrückt.<br />
5 Richten Sie die aktuelle Position als P1 ein. Klicken Sie auf die Schaltfläche<br />
und ändern Sie die aktuelle Position in P1. Klicken Sie auf die<br />
Schaltfläche .<br />
6 Bewegen Sie die Arme per Hand in die nächsten gewünschten Positionen.<br />
7 Richten Sie die aktuelle Position als P2 ein. Klicken Sie auf die Schaltfläche<br />
und ändern Sie die aktuelle Position in P2. Klicken Sie auf die<br />
Schaltfläche .<br />
8 Durch obige Schritte haben Sie die Positionen eingerichtet. Schalten Sie die Motoren mit<br />
Hilfe der [Achsen frei]-Schaltfläche wieder ein.<br />
9 Bewegen Sie den Roboter zur Überprüfung mit Hilfe von JUMP zu P1. Stellen Sie vorher<br />
sicher, daß sich kein Hindernis in der Nähe der Zielposition befindet.<br />
Tragen Sie 1 im Textfeld [Punkt #:] ein, und klicken Sie auf die Schaltfläche .<br />
10 Tragen Sie 2 im Textfeld [Punkt #:] ein, und klicken Sie auf die Schaltfläche .<br />
Klicken Sie auf die Schaltfläche , und verlassen Sie das [Jog und Teach]-<br />
Menü.<br />
27
Beispielprogrammierung<br />
28<br />
Erstellen Sie ein einfaches Programm, das die Positionsdaten verwendet, die Sie eingerichtet haben. Es<br />
handelt sich hierbei um ein kurzes Programm, das jedoch den Roboter veranlaßt, zwischen Punkt 1 (P1)<br />
und Punkt 2 (P2) hin- und herzuverfahren. Sollten Sie mehr als zwei Punkte eingerichtet haben, geben<br />
Sie diese nach Zeile 30 ein.<br />
Geben Sie folgendes ein:<br />
10 FUNCTION MAIN<br />
20 JUMP P1<br />
30 JUMP P2<br />
40 GOTO 20<br />
50 FEND<br />
• Mit SPEL Editor:<br />
1 Geben Sie das oben dargestellte Programm im Programmiermodus ein. Geben Sie<br />
zusätzlich am Ende jeder Zeile [Return] (Enter) ein.<br />
2 Um sicherzustellen, daß jede Zeile eingegeben wurde, können Sie das Programm mit dem<br />
Befehl LIST anzeigen lassen.<br />
>LIST<br />
10 FUNCTION MAIN<br />
20 JUMP P1<br />
30 JUMP P2<br />
40 GOTO 20<br />
50 FEND<br />
• Mit SPEL für Windows:<br />
1 Erzeugen Sie ein neues Projekt.<br />
Führen Sie den Befehl [Project]-[Neu] aus. Geben Sie den Namen des Projekts in der<br />
Eingabezeile [New Project Name] ein. Z. B.: FIRSTAPP. Klicken Sie dann auf .<br />
2 Geben Sie das oben dargestellte Programm im Fenster [MAIN.PRG] ein.
2.8 Ausführen eines Programms<br />
Kompilieren<br />
Ein Programm, wie dieses, welches wir gerade erstellt haben, nennt man „Quellprogramm“. Das<br />
Programm, das von der Steuerung ausgeführt wird, heißt „Objektprogramm“. Es unterscheidet sich vom<br />
Quellprogramm. Das Quellprogramm muß in ein Objektprogramm geändert werden. Diesen Vorgang<br />
nennt man kompilieren. Wenn der Kompiliervorgang beendet ist, kann das Programm per PC und<br />
Bedieneinheit ausgeführt werden.<br />
• Mit SPEL Editor:<br />
Führen Sie den Befehl COM im Programmiermodus aus.<br />
>COM<br />
COMPILE END<br />
• Mit SPEL für Windows:<br />
Führen Sie den Befehl [Project]-[Build] aus. Das Fenster [Project Build Status] erscheint,<br />
und die einzelnen Kompilierprozeduren werden angezeigt. (Das erzeugte Programm wird<br />
zur Steuerung übertragen und kompiliert.)<br />
Ausführen des Programms mit dem PC<br />
Führen Sie das Programm aus.<br />
• Mit SPEL Editor:<br />
Führen Sie den Befehl XQT im Programmiermodus aus.<br />
>XQT<br />
• Mit SPEL für Windows:<br />
Wenn Sie den Befehl [Run]-[Start], ausführen wird das Fenster [Run] angezeigt. Klicken<br />
Sie dann auf die Schaltfläche , wird das Programm ausgeführt.<br />
Um die Ausführung zu beenden, klicken Sie auf die Schaltfläche im [Run]-<br />
Fenster.<br />
29
Ausführen des Programms mit der Bedieneinheit<br />
30<br />
1 Stellen Sie den Bedienmodus der Steuerung auf AUTO. Stellen Sie hierzu den<br />
Modusauswahlschalter der Bedieneinheit in die Position AUTO.<br />
2 Schließen Sie die Sicherheitsabschrankung.<br />
3 Drücken Sie den START-Schalter auf der Bedieneinheit.<br />
4 Um das Programm anzuhalten, drücken Sie zuerst den PAUSE-Schalter auf der<br />
Bedieneinheit (temporärer Halt) und dann den RESET-Schalter.<br />
Die LEDs auf jedem Schalter zeigen folgende Zustände an:<br />
LED Zustand<br />
RESET<br />
Programm ist beendet. (Wenn der Schalter während eines Pausezustandes<br />
gedrückt wurde.)<br />
PAUSE Kurzfristige Programmunterbrechung.<br />
START<br />
Ausführung des Programms. (Nach einer kurzfristigen<br />
Programmunterbrechung.)<br />
Ausführen des Programms über REMOTE3<br />
Sie können die E/A-1-Schnittstelle als REMOTE 3-Schnittstelle verwenden. So können Sie diese<br />
Schnittstelle (als Haupt-REMOTE) im AUTO-Modus anstelle der Bedieneinheit OPU-<strong>300</strong>/OPU-<strong>320</strong><br />
verwenden. Auf diese Art können verschiedene Bedienmöglichkeiten genutzt werden.<br />
Wenn Sie die E/A-1 an der Rückseite der Steuerung als REMOTE3 benutzen wollen, müssen Sie<br />
folgende Schritte ausführen:<br />
1 Stellen Sie Bit 1 des Softwareschalters SS1 auf EIN.<br />
2 Stellen Sie das notwendige Bit als REMOTE3 vom Eingang/Ausgang der E/A-1 ein.<br />
*Das Einrichten des Softwareschalters und der REMOTE3 werden über den SPEL Editor<br />
bzw. SPEL für Windows vorgenommen. Weitere Informationen erhalten Sie in den<br />
entsprechenden Handbüchern.<br />
3 Schalten Sie die Spannungszufuhr der Steuerung aus und sofort wieder ein.<br />
4 Geben Sie ein START-Signal über die REMOTE3 ein, und führen Sie das Programm aus.<br />
Um das Programm anzuhalten, geben Sie zuerst ein PAUSE-Signal (temporärer Halt) und<br />
dann das RESET-Signal ein.<br />
* Die Pinbelegung und Zeitliniendiagramme entnehmen Sie bitte dem Kapitel 7 „E/A-<br />
REMOTE-Einstellungen (REMOTE 3)“ des Handbuches über die Steuerung.
2.9 Auswahl des Programms zum Ändern von Zeilen<br />
Wenn Sie Zeilen eines Programms ändern wollen, müssen Sie das ganze Programm ändern. D. h., die<br />
entsprechenden ausführbaren Dateien (Objektdatei und Symboldatei) müssen ausgewählt werden.<br />
Wie Sie das entsprechende Programm, das Sie ändern wollen, auswählen können, wird nachfolgend<br />
beschrieben.<br />
Auswahl des Programms per REMOTE-Eingang<br />
Das entsprechende Programm muß im Dateispeicher vorhanden sein, um es auswählen und ändern zu<br />
können.<br />
1) Übertragen Sie eine ausführbare Datei in den Dateispeicher.<br />
Sichern Sie ein Quellprogramm und eine Punktdatei mit Hilfe des Befehls DSAVE in den<br />
Dateispeicher, und führen Sie dann den Befehl COMPILE aus, um ein Objektprogramm<br />
und eine Symboldatei zu erzeugen.<br />
<br />
>DSAVE“01TEST“<br />
>COMPILE“01TEST“<br />
COMPILE END<br />
><br />
Wenn die ersten zwei Zeichen des Programmnamens Zahlen sind, ist dies die<br />
„Programmnummer“. Die Programmnummer wird zur Auswahl des Programms<br />
verwendet. Z. B. mit Hilfe der Pfeiltasten � � (OPU-<strong>300</strong>) oder durch Eingabe dieser<br />
Nummer über die REMOTE3.<br />
2) Bringen Sie die ausführbare Datei in den Hauptspeicher.<br />
Die Methoden hierfür werden nachfolgend beschrieben:<br />
• Bei Verwendung der OPU-<strong>300</strong>:<br />
Die ausführbaren Dateien werden mit Hilfe des Dateiauswahlmenüs 1 oder 2<br />
ausgewählt. Es ist möglich, alle im Dateiauswahlmenü ausgewählten ausführbaren<br />
Dateien in den Hauptspeicher zu übertragen. Weitere Informationen entnehmen Sie<br />
bitte dem Handbuch über die Bedieneinheit OPU-<strong>300</strong>.<br />
• Bei Verwendung der REMOTE3:<br />
Die ausführbaren Dateien werden mit Hilfe der Programmnummern ausgewählt.<br />
Es sind zwei verschiedene Wege zur Eingabe der Programmnummern möglich: die<br />
Binärmethode und die Auf/Ab-Zähl-Methode. Die Binärmethode ist leichter zu<br />
steuern. Es ist mit dieser Methode jedoch nur möglich, max. 15 Dateien<br />
(Programmnummer 01 bis 15) auszuwählen. Wenn es notwendig sein sollte, mehr als<br />
15 Dateien auszuwählen, verwenden Sie bitte die Auf/Ab-Zähl-Methode.<br />
Wenn START nach Einrichten des Eingangssignals der Programmnummer eingegeben wird, werden<br />
die ausführbaren Dateien in den Hauptspeicher übertragen und das Programm wird gestartet. Weitere<br />
Informationen erhalten Sie im Handbuch über die Steuerung in Kapitel 7.4 „Zeitliniendiagramme<br />
(Zeittabellen)“ im Abschnitt „Zeitliniendarstellung bei Programmausführung“.<br />
31
Verwendung des CHAIN-Befehls<br />
32<br />
Auch mit Hilfe des Befehls CHAIN können Sie Objektprogramme ändern. Sie können diesen Befehl<br />
nicht verwenden, wenn Sie mit Hilfe des REMOTE-Eingangs Programmnummern festlegen.<br />
Der CHAIN-Befehl wurde zum Ändern von Daten während der Programmausführung entworfen. Der<br />
CHAIN-Befehl kann das laufende Programm durch ein im Dateispeicher ausgewähltes Programm<br />
ersetzen.<br />
Weitere Informationen erhalten Sie im Kapitel 2.1 „Erzeugen eines umfangreichen Programms“.<br />
2.10 Handhabung von Dateien<br />
• Mit SPEL Editor:<br />
Das erzeugte Programm und die Positionsdaten werden im Hauptspeicher der Steuerung<br />
gespeichert. Es ist immer nur möglich, eine Programmnummer und auch nur eine<br />
Nummer für die Positionsdatengruppe im Hauptspeicher zu halten. Daher müssen Sie bei<br />
dem Erzeugen eines neuen Programmes und der Positionsdaten beides aus dem<br />
Hauptspeicher in den Dateispeicher übertragen. (Siehe auch Kapitel 3.4 „Sichern und<br />
Laden von Dateien“ im SPEL Editor-Handbuch.)<br />
Lesen Sie bitte die Informationen zu den nachfolgend aufgeführten Befehlen, wenn Sie<br />
den SPEL Editor verwenden:<br />
DSAVE Speichert das Quellprogramm und die Positionsdatendateien vom<br />
Haupt- in den Dateispeicher.<br />
DLOAD Lädt ausgewählte Dateien in den Hauptspeicher.<br />
DIR, FILES Zeigt die Informationen über die Dateien des Dateispeichers an.<br />
COPY Kopiert eine Datei<br />
KILL, DEL Löscht Dateien<br />
• Mit SPEL für Windows:<br />
Bei Verwendung von SPEL für Windows werden alle Programm- und<br />
Positionsdatendateien im PC gespeichert. Weitere Information erhalten Sie im SPEL für<br />
Windows Handbuch.
3. JOG-Betrieb<br />
Beim REMOTE Teaching wird der Manipulator in die gewünschte Position verfahren, indem die JOG-<br />
Taste des PCs und des Handprogrammiergerätes gedrückt werden, ist die gewünschte Position erreicht,<br />
wird diese eingerichtet. Das Verfahren der verschiedenen Achsen mit der JOG-Taste wird „JOG-<br />
Verfahren“ genannt.<br />
Im JOG-Verfahren können Sie die Richtung, in der sich der Manipulator und die Methode, wie er sich<br />
bewegen soll, ändern. Dazu stellen Sie „benutzte Koordinaten im JOG-Verfahren“ oder „JOG-<br />
Verfahrmethode“ ein, während Sie die JOG-Taste gedrückt halten. Wählen Sie die besten Einstellungen<br />
für Ihre Anwendung, um ein wirkungsvolles Einrichten zu gewährleisten.<br />
Wenn Sie ein TP-<strong>320</strong>/TP-<strong>320</strong>J verwenden, erhalten Sie weitere Informationen zum Einrichten in<br />
Kapitel 4 in diesem Handbuch.<br />
3.1 Das verwendete Koordinatensystem im JOG-Verfahren<br />
Entscheiden Sie bitte, welches der Koordinatensysteme Sie beim JOG-Verfahren verwenden wollen. Die<br />
Verfahrrichtung der Achsen ist abhängig vom gewählten Koordinatensystem.<br />
Koordinatensystem Beschreibung<br />
BASE Basis-Koordinatensystem. Das JOG-Verfahren wird gemäß der Basiskoordinaten<br />
des Manipulators (BASE0) ausgeführt. Da dies das Koordinatensystem ist, das<br />
fest im Manipulator eingerichtet ist, können Sie die Richtung jeder<br />
Koordinatenachse auf einen Blick sehen.<br />
TOOL Tool-Koordinatensystem. Wählen Sie ein Koordinatensystem, das mit dem Tool-<br />
Koordinatensystem übereinstimmt, wenn angenommen wird, daß das Werkzeug<br />
(Tool) am Ende des Greifer befestigt ist. Die Richtung jeder Koordinatenachse<br />
ist abhängig von der Rotation des Greifers.<br />
JOINT Joint-Koordinatensystem. Ausführen des JOG-Verfahrens für jedes<br />
Manipulatorgelenk.<br />
Weitere Informationen zur Auswahl der Koordinatensysteme erhalten Sie im SPEL Editor Handbuch in<br />
Kapitel 6 und im SPEL für Windows Handbuch in Kapitel 3.<br />
Erläuterungen zu jedem Koordinatensystem finden Sie auf den nächsten Seiten.<br />
33
JOG-Verfahren im Basis-Koordinatensystem<br />
34<br />
Wenn das Basis-Koordinatensystem ausgewählt ist, kann die Verfahrrichtung jeder Achse entsprechend<br />
des Basis-Koordinatensystems des Manipulators (BASE0) ausgeführt werden.<br />
Innerhalb des Basis-Koordinatensystems bewegt sich der Manipulator gemäß des Koordinatensystems,<br />
das fest im Manipulator eingerichtet ist. So bleibt immer eine feste Beziehung zwischen der JOG-<br />
Richtung jeder Achse und der Ausrichtung des Manipulatorsockels erhalten. Da es so einfacher ist, die<br />
JOG-Richtung auf einen Blick zu erkennen, ist dies das am häufigsten eingesetzte Koordinatensystem.<br />
Verschiedene Manipulatortypen haben verschiedene Basis-Koordinatensysteme. Weitere Informationen<br />
über das verwendete Basis-Koordinatensystem erhalten Sie in dem Handbuch über Ihren Manipulator.<br />
Allgemein sieht das Koordinatensystem wie folgt aus:<br />
���� HINWEIS<br />
JOG-Verfahren im Basis-Koordinatensystem<br />
Bitte überprüfen Sie das Koordinatensystem, wenn das Basis-Koordinatensystem<br />
durch Ausführung der Befehle BASE0 oder LOCAL 0 verändert worden ist.
JOG-Verfahren im Tool-Koordinatensystem<br />
���� HINWEIS<br />
Wenn Sie das Tool-Koordinatensystem ausgewählt haben, wird die Richtung jeder<br />
Bewegung, die durch die JOG-Taste ausgeführt wird, festgelegt durch die<br />
Ausrichtung des Greifers. Auch wenn der Greifer rotiert, wird das JOG-Verfahren<br />
durch feste Koordinaten für die Ausrichtung des Greifers ausgeführt. Es kann<br />
daher für Düsen oder ähnliches, mit gleicher Richtung, eingesetzt werden.<br />
Der Ursprungspunkt des Tool-Koordinatensystems kann auch auf einen Punkt, der sich nicht im<br />
Mittelpunkt der 4. Achse (rotierende Achse) befindet, eingestellt werden. Der Ursprungspunkt des Tool-<br />
Koordinatensystems wird mit dem TLSET-Befehl mittig auf das Werkzeug eingestellt.<br />
���� HINWEIS<br />
JOG-Verfahren im Tool-Koordinatensystem<br />
Weitere Informationen über das Tool-Koordinatensystem erhalten Sie in dem<br />
SPEL III Referenzhandbuch in den jeweiligen Abschnitten über die Befehle TOOL<br />
und TLSET.<br />
JOG-Verfahren im Joint-Koordinatensystem<br />
Wenn Sie das Joint-Koordinatensystem ausgewählt haben, entspricht jede JOG-Taste jedem<br />
Manipulatorgelenk.<br />
JOG-Verfahren im Joint-Koordinatensystem<br />
35
3.2 JOG-Bewegung<br />
36<br />
Die Strecke der JOG-Bewegung kann verändert werden. Wir empfehlen, daß Sie zuerst den großen Wert<br />
einstellen und den Arm nahezu in Zielposition bringen und dann den Arm bewegen, so daß Sie den<br />
kleinen Wert nach und nach einstellen können, bis Sie die genaue Zielposition erreicht haben.<br />
Die Einheit für die Strecke der JOG-Bewegung ist abhängig von dem eingesetzten Koordinatensystem<br />
für das JOG-Verfahren.<br />
1. Achse<br />
(X/J1)<br />
2. Achse<br />
(Y/J2)<br />
3. Achse<br />
(Z/J3)<br />
4. Achse<br />
(U/J4)<br />
Basis-Koordinatensystem mm mm mm Grad<br />
Tool-Koordinatensystem mm mm mm Grad<br />
Joint-Systemeinheit (direkt aktive Achse) mm mm mm -<br />
Joint-Systemeinheit (rotierende Achse) Grad Grad Grad Grad<br />
Weitere Informationen zur Stecke des JOG-Verfahrens erhalten Sie im SPEL Editor Handbuch in<br />
Kapitel 6 und im SPEL für Windows Handbuch in den Kapiteln 3 und 8.<br />
���� HINWEIS<br />
Wenn Sie den SPEL Editor und das Handprogrammiergerät TP-<strong>320</strong>/TP-<strong>320</strong>J<br />
zusammen einsetzen, lesen Sie bitte vorher das Kapitel 4 im Handbuch des<br />
Handprogrammiergeräts TP-<strong>320</strong>/TP-<strong>320</strong>J. Beachten Sie bitte, daß die Strecke des<br />
JOG-Verfahrens, die mit dem SPEL Editor eingestellt wurde, in den Wert<br />
geändert wird, der mit dem Handprogrammiergerät eingegeben worden ist.<br />
Wenn Sie SPEL für Windows und das Handprogrammiergerät TP-<strong>320</strong>/TP-<strong>320</strong>J<br />
zusammen einsetzen, lesen Sie bitte vorher das Kapitel 7 im SPEL für Windows<br />
Handbuch.<br />
Wenn Sie die JOG-TASTE ununterbrochen gedrückt halten, kann der Arm hinter den<br />
Bewegungsbereich gelangen. Dann wird ein NOT-AUS ausgelöst und der Motor angehalten. Sollte dies<br />
passieren, ergreifen Sie bitte die folgenden Maßnahmen:<br />
1 Bringen Sie den Arm per Hand zurück in den Bewegungsbereich.<br />
2 Drücken Sie die RESET-Taste, um den Fehler zu löschen.<br />
3 Führen Sie den Befehl MOTOR ON aus. Dies schaltet den Motor ein und bringt den<br />
Roboter zurück in die Grundstellung.
GRUNDLAGEN<br />
37
1. Bewegungsgeschwindigkeit<br />
1.1 Beschleunigungs-/Verzögerungsgeschwindigkeit<br />
38<br />
Wenn Sie den Befehl für das Bewegen des Roboters eingeben, verändert sich die Bewegung, wie unten<br />
dargestellt:<br />
Die Geschwindigkeitskurve wird durch die Geschwindigkeit und die Beschleunigungs-<br />
/Verzögerungseinstellung bestimmt.<br />
Befehle, die sich auf die Geschwindigkeit beziehen, werden abhängig vom Bewegungsbefehl in zwei<br />
Kategorien aufgeteilt:<br />
Geschwindigkeit Beschleunigung/Verzögerung Entsprechende Bewegungsbefehle<br />
SPEED<br />
(%)<br />
SPEED<br />
(mm/s)<br />
ACCEL<br />
(%)<br />
ACCELS<br />
(mm/s 2 )<br />
JUMP<br />
GO<br />
PASS<br />
MOVE<br />
ARC<br />
CVMOVE<br />
* Einheit der Geschwindigkeit und Beschleunigung/Verzögerung in Klammern ().<br />
PTP Bewegung<br />
CP Bewegung<br />
PTP-Befehle (Punkt-zu-Punkt) werden häufig für pick-and-place-Anwendungen eingesetzt. Bei dieser<br />
Art von Anwendung ist höchstmögliche Bewegung zur Zielposition erforderlich. Daher ist die<br />
Geschwindigkeitseinstellung in mm/s nicht so wichtig. Im Fall der horizontal ausgerichteten Roboter<br />
(SCARA) weichen die zulässige maximale Geschwindigkeit und die Beschleunigung/Verzögerung auf<br />
Grund der Bewegungspositionen innerhalb des Bewegungsbereiches voneinander ab. Die SPEED und<br />
ACCEL Werte werden daher in Prozent angegeben, während die maximal zulässige Geschwindigkeit<br />
mechanisch gesehen als 100 angenommen wird.<br />
CP-Befehle (Kontinuierliche Wege) werden oft für Verpackungsanwendungen eingesetzt.<br />
Verpackungsanwendungen benötigen eine konstante Geschwindigkeitsbewegung ohne Bezug auf die<br />
aktuelle oder Zielposition. Die SPEED und ACCELS Werte werden daher in mm/s und mm/s 2<br />
angegeben.<br />
Weitere Informationen über die Befehle SPEED, SPEEDS, ACCEL und ACCELS erhalten Sie im SPEL<br />
III Referenzhandbuch.
1.2 Hochgeschwindigkeit im Teach-Modus<br />
Wenn die Steuerung zum Programmieren oder Einrichten auf den Teach-Modus eingestellt ist, schaltet<br />
der Roboter in der Regel in den LP-Modus (Low Power-Modus). Dieser Modus reduziert die<br />
Motorleistung. Der Roboter schaltet aus Sicherheitsgründen automatisch in den „Low Power“-Modus<br />
und arbeitet in einer kontrollierten, langsameren Geschwindigkeit, wenn er sich im TEACH-Modus<br />
befindet.<br />
Es wurden daher die folgenden drei Blockaden eingebaut, und erst wenn diese drei Blockaden<br />
ausgeschaltet werden, ist es möglich, die programmierte Anwendung mit einer höheren<br />
Geschwindigkeit wieder aufzunehmen.<br />
• Blockierung durch die Sicherheitsabschrankung<br />
• Blockierung durch den POWER-(LP)-Befehl<br />
• Blockierung durch den TSPEED-Befehl<br />
Blockierung durch die Sicherheitsabschrankung<br />
Ist die Sicherheitsabschrankung geöffnet (mit anderen Worten, wenn der Eingang REMOTE1 der<br />
Sicherheitsabschrankung freigeschaltet ist), bleibt der Roboter im Low Power-Modus. Solange die<br />
Sicherheitsabschrankung geöffnet bleibt, arbeitet der Roboter nur in der Geschwindigkeit, die durch die<br />
Einstellungen festgesetzt oder mit Hilfe des Befehls TSPEED eingegeben wurde.<br />
Bevor der Roboter in seiner programmierten Geschwindigkeit weiter arbeiten kann, muß die<br />
Sicherheitsabschrankung geschlossen werden.<br />
Weiter Informationen entnehmen Sie bitte den Kapiteln 1.4 in der Einleitung und 4 im Handbuch über<br />
die Steuerung.<br />
Blockierung durch den POWER-(LP)-Befehl<br />
Wenn der Befehl POWER LOW (LP ON) ausgeführt wird, schaltet der Roboter in den Low Power-<br />
Modus. Damit der Roboter wieder in seiner programmierten Geschwindigkeit arbeiten kann, muß der<br />
Befehl POWER HIGH (LP OFF) eingegeben werden.<br />
Wenn der Roboter vom AUTO in den TEACH-Modus geschaltet wird, schaltet er automatisch in den<br />
Low Power-Modus. Auch wenn dann die Sicherheitsabschrankung geschlossen wird, bleibt er im Low<br />
Power-Modus und arbeitet mit der eingestellten Geschwindigkeit, die abhängig vom Robotermodell<br />
variiert.<br />
Aus Sicherheitsgründen wird der Low Power-Modus im Teach-Modus immer eingeschaltet, d.h. bei<br />
folgenden Operationen wird der Motor-Power-Modus standardmäßig auf LOW gesetzt. Dabei werden<br />
die Einstellungen für die Geschwindigkeit und die Beschleunigung auf die Standardwerte zurückgesetzt<br />
(initialisiert). Informationen zu diesen Standardwerten erhalten Sie in den Spezifikationen der<br />
Manipulatoren, da diese modellabhängig sind.<br />
39
40<br />
Unter folgenden Umständen wird in den Low Power-Modus geschaltet:<br />
• Wenn ein Fehler auftritt, der nur durch RESET oder Aus- und Einschalten der Spannungszufuhr<br />
rückgängig gemacht werden kann.<br />
• Wenn vom Auto- in den Teach-Modus geschaltet wird.<br />
• Wenn der STOP-Taster oder die Tastenkombination Ctrl + C gedrückt wird.<br />
• Wenn der Befehl MOTOR ON ausgeführt wird.<br />
Blockierung durch den TSPEED-Befehl<br />
Wie bereits vorher erwähnt, kann der Roboter im TEACH-Modus mit niedriger Geschwindigkeit<br />
betrieben werden, auch wenn die Sicherheitsabschrankung geöffnet ist, um das Einrichten zu<br />
ermöglichen. So ist es möglich, daß derjenige, der den TEACH-Vorgang ausführt, nahe an den Roboter<br />
herankommt. Der Roboter wird normalerweise im TEACH-Modus im LOW-POWER-Status betrieben,<br />
um die Sicherheit des Bedieners zu gewährleisten.<br />
Der Befehl TSPEED (TSPEEDS) wird verwendet, um die Geschwindigkeit im Teach-Modus, die mit<br />
dem Befehl SPEED (SPEEDS) eingegeben wurde, nochmals zu reduzieren. Diese Geschwindigkeit<br />
wird, auch wenn die Spannungszufuhr der Steuerung ausgeschaltet wird, im Speicher behalten.
1.3 Beschleunigungs-/Verzögerungssteuerung der 3. Achse mit dem<br />
JUMP-Befehl<br />
Die grundlegende Bewegung des JUMP-Befehls wird nachfolgend dargestellt:<br />
Die Geschwindigkeit und die Beschleunigung/Verzögerung wirken sich auf alle oben dargestellten<br />
Bewegungen aus. Da die Beschleunigung/Verzögerung der Bewegungsgeschwindigkeit der 3. Achse<br />
wichtig ist für pick-and-place-Anwendungen, müssen Sie die geeignetste Geschwindigkeit einstellen. Z.<br />
B., wenn der Roboter einen Gegenstand an der aktuellen Position aufnimmt und ihn an der Zielposition<br />
absetzt, soll die Beschleunigung und die horizontale Bewegung der 3. Achse schnell und das Plazieren,<br />
also die Verzögerung, langsam vonstatten gehen.<br />
Damit diese Anwendung zufriedenstellend ausgeführt werden kann, lassen sich die<br />
Beschleunigung/Verzögerung und die Geschwindigkeit bei der horizontalen Bewegung einzeln<br />
einstellen.<br />
Die Bewegungsgeschwindigkeit der 3. Achse läßt sich durch drei Parameter des Befehls SPEED<br />
einstellen.<br />
Format: SPEED [A],[B],[C]<br />
A: Spezifikationswert der Geschwindigkeit<br />
B: Aufwärtsgeschwindigkeit der 3. Achse<br />
C: Abwärtsgeschwindigkeit der 3. Achse<br />
Die Beschleunigungs-/Verzögerungsgeschwindigkeit der 3. Achse läßt sich durch sechs Parameter des<br />
Befehls ACCEL einstellen.<br />
Format: ACCEL [A],[B],[C],[D],[E],[F]<br />
A: Spezifikationswert der Beschleunigungsgeschwindigkeit<br />
<br />
B: Spezifikationswert der Verzögerungsgeschwindigkeit<br />
C: Erhöhen der Beschleunigungsgeschwindigkeit der 3. Achse<br />
D: Erhöhen der Verzögerungsgeschwindigkeit der 3. Achse<br />
E: Verringern der Beschleunigungsgeschwindigkeit der 3. Achse<br />
F: Verringern der Verzögerungsgeschwindigkeit der 3. Achse<br />
1000 FUNCTION MAIN<br />
1010 SPEED 100,80,20<br />
1020 ACCEL 100,100,100,100,80,20<br />
M<br />
2000 JUMP P1<br />
M<br />
<strong>300</strong>0 FEND<br />
41
1.4 Transport von Objekten, die das Nominalgewicht überschreiten<br />
42<br />
Die Geschwindigkeit und die Einstellungen für Verzögerung und Beschleunigung variieren in<br />
Abhängigkeit von der am Ende des Greifers angebrachten Last.<br />
Um geeignete Werte für die Geschwindigkeit, Verzögerung und Beschleunigung einzustellen, sollten<br />
Sie zuerst das Gewicht der zu transportierenden Objekte messen und es dann mit Hilfe des WEIGHT-<br />
Befehls eingeben.<br />
Die einzugebende Last (Greifergewicht) setzt sich zusammen aus dem Gewicht des Greifers und des zu<br />
transportierenden Objekts.<br />
Format: WEIGHT [Greifergewicht],[Armlänge]<br />
Die Armlänge ist die Strecke vom Rotationsmittelpunkt der 2. Achse zur Mitte des Schwerpunkts des<br />
Greifers (inkl. zu transportierendes Objekt). Handelt es sich bei der Mitte des Schwerpunkts um den<br />
Mittelpunkt der 3. Achse, muß es nicht extra eingegeben werden. Es muß aber angegeben werden, wenn<br />
es sich bei dem eingesetzten Roboter nicht um ein horizontal ausgerichtetes Modell handelt.<br />
Wird der WEIGHT-Befehl ausgeführt, errechnet die Steuerung für das eingegebene Gewicht die<br />
maximale Geschwindigkeit und die ausführbaren Werte für Verzögerung und Beschleunigung. Wenn<br />
mit Hilfe des Befehls SPEED oder ACCEL ein Wert von 100 eingegeben worden ist, wird dieser Wert<br />
unter Umständen eingehalten, wenn die Berechnung der Steuerung ergibt, daß es kein mechanisches<br />
Hindernis gibt.<br />
���� HINWEIS<br />
Warnung<br />
Weitere Informationen, wie Sie im Hinblick auf das Greifergewicht den Wert für<br />
den WEIGHT-Befehl richtig einstellen, erhalten Sie in Kapitel 5 im<br />
Manipulatorhandbuch. Die Verwendung des WEIGHT-Befehls wird im SPEL III<br />
Handbuch erläutert.<br />
Transporte von Objekten, die das Nominalgewicht, bei standardmäßig<br />
eingestellten Werten von Last, Geschwindigkeit und<br />
Verzögerung/Beschleunigung, weit überschreiten, können nicht nur einen Fehler<br />
wegen Überlastung, sondern auch Unfälle hervorrufen.
2. Programmierung<br />
2.1 Grundlegende Bestandteile eines Programms<br />
Die Grundeinheit eines Programms wird „Zeile“ genannt, und eine Anzahl von Zeilen macht ein<br />
Programm aus. Die Zeilen selbst bestehen aus Zeilennummern und Anweisungen.<br />
Ein Programm beginnt immer mit der 1. Zeile „FUNCTION MAIN“ und endet mit der letzten Zeile<br />
„FEND“.<br />
10 FUNCTION MAIN<br />
M<br />
1000 FEND<br />
Alles, was von FUNCTION bis FEND steht, wird eine Funktion genannt. Nach Eingabe von<br />
FUNCTION ist ein Name, im Beispiel MAIN, erforderlich.<br />
SPEL III verfügt über 16 multi-tasking Ressourcen. Multi-tasking bezieht sich auf Prozesse, in denen<br />
einzelne Tasks gleichzeitig oder der Reihe nach ausgeführt werden. Ein multi-tasking Programm wird<br />
beschrieben durch eine Fortsetzung der Funktion. Die Stellen, an denen verschiedene Funktionen<br />
ausgeführt werden, werden Tasks genannt, und die Steuerung verfügt über 16 dieser Tasks (Nr. 1-16).<br />
Die maximale Anzahl von Funktionsnummern in einem Programm kann 69 betragen. Die Task kann<br />
ausgeführt und wenn notwendig angehalten werden. Weitere Informationen erhalten Sie im Kapitel<br />
„Multi-tasking“ in diesem Handbuch.<br />
Die allererste Funktion in einem Programm ist die Hauptfunktion und wird immer als Task 1<br />
ausgeführt. Alle anderen Funktionen müssen eine Funktionsnummer enthalten, die mit Hilfe des XQT-<br />
Befehls in der Hauptfunktion festgelegt werden müssen.<br />
<br />
10 FUNCTION Function 1<br />
20 XQT !2, Function 2<br />
30 XQT !5, Function 3<br />
M<br />
980 FEND<br />
990 ‘------------------<br />
1000 FUNCTION Function 2<br />
M<br />
1980 FEND<br />
1990 ‘------------------<br />
2000 FUNCTION Function 3<br />
M<br />
<strong>300</strong>0 FEND<br />
678<br />
Hauptfunktion<br />
43
Funktionsname<br />
44<br />
Im Folgenden werden die Beschränkungen bei der Verwendung von Funktionsnamen aufgeführt:<br />
Kommentare<br />
• Als verwendbare Zeichen sind alle alphanumerischen Zeichen und Unterstriche ( _ ) zugelassen.<br />
• Der Funktionsname darf aus max. acht Zeichen bestehen.<br />
• Das erste Zeichen muß ein Buchstabe (außer P) sein.<br />
• Reservierte Worte (z. B. Befehle, Anweisungen und Funktionen) dürfen nicht verwendet werden.<br />
Auch wenn Sie reservierte Worte durch Unterstriche oder Zahlen ergänzen oder verändern, werden<br />
sie trotzdem als reservierte Worte erkannt.<br />
Um ein Programm verständlicher zu machen, können Sie, wenn notwendig, Kommentare einfügen. Das<br />
Symbol, das einen Kommentar einleitet ist das Apostroph ‘ . Alle Zeichen, die auf ein Apostroph folgen,<br />
werden als Kommentar berücksichtigt. Bei Ausführung des Programms werden alle Kommentare, die<br />
auf ein Apostroph folgen, außer Acht gelassen.<br />
Als Kommentar können Sie jedes Zeichen benutzen, allerdings darf der Kommentar, einschließlich<br />
Zeilennummer, Anweisung und Text, 79 Zeichen nicht überschreiten.<br />
<br />
10 FUNCTION MAIN<br />
20 ‘ ************************<br />
30 ‘ * HANDLER-1 *<br />
Kommentarzeilen<br />
40 ‘ *programmiert von SATO *<br />
50 ‘ ************************<br />
60 ‘ GOSUB 1000<br />
70 SPEED 100 ;ACCEL 50,100<br />
80 JUMP P10 ;ON 1 ;WAIT 0,2 ‘Nimmt<br />
Objekt von Einzug1 auf.<br />
Mehrfachanweisung<br />
64748<br />
←GOSUB wird nicht<br />
ausgeführt!<br />
←Kommentar<br />
Wird das Semikolon (;) benutzt, können mehrere Befehle in eine Zeile geschrieben werden. Dies wird<br />
Mehrfachanweisung genannt.<br />
Mit Hilfe der Mehrfachanweisungen können Programme leichter gelesen werden, und die<br />
Programmgröße wird verringert. Auch ist die Ausführzeit geringer. Werden jedoch unwichtige<br />
Mehrfachanweisungen eingegeben, kann das Programm unübersichtlich und schwer verständlich<br />
werden.<br />
<br />
100 JUMP P7 ; ON 1 ; WAIT 0,2<br />
110 JUMP P17 ; OFF 1 ; WAIT 0,2
Sprungmarken<br />
Wenn Sie die Programmausführungsreihenfolge mit Hilfe von GOTO, GOSUB oder IF...THEN...ELSE<br />
ändern, wird das Programm gemäß der festgelegten Zeilennummern ausgeführt. Die Zeilennummer ist<br />
nur eine Nummer und hat keinerlei weitere Bedeutung. Wenn Sie ein Wort benutzen können, um eine<br />
Bewegung anzuzeigen, ist dies für den Programmierer und den Benutzer viel angenehmer.<br />
In SPEL III können Sie eine Sprungmarke anstatt nur einer Zeilennummer für die GOTO, GOSUB oder<br />
IF...THEN...ELSE Anweisungen verwenden.<br />
<br />
10 FUNCTION MAIN ←<br />
20 LOOP: ←Sprungmarke<br />
30 JUMP P1<br />
40 JUMP P2<br />
50 GOTO LOOP ←Verzweigung mit Hilfe der Sprungmarke<br />
60 FEND0<br />
Im Beispiel ist die Zeile 20 mit der Sprungmarke „LOOP“ versehen. Erst der Doppelpunkt (:) hinter<br />
LOOP zeigt an, daß es sich tatsächlich um eine Sprungmarke handelt.<br />
Im Folgenden werden die Beschränkungen bei der Verwendung von Sprungmarken aufgeführt:<br />
• Als verwendbare Zeichen sind alle alphanumerischen Zeichen und Unterstriche ( _ ) außer dem<br />
Doppelpunkt (:) zugelassen.<br />
• Die Sprungmarke darf aus max. acht Zeichen bestehen.<br />
• Das erste Zeichen muß ein Buchstabe (außer P) sein.<br />
• Groß- und Kleinschreibung ist egal.<br />
Es gibt eine spezielle Funktion, um Zeilennummern automatisch neu zu vergeben (renumber), so daß die<br />
festgelegten Zeilennummern für GOTO, GOSUB, oder IF...THEN...ELSE automatisch geändert werden.<br />
Das Programm ist leichter zu verstehen, wenn die Sprungmarken so definiert werden.<br />
45
2.2 Konstanten<br />
46<br />
Konstanten sind aktuelle Werte, die SPEL III während der Ausführung benutzt. Es gibt zwei<br />
verschiedene Arten von Konstanten: Zeichenketten (oder Zeichen) und numerische Konstanten.<br />
Numerische Konstanten<br />
Numerische Konstanten können ganze oder reelle Zahlen sein. Es ist wichtig, ein Minuszeichen (-) vor<br />
eine negative Zahl zu stellen, aber vor positiven Zahlen wird kein Pluszeichen (+) gesetzt.<br />
Ganze Zahlen<br />
Ganze Zahlen haben kein Dezimalkomma. Sie sind in dem folgenden Bereich zulässig: -32768 bis<br />
32768.<br />
Es gibt die folgenden Beschreibungen für ganze Zahlen:<br />
• Dezimalformat<br />
Der Wert wird in Dezimalzahlen (0-9) ausgedrückt.<br />
• Hexadezimalformat<br />
Der Wert wird in Hexadezimalzahlen (0-F) mit dem Präfix „&H“ ausgedrückt. Die entsprechenden<br />
Werte für Hexadezimal- und Dezimalzahlen finden Sie in der folgenden Tabelle:<br />
Hexadezimal 0-9 A B C D E F<br />
Dezimal 0-9 10 11 12 13 14 15<br />
<br />
Hexadezimal Dezimal<br />
&H25 2 x 16 1 + 5 = 37<br />
&H3F 3 x 16 1 + 15 = 63<br />
• Binärformat<br />
Der Wert wird in Binärzahlen (0 und 1) mit dem Präfix „&B“ ausgedrückt.<br />
<br />
Binär Dezimal<br />
&B1111 2 3 + 2 2 + 2 1 +2 0 = 15<br />
&B101 2 2 + 2 0 = 5<br />
Reelle Zahlen<br />
Diese Werte enthalten Dezimalkommas, liegen innerhalb des Bereiches der ganzen Zahlen und werden<br />
in exponentieller Form ausgedrückt.<br />
Zeichenketten<br />
Zeichenketten werden immer in Anführungszeichen (“) eingeschlossen. Sie können aus einzelnen<br />
Zeichen, Zeichenfolgen und Zahlen bestehen. Besteht die Zeichenfolge nur aus zwei Anführungszeichen<br />
(““), hat die Zeichenfolge eine „Nulllänge“ und wird als Leerzeichen interpretiert.<br />
<br />
>PRINT “HALLO“<br />
HALLO<br />
>PRINT HALLO“<br />
123 ←Hier wird das Wort HALLO durch einen Wert ersetzt, da das<br />
Wort nicht in Anführungszeichen gesetzt wurde.
2.3 Variablen<br />
Variablen werden als vorübergehende Ersatzdaten verwendet. Es gibt viele verschiedene Arten von<br />
Variablen, daher muß vor dem Benutzen einer Variable eine Variablendefinition eingegeben werden.<br />
Der Wert, durch den die Variable ersetzt wird, muß vom selben Typ sein wie die Variable selbst.<br />
Die Werte der Variablen werden solange beibehalten, bis das Objektgebiet überschrieben oder gelöscht<br />
wird (Ausschalten der Spannungszufuhr, Überschreiben durch ein Programm, etc.). Sie werden immer<br />
dann gelöscht, wenn der COM-Befehl oder eine andere ausführbare Datei ausgeführt wird. Um<br />
Variablenwerte zu speichern, müssen Sie Backup-Variablen, wie unten beschrieben, verwenden.<br />
Spezifische Anzahl von Variablen<br />
Die spezifische Anzahl von Variablen kann durch die folgende Gleichung bestimmt werden:<br />
Spezifische Anzahl von Variablen = 448 – (Anzahl der Funktionen)<br />
Dies ergibt sich daraus, daß die Variablen- und die Funktionsnamen in dem selben Bereich<br />
(Symboltabelle) verwaltet werden z.B.: In einem Programm mit nur einem Task können Sie bis zu 447<br />
Variablen definieren. Sie müssen jedoch beachten, daß die Anzahl der Bereichsvariablen in<br />
Abhängigkeit von deren Größe variiert. (Wenn große Bereiche benutzt werden, können weniger<br />
Variablen verwendet werden!)<br />
Für andere als Bereichsvariablen (numerische Variablen oder Zeichenkettenvariablen) hat die<br />
Variablengröße keinen Einfluß auf die Anzahl der Variablen.<br />
Die Anzahl dieser Variablen kann durch andere Faktoren beeinflußt werden. Der Bereich, in den<br />
Variablenwerte gespeichert werden, entspricht dem Objektbereich zum Speichern ausführbarer<br />
Programme. Dementsprechend kann, wenn ein großes Programm verwendet wird, der Bereich zum<br />
Speichern der Variablen besetzt sein. In diesen Fällen tritt während des Kompilierens ein Fehler auf.<br />
Um das Problem zu beheben, müssen Sie entweder die Programmgröße verkleinern oder die Anzahl der<br />
verwendeten Variablen verringern.<br />
Numerische Variablen<br />
1. Verschiedene numerische Variablen (siehe nächste Tabelle)<br />
Ganze Zahlen<br />
Beschreibung Bytes verfügbarer Wert/Gültige Ziffer<br />
BYTE 1 -128 bis 127<br />
INTEGER 2 -32768 bis 32767<br />
LONG 4 -2147483648 bis 2147483647*<br />
REAL 4 7 Ziffern<br />
Reelle Zahlen DOUBLE 8 14 Ziffern<br />
Wenn Sie eine Variable definieren, müssen Sie zuerst die Definition und dann den Namen eingeben.<br />
Wenn verschiedene Variablen vom gleichen Typ definiert werden sollen, benutzen Sie bitte ein Komma<br />
“,“, um verschiedene Variablennamen zu vergeben (siehe Beispiel). Die Variablendefinition für einen<br />
Typ muß in einer Zeile erfolgen. Um einen weiteren Typ zu definieren, benutzen Sie bitte eine weitere<br />
Zeile.<br />
Format: [Variablendefinition] [Name]{,[Name]}n<br />
* Bei dem PRINT-Befehl ist der verfügbare Wert für LONG Variablen wie folgt eingeschränkt:<br />
von –9999999 bis 9999999. Der dargestellte Wert ist eingeschränkt, aber der interne Wert wird<br />
innerhalb des oben dargestellten Bereiches berechnet und ist gültig.<br />
47
48<br />
2. Variablennamen<br />
Variablennamen unterliegen den folgenden Beschränkungen:<br />
• Als verwendbare Zeichen sind alle alphanumerischen Zeichen und Unterstriche ( _ ) außer dem<br />
Doppelpunkt (:) zugelassen.<br />
• Der Variablenname darf aus max. acht Zeichen bestehen.<br />
• Das erste Zeichen muß ein Buchstabe (außer P) sein.<br />
• Groß- und Kleinschreibung ist egal.<br />
• Reservierte Worte (z. B. Befehle, Anweisungen und Funktionen) dürfen nicht verwendet werden.<br />
Auch wenn Sie reservierte Worte durch Unterstriche oder Zahlen ergänzen oder verändern, werden<br />
sie trotzdem als reservierte Worte erkannt.<br />
3. Bei reellen Variablen wird der Wert durch Ziffern dargestellt.<br />
Zeichenketten-Variablen<br />
Zeichenketten-Variablen werden mit Hilfe der Anweisung STRING definiert.<br />
Funktion: STRING [Zeichenkettenname]{,[Zeichenkettenname]}n<br />
Zeichenkettennamen werden mit einem Dollarzeichen “$“ als letztem Buchstaben gekennzeichnet, um<br />
sie von numerischen Variablen unterscheiden zu können. Zeichenkettennamen unterliegen den<br />
folgenden Beschränkungen:<br />
• Als verwendbare Zeichen sind alle alphanumerischen Zeichen und Unterstriche ( _ ) außer dem<br />
Doppelpunkt (:) zugelassen.<br />
• Der Zeichenkettenname darf aus max. acht Zeichen (einschließlich des $-Zeichens) bestehen.<br />
• Das erste Zeichen muß ein Buchstabe (außer P) sein.<br />
• Groß- und Kleinschreibung ist egal.<br />
• Reservierte Worte (z. B. Befehle, Anweisungen und Funktionen) dürfen nicht verwendet werden.<br />
Auch wenn Sie reservierte Worte durch Unterstriche oder Zahlen ergänzen oder verändern, werden<br />
sie trotzdem als reservierte Worte erkannt.
Bereichsvariablen<br />
Eine Bereichsvariable ist eine Gruppe oder Tabelle, die sich auf einen Namen bezieht. Sowohl<br />
numerische wie auch Zeichenketten-Variablen können als Bereichsvariablen verwendet werden. Bei der<br />
Definition einer Bereichsvariablen geben Sie den Namen einschließlich der Größe in Klammern () ein.<br />
Die Größe kann in bis zu 3 Dimensionen definiert werden.<br />
Wenn verschiedene Variablen vom gleichen Typ definiert werden sollen, benutzen Sie bitte ein Komma<br />
“,“, um verschiedene Variablennamen zu vergeben.<br />
Format: [Variablendefinition] [Name](a,b,c)<br />
a,b,c: Bereichsgröße jeder Dimension<br />
Ganze Zahl von 0 bis 254<br />
a*b*c 32767<br />
<br />
INTEGER A(10) eindimensionaler Bereich<br />
BYTE B(8,5) zweidimensionaler Bereich<br />
LONG C(10,10,5) dreidimensionaler Bereich<br />
Eine Variablentabelle der Bereichsvariablen B(8,5) wird , wie unten dargestellt, erzeugt. Die Zahlen in<br />
Klammern () werden Subskriptionen genannt. Es ist wichtig, jede Subskription einzeln anzugeben,<br />
wenn einzelne individuelle Variablen benutzt werden.<br />
Auflisten der Variablennamen<br />
B(0,0) B(1,0) B(2,0) B(3,0) B(4,0) B(5,0) B(6,0) B(7,0) B(8,0)<br />
B(0,1) B(1,1) B(2,1) B(3,1) B(4,1) B(5,1) B(6,1) B(7,1) B(8,1)<br />
B(0,2) B(1,2) B(2,2) B(3,2) B(4,2) B(5,2) B(6,2) B(7,2) B(8,2)<br />
B(0,3) B(1,3) B(2,3) B(3,3) B(4,3) B(5,3) B(6,3) B(7,3) B(8,3)<br />
B(0,4) B(1,4) B(2,4) B(3,4) B(4,4) B(5,4) B(6,4) B(7,4) B(8,4)<br />
B(0,5) B(1,5) B(2,5) B(3,5) B(4,5) B(5,5) B(6,5) B(7,5) B(8,5)<br />
Wenn Sie neue Variablennamen definieren, müssen Sie unter Umständen vorher wissen, welche Namen<br />
bereits vergeben sind. Variablennamen und Typen werden aufgelistet (ausschließlich Backup-<br />
Variablennamen) durch Ausführen des Befehls VARIABLE.<br />
Format: VARIABLE {-A}<br />
Wird dem Befehl ein –A hinzugefügt, werden auch die Namen der Funktionen angezeigt.<br />
Diese Funktion zeigt nur die Variablennamen, die in der Symboltabelle gespeichert sind. Sie müssen<br />
daher Ihr Quellprogramm zuerst kompilieren.<br />
49
Backup-Variablen<br />
50<br />
Gewöhnlich wird, wenn das Programm kompiliert ist, eine Symboltabelle erzeugt. Wenn dann das<br />
Programm abläuft, werden die Werte der Variablen in dieser Tabelle gespeichert. Wird das Programm<br />
jedoch erneut kompiliert oder wird ein anderes Programm gestartet, werden diese Werte gelöscht. Auch<br />
wenn die Spannungszufuhr ausgeschaltet wird, gehen diese Werte verloren.<br />
Wenn Sie den Wert einer Variablen speichern wollen, müssen Sie die SYS-Anweisung benutzen, um die<br />
Variable als Backup-Variable einzutragen, bevor Sie verwendet wird. Als Backup-Variable wird sie<br />
nicht in der Symboltabelle gespeichert, sondern im Hauptspeicher des Backup-Variablen-Bereichs.<br />
Dieser Speicherbereich ist durch eine Batterie gesichert und wird nicht von Kompilier- oder<br />
Ausführvorgängen beeinflußt.<br />
Backup-Variablen sind hilfreich, wenn Sie z.B. eine Anwendung fortsetzen möchten, die Sie tags zuvor<br />
beendet haben oder Variablen in verschiedenen Programmen benutzen möchten.<br />
1. Anzahl spezifizierbarer Backup-Variablen<br />
Der Standardwert für die Anzahl spezifizierbarer Backup-Variablen ist 10. Benutzen Sie den<br />
Befehl LIBSIZE, um den Maximumwert auf bis zu 1.000 einzustellen. Bedenken Sie, daß ein<br />
großer Wert viel Platz im Objektbereich benötigt, dadurch den Platz zum Speichern des<br />
Programmes verkleinert und so eine Ausführung großer Programme nicht möglich ist.<br />
Es wird daher geraten, den Bereich der Backup-Variablen so klein wie möglich zu halten.<br />
Weitere Informationen entnehmen Sie bitte dem SPEL III Referenzhandbuch.<br />
2. Speicherprogramm für Backup-Variablen<br />
Die Symboltabelle, in der normale Variablen gespeichert werden, gehört zum Objektprogramm.<br />
Im Gegensatz dazu wird die Speichertabelle der Backup-Variablen vom eigentlichen Programm<br />
getrennt. Im Allgemeinen werden also die Speicherprogramme für Backup-Variablen separat<br />
von den anderen Programmen erzeugt.<br />
<br />
10 FUNCTION B_UP<br />
20 ‘SYS BYTE HELLO ;HELLO=0 ‘bereits gespeicherte Backup-Variable<br />
30 SYS INTEGER V(50)<br />
40 SYS STRING ERR_M$(10)<br />
50 FEND<br />
Wird versucht ein Variablenname zu speichern, der bereits existiert, wird ein Fehler (Zweifach-<br />
Definition einer Variablen) ausgegeben. Verwenden Sie einen Kommentarhinweis, wie in Zeile<br />
20, wenn die Variable bereits vorhanden ist.<br />
3. Speichern von Backup-Variablen<br />
Mit einem normalen Compiler wird die Registrierung der Variablen während des Kompilierens<br />
vollzogen. Im Gegensatz dazu muß beim Einsatz von SPEL III das Programm ausgeführt<br />
werden, damit die Variablen gespeichert werden können.<br />
Beim Einsatz von Variablen ist es wichtig, den Variablennamen und den Speicherplatz zu<br />
haben, um den Variablenwert zu speichern. Nach dem Kompilieren ist nur der Variablenname<br />
gespeichert, aber nicht der Speicher, in dem er sich befindet. Der Speicher wird erst gesichert,<br />
wenn das Programm abläuft. Wird nach dem Kompilieren versucht, eine Variable zu benutzen,<br />
tritt ein Fehler auf. Stellen Sie sicher, daß zuerst das Programm abläuft, bevor Variablen<br />
verwendet werden.<br />
<br />
10 FUNCTION V_EX<br />
20 SYS INTEGER A ;A=1<br />
30 SYS INTEGER B ;B=10 ‘speichert A und B als Backup-Variablen<br />
40 PRINT A,B<br />
50 FEND<br />
Kompilieren Sie das Programm, und führen Sie es aus.
4. Auflisten der Backup-Variablen<br />
Alle gespeicherten Backup-Variablen und Typen werden mit Hilfe des Befehls LIBRARY<br />
aufgelistet.<br />
Format: LIBRARY<br />
5. Löschen von Backup-Variablen<br />
Um alle gespeicherten Backup-Variablen zu löschen benutzen Sie den Befehl CLRLIB.<br />
Format: CLRLIB<br />
Es ist nicht möglich, nur einige der gespeicherten Variablen zu löschen. Wenn nur einige<br />
Variablen gelöscht werden sollen, löschen Sie bitte zuerst alle Variablen, und lassen Sie dann<br />
nur die, die Sie benötigen, neu registrieren.<br />
Hinweis zur Verwendung von Variablen<br />
1. Variablendefinition<br />
• Im Allgemeinen wird die Variablendefinition am Anfang des Programms vorgenommen.<br />
Wird eine Variable benutzt, bevor sie registriert ist, wird sie als reelle Variable (REAL)<br />
registriert und, wenn danach die Variablendefinition durchgeführt wird ein Fehler verursacht<br />
(Zweifach-Definition von Variablen).<br />
Es ist auch nicht möglich, eine Variable zu verwenden, bevor sie registriert ist. Auch wenn es<br />
eine reelle Variable ist, muß sie angemeldet sein.<br />
• Wenn Sie prüfen wollen, ob eine undefinierte Variable vorhanden ist, kompilieren Sie Ihr<br />
Programm mit dem Befehl COM–V. Ist eine undefinierte Variable vorhanden, erscheint der<br />
Fehler 2.<br />
• Die Anweisung zur Variablendefinition muß am Zeilenanfang stehen. Die<br />
Variablendefinition für einen Typ muß in einer Zeile erfolgen. Um einen weiteren Typ zu<br />
definieren, benutzen Sie bitte eine weitere Zeile.<br />
<br />
50 BYTE S_1,S_2 ;S_1=0 ;S_2=0 ;INTEGER E-1 ;E_1=1 ‘nicht erlaubt!<br />
50 BYTE S_1,S_2 ;S_1=0 ;S_2=0<br />
60 INTEGER E-1 ;E_1=1<br />
2. Fälle, in denen die Variablen vorher definiert sein müssen<br />
• Wenn eine Variable als Parameter für Positionsdaten benutzt wird.<br />
• Wenn eine Variable in einem Parallel-Prozeß benutzt wird.<br />
<br />
3. Fälle, in denen Variablen nicht verwendet werden können<br />
richtig!<br />
Definieren Sie die Variablen OFSET,<br />
HAND_DU vorher!<br />
• Für die Ortskoordinate von Positionsdaten.<br />
• Für Tasknummern und für die Nummer der RS-232C-Schnittstelle.<br />
<br />
P0=P1/LNO<br />
PRINT #RS,5<br />
HALT !TK<br />
RESET #RAIOC<br />
nicht erlaubt!<br />
4. Fälle, in denen eine Zeichenkettenbereichsvariable nicht verwendet werden kann<br />
• Für Dateinamen bei CURVE-, CVMOV-Befehlen.<br />
51
2.4 Operationen<br />
Mathematische Operationen<br />
52<br />
Die Mathematik wird für Operationen von numerischen Werten benutzt. Die mathematischen<br />
Operatoren sind wie nachfolgend aufgeführt:<br />
Operator Operation Ausdruck Mathematisches Zeichen<br />
+ Addition A+B +<br />
- Subtraktion A-B -<br />
* Multiplikation A*B x<br />
/ Division A/B ÷<br />
MOD Module Mathematik A MOD B<br />
(MOD kann nur für ganze Zahlen benutzt werden.)<br />
Logische Operatoren<br />
Die logischen Operatoren können für ganze Zahlen benutzt werden. Das Ergebnis ist auch eine ganze<br />
Zahl. Der numerische Wert wird innerhalb der Steuerung durch eine binäre Ziffer ausgedrückt. Die<br />
Operation wird in dieser Reihenfolge ausgeführt. Das heißt, daß jedes Bit des Ergebnisses von den<br />
entsprechenden Bits in den zwei Operanden bestimmt wird. Jede Operation ist unten aufgeführt, es<br />
werden die numerischen Werte A und B benutzt.<br />
1. AND (Konjunktion) BIT von A BIT von B Ergebnis<br />
Format: A AND B 0 0 0<br />
0 1 0<br />
1 0 0<br />
1 1 1<br />
2. OR (Disjunktion) BIT von A BIT von B Ergebnis<br />
Format: A OR B 0 0 0<br />
0 1 1<br />
1 0 1<br />
1 1 1<br />
3. XOR (ausschließliches OR) BIT von A BIT von B Ergebnis<br />
Format: A XOR B 0 0 0<br />
0 1 1<br />
1 0 1<br />
1 1 0<br />
4. NOT (logische Ergänzung) BIT von A Ergebnis<br />
Format: NOT A 0 1<br />
1 0<br />
5. Beispiel: Im Falle von A=1, B=0, C=1<br />
A AND B OR C = 1<br />
A AND B XOR C = 1<br />
NOT A) AND C = 0
Relationale Operatoren<br />
Operator Ausdruck Beschreibung<br />
= A=B A und B sind gleich.<br />
oder >< AB A und B sind nicht gleich.<br />
> A>B A ist größer als B.<br />
< A= oder => A>=B A ist größer oder gleich B.<br />
, =, <br />
Die Operationen werden nach dieser Rangfolge ausgeführt, das Benutzen von Klammern erleichtert das<br />
Lesen des Programms.<br />
Operationen mit ganzen und reellen Zahlen<br />
SPEL III unterscheidet Operationen mit ganzen Zahlen von denen mit reellen Zahlen, dadurch wird die<br />
Operation schneller. In Übereinstimmung mit dem Operandentyp unterscheiden sich die<br />
Operationsmethode und das Resultat wie folgt:<br />
Operandentyp Ergebnis<br />
Alles ganze Zahlen ganze Zahl<br />
Alles reelle Zahlen<br />
Ganze und reelle Zahlen<br />
Reelle Zahl<br />
Für die oben genannten Operationen beachten Sie folgende Punkte.<br />
(1) Bei der Division von ganzen Zahlen wird das Ergebnis auf eine ganze Zahl gerundet.<br />
(2) Wenn das Ergebnis einer ganzzahligen Operation außerhalb des Bereichs der ganzen Zahlen (-<br />
32768 bis 32767) liegt, wird ein Fehler angezeigt.<br />
53
54<br />
(3) Wenn eine reelle Zahl einer Ganzzahlvariablen zugewiesen wird, wird die zehnte Stelle gerundet.<br />
1<br />
2<br />
3<br />
Rückgabewerte<br />
Operation mit ganzen Zahlen Operation mit reellen Zahlen<br />
>PRINT 3/2<br />
1<br />
>PRINT TAN(1/2)<br />
0<br />
PRINT A<br />
1<br />
>PRINT 3,0/2<br />
1.5<br />
>PRINT TAN(1,0/2)<br />
.5463025<br />
>PRINT 1000,0*1000<br />
1000000<br />
Die Typen der Werte werden von der Funktion wie folgt zurückgegeben:<br />
Typ Funktionsname<br />
Reelle Zahl SIN( )<br />
COS( )<br />
TAN( )<br />
ganze Zahl (2 Byte) SW( )<br />
IN( )<br />
INBCD( )<br />
SW($ )<br />
IN($ )<br />
ganze Zahl (4 Byte) PLS( )<br />
ATAN( )<br />
ATAN2( )<br />
OPORT( )<br />
ZEROFLG(0)<br />
NOT( )<br />
LSHIFT( )<br />
RSHIFT( )<br />
CX( )<br />
CY( )<br />
CZ( )<br />
CU( )<br />
MYTASK<br />
(0)<br />
LOF( )<br />
DSW( )<br />
STAT( )<br />
Argument SGN( ) INT( ) ABS( )<br />
Fälle, in denen Operationen und Funktionen benutzt werden können<br />
AGL( )<br />
SQA( )<br />
TMR( )<br />
VAL( )<br />
CTR( )<br />
TIME( )<br />
JS(0)<br />
LEN( )<br />
ASC( )<br />
Grundsätzlich ist es unmöglich, Operationen und Funktionen im Parameterteil jedes Befehls zu<br />
benutzen. In so einem Fall weisen Sie das Ergebnis der Operation oder der Funktion einer Variablen zu,<br />
und benutzen Sie den Variablennamen für den Parameter.<br />
Der folgende Zustandsbefehl kann die logische Operation durchführen.<br />
IF...THEN...ELSE, SELECT...SEND, WHILE...WEND, SENSE, TILL, WAIT, PRINT<br />
<br />
P0=P1:ZCZ(P0) → A=CZ(P0);P0=P1:ZA
2.5 Steueranweisungen des Programms<br />
FOR...NEXT<br />
GOTO<br />
SPEL III verfügt über folgende Steueranweisungen. Für Details sehen Sie bitte im Handbuch nach.<br />
FOR...NEXT (Führt eine Reihe von Anweisungen in einer bestimmten Zeit aus.)<br />
GOTO (Geht zur gewünschten Anweisung über)<br />
IF...THEN...ELSE (Führt Anweisungen auf der Grundlage von spezifizierten Konditionen<br />
aus)<br />
GOSUB...RETURN (Verzweigt zum Unterprogramm, führt es aus und verläßt es wieder)<br />
CALL (Ruft ein Unterprogramm auf)<br />
SELECT...CASE...SEND (Spezifiziert die Verzweigungsvorschrift und die entsprechende<br />
Verzweigungsanweisungssequenz)<br />
WHILE...WEND (Führt eine Reihe von Anweisungen aus, während der festgelegte Zustand<br />
erhalten bleibt)<br />
TRAP (Definiert einen Unterbrechungsprozeß)<br />
Führt eine Reihe von Anweisungen von FOR bis NEXT in einer bestimmten Zeit aus.<br />
GOTO geht zur spezifizierten Zeile oder zur Sprungmarke.<br />
<br />
10 FUNCTION MAIN<br />
20 LOOP: ‘Markiert Zeile 20 als “LOOP“<br />
30 FOR I=1 TO 4<br />
40 JUMP PI<br />
50 NEXT I<br />
60 GOTO LOOP ‘Geht zu Zeile 20, die als LOOP markiert ist<br />
70 FEND<br />
IF THEN ELSE<br />
IF (Bedingung) THEN (Anweisung 1) ELSE (Anweisung 2)<br />
Wenn die (Bedingung) wahr ist, wird die (Anweisung 1) ausgeführt, und wenn sie nicht wahr ist, wird<br />
die (Anweisung 2) ausgeführt.<br />
<br />
10 FUNCTION MAIN<br />
20 I=1<br />
30 IF I=1 THEN JUMP P2 ELSE JUMP P3<br />
40 JUMP PI<br />
50 I=0-I<br />
60 GOTO 30<br />
70 FEND<br />
Wiederholt die Sprungbewegung zwischen P1 und P2, und<br />
zwischen P1 und P3 abwechselnd.<br />
55
GOSUB...RETURN<br />
56<br />
Wenn ein GOSUB-Befehl gefunden wird, verzweigt er zur definierten Zeilennummer oder zur<br />
Sprungmarke. Wenn ein RETURN-Befehl ausgeführt wird, lenkt er die Programmausführung zu der<br />
Zeile um, die dem GOSUB-Befehl folgt.<br />
<br />
Wiederholt die Bewegung 3-mal<br />
zwischen P1 und P2, P2 und P3, P3<br />
und P4 und P4 und P1. Die<br />
Wiederholbewegung wird als<br />
Unterprogramm programmiert.<br />
10 FUNCTION MAIN<br />
20 I=1;J=2<br />
30 GOSUB I_J<br />
40 I=2;J=3<br />
50 GOSUB I_J<br />
60 I=3;J=4<br />
70 GOSUB I_J<br />
80 I=4;J=1<br />
90 GOSUB I_J<br />
100 END<br />
1000 I_J: ‘Sprungmarke des Unterverzeichnisses<br />
1010 FOR LOOP=1 TO 3<br />
1020 JUMP PI;JUMP PJ<br />
1030 NEXT<br />
1040 RETURN<br />
1050 FEND<br />
GOTO, FOR...NEXT, GOSUB...RETURN, IF...THEN...ELSE<br />
<br />
Die Bewegungsgeschwindigkeit wird jedesmal erhöht, wenn zur<br />
nächsten Position übergegangen wird. Wenn die Geschwindigkeit<br />
„100“ erreicht, wird sie auf „10“ verringert. Die 3. Achse bewegt<br />
sich an jeder Position 3-mal auf und ab.<br />
10 FUNCTION MAIN<br />
20 SPEED 10;A=10<br />
30 FOR I=1 TO 4<br />
40 JUMP PI<br />
50 GOSUB H_L<br />
60 A=A+10<br />
70 IF A>100 THEN A=10<br />
80 SPEED A<br />
90 NEXT I<br />
100 GOTO 30<br />
200 ‘<br />
210 H_L:<br />
220 FOR J=1 TO 3<br />
230 JUMP PI<br />
240 NEXT J<br />
250 RETURN<br />
<strong>300</strong> ‘<br />
310 FEND
CALL<br />
CALL ruft eine Funktion, die durch FUNCTION..FEND definiert wird, als Unterprogramm auf.<br />
<br />
100 FUNCTION MAIN<br />
110 OFF $0 ‘E/A-Speicher für ausschließliche<br />
Steuerung<br />
120 XQT !2 SUB<br />
M<br />
200 CALL ERROR<br />
M<br />
<strong>300</strong> FEND<br />
305 ‘<br />
310 FUNCTION SUB<br />
M<br />
350 CALL ERROR<br />
M<br />
400 FEND<br />
405 ‘<br />
410 FUNCTION ERROR<br />
420 ON $0; IF ZEROFLG(0)=1 THEN WAIT<br />
SW($0)=0; GOTO 420<br />
M<br />
490 OFF $0<br />
500 FEND<br />
* ZEROFLG(0)<br />
Gibt Werte aus dem E/A-Speicher zurück, die vor dem letzten Ein- oder Ausschalten dort vorhanden<br />
waren.<br />
SELECT...CASE...SEND<br />
SELECT[Formel]<br />
CASE [Punkt1];[Anweisung1]<br />
CASE [Punkt2];[Anweisung2]<br />
SEND<br />
Entspricht einer der CASE-Punkte dem Ergebnis der SELECT-Formel, wird die CASE-Anweisung<br />
ausgeführt.<br />
<br />
110 FUNCTION MAIN<br />
120 INTEGER I<br />
130 FOR I=0 TO 10<br />
140 SELECT I<br />
150 CASE 0; OFF1; ON2; JUMP P1<br />
160 CASE 3; ON1; OFF2<br />
170 JUMP P2; MOVE P3; ON3<br />
180 CASE 7; ON4<br />
190 DEFAULT; ON7<br />
200 SEND<br />
210 NEXT<br />
220 FEND<br />
57
WHILE[Bedingung]...WEND<br />
TRAP<br />
58<br />
Ist die WHILE-Bedingung wahr, wird die Anweisung zwischen WHILE und WEND ausgeführt. Danach<br />
wird die WHILE-Bedingung nochmals überprüft.<br />
<br />
100 FUNCTION MAIN<br />
120 WHILE I
NESTING<br />
Die NESTING-Funktion kann für einige Anweisungen benutzt werden. Es wird in diesem Punkt anhand<br />
GOSUB als Beispiel erklärt.<br />
GOSUB verzweigt das Programm zu der definierten Zeilennummer (oder der Sprungmarke), führt das<br />
Unterprogramm aus und lenkt danach die Programmausführung zu der Zeile um, die dem GOSUB-<br />
Befehl folgt. Verwendet man eine weitere GOSUB...RETURN-Anweisung innerhalb des<br />
Unterprogramms, können Sie ein weiteres Unterprogramm ausführen. Dies wird NESTING<br />
(Verschachteln) genannt.<br />
• Verschachtelung:<br />
Die Verschachtelungen beim NESTING werden als „Schritte“ beschrieben. Das obere Beispiel hat<br />
„2 Schritte“. Es gibt Einschränkungen bei der Anzahl der Verschachtelungen, die jedoch abhängig<br />
von der verwendeten Anweisung variieren. In diesem Handbuch wird die Anzahl der<br />
Verschachtelungen auf 10 beschränkt.<br />
• Die folgenden Befehle erlauben Verschachtelungen<br />
#include<br />
CALL<br />
FOR...NEXT<br />
GOSUB...RETURN<br />
SELECT...SEND<br />
WHILE...WEND.<br />
59
2.6 Pseudobefehl<br />
60<br />
Der Pseudobefehl wird verwendet, um das Editieren und Kompilieren im ersten Schritt des<br />
Kompilierens einfacher zu gestalten. Das Benutzen des Pseudobefehls ermöglicht das Ersetzen von<br />
Bezeichnern im Programm, die Installation anderer Dateien oder das Kompilieren von Programmteilen.<br />
Als erster Buchstabe des Pseudobefehls muß das #-Zeichen stehen, und die weiteren Buchstaben des<br />
Befehls müssen in Kleinschreibung folgen. Folgende Pseudobefehle werden von SPEL III zur Verfügung<br />
gestellt.<br />
#define<br />
#include<br />
#ifdef<br />
#ifndef<br />
#endif<br />
Der Pseudobefehl muß sofort nach der Zeilennummer beschrieben werden. Nach dem Pseudobefehl muß<br />
mindestens ein Leerzeichen stehen, bevor andere Buchstaben folgen.<br />
Die Position des Pseudobefehls kann irgendwo im Programm sein. Auch wenn der Pseudobefehl in der<br />
Mitte des Programms steht, gilt er für das ganze Programm.<br />
<br />
1000 FUNCTION MAIN<br />
1010 #define LED1 8<br />
1020 #define LED2 9<br />
1030 #define LED3 10<br />
M<br />
2000 ON LED1; WAIT 1;<br />
OFF LED1<br />
2010 ON LED2; ON LED3<br />
M<br />
<strong>300</strong>0 FEND<br />
Die Beschreibungen und Beispiele für die einzelnen Pseudobefehle erhalten Sie im SPEL III<br />
Referenzhandbuch.
3. Dateien<br />
Dateien sind Ansammlungen von Daten. Erzeugte Programme oder für die Einrichtung relevante<br />
Positionsdaten werden als Dateien behandelt.<br />
Die Steuerung beinhaltet einen Hauptspeicher als Arbeitsbereich zum Erzeugen und Ausführen von<br />
Programmen sowie einen Dateispeicher zum Speichern der Dateien.<br />
Dieses Kapitel beschreibt, wie die Dateien in diesen beiden Speichern behandelt werden.<br />
3.1 Haupt- und Dateispeicher<br />
Die Größe des Hauptspeichers für die Bereiche des Quellprogramms, der Positionsdaten und der<br />
Backup-Variablen läßt sich mit Befehlen zum Ändern der Größe verändern.<br />
Hauptspeicher Nr. 1 Nr. 2 Nr. 3 Befehl zur Größenänderung<br />
Quellprogramm 64 KB 64 KB 128 KB PRGSIZE<br />
Positionsdaten 200 Punkte, 5,5 KB PNTSIZE<br />
Backup-Variablen 10 Variablen, 0,5 KB LIBSIZE<br />
Objektbereich 97 KB 97 KB 233 KB kann mit den oberen<br />
Befehlen geändert werden.<br />
Dateispeicher 100 KB 1100 KB 900 KB<br />
Nr. 1: Standardeinstellung<br />
Nr. 2: mit zusätzlichem RAM und DIP-Schalter SD2-1 auf ON (auf der MPU-Platine der Steuerung)<br />
Nr. 3: mit zusätzlichem RAM und DIP-Schaltern SD2-1 und SD2-2 auf ON (auf der MPU-Platine<br />
der Steuerung)<br />
Speicherbereich im Hauptspeicher<br />
Der Hauptspeicher ist ein Bereich, der die Bewegung des Roboters bewirkt und ist in die folgenden fünf<br />
Bereiche unterteilt:<br />
(1) Quellprogrammbereich<br />
Das Quellprogramm wird hier gespeichert. Um es ausführen zu können, muß es in ein<br />
Objektprogramm kompiliert werden.<br />
(2) Positionsdatenbereich<br />
Die Positionsdaten, die durch das Einrichten erzeugt werden, werden hier gespeichert. Die<br />
bestehenden Positionsdaten werden als die notwendigen Positionsdaten für die<br />
Programmausführung benötigt.<br />
(3) Bereich der Backup-Variablen<br />
Das ist der Bereich zum Speichern der Backup-Variablen-Speichertabelle.<br />
(4) Symbolbereich<br />
Das ist der Bereich zum Speichern der Speichertabelle der Funktions- und Variablennamen. Wenn<br />
das Quellprogramm kompiliert wird, werden die Funktions- und Variablennamen automatisch hier<br />
gespeichert.<br />
(5) Objektbereich<br />
Das ist der Bereich, in dem das aktuelle ausführbare Programm gespeichert wird.<br />
61
Bereich zur Programmausführung<br />
62<br />
Wenn ein Programm abläuft, werden Daten aus jedem Hauptspeicherbereich, mit Ausnahme des<br />
Quellprogrammbereichs benutzt. Diese Daten müssen verbunden werden, damit sie zu der<br />
Roboteroperation passen. Stellen Sie sicher, daß sich die Daten aufeinander beziehen, bevor Sie ein<br />
Programm ausführen.<br />
Dateispeicher<br />
Hauptspeicher<br />
Quellprogrammbereich<br />
Positionsdatenbereich<br />
Bereich der Backup-Variablen<br />
Symbolbereich<br />
Objektbereich<br />
64748<br />
Ausführbare Daten<br />
Der Dateispeicher ist der Speicher, in dem alle Arten von Dateien gespeichert werden können. Die<br />
Anzahl der speicherbaren Dateien ist nachfolgend aufgeführt:<br />
Dateispeicher Größe Anzahl Dateien<br />
Nr. 1 100 KB 64<br />
Nr. 2 1,1 MB 192<br />
Nr. 3 900 KB 192<br />
Nr. 1: Standardeinstellung<br />
Nr. 2: mit zusätzlichem RAM und DIP-Schalter SD2-1 auf ON (auf der MPU-Platine der Steuerung)<br />
Nr. 3: mit zusätzlichem RAM und DIP-Schaltern SD2-1 und SD2-2 auf ON (auf der MPU-Platine<br />
der Steuerung)
3.2 Dateinamen<br />
Für jede Datei muß ein Dateiname vergeben werden. Um mit der Datei arbeiten zu können, muß ein<br />
Dateiname festgelegt werden.<br />
Die Bestandteile eines Dateinamens<br />
Der Dateiname setzt sich zusammen aus dem Dateinamen, der Erweiterung und dem Punkt “.“.<br />
Der Dateiname und die Erweiterung werden durch den Punkt getrennt. Es handelt sich um verschiedene<br />
Dateien, wenn zwar die Dateinamen identisch sind, sich aber die Erweiterungen unterscheiden.<br />
Erzeugen eines Dateinamens<br />
Wenn ein Quellprogramm und Positionsdaten gespeichert werden sollen, die sich im Hauptspeicher<br />
befinden, muß ein Name vergeben werden.<br />
Erweiterung<br />
Dateinamen unterliegen den folgenden Beschränkungen:<br />
• Der Name darf aus max. acht Zeichen bestehen.<br />
• Verwendbare Zeichen:<br />
- Alphabet (A bis Z, a bis z)<br />
- Zahlen (0 bis 9)<br />
- Symbole (! # $ % & ( ) - ^ @ ~ { } _)<br />
Die Erweiterung zeigt den Dateityp auf. Im Allgemeinen muß der Anwender die Erweiterung nicht<br />
selbst vergeben, da die Steuerung die Erweiterung automatisch vergibt. Es handelt sich um verschiedene<br />
Dateien, wenn zwar die Dateinamen identisch sind, sich aber die Erweiterungen unterscheiden.<br />
Die Dateitypen sind wie folgt festgelegt:<br />
Erweiterung Datei Dateityp<br />
PRG Quellprogrammdatei Erzeugtes Programm<br />
OBJ Objektdatei Ausführbares Zwischencodeprogramm<br />
SYM Symboldatei Variablen- und Funktionnamenspeichertyp<br />
PNT Positionsdatendatei Positionsdatendatei<br />
CRV Frei Kurven-Datei Freie Kurvendaten, die der CURVE-Befehl verwendet.<br />
BAT Stapeldatei Datei, die Befehle beinhaltet, die automatisch ausgeführt<br />
werden sollen.<br />
SYS Systemumgebungsdatei Datei, die alle Daten der Systemumgebung speichert.<br />
63
64<br />
Wenn Sie eine Textdatei mit einem PC oder mit Hilfe der Befehle WOPEN und VSAVE editieren<br />
wollen, legen Sie selbst die Erweiterung fest. In diesen Fällen dürfen Sie nicht die oben erwähnten<br />
Erweiterungen benutzen.<br />
Erweiterungen unterliegen den folgenden Beschränkungen:<br />
• Die Erweiterung muß aus drei Zeichen bestehen.<br />
• Verwendbare Zeichen:<br />
- Alphabet (A bis Z, a bis z)<br />
- Zahlen (0 bis 9)<br />
- Symbole (! # $ % & ( ) - ^ @ ~ { } _)<br />
• Dateinamen müssen immer angegeben werden. Im Gegensatz dazu können Erweiterungen<br />
weggelassen werden. Wenn Sie die Erweiterung weglassen, müssen Sie auch den Punkt weglassen.<br />
Spezielle Dateinamen<br />
Die Dateien mit den folgend aufgeführten Dateinamen werden bei Einschalten der Spannungszufuhr<br />
automatisch ausgeführt. Diese Dateien bzw. Dateinamen dürfen zu keinem anderen Zweck verwendet<br />
werden.<br />
AUTO.BAT, IPL.OBJ und CNFG.SYS<br />
3.3 Dateien, die während der Ausführung geladen werden<br />
Wenn Sie ein Programm ausführen, werden die folgenden drei Dateien vom Haupt- in den Dateispeicher<br />
geladen. Wenn jedoch nur eine von den drei Dateien fehlen sollte, tritt ein Fehler auf.<br />
Bitte beachten Sie, daß das Quellprogramm nicht geladen wird.<br />
Hauptspeicher Dateispeicher<br />
Quellprogramm TEST.PRG<br />
(TEST.PNT) TEST.PNT<br />
(TEST.SYM) ←⎯<br />
TEST.SYM<br />
(TEST.OBJ)<br />
678<br />
678<br />
TEST.OBJ<br />
Wenn erst einmal die für die Ausführung notwendigen Dateien in den Hauptspeicher geladen sind, kann<br />
das Programm durch Eingeben des Befehls XQT (ohne Eingeben des Dateinamens) oder durch Drücken<br />
des Starttasters auf der Bedieneinheit (ohne Auswahl der Datei) gestartet werden.
4. Verzeichnis<br />
4.1 Verzeichnis<br />
Wird eine Datei im Dateispeicher abgelegt, wird zusätzlich zu dem Dateinamen und der Erweiterung die<br />
Dateigröße und das Datum, an dem die Datei erzeugt wurde, im Verzeichnis abgespeichert.<br />
Um die Dateien zu verwalten, sortiert und registriert das Verzeichnis die Dateien in verschiedene<br />
Gruppen. Beachten Sie, daß das Verzeichnis ein Ort ist, wo die Dateien gespeichert werden und, daß<br />
sich Verzeichnis und Datei unterscheiden.<br />
Es gibt zwei verschiedene Arten von Verzeichnissen: das „Haupt- oder Wurzelverzeichnis“ und<br />
„Unterverzeichnisse“.<br />
Hauptverzeichnis<br />
Das Grundverzeichnis, das automatisch erstellt wird, wenn der Dateispeicher formatiert wird, heißt<br />
Hauptverzeichnis. Es wird durch einen umgekehrten Schrägstrich “\“ ausgedrückt. Dieses Symbol kann<br />
nicht verändert werden. Es ist auch nicht möglich, das Hauptverzeichnis zu löschen.<br />
Unterverzeichnis<br />
Wenn viele verschiedene Dateien und/oder Dateitypen im Hauptverzeichnis stehen, wird die<br />
Dateiverwaltung umständlich, und ein falscher Gebrauch von Dateien wird möglich. Die Größe des<br />
Hauptverzeichnisses ist vorher festgelegt. Die Anzahl von Dateien ist daher limitiert. Um eine Gruppe<br />
von Dateien leichter handhaben zu können, können Verzeichnisse angelegt und gelöscht werden. Diese<br />
Verzeichnisse nennt man Unterverzeichnisse. Die Anzahl von Dateien, die in ein Unterverzeichnis<br />
geschrieben werden können, ist abhängig von der Größe des Dateispeichers.<br />
Erzeugen eines Unterverzeichnisses<br />
Das Unterverzeichnis wird, genau wie eine Datei, mit einem Namen versehen. Ein Unterverzeichnis<br />
wird mit Hilfe der Befehle MKDIR oder MD (Make Directory) erzeugt.<br />
Namen der Unterverzeichnisse unterliegen den folgenden Beschränkungen:<br />
• Der Verzeichnisname darf aus max. acht Zeichen bestehen.<br />
• Verwendbare Zeichen:<br />
- Alphabet (A bis Z, a bis z)<br />
- Zahlen (0 bis 9)<br />
- Symbole (! # $ % & ( ) - ^ @ ~ { } _)<br />
<br />
>MKDIR DATA Erzeugen eines Unterverzeichnisses DATA im Hauptverzeichnis<br />
>MKDIR \DATA\TEXT Erzeugen eines Unterverzeichnisses TEXT im Unterverzeichnis DATA im<br />
Hauptverzeichnis, wobei das Verzeichnis DATA bereits besteht.<br />
Sie erreichen das gleiche durch Wechseln vom Haupt- in das Unterverzeichnis DATA:<br />
>CHDIR DATA Wechseln des Verzeichnisses<br />
>MD TEXT Erzeugen eines Unterverzeichnisses TEXT<br />
Es ist nicht möglich, mehr als zwei Verzeichnisse gleichzeitig zu erzeugen. Erzeugen Sie Verzeichnisse<br />
immer nacheinander.<br />
65
Löschen eines Unterverzeichnisses<br />
66<br />
Ein Unterverzeichnis wird mit Hilfe der Befehle RMDIR oder RD (Remove Directory) gelöscht. Es ist<br />
nicht möglich, ein Unterverzeichnis zu löschen, in dem sich Dateien oder andere Unterverzeichnisse<br />
befinden.<br />
<br />
>RD DATA Löschen des Unterverzeichnisses DATA. Überzeugen Sie sich vorher, daß<br />
das Verzeichnis keine weiteren Daten mehr enthält.<br />
<br />
>RD \DATA\TEXT Löschen des Unterverzeichnisses TEXT im Unterverzeichnis DATA.<br />
Überzeugen Sie sich vorher, daß das Verzeichnis TEXT keine weiteren<br />
Daten mehr enthält.<br />
Sie erreichen das gleiche durch Wechseln vom Haupt- in das Unterverzeichnis DATA:<br />
>CD DATA Wechseln des Verzeichnisses<br />
>RD TEXT Löschen des Unterverzeichnisses TEXT<br />
Baumstrukturierte Verzeichnisse<br />
Wenn Sie verschiedene Unterverzeichnisse erzeugen, wird eine Hierarchie angelegt. Sie wird<br />
Verzeichnishierarchie genannt. Wenn das Verzeichnis ausgelesen wird, sieht es aus wie die<br />
Verzweigungen eines Baumes und wird daher auch baumstrukturiertes Verzeichnis genannt.<br />
[]: stellt die Verzeichnisnamen in obiger Abbildung dar.<br />
Stammverzeichnis (Mutterverzeichnis), Unterverzeichnis (Kinderverzeichnis)<br />
In der Verzeichnishierarchie wird das Verzeichnis, das auf der höchsten Ebene ist, Stammverzeichnis,<br />
und die, die unterhalb dieser Ebene sind, Unterverzeichnisse genannt.<br />
In der oben gezeigten Verzeichnishierarchie ist das Hauptverzeichnis das Stammverzeichnis des<br />
Verzeichnisses TEXT und das Verzeichnis DATA ist das Unterverzeichnis. Das Verhältnis ist relativ.<br />
Das Verzeichnis TEXT ist das Stammverzeichnis des Verzeichnisses DATA, aber auch das<br />
Unterverzeichnis vom Hauptverzeichnis.<br />
Ein Punkt [.] weist auf ein aktuell bestehendes Verzeichnis hin. Zwei Punkte [..] weisen auf sein<br />
Stammverzeichnis. Diese Punkte werden gewöhnlich verwendet, wenn Pfad- oder Dateinamen mit Hilfe<br />
des Befehls DIR angezeigt werden sollen.<br />
Aktuelles Verzeichnis<br />
Das aktuelle Verzeichnis ist immer das gegenwärtig ausgewählte Verzeichnis. Ist ein Verzeichnis nicht<br />
spezifiziert, startet SPEL II den Suchvorgang vom aktuellen Verzeichnis aus. Wenn Sie SPEL III<br />
starten, ist immer das Hauptverzeichnis des Dateispeichers das aktuelle Verzeichnis.<br />
Zum Verzeichniswechsel benutzen Sie die Befehle CHDIR oder CD (Change Directory).<br />
Beim Einschalten der Spannungszufuhr ist immer das Hauptverzeichnis das aktuelle Verzeichnis.
Festlegen eines Pfades<br />
Wenn Sie mit Hilfe eines Befehlsparameters zu einem anderen Verzeichnis wechseln oder ein<br />
Verzeichnis festlegen wollen, kann dies nicht sauber ausgeführt werden, wenn Sie nur das Verzeichnis<br />
festlegen. Das Verzeichnis muß basierend auf dem Haupt- und dem aktuellen Verzeichnis festgelegt<br />
werden. Die Anweisung zum Ordnen und Trennen der Verzeichnisse durch den umgekehrten<br />
Schrägstrich “\“ wird Pfadname genannt.<br />
Es gibt zwei verschiedene Arten von Pfadnamen: absolute und relative. Der absolute Pfadname<br />
spezifiziert das Verzeichnis vom Hauptverzeichnis aus, und der relative Pfadname spezifiziert das<br />
Verzeichnis vom aktuellen Verzeichnis aus.<br />
• Absoluter Pfadname<br />
Ein absoluter Pfadname zeigt, wie man vom Hauptverzeichnis den Weg in das gewünschte Verzeichnis<br />
findet. Dabei muß am Anfang des Pfadnamens der umgekehrte Schrägstrich “\“ stehen. Der Startpunkt<br />
für den absoluten Pfadnamen ist immer das Hauptverzeichnis.<br />
<br />
Wenn das aktuelle Verzeichnis DATA1 ist, spezifizieren Sie das Verzeichnis DATA2.<br />
Der umgekehrte Schrägstrich “\“ wird sowohl zum Trennen von Verzeichnissen als auch für das<br />
Hauptverzeichnis genutzt. Im Falle eines absoluten Pfadnamens steht der umgekehrte Schrägstrich “\“<br />
am Anfang immer für das Hauptverzeichnis.<br />
Der Pfad zum Auffinden von Verzeichnissen bei absoluten Pfadnamen ist immer der folgende:<br />
Hauptverzeichnis (Startpunkt) → Unterverzeichnis (TEST) → Unterverzeichnis (DATA2)<br />
• Relativer Pfadname<br />
Ein relativer Pfadname zeigt, wie man vom aktuellen Verzeichnis den Weg in das gewünschte<br />
Verzeichnis findet. Der Startpunkt für den relativen Pfadnamen ist immer das aktuelle Verzeichnis.<br />
D.h., der Pfadname variiert abhängig vom Namen des aktuellen Verzeichnisses. Wenn Sie zwei Punkte<br />
(..) in einem Pfadnamen verwenden, heißt das, daß man sich eine Ebene in der Baumstruktur nach oben<br />
bewegt.<br />
<br />
Der Beispielausdruck des absoluten Pfadnamens entspricht dem folgenden relativen Pfandnamen:<br />
Bei relativen Pfadnamen stellen die umgekehrten<br />
Schrägstriche “\“ die Unterscheidungen zwischen<br />
verschiedenen Verzeichnissen dar.<br />
Die ersten beiden Punkte verweisen auf das Stammverzeichnis. Also ist das Verzeichnis TEST das<br />
Stammverzeichnis von DATA2. Die folgenden beiden Punkte verweisen auf das Stamm- oder das<br />
Hauptverzeichnis.<br />
Der Pfad zum Auffinden von Verzeichnissen bei relativen Pfadnamen ist der folgende:<br />
aktuelles Verzeichnis 1 (DATA 1 als Startpunkt) → Stammverzeichnis (TEXT) → Stammverzeichnis<br />
(Hauptverzeichnis) → Unterverzeichnis (TEST) → Unterverzeichnis (DATA2)<br />
67
Umgebungsvariablen<br />
68<br />
Es ist möglich, für die Befehle COM und PLI optionale Parameter einzustellen.<br />
Wenn Sie viele Unterverzeichnisse eingerichtet haben, müssen Sie den Pfadnamen zu der Datei, die Sie<br />
aufrufen wollen, eingeben. Es sei denn, die Datei befindet sich im aktuellen Verzeichnis. Sie können<br />
vorher die Verzeichnisumgebung einer Datei festlegen, wenn Sie diese häufig ausführen . Um solch eine<br />
Ausführungsumgebung festzulegen, benutzen Sie den Befehl SETENV zum Festlegen einer<br />
Umgebungsvariablen.<br />
Folgende Umgebungsvariablen sind möglich:<br />
COM Setzt den optionalen Parameter (-V, -L) des COM-Befehls<br />
PLI Setzt den optionalen Parameter (/W) des PLI-Befehls<br />
XQT Legen Sie den Pfadnamen für die Datei fest, die durch den Befehl XQT “Dateiname“<br />
ausgeführt werden soll. Wird der Pfadname nicht festgelegt, wird die Datei, ausgehend vom<br />
aktuellen Verzeichnis, gesucht.<br />
PATH Legen Sie den Pfadnamen (Verzeichnis), der zum Ausführen der Stapeldatei benötigt wird,<br />
fest. Wird der Pfadname nicht festgelegt, kann die Datei nicht ausgeführt werden.<br />
Der [Pfadname] auf der rechten Seite von XQT und PATH kann wiederholt in derselben Zeile<br />
auftauchen. Trennen Sie sie mit Hilfe des Semikolons “;“. Die max. Anzahl der Zeichen pro Zeile ist 79.<br />
Sie können PATH auch ohne den Befehl SETENV spezifizieren.<br />
Weitere Informationen erhalten Sie im SPEL III Referenzhandbuch.<br />
<br />
>SETENV COM=-V Spezifiziert die Kompilierbedingungen<br />
>SETENV PLI=/W Spezifiziert das Anzeigeformat für PLIST<br />
>SETENV PATH=\;\BIN Legt den Pfad zum Ausführen von Stapeldateien fest<br />
>SETENV XQT=\ Legt den Pfad zum Ausführen von Dateien fest<br />
>SETENV Zeigt die aktuellen Einstellungen an<br />
COM=-V<br />
PLI=/W<br />
PATH=\;\BIN<br />
XQT=\<br />
>PATH Zeigt den aktuellen Pfad zum Ausführen von Stapeldateien<br />
>PATH=\;\BIN<br />
>PATH=\ Legt den Pfad zum Ausführen von Stapeldateien fest<br />
>PATH Zeigt den aktuellen Pfad<br />
>PATH=\<br />
���� HINWEIS<br />
Selbst wenn die PATH- und XQT-Umgebungsvariable bereits festgelegt wurde,<br />
wird nicht nach ihr gesucht, wenn ein Verzeichnis mit Dateiname spezifiziert ist.<br />
<br />
XQT=\BIN;\TEST 1. Beim Ausführen von XQT „TMP“ (TMP ist der Dateiname), wird zuerst<br />
nach „TMP“ gesucht, dann nach „\BIN\TMP“ und dann nach<br />
“\TEST\TMP“.<br />
2. Beim Ausführen von XQT “¥TMP“ wird nur nach „\TMP“ gesucht.
ANWENDUNGEN<br />
69
1. Multitasking<br />
1.1 Was ist Multitasking<br />
70<br />
Wenn eine Reihe von Befehlen, die ausgeführt werden sollen, durch Verarbeitungsfunktionen in<br />
kleinere Einheiten aufgeteilt wird, wird jede dieser Verarbeitungsfunktionen „Task“ genannt.<br />
„Multitasking“ verweist auf einen Verarbeitungstyp, in dem mehrere Tasks gleichzeitig oder der Reihe<br />
nach ausgeführt werden.<br />
Es gibt zwei Wege, Multitasking zu erreichen. Der eine ist der „Multiprozeß“, ein Verarbeitungsmodus,<br />
in dem zwei oder mehr verbundene Verarbeitungsfunktionen einen oder mehrere Verarbeitungen in<br />
Übereinstimmung ausführen. Der andere ist der „Time-Sharing“-Modus, in dem eine einzelne<br />
Verarbeitungseinheit zwei oder mehr Tasks Zeit für die Ausführung zuweist, so daß es den Anschein<br />
hat, als würden sie gleichzeitig ausgeführt.<br />
Unsere Steuerung arbeiten nach dem Time-Sharing-Modus.<br />
Vorteile des Multitaskings<br />
Ein Multitasking-System hat die folgenden Vorteile:<br />
• verkürzte Taktzeiten<br />
Ein-Task-Systeme führen immer nur einen Task aus, wohingegen Multitasking-Systeme immer<br />
mehrere Tasks gleichzeitig ausführen. Das bedeutet, mehr Arbeit wird gleichzeitig ausgeführt und<br />
somit die Taktzeit (Arbeitszeit) wesentlich verkürzt.<br />
• Produktivität<br />
Zusätzlich zur verkürzten Arbeitszeit kann man mit Multitasking Peripheriegeräte gleichzeitig<br />
steuern. Das bedeutet, daß die ganze Arbeit effizienter ist und die Produktivität erhöht wird.<br />
• einfache Wartung<br />
Durch das Aufteilen des Programms in einzelne Tasks werden die Überprüfung und die Wartung<br />
des Programmes wesentlich vereinfacht.<br />
• Erweiterbarkeit<br />
Erweiterungen des Programms lassen sich durch das Hinzufügen neuer Tasks einfach vollziehen.
Multitasking in SPEL III<br />
Die Steuerungen <strong>SRC</strong>-<strong>300</strong>/310A/<strong>320</strong> können jeweils 16 Tasks mit Hilfe des Time-Sharing-Modus<br />
übereinstimmend ausführen. Jeder Task darf max. 2 ms dauern. Die Tasks werden durch die<br />
Systemsteuerung alle 2 ms weitergeschaltet.<br />
SPEL III verbindet FEND und FUNCTION in einem Task. Der XQT-Befehl des TEACH-Modus und<br />
der START-Schalter des AUTO-Modus führen FUNCTION...FEND am Anfang des Programms als<br />
Task 1 aus, und danach werden die Tasks in Übereinstimmung mit den XQT-Befehlen des Programms<br />
gestartet.<br />
<br />
1000 FUNCTION MAIN ‘Task 1<br />
1010 XQT !2,TASK2 ‘Start von Task 2<br />
1020 XQT !3,Task3 ‘Start von Task 3<br />
1030 XQT !4,Task4 ‘Start von Task 4<br />
1040 XQT !5,Task5 ‘Start von Task 5<br />
M<br />
1500 FEND<br />
2000 FUNCTION Task2 ‘Task 2<br />
M<br />
2500 FEND<br />
<strong>300</strong>0 FUNCTION TASK3 ‘Task 3<br />
M<br />
3500 FEND<br />
4000 FUNCTION TASK4 ‘Task 4<br />
M<br />
4500 FEND<br />
5000 FUNCTION TASK5 ‘Task 5<br />
M<br />
5500 FEND<br />
71
Tasks während der Ausführung des WAIT-Befehls, des INPUT-Befehls und des Bewegungs-Befehls<br />
72<br />
Die Tasks, die Befehle wie den WAIT-Befehl, den WAIT SW( )-Befehl, den INPUT-Befehl und<br />
Operationsbefehle (JUMP etc.) ausführen, werden zeitweise eingeschaltet und von der Gruppe der sofort<br />
auszuführenden Tasks getrennt. Diese Anordnung wird benutzt, da die Zuweisung einer bestimmten<br />
Ausführungszeit zu Tasks, deren einzige Aufgabe das Warten ist, nur zu einer abnehmenden Effizienz<br />
des CPU beitragen würde.<br />
Für diese Tasks überwacht das System die Übereinstimmung der Eingangskonditionen, den<br />
Dateneingang oder die Komplettierung der Bewegung, und wenn die vorausgesetzten Konditionen<br />
getroffen werden, führt das System Sie vorrangig zu den anderen Tasks aus. Danach werden sie wieder<br />
zeitweise für die Ausführung aktiviert.<br />
Task 3 führt den WAIT-Befehl aus.<br />
Task 2 Eingangsschnittstelle wechselt<br />
WAIT-Befehl und IF-Satz<br />
Basierend auf dem oben angegebenen haben die folgenden zwei Programme unterschiedliche<br />
Bedeutungen:<br />
Liste 1 Liste 2<br />
1000 FUNCTION TASK<br />
M<br />
1200 WAIT SW(1) = 1<br />
M<br />
1<strong>300</strong> FEND<br />
1000 FUNCTION TASK<br />
M<br />
1200 IF SW(1) = 0 THEN GOTO 1200<br />
M<br />
1<strong>300</strong> FEND
Beide warten darauf, daß sich Eingang 1 ändert. Liste 1 ist von der zeitweisen Aktivierung der Tasks<br />
ausgeschlossen, und Liste 2 wiederholt die Auswertung der Gleichung SW (1) = 0 für einen Zeitraum von 2<br />
Sekunden, nachdem eine bestimmte Zeit verstrichen ist. Gibt es Vielfach-Tasks wie in Liste 2, wird der größte<br />
Teil der Verarbeitungszeit der CPU auf die Auswertung der Bedingungsausdrücke verwendet.<br />
Weiterhin wird, wenn z.B. 16 Tasks ausgeführt werden sollen, einer alle 32 ms ausgeführt. In manchen Fällen<br />
ist es möglich, daß Liste 2 nicht auf Signale, die kürzer als 30 ms sind, reagiert.<br />
Zeitprogrammierung für den Wechsel der Tasks<br />
Der Wechsel der Tasks erfolgt an einer willkürlichen Position nach 2 ms. Die Werte der Variablen im<br />
folgenden Programm sind nicht garantiert:<br />
<br />
1000 FUNCTION MAIN<br />
M<br />
1200 IF A = 1 THEN...<br />
1210 IF A = 2 THEN...<br />
M<br />
1400 FEND<br />
2000 FUNCTION TASK2<br />
M<br />
2100 A=1<br />
M<br />
2200 FEND<br />
<strong>300</strong>0 FUNCTION TASK3<br />
M<br />
3100 A = 2<br />
M<br />
<strong>320</strong>0 FEND<br />
Werden Daten der Vielfach-Tasks in asynchroner Weise in eine Variable geschrieben, werden die Tasks<br />
aktiviert, während 2100 A = 1 ausgeführt wird (z.B. direkt nachdem Daten auf ein von vier Bytes<br />
geschrieben wurden), und dann wird 3100 A = 2 ausgeführt. Außerdem, wenn die Tasks wieder<br />
aktiviert werden und die Kontinuität von 2100 A = 1 ausgeführt wird, nimmt die Variable A einen<br />
Wert an, der äußerst unvorhersehbar ist.<br />
Überdies wird der Wert der Variablen A während der Ausführung des Teils, der auf THEN folgt, neu<br />
geschrieben, was den Bedingungsausdruck von IF bedeutungslos macht.<br />
73
1.2 Ineinandergreifen von Tasks<br />
Störungen der Steuerung<br />
74<br />
Beim Multitasking wird die Weiterverarbeitung gewöhnlich durchgeführt, während gegenseitige<br />
Störungen der Tasks vermieden werden und der fortschreitende Zustand der anderen Tasks gemeinsam<br />
geprüft wird. Dieser Vorgang wird Ineinandergreifen der Tasks genannt.<br />
Um dieses Ineinandergreifen sicherzustellen, macht SPEL III Gebrauch von dem E/A-Speicher. Der<br />
E/A-Speicher ist eine Gruppe von 512 Kennzeichen „Flags“ (1-Bit-Variablen), die von 0 bis 511<br />
numeriert sind. Es wird mit den Befehlen On $n/OFF $n, IN ($m)/OUT $m, und d gearbeitet.<br />
<br />
1000 FUNCTION TASK1<br />
M<br />
1100 LOOP1:<br />
1110 ON $0 ‘Befehl für Task 2, die Verarbeitung zu beginnen.<br />
M<br />
1200 WAIT SW($1) = 1; OFF $1 ‘Warten Sie auf den Hinweis, daß der<br />
Verarbeitungsprozeß von Task 2 abgeschlossen ist.<br />
‘Von hier an wird die Störung des Geräts von Task 2<br />
gesteuert.<br />
M<br />
1<strong>300</strong> GOTO LOOP1<br />
1310 FEND<br />
2000 FUNCTION TASK2<br />
M<br />
2100 LOOP2:<br />
2110 WAIT SW($0) = 1; OFF $0 ‘Warten Sie auf einen Befehl, die Verarbeitung zu<br />
beginnen.<br />
‘Von hier an wird die Störung des Geräts von Task 1<br />
gesteuert.<br />
M<br />
2<strong>300</strong> ON $1 ‘Hinweis: Verarbeitungsprozeß ist abgeschlossen.<br />
M<br />
2400 GOTO LOOP2<br />
2410 FEND
Nur ein Gerät wird von Vielfach-Tasks benutzt<br />
Die Datenausgabe an das einzig verfügbare Gerät (Anzeige für OPU-<strong>300</strong>, RS-232C,etc.) sollte im<br />
Wesentlichen den ausgewählten Tasks zugewiesen werden. Wenn das nicht vorhanden ist, muß ein<br />
sinnvolles Schema erdacht werden, um gleichzeitige Datenausgaben an eine einzige Vorrichtung zu<br />
vermeiden. Solch ein Schema wird als ausschließliche Steuerung bezeichnet.<br />
Nr. 0(null) des E/A-Speichers wird der Gebrauch/Nichtgebrauch der Datenausgabegeräte<br />
zugewiesen.<br />
1000 FUNCTION TASK1<br />
1010 XQT !2,TASK2<br />
1020 WAIT SW($0) = 0<br />
1030 ON $0<br />
1040 PRINT “1234567890“<br />
1050 PRINT “1234567890“<br />
1060 PRINT “1234567890“<br />
1070 OFF $0<br />
1080 GOTO 1020<br />
1090 FEND<br />
2000 FUNCTION TASK2<br />
2010 WAIT SW($0) = 0<br />
2020 ON $0<br />
2030 PRINT “abcdefg“<br />
2040 PRINT “abcdefg“<br />
2050 PRINT “abcdefg“<br />
2060 OFF $0<br />
2070 GOTO 2010<br />
2080 FEND<br />
><br />
abcdefg<br />
1234567890<br />
abcdefg<br />
abcdefg<br />
1234567890<br />
75
76<br />
Im -Programm, wenn der Task sofort nach WAIT SW ($0) = 0 aktiviert wird, wird eine<br />
Zeichenkette von einem anderen Task durch Unterbrechung in die Mitte der Datenausgabe der drei<br />
Zeichenketten geliefert. Um dies zu vermeiden, stellt SPEL III die ZEROFLG (0)-Funktion bereit.<br />
<br />
1000 FUNCTION TASK1<br />
1010 XQT !2,TASK2<br />
1020 ON $0<br />
1030 IF ZEROFLG(0) = 1 THEN WAIT SW($0) = 0; GOTO 1020<br />
1040 PRINT “1234567890“<br />
1050 PRINT “1234567890“<br />
1060 PRINT “1234567890“<br />
1070 OFF $0<br />
1080 GOTO 1020<br />
1090 FEND<br />
2000 FUNCTION TASK2<br />
2010 ON $0<br />
2020 IF ZEROFLG(0) = 1 THEN WAIT SW($0) = 0; GOTO 2010<br />
2030 PRINT “abcdefg“<br />
2040 PRINT “abcdefg“<br />
2050 PRINT “abcdefg“<br />
2060 OFF $0<br />
2070 GOTO 2010<br />
2080 FEND<br />
><br />
1234567890<br />
1234567890<br />
1234567890<br />
abcdefg<br />
abcdefg<br />
abcdefg<br />
1234567890<br />
1234567890<br />
1234567890<br />
Die ZEROFLG(0)-Funktion gibt den n-th-Status des E/A-Speichers zurück, der existiert, bevor das<br />
sofort vorangehende ON (OFF) $n ausgeführt wird.
2. Programmiertechniken<br />
2.1 Schreiben eines umfangreichen Programms (Effizienter Einsatz von<br />
CHAIN/LINK)<br />
Ein kleines Programm beinhaltet normalerweise eine einzige Datei. Wird das Programm größer, können<br />
die nachfolgend aufgeführten Probleme entstehen:<br />
• Paßt nicht in die Programmbereiche.<br />
• Kann nicht mit dem Editor bearbeitet werden.<br />
• Benötigt viel Zeit zum Kompilieren.<br />
• Benötigt viel Zeit zum Anzeigen mit Hilfe des Befehls LIST.<br />
• Alle Variablen und Sprungmarken müssen unterschiedliche Namen haben. (Es ist lästig,<br />
angemessene Namen zu finden.)<br />
Die Befehle CHAIN und LINK stehen zur Verfügung, um mit diesen Problemen fertig zu werden.<br />
Der erste Befehl wird verwendet, um zwischen Einrichtungsarten zu wechseln. Der zweite wird in allen<br />
anderen Fällen verwendet. Es gibt kein eindeutiges Kriterium zur Verwendung der Befehle CHAIN und<br />
LINK. Es bleibt dem Programmierer frei überlassen, mit Ausnahme der Fälle, in denen spezielle<br />
Umstände den Einsatz der Befehle erforderlich machen, wenn z.B. ein Programm nicht in den<br />
Programmbereich paßt. Als allgemeine Regel läßt sich sagen, daß es ratsam ist, die Befehle CHAIN und<br />
LINK bei Programmen einzusetzen, die mehr als 3.000 Zeilen beinhalten (Wenn eine Zeilennummer<br />
jeder zehnten Zeile, ausgehend von 10 bis zu 32.767, zugewiesen wird, ist die Grenze bei 3276 Zeilen.)<br />
Einsatzmöglichkeiten des CHAIN-Befehls<br />
Angenommen, ein Programm, in dem verschiedene Arten von ICs per DIP-Schalter festgelegt werden<br />
sollen, stellt einen Fall dar, in dem klar abgegrenzte Routinen ausgeführt werden sollen.<br />
<br />
Funktion (IC), die geändert werden soll, wird ausgewählt durch Eingang IN(0) und<br />
verzweigt zur Verfahrensroutine. Jede Routine ist unabhängig von den anderen und<br />
teilt sich nie die gleichen Unterprogramme.<br />
IN(0)= 1 :PLCC<br />
2 :DIP<br />
3 :SOP<br />
100 IF IN(0)=1 THEN GOTO PLCC ‘PLCC Auswahl<br />
110 IF IN(0)=2 THEN GOTO DIP ‘DIP Auswahl<br />
120 IF IN(0)=3 THEN GOTO SOP ‘SOP Auswahl<br />
M<br />
<strong>300</strong>0 PLCC:<br />
M<br />
3900 GOTO PLCC<br />
4000 DIP:<br />
M<br />
4900 GOTO DIP<br />
5000 SOP:<br />
M<br />
5900 GOTO SOP<br />
77
78<br />
(Einsatz von CHAIN)<br />
100 IF IN(0)=1 THEN CHAIN “PLCC“ ‘PLCC Auswahl<br />
110 IF IN(0)=2 THEN CHAIN “DIP“ ‘DIP Auswahl<br />
120 IF IN(0)=3 THEN CHAIN “SOP“ ‘SOP Auswahl<br />
Datei: PLCC.PRG<br />
1000 FUNCTION MAIN<br />
1010 PLCC:<br />
M<br />
1900 GOTO PLCC<br />
2000 FEND<br />
Datei: DIP.PRG<br />
1000 FUNCTION MAIN<br />
1010 DIP:<br />
M<br />
1900 GOTO DIP<br />
2000 FEND<br />
Datei: SOP.PRG<br />
1000 FUNCTION MAIN<br />
1010 SOP:<br />
M<br />
1900 GOTO SOP<br />
2000 FEND<br />
Wie im obigen Beispiel dargestellt, können Programme für individuelle Einrichtungsarten einzeln<br />
entwickelt werden. Dies bietet eine gute Debugging-Leistung und erzielt so kürzere Entwicklungszeiten.<br />
Darüber hinaus kann, wenn z.B. ein Programm durch Auswahl der REMOTE3 und nicht per OPU-<strong>300</strong>,<br />
aktiviert wird, auch der CHAIN-Befehl verwendet werden.<br />
Einsatzmöglichkeiten des CHAIN-Befehls<br />
Der LINK-Befehl kann unter den folgenden Bedingungen eingesetzt werden:<br />
• Ein Programm ist zu groß, um in den Programmbereich zu passen.<br />
• Ein Programm ist zu groß, um mit dem Editor bearbeitet zu werden.<br />
• Lokale Variablen sollen verwendet werden.<br />
• Die Programmierarbeit wird unter mehreren Personen aufgeteilt.<br />
• Das Programm soll aus mehreren wiederverwendbaren Modulen bestehen.<br />
• Das Kompilieren soll verkürzt werden.<br />
• Für Variablen und Sprungmarken sollen gleiche Namen verwendet werden, wobei die Dateien<br />
unterschiedlich sind.<br />
In allen obigen Fällen wird der Einsatz des Befehls LINK empfohlen. Sie sollten sich jedoch darüber im<br />
Klaren sein, daß eine Verwendung des LINK-Befehls die folgenden Nachteile mit sich bringen kann:<br />
• Um Variablen zu teilen, sind zusätzliche Prozeduren (z.B. ENTRY/EXTERN) notwendig.<br />
• Die Anzahl der Prozeduren erhöht sich. Zusätzlich zum Kompilieren muß der LINK-Befehl<br />
ausgeführt werden, und wenn es nur eine Fehlanpassung (z.B. keine Übereinstimmung zwischen<br />
ENTRY und EXTERN) gibt, müssen alle Prozeduren mit dem Kompilieren neu begonnen werden.<br />
• Mehrere Dateien müssen zur selben Zeit bearbeitet werden.
2.2 Bewegung zu mehreren gleichweit voneinander entfernten Punkten<br />
Der Befehl PALET wird, wie unten dargestellt, für Bewegungen zu mehreren gleichweit voneinander<br />
entfernten Punkten eingesetzt.<br />
Definieren von Paletten<br />
Format: PALETn Pa,Pb,Pc [Anzahl der 1. Abschnitte],[Anzahl der 2.<br />
Abschnitte]<br />
n: Anzahl Paletten (0 bis 15)<br />
a, b ,c: Anzahl Punkte (0 bis 99)<br />
[Anzahl der 1. Abschnitte]: Anzahl der Abschnitte zwischen Pa und Pb<br />
[Anzahl der 2. Abschnitte]: Anzahl der Abschnitte zwischen Pa und Pc<br />
<br />
PALET1, P1,P2,P3,5,3 Wenn die Eingaben wie im Beispiel vorgenommen werden, werden<br />
die Palette und die Anzahl der Punkte eingestellt, wie unten<br />
dargestellt.<br />
* Die Ecke der Palette, die durch drei Punkte gestaltet wird, muß bei „Pa“ liegen.<br />
* Wenn die drei Standardpunkte keinen rechten Winkel ergeben, wird die Palette deformiert.<br />
* Die Z-Koordinaten werden durch drei gleichweit voneinander entfernte Punkte in einer Ebene<br />
geformt.<br />
Einzeilige Palette<br />
Für eine einzeilige Palette wird das Einrichten an den zwei Punkten an beiden Enden vorgenommen und<br />
wird daher, wie folgt, definiert:<br />
Format: PALETn P1,P2,P1 [Anzahl der Abschnitte],1<br />
<br />
PALET1, P1,P2,P1,5,1<br />
79
Positionsbestimmung innerhalb der Palette<br />
80<br />
Vor der Programmausführung geben Sie direkt den Befehl JUMP ein und bewegen den Roboter zu<br />
jedem Punkt innerhalb der Palette und bestimmen so die richtige Position. Wenn Sie eine Zeichnung der<br />
Palette angelegt haben, erleichtert dies die Überprüfung der Bewegung zu jedem Punkt.<br />
Bestimmen Sie die Position innerhalb der Palette wie folgt:<br />
Format: PALETn (C)<br />
n: Anzahl Paletten (0 bis 15)<br />
C= Anzahl der Gitter<br />
���� HINWEIS<br />
Wenn die Palette nicht definiert ist, tritt ein Fehler auf. Stellen Sie die drei Punkte<br />
ein, bevor Sie das Programm ausführen.<br />
Wechsel von Palette 1 zu Palette 2<br />
10 FUNCTION MAIN<br />
20 PALET1 P1,P2,P3,3,5<br />
30 PALET2 P11,P12,P13,5,3<br />
40 FOR I=1 TO 15<br />
50 JUMP PALET1(I)<br />
60 ON 1 ; WAIT 0,5<br />
70 JUMP PALET2(I)<br />
80 OFF 1 ; WAIT 0,5<br />
90 NEXT I<br />
100 FEND<br />
Die Nummern der E/A-Ausgangsschnittstellen zum Bedienen des Greifers und die Anzahl der<br />
Palettenabschnitte sollten individuell eingestellt werden.
2.3 Techniken zum Verkürzen der Zykluszeit<br />
SPEL III stellt mehrere Befehle bereit, um die Zykluszeit zu verkürzen. Es gibt vier Methoden, die<br />
Zykluszeit zu verringern:<br />
• Bewegen zum höchstmöglichen Punkt<br />
• Ausführen übereinstimmender Prozeduren<br />
• Beseitigen überflüssiger Bewegungen<br />
• Beseitigen überflüssiger Positionen<br />
Benutzen einer Bogenbewegung<br />
Eine horizontale Bewegung wird während einer vertikalen Bewegung mit Hilfe des Befehls JUMP<br />
ausgeführt.<br />
Die Form der Bewegung kann frei gewählt werden:<br />
Vertikal ansteigende Strecke (a: mm)<br />
Vertikale Abwärtsbewegung (b: mm)<br />
Horizontale Bewegungshöhe (z: mm)<br />
Befehle: JUMP, ARCH, LIMZ<br />
Freies Einstellen des Zeitverhaltens bei Abschluß der Positionierung<br />
Definiert den Wert für den Bewegungsendpunkt und führt den nachfolgenden Befehl vor dem Zielpunkt<br />
aus. Die endgültige Position der Bewegung ändert sich nicht, auch wenn der Befehl FINE verwendet<br />
wird. Lediglich das Timing für das Ausführen des nächsten Befehls wird erhöht.<br />
Wählen Sie den besten Wert für Ihr System: ca. 500 bis 1000 Pulse für normale und 100 Pulse für<br />
Montageprozeduren.<br />
Befehl: FINE<br />
Parallele Prozesse<br />
Während der Anwendungen können anstelle Ihrer Auswahl die Ein- und Ausgaben der E/A und RS-<br />
232C ausgeführt werden.<br />
• Öffnen und Schließen des Greifers während der pick-and-place-Anwendung (siehe<br />
Abbildung)<br />
• Ein- und Ausschalten der Düse für Schreibvorgänge<br />
Befehl: !...!<br />
81
Bedingter Stop während der Bewegung<br />
82<br />
Wenn die Eingabebedingungen während der Bewegung eingerichtet sind, verlangsamt der Roboter<br />
sofort und hält an. Im Beispiel zeigen wir, daß der Stop auftritt, wenn die Bedingung „kein Werkstück“<br />
während der pick-and-place-Anwendung anliegt. Wenn der Stop durch die Abwesenheit des Werkstücks<br />
auftritt, wird eine überflüssige Bewegung durch wiederholtes Versuchen verhindert.<br />
Befehle: JUMP, SENSE, TILL<br />
JUMP mit TILL-Bedingung<br />
Montageanwendung mit langsamer Geschwindigkeit<br />
Wenn es während der Montage notwendig ist zu verlangsamen, sieht man oft Programmierungen mit<br />
JUMP- und GO-Befehlen, wie in Beispiel 1. Wird jedoch die Positionierung auf einmal durchgeführt, ist<br />
ein Einzel-Bewegungs-Befehl nicht passend, auch wenn FINE angewendet wird.<br />
JUMP PN<br />
GO Pm<br />
In diesem Fall ist es sinnvoller, die Zykluszeit mit geschickter Verwendung des Befehls ACCEL zu<br />
verkürzen, bevor der JUMP-Befehl angewendet wird.<br />
ACCEL 100,100, 100,100, 100,10 ;JUMP Pm<br />
Vereinigte Befehle<br />
Fünf Beispiele sind oben angegeben. Die vereinigten Befehle sind unten aufgeführt. Weitere<br />
Informationen erhalten Sie im SPEL III Referenzhandbuch.<br />
• Bewegen mit größtmöglicher Geschwindigkeit: SPEED, SPEEDS, ACCEL, ACCELS, WEIGHT<br />
• Ausführen übereinstimmender Prozeduren !...! (Parallelprozeß), Multitasking<br />
• Beseitigen überflüssiger Bewegungen ARCH, LIMZ, SENSE, TILL<br />
• Beseitigen überflüssiger Positionen PASS, FINE, CMOVE, CARC
2.4 Benutzen von Positionsdaten<br />
Wenn Sie zwischen Positionsdaten umschalten müssen, weil ein Einzelprogramm zwei oder mehr<br />
Werkstücke bearbeitet, ist es sinnvoll, die werkstückspezifischen Daten in den Positionsdaten zu<br />
speichern. Es ist z.B. sinnvoll, wenn sich zwei verschiedene Arten von Werkstücken in der Anzahl von<br />
Werkstücken, die in einer Einzelpalette behandelt werden können, unterscheiden, oder wenn die<br />
Bearbeitungsgeschwindigkeit in Abhängigkeit von dem zu bearbeitenden Werkstück variiert.<br />
Um Koordinatenwerte von den Punktdaten zu erhalten, benutzen Sie die Funktionen CX(Pn), CY(Pn),<br />
CZ(Pn) und CU(Pn).<br />
<br />
Geben Sie die Anzahl der Werkstücke als X von Punkt Nr. 190 der 1. Werkstück-Punktdatei ein (z.B.:<br />
01WORK.PNT). Geben Sie außerdem die Bearbeitungsgeschwindigkeit in X, Y, Z und U von Nr. 191<br />
ein.<br />
M<br />
P190=10,0,0,01<br />
P191=100,100,20,50<br />
Wie für Werkstück 1 geben Sie die Anzahl der Werkstücke als X von Punkt Nr. 190 der 2. Werkstück-<br />
Punktdatei ein (z.B.: 02WORK.PNT). Geben Sie außerdem die Bearbeitungsgeschwindigkeit in X, Y, Z<br />
und U von Nr. 191 ein.<br />
M<br />
P190=12,0,0,01<br />
P191=80,80,20,50<br />
Sie erreichen die Daten in dem Programm wie folgt:<br />
M<br />
1100 COUNT = CX(P190)<br />
1110 SPD1 = CX(P191);ACL1 = CY(P191)<br />
1120 SPD2 = CZ(P191);SPD3 = CU(P191)<br />
M<br />
1200 SPEED SPD1; ACCEL ACL1,ACL1<br />
M<br />
1500 FOR I = 1 TO COUNT<br />
1510 JUMP PALET1(I)<br />
M<br />
1590 NEXT<br />
M<br />
1700 SPEED SPD2<br />
1710 GO P10<br />
1720 SPEED SPD1<br />
M<br />
1900 SPEED SPD3<br />
1910 GO P11<br />
1920 SPEED SPD1<br />
M<br />
Erreichen der Anzahl von Werkstücken, die<br />
von P190 in eine Palette geladen werden soll.<br />
Erreichen der Geschwindigkeit und<br />
Beschleunigung/Verzögerungswerte von P191.<br />
83
3. Fehlerbeseitigung (Debuggen)<br />
3.1 Fehlerbeseitigung im Multitasking<br />
Komfortable Befehle zur Fehlerbeseitigung<br />
84<br />
SPEL II verfügt über viele Befehle, die bei der Fehlerbeseitigung in Multitasking-Programmen hilfreich<br />
sind. Diese Befehle werden im Befehlsmodus des SPEL Editors oder im Monitorfenster von SPEL for<br />
Windows ausgeführt.<br />
XQT-Befehl<br />
• XQT: Taskausführung<br />
• TSTAT: Anzeige des Taskstatus<br />
• TON/TOFF: Anzeige der ausgeführten Zeilennummer an der Steuerung und dem PC.<br />
• PRINT: Anzeige von Zeichenketten, Variablen, E/A, Speicher E/A.<br />
Der XQT-Befehl führt ein Programm aus.<br />
Wenn der Befehl per PC eingegeben wird, wird FUNCTION...FEND am Anfang des Programms als<br />
Task 1 ausgeführt. Der XQT-Befehl ist abgeschlossen, wenn Task 1 beendet ist. Daher kann der nächste<br />
Befehl erst dann eingegeben werden, wenn dieser Befehl beendet ist.<br />
Mit dem XQT-Befehl können Sie die Tasknummer des auszuführenden Programms, die FUNCTION<br />
und die Zeilennummer festlegen. Sie können einen Teil des Programms durch Eingabe der<br />
Zeilennummer ausführen lassen, um z. B. Einzelheiten zu überprüfen.<br />
Sie können auch den Befehl TSTAT verwenden (siehe unten) wenn Sie den Task festlegen.<br />
<br />
>XQT !2,MAIN Start der FUNCTION MAIN als Task 2<br />
> Es ist möglich, Befehle einzugeben, während das Programm abläuft.<br />
<br />
>XQT !2,MAIN,2100-2200 Ausführen der Zeilen 2100 bis 2200 der FUNCTION MAIN.<br />
><br />
TSTAT-Befehl<br />
Wenn der TSTAT-Befehl ausgeführt wird, wird der Status der Tasks 1 bis 16 angezeigt. Mit diesem<br />
Befehl können Sie die Ausführungsmodi aller Tasks anzeigen lassen.<br />
Im Befehlsmodus des SPEL Editors können Sie die Tasknummern von 2 bis 16 mit Hilfe des Befehls<br />
XQT festlegen und das Programm ausführen.<br />
<br />
>XQT !2,MAIN<br />
>TSAT<br />
Task 1 2 3 4 5 6 7 8<br />
Status QUIT QUIT QUIT QUIT QUIT QUIT QUIT QUIT<br />
Zeile 0 100 250 0 0 0 0 0<br />
Task 9 10 11 12 13 14 15 16<br />
Status QUIT QUIT QUIT QUIT QUIT QUIT QUIT QUIT<br />
Zeile 0 0 0 0 0 0 0 0
Zeigt die letzte Zeilennummer, die vor dem Status jeder Task, QUITE, RUN, HALT und TSTAT<br />
ausgeführt wurde.<br />
In SPEL für Windows können Sie den Status jedes Tasks im Fenster [Task Manager] überprüfen.<br />
Weitere Informationen erhalten Sie im SPEL für Windows Handbuch.<br />
TON/TOFF-Befehl<br />
Sie können die Programmreihenfolge ab der gegenwärtig ausgeführten Zeilennummer herausfinden. Es<br />
gibt eine LED an der Vorderseite der Steuerung, die die Zeilennummer anzeigt. Im Normalfall wird die<br />
Zeilennummer der Task 1 hier angezeigt. Wenn Sie den TON-Befehl anwenden, können Sie die<br />
Zeilennummern für andere als Task 1 anzeigen lassen.<br />
<br />
>XQT !2,MAIN<br />
[1010] Zeigt die Zeilennummer, die ausgeführt wird.<br />
[1020]<br />
M<br />
PRINT-Befehl<br />
Die einfachste Technik zur Fehlerbehebung ist die Anzeige der Zeichenketten in der Mitte des<br />
Programms und deren Überprüfung. PRINT ist ein Befehl zum Anzeigen von Zeichenketten,<br />
Variablenwerte, Funktionswerte, etc. an der Programmiereinheit.<br />
<br />
1000 FUNCTION MAIN<br />
1010 XQT !2,TASK2<br />
1020 PRINT “Start Task2“<br />
M<br />
1200 A = A + B + C<br />
1210 PRINT “A = “,A<br />
M<br />
Folgendes wird angezeigt, wenn Sie das Programm ausführen:<br />
Start Task2<br />
A = 100<br />
85
4. Stapelverarbeitung<br />
86<br />
In MS-DOS gibt es eine Verarbeitungsmöglichkeit, die „Stapelverarbeitung“ genannt wird. Diese<br />
Stapelverarbeitung führt automatisch Befehle und Anweisungen in der angegebenen Reihenfolge aus.<br />
Die Datei, die die auszuführenden Befehle enthält heißt Stapelverarbeitungs- oder Stapeldatei.<br />
SPEL III bietet die Verwendung von Stapeldateien wie MS-DOS. SPEL III Befehle und Anweisungen<br />
können in der Stapeldatei beschrieben werden.<br />
Die Dateierweiterung der Stapeldatei muß BAT sein. Durch diese Erweiterung wird sofort erkannt, daß<br />
es sich um eine Stapeldatei handelt, und die Befehle und Anweisungen, die in ihr enthalten sind, werden<br />
automatisch ausgeführt.<br />
Beim Ausführen der Stapelverarbeitung geben Sie den Namen der Stapeldatei wie einen Befehl ein. Zur<br />
Ausführung der Datei ist es jedoch nicht erforderlich, die Erweiterung (.BAT) mit einzugeben. Zum<br />
Bearbeiten der Stapeldatei kann der Befehl EDIT benutzt werden. Weitere Informationen zum EDIT-<br />
Befehl erhalten Sie im SPEL III Referenzhandbuch.<br />
4.1 Befehle zur Stapelverarbeitung<br />
In SPEL III gibt es einen Befehl „ECHO“, mit dem die Anzeige der Befehle und Meldungen während<br />
der Stapelverarbeitung gesteuert werden kann. Er hat folgendes Format:<br />
Format: ECHO ON<br />
ECHO OFF<br />
ECHO [Meldung]<br />
Im Allgemeinen werden die festgelegten Befehle an der Konsole angezeigt. Der Befehl ECHO steuert<br />
diese Anzeige. Wenn der Befehl, der ausgeführt wird, angezeigt werden soll, geben Sie „ECHO ON“<br />
ein, soll er nicht angezeigt werden, geben Sie „ECHO OFF“ ein. Im Normalfall ist die Anzeige im<br />
„ECHO ON“-Status. D.h., auch wenn Sie ECHO OFF eingeben, ändert sich der Status nach Ausführung<br />
der Stapeldatei automatisch in ECHO ON.<br />
Wird „ECHO [Meldung]“ eingegeben, wird die Meldung an der Konsole dargestellt. Auch wenn ein<br />
ECHO OFF-Zustand definiert ist und die Meldung angezeigt werden kann, ist es sinnvoll, die Meldung<br />
über den ausgeführten Befehl als Verzeichnis des ausgeführten Befehls angeben zu lassen. In [message]<br />
können alle Eigenschaften außer dem Steuerungscode (character codes 00H zu 1FH) verwendet werden.<br />
Im Falle der MS DOS-Anwendung, wenn der ECHO-Befehl ohne ON, OFF und [message] eingegeben<br />
ist, wird der aktuelle ECHO-Status zugeordnet. SPEL III bietet diese Funktion jedoch nicht an. Wenn<br />
Sie hier nur ECHO eingeben, werden die Leerzeichen deshalb als Meldung verstanden, und eine Zeile<br />
wird gewechselt.<br />
Dateiname „ECHO.BAT“.<br />
10 ECHO OFF<br />
20 ECHO MESSAGE1<br />
30 ECHO<br />
40 ECHO ON<br />
50 ECHO MESSAGE2<br />
Wenn Sie das Beispielprogramm ausführen, wird das Ergebnis wie folgt aussehen:<br />
>ECHO<br />
MESSAGE1 `Meldung wird angezeigt<br />
`Veränderung der Zeile durch den Befehl ECHO<br />
MESSAGE2 `Meldung wird angezeigt
Was den SPEL III-Befehl „ECHO“ von dem unter MS-DOS unterscheidet, ist, daß im ECHO ON-Status<br />
die ECHO-Anzeige nicht erscheint. Zum Beispiel in dem oben dargestellten Beispiel: Wenn dieselbe<br />
Stapeldatei unter MS-DOS läuft, werden die Ergebnisse wie folgt aussehen:<br />
>ECHO<br />
ECHO OFF `1)<br />
MESSAGE1<br />
ECHO `2)<br />
ECHO MESSAGE2 `3)<br />
MESSAGE2<br />
1. Bevor Sie ECHO OFF ausgeführt haben, war der ECHO ON-Status eingestellt. Also wird dieser<br />
Status angezeigt.<br />
2. Der gegenwärtige Einstellungsstatus von ECHO wird angezeigt.<br />
3. Anzeige gemäß des ECHO ON-Status. (Die Zeichenkette von ECHO ON wird nicht angezeigt,<br />
solange der ECHO OFF-Status eingestellt ist.)<br />
Weitere Informationen zur Stapelverarbeitung und zur Anzeige der Stapeldateien erhalten Sie im MS-<br />
DOS-Handbuch.<br />
87
4.2 Stapeldatei<br />
88<br />
Es gibt viele Befehle wie z.B. den COMMAND-Befehl, die nicht unter SPEL III ausgeführt werden<br />
können. Wenn diese Befehle aber in einer Stapeldatei beschrieben werden, dann können diese Befehle<br />
ausgeführt werden.<br />
Herstellen einer Stapeldatei<br />
Wenn Sie eine Stapeldatei editieren, dann müssen Sie zuerst den EDIT-Modus eingeben bei<br />
gleichzeitiger Spezifizierung des EDIT-Befehls.<br />
Siehe dazu das Kapitel 6.2 „Editieren von Dateien“ in diesem Teil des Handbuches.<br />
Die Stapeldatei wird mit der Erweiterung BAT versehen. Eine Datei kann nicht mit demselben Wort wie<br />
ein SPEL-Befehl bezeichnet werden, da der Befehl Vorrang hat.<br />
Direkt wirksame Befehle können in einer Stapeldatei definiert werden. Solche Befehle werden in einer<br />
bestimmten Reihenfolge ausgeführt. Sie können während der Arbeit mit einer Stapeldatei keine anderen<br />
Stapeldateien aufrufen.
5. Automatische Programmausführung bei Einschalten<br />
der Spannungsversorgung<br />
Es ist möglich, die Programmausführung automatisch zu starten, wenn die Spannungsversorgung<br />
eingeschaltet wird.<br />
Diese automatische Ausführung kann erreicht werden durch das Erstellen einer „AUTO.BAT“-Datei<br />
oder einer „IPL.OBJ“-Datei in dem Wurzelverzeichnis der aktuellen Steuerung.<br />
5.1 Die AUTO.BAT-Datei<br />
Erstellen Sie diese Datei auf demselben Weg wie eine gewöhnliche Stapeldatei mit dem EDIT-Befehl.<br />
Aufgrund der Benennung dieser Datei mit „AUTO.BAT“ sind Sie in der Lage, die Befehle, die in der<br />
Datei gespeichert sind, automatisch auszuführen. (Zu Details des EDIT-Befehls siehe auch Kapitel 6.2<br />
„Editieren von Dateien“.)<br />
Ein Beispiel, die ausführbare Datei „MAINGRP“ automatisch nach dem Drehen des<br />
Reglers auszuführen<br />
>EDIT AUTO.BAT<br />
New file<br />
>10 XQT „MAINGRP“<br />
>END<br />
5.2 Das IPL-Programm<br />
Edit End...file save<br />
><br />
Diese Stapeldatei kann unabhängig vom Startmodus ausgeführt werden.<br />
Beim Erstellen der Datei mit der Erweiterung IPL, kann XQT“IPL“ ausgeführt werden, wenn die<br />
Spannungsversorgung eingeschaltet ist. Der Start-Modus muß jedoch auf AUTO-Modus eingestellt sein.<br />
89
6. Systemkonfigurationsdatei<br />
6.1 CNFG.SYS-Datei<br />
90<br />
Um den Computer effizient zu nutzen müssen Sie Systeminformationen in Übereinstimmung mit der<br />
Hardware und dem genutzten Programm definieren. Diese Informationen werden in der „CNFG.SYS“-<br />
Datei beschrieben. Daneben wird in dieser Datei die Systemumgebung spezifiziert.<br />
Die Anforderungen, die in SPEL III definiert werden können sind die Kapazität des<br />
Fehlerhistorienspeichers, die Kapazität der Zeilenhistorie jedes Tasks und die maximale Anzahl der<br />
Benutzertasks.<br />
Wenn die „CNFG.SYS“-Datei nicht existiert, werden Standardwerte für die Systemkonfiguration<br />
angenommen.<br />
Die „CNFG.SYS“-Datei muß im Stammverzeichnis registriert werden. Selbst wenn die „CNFG.SYS“-<br />
Datei in einem anderen Verzeichnis existiert wird sie nicht beachtet werden.<br />
TASK=k Spezifiziert die verfügbare Anzahl der Benutzertasks in k.<br />
k: Ganze Zahl zwischen 1 und 16 [ angenommener Standardwert:16]<br />
ERRBUF=m Speichert die Fehlerhistorie bis m.<br />
m: Ganze Zahl zwischen 1 und 20 [angenommener Standardwert:20]<br />
LINBUF=n Speichert die Zeilenhistorie jedes Tasks bis n.<br />
n: Ganze Zahl zwischen 1 und 512 [angenommener Standardwert:10]<br />
Wie bei den oben angegebenen Anforderungen wird der Systemspeicherbereich der Speicherkapazität in<br />
Byte wie unten angegeben zugewiesen.<br />
Benötigter Speicher [Einheit: Byte]<br />
Benutzertask (Spezifizierte Anzahl) x (ungefähr 1600)<br />
ERRBUF (Spezifizierte Anzahl) x 8<br />
LINBUF (Spezifizierte Anzahl) x 6 x (Anzahl der durch TASK spezifizierten Tasks)<br />
Der Systemspeicherbereich wird benutzt, um den benötigten RAM zu sichern, der für die laufenden<br />
Tasks benötigt wird. Daher kann es sein, daß, wenn der „ERRBUF“ oder „LINBUF“ zu groß eingestellt<br />
sind, die Tasks nicht laufen. Achten Sie darauf, nicht mehr Platz als notwendig zu spezifizieren.<br />
Stellen Sie außerdem sicher, daß „TASK=k“ in der CNFG.SYS-Datei vor der Zeile „LINEBUF=n“<br />
steht. Ist dies nicht der Fall, wird der für LINBUF gesicherte Bereich der für 16 Tasks sein.
6.2 Editieren von Dateien<br />
SPEL III bietet für das Bearbeiten von Textdateien ist (ausgenommen Programmdateien) den EDIT-<br />
Befehl an. Das Format des EDIT-Befehls ist wie folgt;<br />
Format: EDIT [Pfadname][Dateiname]<br />
Wenn Sie den EDIT-Befehl benutzen, wird in den Editmodus gewechselt und die Dateien können<br />
bearbeitet werden. Um eine Datei zu editieren, erstellen Sie Zeilen mit Zeilennummern, genau wie ein<br />
Programm erstellt wird. Es ist nicht notwendig, „FUNCTION (Funktionsname)“ und „FEND“ zu<br />
beschreiben.<br />
Im Editmodus ist es möglich, die unten aufgelisteten Befehle zu benutzen.<br />
LIST, RENUM, DELETE(DEL), NEW, FREE, COPY, RENAME(REN), CHDIR(CD),<br />
RMDIR(RD), MKDIR(MD), RENDIR, DIR, QUIT, END<br />
Wenn Sie in den Editiermodus wechseln, geben Sie den Pfad- und den Dateinamen an. Dann, wenn der<br />
Dateiname im Verzeichnis existiert, wird die Datei gelesen.<br />
END of input file<br />
Die oben gezeigte Meldung erscheint. Existiert der spezifizierte Dateiname nicht,<br />
NEW FILE<br />
erscheint die oben dargestellte Meldung. Das Editieren ist dann ist möglich.<br />
Um den Editiermodus wieder zu verlassen, können Sie den QUIT-Befehl benutzen (Ende ohne<br />
speichern)oder END (es wird gespeichert und dann beendet). Die folgenden Meldungen werden in den<br />
jeweiligen Fällen erscheinen.<br />
>QUIT<br />
Edit End...<br />
>END<br />
Edit End...file save<br />
><br />
Die Programmeditierungsbereiche für den Editiermodus und für das Roboterprogramm sind<br />
unterschiedlich. Daher wird das Programm im Roboterprogrammierbereich nicht durch das Editieren<br />
einer Datei im Editiermodus behindert.<br />
EDIT-Befehle löschen Zeilennummern, wenn sie Daten speichern, und wenn sie Dateien lesen, werden<br />
die Zeilennummern wie 10, 20, 30....hinzugefügt. Daher weichen die Zeilennummern vor und nach dem<br />
Speichern voneinander ab.<br />
91
92<br />
<br />
>EDIT CNFG.SYS<br />
New file<br />
>10 TASK=8<br />
>20 ERRBUF=20<br />
>30 LINBUF=256<br />
>END<br />
Edit End...file save<br />
><br />
���� HINWEIS<br />
Wenn die Palette nicht definiert ist, tritt ein Fehler auf. Stellen Sie die drei Punkte<br />
ein, bevor Sie das Programm ausführen.<br />
Die Zeichenanzahl in einer Zeile ist bis zu 79, einschließlich der Zeilennummer, zulässig. Achten Sie<br />
darauf, daß die Anzahl der gelesenen Zeichen (Zeilennummern nicht eingeschlossen) 74 ist, alles<br />
darüber hinaus wird abgeschnitten.<br />
Die maximale Dateigröße, die editiert werden kann, ist 6 Kbyte.
7. RS-232C<br />
7.1 Übersicht über die RS-323C<br />
Die <strong>Robotersteuerung</strong>en <strong>SRC</strong>-<strong>300</strong>/310A/<strong>320</strong> haben eine RS-232C-Schnittstelle als Standardschnittstelle,<br />
und die Kommunikation wird durch die SPEL III Roboterprogrammiersprache unterstützt. Die RS-<br />
232C-Schnittstelle kann für die folgenden Kommunikationsarten genutzt werden.<br />
• Kommunikationseingang für SPEL-Editor oder SPEL für Windows<br />
• Kommunikation zwischen Robotern<br />
• Kommunikation mit Benutzereinrichtungen<br />
• Kommunikation mit einem Hauptrechner<br />
Konfiguration<br />
Weil SPEL III asynchrone Kommunikation benutzt, müssen die verschiedenen<br />
Kommunikationseinstellungen (wie der Kommunikationsmodus, Protokoll und Baudrate) unter allen<br />
Kommunikationseinrichtungen dieselben sein. Diese Gruppe von Einstellungen wird „Konfiguration“<br />
genannt.<br />
Kommunikationsmodus<br />
Der Kommunikationsmodus beinhaltet Datenbit-, Paritäts- und Stop-Bit-Einstellungen, die für die<br />
Übertragung von Daten per RS-232C-Schnittstelle gemacht sind.<br />
Protokoll<br />
Das Protokoll ist die Folge, in der die Daten zwischen den Kommunikationsstationen transferiert<br />
werden. SPEL III unterstützt „BASIC Protokoll“ und „TTY Protokoll“-Einstellungen. Das „BASIC<br />
Protokoll“ wird empfohlen, um die Zuverlässigkeit der Kommunikationsdaten zu sichern.<br />
Konfiguration für SPEL III<br />
Die SPEL III-Konfiguration kann über die folgenden Befehle eingestellt werden.<br />
Format: CONFIG #[port no.],[mode no.],[protocol no.],[timeout period],[baud rate no.]<br />
Schnittstellennummer<br />
:<br />
20 oder 21 (ganze Zahl zwischen 20 und 23 für erweiterte<br />
Eingänge)<br />
Modusnummer. Ganze Zahl zwischen 0 und 47<br />
Protokollnummer. Ganze Zahl zwischen 0 und 19<br />
Baudratenummer. Ganze Zahl zwischen 0 und 7<br />
Die folgenden Werte sind als Anfangswerte für den RS-232C-Eingang der Steuerung eingestellt.<br />
Dieselben Werte werden auch bei der Ausführung des VERINIT-Befehls eingestellt.<br />
Modusnummer: 2 (7 Bits, gerade Parität, 1 Stop Bit)<br />
Protokollnummer: 1 (BASIC Protokoll, zweite Station)<br />
Timeoutzeitspanne: 3 (3 Sekunden Timeoutzeitspanne)<br />
Baudratennummer: 0 (9.600 bps)<br />
93
94<br />
Schnittstellennummer<br />
Dies ist die Schnittstellennummer der RS-232C, die auf der Rückseite der Steuerung angebracht ist.<br />
Modusnummer<br />
Modusnummer<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
21<br />
22<br />
23<br />
Zeichenbits<br />
Zeichenbits Parität Stop Bits Modusnummer<br />
7<br />
7<br />
7<br />
7<br />
8<br />
8<br />
8<br />
8<br />
7<br />
-<br />
7<br />
-<br />
7<br />
7<br />
7<br />
-<br />
8<br />
8<br />
-<br />
8<br />
8<br />
-<br />
8<br />
-<br />
EVEN<br />
ODD<br />
EVEN<br />
ODD<br />
NONE<br />
NONE<br />
EVEN<br />
ODD<br />
EVEN<br />
–<br />
ODD<br />
–<br />
NONE<br />
NONE<br />
NONE<br />
-<br />
EVEN<br />
EVEN<br />
-<br />
ODD<br />
ODD<br />
-<br />
NONE<br />
-<br />
2<br />
2<br />
1<br />
1<br />
2<br />
1<br />
1<br />
1<br />
1,5<br />
-<br />
1,5<br />
-<br />
2<br />
1<br />
1,5<br />
-<br />
2<br />
1,5<br />
-<br />
2<br />
1,5<br />
-<br />
1,5<br />
-<br />
24<br />
25<br />
26<br />
27<br />
28<br />
29<br />
30<br />
31<br />
32<br />
33<br />
34<br />
35<br />
36<br />
37<br />
38<br />
39<br />
40<br />
41<br />
42<br />
43<br />
44<br />
45<br />
46<br />
47<br />
Zeichenbits Parität Stop<br />
Bits<br />
6<br />
6<br />
6<br />
-<br />
6<br />
6<br />
6<br />
-<br />
6<br />
6<br />
6<br />
-<br />
5<br />
5<br />
5<br />
-<br />
5<br />
5<br />
5<br />
-<br />
5<br />
5<br />
5<br />
-<br />
EVEN<br />
EVEN<br />
EVEN<br />
-<br />
ODD<br />
ODD<br />
ODD<br />
-<br />
NONE<br />
NONE<br />
NONE<br />
-<br />
EVEN<br />
EVEN<br />
EVEN<br />
-<br />
ODD<br />
ODD<br />
ODD<br />
-<br />
NONE<br />
NONE<br />
NONE<br />
-<br />
Dies ist die Anzahl der Bits, die benutzt wird, um Textzeichen während der Datenübermittlung<br />
darzustellen.<br />
Parität<br />
Das Paritätsbit wird benutzt, um die Zuverlässigkeit der Datenkommunikation zu sichern.<br />
EVEN: Ein Paritätsbit wird hinzugefügt, so daß die Gesamtzahl von 1 in der Bit-Zeichenfolge eine<br />
gerade Zahl wird.<br />
ODD: Ein Paritätsbit wird hinzugefügt, so daß die Gesamtzahl von 1 in der Bit-Zeichenfolge eine<br />
ungerade Zahl wird.<br />
NONE: Es wird kein Paritätsbit hinzugefügt.<br />
Stopbits<br />
Das Stopbit zeigt das Ende der Datenübermittlung an. Tatsächlich zeigt es einen Bitzeitwert an, d.h.<br />
„1,5 Stopbits“ bedeutet die benötigte Zeit zur Übertragung von 1,5 Bits.<br />
2<br />
1,5<br />
1<br />
-<br />
2<br />
1,5<br />
1<br />
-<br />
2<br />
1,5<br />
1<br />
-<br />
2<br />
1,5<br />
1<br />
-<br />
2<br />
1,5<br />
1<br />
-<br />
2<br />
1,5<br />
1<br />
-
Protokollnummer<br />
Protokollnummer Protokoll Station Funktionskontrolle des Speichers Terminator<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
���� HINWEIS<br />
Timeoutzeitspanne<br />
TTY<br />
BASIC<br />
BASIC<br />
TTY<br />
TTY<br />
TTY<br />
TTY<br />
TTY<br />
BASIC2<br />
BASIC2<br />
TTY<br />
BASIC<br />
BASIC<br />
TTY<br />
TTY<br />
TTY<br />
TTY<br />
TTY<br />
BASIC2<br />
BASIC2<br />
-<br />
2<br />
1<br />
-<br />
-<br />
-<br />
-<br />
-<br />
2<br />
1<br />
-<br />
2<br />
1<br />
-<br />
-<br />
-<br />
-<br />
-<br />
2<br />
1<br />
None<br />
-<br />
-<br />
XON/XOFF<br />
XON/XOFF<br />
XON/XOFF<br />
None<br />
None<br />
-<br />
-<br />
CS<br />
CS<br />
CS<br />
CS&XON/XOFF<br />
CS&XON/XOFF<br />
CS&XON/XOFF<br />
CS<br />
CS<br />
CS<br />
CS<br />
CR<br />
-<br />
-<br />
CR<br />
CR-LF<br />
LF<br />
CR-LF<br />
LF<br />
-<br />
-<br />
CR<br />
-<br />
-<br />
CR<br />
CR-LF<br />
LF<br />
CR-LF<br />
LF<br />
-<br />
-<br />
Protokollnummern von 10 bis 19 sind in der Version 3.2 und früher von SPEL III<br />
nicht möglich.<br />
Beim Verwenden des BASIC-Protokolls tritt ein Kommunikationsfehler (Error Code 31) auf, wenn die<br />
Daten nicht in der spezifizierten Zeitspanne empfangen werden. Diese spezifizierte Zeitspanne wird<br />
„Timeoutzeitspanne“ genannt.<br />
Baudratennummer<br />
Nr. der Baudrate Baudrate (bps)<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
9600<br />
4800<br />
2400<br />
1200<br />
600<br />
<strong>300</strong><br />
19200<br />
38400<br />
95
Computerkonfiguration<br />
96<br />
Der Computer, der über eine RS-232C-Schnittstelle angeschlossen ist muß dieselbe<br />
Kommunikationskonfiguration haben, wie die <strong>Robotersteuerung</strong>.<br />
Die Methode zur Einstellung der Konfiguration variiert abhängig vom verwendeten Computer. Prüfen<br />
Sie die Handbücher des verbundenen Computers und sein Betriebsystem wie z.B. MS-DOS (*1) , führen<br />
Sie dann die selben Konfigurationseinstellungen am Computer und an der Steuerung durch.<br />
<br />
Computer: IBM PC (oder kompatibel)<br />
Betriebssystem: MS-DOS<br />
Der Gerätetreiber von MS-DOS muß möglicherweise installiert werden, um eine Kommunikation<br />
über die RS-232C zu ermöglichen. Installieren Sie den Treiber, indem Sie folgende Zeile in die<br />
CONFIG.SYS-Datei schreiben:<br />
DEVICE=ANSI.SYS<br />
RS-232C-Kommunikation ist jetzt mit Nutzung der Diskette möglich, auf der das Gerät, wie oben<br />
gezeigt, installiert wurde. Sie müssen allerdings immer noch die Kommunikationkonfiguration<br />
einstellen, bevor Sie die RS-232C-Kommunikationen ausführen können.<br />
Stellen Sie sicher, daß die Konfigurationseinstellungen von Computer und Steuerung identisch sind.<br />
Wenn Sie zum Beispiel die Anfangssteuerungseinstellungen benutzen, stellen Sie die folgenden<br />
Konfigurationen an der DOS-Aufforderung des Computers auf.(A>).<br />
A>MODE COM1 : 9600, E, 8, 2<br />
(*1) MS-DOS ist ein eingetragener Markenname der Microsoft Corporation.
TTY Protokoll und XON/XOFF Steuerung<br />
TTY Protokoll<br />
Das TTY-Protokoll wird wie „kein Protokoll“ behandelt, da es ein Protokoll ist, das einfach nur die<br />
Daten sendet, ohne zu überprüfen, ob der Empfänger bereit ist oder nicht.<br />
TTY fügt den Daten CR(&HOD) als Terminator zu. Wenn Übertragungsfehler oder andere Probleme<br />
auftreten, ist es unmöglich, die übermittelten Daten wiederzufinden, so daß man sehr vorsichtig bei der<br />
Benutzung von TTY sein muß.<br />
Statt dessen empfehlen wir das BASIC-Protokoll zu benutzen, da es die Überprüfung des Bereit-Status<br />
und die Fehlerfindung wie die Paritätsprüfung bereitstellt, die hilft, eine zuverlässige Kommunikation<br />
sicherzustellen.<br />
Details des BASIC-Protokolls werden auf der nächsten Seite beschrieben.<br />
XON/XOFF Steuerung<br />
Unter Verwendung des TTY-Protokolls, gibt es einen Überlauf des Empfangsspeichers, wenn die<br />
Datenverarbeitung an der Eingangsseite nicht reibungslos funktioniert. Die XON/XOFF-Steuerung ist<br />
eine Kontrollfunktion, die einen solchen Überlauf verhindert.<br />
Ablaufdiagramm der XON/XOFF-Steuerung<br />
97
BASIC-Protokoll<br />
98<br />
BASIC-Protokoll<br />
Die folgenden Regeln wurden für das BASIC-Protokoll erstellt, um eine größere Zuverlässigkeit zu<br />
erreichen.<br />
• Bevor die sendende Seite Daten übertragen kann, muß bestätigt werden, daß die empfangende Seite<br />
bereit ist, die Daten zu empfangen.<br />
• Ein Paritätsbit wird den zu übermittelnden Daten hinzugefügt. Die empfangende Seite nutzt das<br />
Paritätsbit, um nach Übertragungsfehlern zu suchen und der sendende Seite zu melden, wenn ein<br />
Fehler entdeckt wurde.<br />
Diese grundlegenden Regeln werden die „Übertragungssteuerung“ genannt. Das BASIC-Protokoll<br />
benutzt folgende Codes, um die Übertragungssteuerung zu implementieren.<br />
Bezeichnung Code Name<br />
STX &H02 Start des Textes<br />
ETX &H03 Ende des Textes<br />
EOT &H04 Ende der Übertragung<br />
ENQ &H05 Untersuchung<br />
ACK &H06 Bestätigung<br />
NAK &H15 Negative Bestätigung<br />
Ablaufdiagramm des BASIC Protokoll<br />
(*1) BCC: Steht für „Block Check Character“. Dieser Code wird benutzt, um Übertragungsfehler zu<br />
finden, die vom horizontalen Paritätswert des Textes und des ETX-Codes bestimmt werden (ein Wert,<br />
der den Text und den ETX-Code einschließt und wie ein ausschließliches OR berechnet wird).
Wenn der Text „RUN“ gesendet wird (&H52,&H55,&H4E)<br />
BBC = (R) XOR (U) XOR (N) XOR (ETX)<br />
= (&H52) XOR (&H55) XOR (&H4E) XOR (&H03) = &H4A<br />
R 0101 0010<br />
U 0101 0101<br />
N 0100 1110<br />
XOR)ETX 0000 0011<br />
BASIC2 Protokoll<br />
BCC= 0100 1010=&H4A<br />
Der einzige Unterschied im BASIC2 Protokoll ist, daß nachdem die sendende Seite eine ACK-Code von<br />
der empfangenden Seite erhält, um einen normalen Empfang zu bestätigen, sendet die sendende Seite<br />
einen EOT-Code.<br />
Ablaufdiagramm des BASIC2-Protokolls<br />
Station (Kollision gesendeter Daten)<br />
Wenn zwei Leute gleichzeitig eine Konversation zur gleichen Zeit beginnen, ist es für keinen von beiden<br />
möglich, eine Nachricht zu übermitteln. Einer muß aufhören zu reden und dem anderen erlauben, zu<br />
sprechen. Genauso kann es bei der Nutzung vom BASIC Protokoll passieren, daß beide Seiten eine<br />
Datenübermittlung zur selben Zeit beginnen. In diesem Fall kollidieren die beiden zu übermittelnden<br />
Datensätze miteinander. Um genau zu sein, werden zwei ENQ-Codes zur selben Zeit gesendet, und<br />
diese beiden kollidieren miteinander.<br />
Um solche Kollisionen zu vermeiden, wird den beiden Stationen entweder der „erste-Station-Status“<br />
oder der „zweite-Station-Status“ zugewiesen. Wenn eine Kollision erfolgt, sendet die „erste Station“<br />
zuerst die Daten noch einmal. Die „zweite Station“ hält die versuchte Datenübermittlung im<br />
Pausenzustand, bis sie die Übertragung der ersten Station erhält und sendet dann die Daten erneut.<br />
99
Übertragungssteuerung per CS-Pin<br />
100<br />
Wie schon zuvor erwähnt, tritt ein Überlauf des Datenspeichers ein, wenn die Datenverarbeitung an der<br />
Eingangsseite nicht reibungslos funktioniert. Die XON/XOFF-Steuerung des TTY Protokoll stellt eine<br />
Methode dar, um einen solchen Überlauf durch Kontrolle des „Speicher beschäftigt“-Zustands zu<br />
verhindern. Dies wird durch Übertragen und Empfangen von Softwarecodes (DC1 und DC3)<br />
ermöglicht. Der CS-Pin stellt eine Hardwaremethode bereit, die den „Speicher beschäftigt“-Zustand<br />
steuert.<br />
Der CS-Pin wird der RS-232C-Schnittstelle Pinnummer 5 zugeordnet, das das Eingabesignal, das den<br />
„frei zur Sendung“-Status bestätigt, kontrolliert. Wird der CS-Eingang auf „L“ eingestellt, können die<br />
Daten, für die die Übertragung ermöglicht wurde, ausgegeben werden. Ist der Eingang auf „H“ gestellt,<br />
wird die Übertragung unterdrückt (nicht möglich).<br />
Im Normalfall speisen die Steuerung und das andere angeschlossene Zubehör ihre RS-Ausgabe<br />
(Pinnummer 4, die immer auf „L“ gestellt ist) direkt in ihren CS-Pin, wenn die CS-Steuerung nicht<br />
benutzt wird, so daß die Übertragung durchgehend möglich ist (siehe in der Beschreibung unten). Wenn<br />
Sie die CS-Steuerung benutzen, ist der CS-Ausgang des verbundenen Zubehörs mit dem CS-Pin der<br />
Steuerung verbunden. Dieser Ausgang ist auf „L“ gestellt , um eine Übertragung zu ermöglichen und<br />
auf „H“, um die Übertragung nicht zu unterdrücken.<br />
���� HINWEIS<br />
���� HINWEIS<br />
RS Steuerung<br />
Für die Protokollnummern 0-9 kann der CS-Pin nicht zur Übertragungssteuerung<br />
genutzt werden: Sogar wenn der CS-Eingang auf „H“ gestellt ist, kann es die<br />
Übertragung nicht steuern.<br />
Eine Übertragungssteuerung durch den CS (frei zur Sendung) Pin ist im SPEL III<br />
Version 3.2 oder früheren Versionen nicht möglich.<br />
Der RS-Ausgang ist immer auf „L“ gestellt, ungeachtet davon, ob er genutzt wird oder nicht. Daher ist<br />
es nicht möglich, die Steuerung Übertragungen zum verbundenen Zubehör der empfangenden Seite<br />
steuern zu lassen. Wenn Sie das TTY-Protokoll ohne die XON/XOFF Steuerung benutzen, beachten Sie,<br />
daß ein Datenstau auftreten kann, wenn Sie eine große Datenmenge vom angeschlossenen Zubehör zur<br />
Steuerung senden wollen.<br />
Anmerkung: CS Übertragung, wenn Sie das BASIC Protokoll benutzen<br />
Die <strong>Robotersteuerung</strong> benutzt einen seriellen Sonderchip, um RS-323C Kommunikationen zu steuern.<br />
Dieser Chip empfängt Anweisungen von der CPU und sendet Daten zum angeschlossenen Zubehör in<br />
Übereinstimmung mit dem Kommunikationsprotokoll, und transferiert die Daten zur CPU. So<br />
reduziert der serielle Chip die Arbeitslast des CPU während des Kommunikationssteuerungsbetriebs.<br />
Eine Übertragungssteuerung per CS-Signal kann mit dem seriellen Chip durchgeführt werden. In<br />
diesem Fall sendet das BASIC Protokoll aber, wie unten beschrieben, zwei ENQ-Codes.<br />
Wenn der CPU einen ENQ-Code sendet, während das CS-Signal auf H eingestellt ist, wird der ENQ-<br />
Code vom seriellen Chip empfangen, kann aber nicht zum angeschlossenen Zubehör gesendet werden<br />
und wird statt dessen intern gespeichert. Die CPU erkennt dann, daß keine Antwort vom verbundenen<br />
Zubehör erhalten wurde und nach einer spezifizierten TimeoutZeitspanne, sendet sie erneut einen<br />
ENQ-Code. Hat der serielle Chip einmal einen ENQ-Code erhalten (den er nicht senden kann), bleibt<br />
er im Standby-Status bis der ENQ-Code gesendet werden kann. Wenn das CS-Signal auf L eingestellt<br />
ist, werden zwei ENQ-Codes, die von der CPU gesendet wurden, vom seriellen Chip zum<br />
angeschlossenen Zubehör gesendet.
RS-232C Schnittstelle<br />
Die RS-323C Signalzeilen sind unten aufgeführt.<br />
Pinnummer (D-Sub 9) Pinnnummer (D-Sub 25) Bezeichnung E/A Signalname<br />
FG (Erde)<br />
1 8 CD Eingang Trägerkennung<br />
2 3 RD Eingang Datenempfang<br />
3 2 SD Ausgang Datensendung<br />
4 20 ER Ausgang Zubehör bereit<br />
5 7 SG - Signalerde<br />
6 - - - -<br />
7 4 RS Ausgang Sendungsanfrage<br />
8 5 CS Eingang Frei für Sendung<br />
9 - - - -<br />
- 6 DR Eingang Datensatz bereit<br />
- 1 FG - Erde<br />
Erde für Wartungszwecke und zur Sicherheit.<br />
SD (Datensendung)<br />
Dies ist eine serielle Datensignalkette, die Daten an die empfangende Seite sendet.<br />
RD (Datenempfang)<br />
Dies ist eine serielle Datensignalzeile, die Daten von der sendenden Seite empfängt.<br />
RS (Sendungsanfrage)<br />
Wenn der Ausgang auf „L“ gestellt ist, funktioniert die RS-Steuerung nicht. Wird das CS-Signal nicht<br />
für die Datenübertragung benutzt, ist der RS Ausgang der Eingang zum CS-Pin.<br />
CS (Frei zur Sendung)<br />
Dieses Signal liefert eine Meldung, daß die Übertragung möglich ist. Wird das CS-Signal zur<br />
Übertragungssteuerung genutzt, ist die Übertragung möglich, wenn das Signal auf „L“ gestellt ist, und<br />
wird unterdrückt, wenn das Signal auf „H“ steht.<br />
ER (Zubehör bereit)<br />
Diese Signal informiert das Zubehör, daß die Übertragung möglich ist. Es ist auf ON (L) gestellt, wenn<br />
die <strong>Robotersteuerung</strong> hochgefahren wird. Wenn Sie MS-DOS benutzen, wird es auf ON gestellt, wenn<br />
der RS-323C-Treiber installiert ist.<br />
DR (Datensatz bereit)<br />
Das Signal wird auf ON gestellt, wenn das verbundene Zubehör bereit ist zur Datenübertragung.<br />
CD (Trägerkennung)<br />
Das Signal wird auf ON gestellt, wenn der Fernsteuerungsträger normal empfangen wird.<br />
101
102<br />
• Anfertigung von sich kreuzenden Kabeln<br />
Die RS-323C Schnittstelle ist ein Standard, der zur Verbindung von DTEs und DCEs (*1) entwickelt<br />
wurde.<br />
Die RS-323C-Schnittstelle wird für die serielle Kommunikation zwischen verschiedenen Arten von<br />
Zubehör benutzt. Natürlich benutzen unterschiedliche Einrichtungen die Signalketten unterschiedlich,<br />
und deshalb ist eine unterschiedliche Verdrahtung erforderlich.<br />
(*1) DTE steht für Data Terminal Equipment, wie z.B. Computer.<br />
DCE steht für Data Circuit Terminating Equipment, wie z.B. Modems.<br />
Verdrahten Sie die Kabel gemäß der folgenden Verdrahtungspläne.<br />
<br />
(*2) Die Anwendereinrichtung in dem oberen Plan bezieht sich auf Einrichtungen (wie<br />
PCs oder Anzeigesysteme), die die RS-323C Schnittstelle benutzen.<br />
<br />
Im zweiten Verdrahtungsplan benutzt der CS-Eingang auf der Steuerungsseite den RS-Ausgang der<br />
Anwendereinrichtung, aber die Verdrahtung kann geändert werden, so daß sie zur Steuerungsmethode<br />
der Anwendereinrichtung paßt.<br />
Da die Steuerung die RS-Steuerung nicht ausführt, kann die Steuerung nicht zur Übertragungssteuerung<br />
von der Anwendereinrichtung genutzt werden
• Herstellung von Steckanschlüssen an Kabeln<br />
Das Abschirmen sollte wie folgt behandelt werden.<br />
1.) Nach dem Entfernen der Abschirmung befestigen Sie einen Kabelbinder an dem Kabel.<br />
2.) Befestigen Sie die Kappe auf dem Steckanschluß.<br />
103
7.2 Die Kommunikation zwischen den Robotern<br />
104<br />
Wenn ein System hergestellt wird, welches verschiedene Roboter einschließt, dann wird eine Art<br />
ineinandergreifender Mechanismus benötigt, um die Datenübertragung oder andere Abläufe zwischen<br />
zwei oder mehr Robotern zu gewährleisten. Die Verbindung der Roboter über die RS-232C-Schnittstelle<br />
ermöglicht, daß Roboter-Tätigkeiten über das Anwenderprogramm spezifiziert und ausgeführt werden<br />
können.<br />
Konfigurationseinstellungen<br />
���� HINWEIS Wenn Sie die RS-232C-Schnittstelle für die Kommunikation nutzen, muß dieselbe<br />
Konfiguration an beiden Kommunikationsstationen eingestellt sein. Verwenden<br />
Sie den CONFIG-Befehl (beschrieben in dem Kapitel 7.1), um die Konfiguration<br />
einzustellen.<br />
Kommunikationsbezogene Befehle<br />
Stellen Sie sicher, daß eine Station als Primärstation und die andere als<br />
Sekundärstation eingestellt ist, wenn Sie das BASIC-Protokoll verwenden, um<br />
eine Kollision während der Datenübertragung zu vermeiden.<br />
Verwenden Sie kommunikationsbezogene Befehle, die von SPEL III unterstützt werden, um die<br />
Kommunikation zwischen den Robotern einzustellen und um sie ausführen zu können. Diese SPEL IIIunterstützten<br />
Befehle sind wie folgt.<br />
PRINT # Datenausgabe an die serielle Schnittstelle.<br />
INPUT #<br />
Dateneingabe von der seriellen Schnittstelle.<br />
LINE INPUT # Fügen Sie eine Zeile Eingangsdaten von der seriellen Schnittstelle als eine<br />
Zeichenkettenvariable ein.<br />
CONFIG Stellen Sie die Konfiguration der RS-232C-Schnittstelle ein.<br />
LOF( ) Sorgt für die Rückgabe der Zeilenanzahl der erhaltenen Daten im RS-232C-<br />
Speicher.<br />
CONSOLE Konsolenspezifizierung, wenn der S.NET-Modus eingestellt ist.<br />
STAT( ) Ermöglicht die Wiederherstellung des Status‘ der Steuerung, die über die RS-<br />
232C-Schnittstelle angeschlossen ist.<br />
Spezielle Anwendungsmethoden für kommunikationsbezogene Befehle<br />
Dieser Abschnitt beschreibt vier typische kommunikationsbezogene Befehle.<br />
• Datenübertragung<br />
• Überprüfung der Dateneingabe<br />
• Lesestatus<br />
• Ineinandergreifen der Roboter<br />
Alle vier Befehle werden unter folgenden Umständen wirksam.<br />
Roboter A<br />
RS-232C-Schnittstelle #20 ←⎯⎯→<br />
Roboter B<br />
RS-232C-Schnittstelle #20
• Datenübertragung<br />
Verwenden Sie die PRINT- und INPUT-Befehle für die Übertragung von numerischen Daten zwischen<br />
den Robotern.<br />
<br />
Das Ausgabebit (1 oder 2) von Roboter A ist auf ON eingestellt, gemäß dem numerischen Wert (1 oder<br />
2), der von Roboter B gesendet wurde.<br />
Roboter A<br />
100 INPUT #20,A<br />
110 IF A=1 THEN ON1<br />
120 IF A=2 THEN ON2<br />
<br />
Roboter B<br />
100 PRINT #20,A<br />
Roboter A erhält Daten von Roboter B, und das Ausgabebit von Roboter A ist gemäß dem erhaltenen<br />
Datenwert auf ON eingestellt. Wenn Roboter A den INPUT-Befehl ausführt, bevor er Daten von Roboter<br />
B erhalten hat, wird Roboter A mit der Ausführung des INPUT-Befehls warten, bis er die Daten von<br />
Roboter B erhält. Alternativ kann Roboter B den PRINT-Befehl verwenden, um Daten zu senden, bevor<br />
Roboter A seine Dateneingabe beginnt.<br />
• Wenn Sie das BASIC-Protokoll verwenden, können bis zu 20 Datenmeldungen im voraus<br />
gesendet werden. Wenn Roboter B mehr als 20 Meldungen im voraus sendet, wartet er mit<br />
der Ausführung des PRINT-Befehls, bis Roboter A die Meldungen über den INPUT-Befehl<br />
angenommen hat.<br />
• Wenn Sie die XON/XOFF-Steuerung mit einem TTY-Protokoll verwenden, können bis zu 20<br />
Meldungen plus 80 Datenbytes im voraus gesendet werden. Wird diese Menge jedoch<br />
überschritten, wartet Roboter B im PRINT-Befehl, bis Roboter A die Meldungen über den<br />
INPUT-Befehl angenommen hat.<br />
• Wenn Sie nicht die XON/XOFF-Steuerung mit dem TTY-Protokoll verwenden, kann dann<br />
ein Überlauf auftreten, wenn mehr als 20 Meldungen plus 120 Datenbytes erhalten werden.<br />
• Wenn Sie die PRINT- und INPUT-Befehle verwenden, muß die Anzahl der PRINT-<br />
Ausführungen dieselbe sein wie die der INPUT-Ausführungen. Die Anzahl der numerischen<br />
Datenketten, die vom PRINT-Befehl bearbeitet wird, muß ebenfalls dieselbe sein wie die<br />
Anzahl, die durch den INPUT-Befehl bearbeitet wird. Stimmt die Anzahl der Datenketten<br />
nicht überein, tritt ein Fehler auf (Fehler 30).<br />
105
106<br />
• Überprüfung der Dateneingabe<br />
Wenn der INPUT-Befehl ausgeführt wird, wartet der Roboter solange mit der Ausführung des INPUT-<br />
Befehls, bis die Daten empfangen wurden. Das ist jedoch nicht besonders effizient, um das Programm zu<br />
implementieren. Eine effizientere Methode ist die Verwendung der LOF( )-Funktion, um die Menge der<br />
erhaltenen Daten zurückzusenden.<br />
<br />
Verwenden Sie die LOF( )-Funktion, um zu überprüfen, ob die Daten von Roboter B zu Roboter A<br />
gesendet wurden oder nicht. Wurden die Daten gesendet, führt der Roboter den INPUT-Befehl aus, um<br />
die Daten einzugeben. Wurden die Daten nicht gesendet, führt der Roboter andere Arbeiten aus.<br />
Roboter A Roboter B<br />
100 IF LOF(20) =0 THEN GOSUB 200<br />
ELSE GOSUB 1000<br />
100 PRINT #20,A<br />
110 GOTO 100<br />
200 ′PROGRAM1<br />
M<br />
900 RETURN<br />
M<br />
1000 INPUT #20,A<br />
M<br />
1100 RETURN<br />
<br />
Bevor der INPUT-Befehl ausgeführt wird, verwendet Roboter A die LOF( )-Funktion, um die<br />
empfangenen Daten zu überprüfen.<br />
Wurden die Daten empfangen, führt der Roboter den INPUT-Befehl mit den eingefügten Daten als<br />
Variable A in der Zeile 1000 aus. Nach Zeile 1000 wird das Programm ausgeführt.<br />
Wurden die Daten nicht empfangen, führt Roboter A das Unterprogramm ab Zeile 200 aus und kehrt<br />
dann zu Zeile 100 zurück.
• Lesestatus<br />
Werden Operationen von zwei oder mehr Robotern ausgeführt, kann die Programmierung der<br />
Tätigkeiten eines Roboters erfordern, daß er in der Lage ist, die Tätigkeiten der anderen Roboter zu<br />
kontrollieren. In diesem Fall können Sie die STAT( )-Funktion verwenden, um den Status der anderen<br />
Roboter, die über die RS-232C-Schnittstelle angeschlossen sind, zu überprüfen.<br />
Bei der Ausführung der STAT( )-Funktion, wird die Statusinformation des Zielroboters als 3-Byte-Daten<br />
empfangen. Verwenden Sie den AND-Befehl, um die Statusbits in den Daten zu verbergen und die<br />
Information herauszuziehen.<br />
Bit Steuerungsstatus, wenn der Bit-Status auf ON eingestellt ist<br />
0 bis15 Status der E/A-Speicherbits 0 bis 15 ist ON<br />
16 Status der Startausgabe von REMOTE2 ist ACTIVE<br />
17 Status der Pausenausgabe von REMOTE2 ist ACTIVE<br />
18 Status der Fehlerausgabe von REMOTE2 ist ACTIVE<br />
19 bis 23 Undefiniert<br />
<br />
Stellen Sie eine bedingte Verzweigung basierend auf der Status-Bit-Information des anderen Roboters<br />
ein (E/A-Speicherbit 7).<br />
Roboter A Roboter B<br />
100 A=STAT(20) AND &H80<br />
110 IF A0 THEN GOTO 1000<br />
M<br />
1000 ′PROGRAM1<br />
<br />
100 IF SW(3) =1 THEN ON $7<br />
ELSE OFF $7<br />
Nachdem Roboter A die Statusinformation von Roboter B erhalten hat, geben Sie den AND-Befehl ein,<br />
um die Statusbits zu verbergen und den Status des E/A-Speicherbits 7 zu überprüfen. Wenn das E/A-<br />
Speicherbit 7 von Roboter B auf ON eingestellt ist, führen Sie das Programm beginnend in Zeile 1000<br />
aus. Alternativ kann der Status der Eingabe der Bit-Nummer 3 von Roboter B genutzt werden, um den<br />
E/A-Speicherstatus auf ON oder OFF einzustellen.<br />
<br />
Stellen Sie eine bedingte Verzweigung ein, die auf der Status-Bit-Information (Fehlerausgabe) des<br />
anderen Roboters basiert.<br />
Roboter A<br />
100 A=STAT(20) AND &H40000<br />
110 IF A0 THEN GOTO 1000<br />
M<br />
1000 ’ERR1<br />
<br />
Roboter B<br />
Roboter A überprüft die Fehlerausgabe von Roboter B. Wenn ein Fehler bei Roboter B aufgetreten ist,<br />
führen Sie ab Zeile 1000 das beschriebene Fehlerverarbeitende Programm aus.<br />
M<br />
M<br />
M<br />
107
108<br />
• Sperre zwischen den Roboter<br />
Teilen sich zwei oder mehr Roboter dieselben Positionsdaten, wird eine Sperre benötigt, um Kollisionen<br />
zwischen den Roboterarmen zu vermeiden. Der E/A-Speicher kann genutzt werden, um solch eine<br />
Sperre einzurichten.<br />
<br />
Roboter A und Roboter B teilen sich den Punkt P1. Beide können arbeiten, wenn die folgende Sperre<br />
verwendet wird.<br />
Roboter A<br />
100 FUNCTION ROBOT1<br />
110 HOME<br />
120 ON #20, $2<br />
130 WAIT SW($1) =1<br />
140 OFF $1<br />
150 JUMP P1; JUMP P2<br />
160 GOTO 120<br />
170 FEND<br />
Roboter B<br />
100 FUNCTION ROBOT2<br />
110 HOME<br />
120 WAIT SW($2) =1<br />
130 OFF $2<br />
140 JUMP P1; JUMP P3<br />
150 ON #20, $1<br />
160 GOTO 120<br />
170 FEND<br />
Hinweis: P1 ist der Positionierungspunkt, der von Roboter A und Roboter B geteilt wird. P2 und P3 sind<br />
Positionierungspunkte innerhalb der Sicherheitszone, um Kollisionen der Roboterarme vorzubeugen.<br />
<br />
Roboter A’s E/A-Speicherbit 1 und Roboter B’s E/A-Speicherbit 2 werden als Markierung für die Sperre<br />
genutzt.<br />
Hat Roboter A die Zeile 120 erreicht und der E/A-Speicher von Roboter B wurde auf ON eingestellt<br />
(was den Betrieb von Roboter B ermöglicht), dann wartet Roboter A an der Zeile 130, bis sein eigener<br />
E/A-Speicher auf ON eingestellt wurde. Nachdem Roboter B seine Tätigkeit an dem gemeinsamen<br />
Positionierungspunkt (P1) abgeschlossen hat, springt er zum Positionierungspunkt P3, der sich in der<br />
Sicherheitszone befindet. Dann wird der E/A-Speicher von Roboter A auf ON eingestellt (was den<br />
Betrieb von Roboter A ermöglicht).<br />
Somit kann eine Sperre unter Verwendung von „ON #m, $n“ oder „OFF #m, $n“ eingerichtet werden,<br />
um den E/A-Speicher des anderen Roboters zu verändern.
7.3 Kommunikation zwischen Robotern und Anwendereinrichtungen<br />
Jedes System, das einen Roboter verwendet, benötigt möglicherweise die Übertragung numerischer oder<br />
Textdaten zwischen der Anwendereinrichtung (z.B. Computer, visuelle Systeme, etc., die eine RS-232C-<br />
Schnittstelle benutzen) und dem Roboter. In diesem Punkt wird beschrieben, wie das Senden und<br />
Empfangen von Daten funktioniert.<br />
Datenformat<br />
Der ASCII-Code ist das Datenformat, welches für die Übertragung der Daten verwendet wird.<br />
Der ASCII-Code für „8“ ist „&H38“ und für „+“ „&H2B“.<br />
Der empfangene ASCII-Code wird direkt als Zeichenkette genommen, so daß diesem Format keine<br />
besondere Beachtung geschenkt werden muß. Es ist jedoch wichtig das Ausdrucksformat und die<br />
wichtigen Ziffern beim Senden oder Empfangen von numerischen Daten zu beachten. Darüber hinaus<br />
muß die sendende Seite numerische Daten senden, die sich innerhalb eines von der empfangenden Seite<br />
festgelegten Bereichs befinden. Das Roboter-Ausgabeformat für zu sendende Daten und das Eingabe-<br />
Format für zu empfangende Daten sind beide vordefiniert. Sie müssen daher sicherstellen, daß sich die<br />
zu übermittelnden Daten im Definitionsbereich befinden.<br />
Sendende Seite Empfangende Seite<br />
Zeichendatenübertragung A → &H41 ⎯→ &H41 → A<br />
Übertragung numerischer Daten -12,345E-1 → ASCII-Daten ⎯→ ASCII-Daten → ?<br />
Während der Übertragung numerischer Daten konvertiert die sendende Seite die numerischen in ASCII-<br />
Daten und sendet dann die Daten an die empfangende Seite. Die empfangende Seite muß dann die<br />
Daten wieder in numerische Daten konvertieren. Wenn jedoch die empfangende Seite ASCII-Daten<br />
empfängt, die nicht genau den konvertierten numerischen Daten entsprechen, können die resultierenden<br />
numerischen Daten von den ursprünglich gesendeten abweichen.<br />
Nachfolgend finden Sie die Ein- und Ausgabeformate der Robotoren:<br />
- Eingabeformat: Siehe Eingabeformat beim Senden von der Anwendereinrichtung zum Roboter<br />
- Ausgabeformat: Siehe Ausgabeformat beim Senden vom Roboter zur Anwendereinrichtung<br />
109
110<br />
• Eingabeformat<br />
Numerische Ausdrücke<br />
Die folgenden Anzahlen von Zeichen können genutzt werden.<br />
Formale Zahlen: 7 Ziffern<br />
Bezeichnende Zahlen: 6 Ziffern<br />
Die folgenden Ausdrucksformate werden unterstützt.<br />
<br />
Eingabeformat Eingabedaten<br />
+123,12<br />
0,12345E1<br />
-97,156E-1<br />
-97<br />
0,1267<br />
Datenausdrücke<br />
123,12<br />
1,2345<br />
-9,7156<br />
-97<br />
0,1267<br />
Die Zahlen, die in einer Zeile der Eingabedaten enthalten sind, werden als Variablen gemäß den<br />
folgenden Regeln gehandhabt.<br />
Abgesehen von „±“ werden alle Zeichen und Leerzeichen, die auf eine Zahl folgen, ignoriert.<br />
Wenn zwei oder mehr Zahlenwerte vorhanden sind, muß wenigstens ein Begrenzer (*1) zwischen jedem<br />
Paar der Zahlenwerte eingefügt werden.<br />
Wenn ein Zeichen (wie beispielsweise ein Buchstabe) auf eine Zahl folgt, werden alle Daten bis zum<br />
nächsten Begrenzer ignoriert. Wird „E“ als Vertreter verwendet, wird es als eine Zahl angesehen.<br />
(*1) Leerzeichen oder Kommata können als Begrenzer verwendet werden.<br />
<br />
Eingabedaten Erkannter Zahlenwert<br />
DV-123,56E-3<br />
+123,45E-3 -97,45<br />
A0=95,62 A1=87,654<br />
• Ausgabeformat<br />
-123,56 x 10 -3<br />
123,45 x 10 -3 und –97,45<br />
0 und 1<br />
Die <strong>Robotersteuerung</strong> drückt numerische Ausgabedaten nach den folgenden Regeln aus.<br />
Ganze Zahlenwerte werden als ganz ausgegeben. Ein Leerzeichen wird für positive Werte eingefügt.<br />
Reale Zahlenwerte werden als reale Zahlen ausgegeben. Aber wenn die Anzahl der Ziffern zu groß ist,<br />
wird der ausgegebene Datenausdruck wie folgt normalisiert (wenn die formale Zahl 7 Ziffern<br />
überschreitet).<br />
± , Ε±<br />
Wurden verschiedene Zahlenwertreihen ausgegeben, wird ein Leerzeichen zwischen jeder<br />
Zahlenwertreihe eingefügt
Programm für die Kommunikation mit dem Anwendereinrichtung<br />
• Kommunikation mit dem TTY-Protokoll<br />
Die Kommunikation mit dem TTY-Protokoll ist eine Methode, bei der ein CR-Code (&H0D) als<br />
Terminator zu den Daten hinzugefügt wird (wie bereits in Kapitel 7.1 beschrieben).<br />
<br />
Inhalt der Übertragung Darstellung der gesendeten Daten<br />
Senden von „8“ und „7“<br />
Senden von „12“<br />
Senden von „-1,3“<br />
���� HINWEIS<br />
(&H38) (&H20) (&H37) (&H0D)<br />
(&H31) (&H32) (&H0D)<br />
(&H2D) (&H31) (&H2E) (&H33) (&H0D)<br />
Bei der Kommunikation mit dem TTY-Protokoll gibt es keine<br />
Fehlerkorrekturmethode für Probleme wie z.B. Übertragungsfehler. Deshalb sollte<br />
statt dessen das BASIC-Protokoll verwendet werden, wann immer es möglich ist.<br />
• Kommunikation mittels des BASIC-Protokolls<br />
Die Kommunikation mittels des BASIC-Protokolls ist eine verläßlichere Kommunikationsmethode, die<br />
einen Ermittlungscode (ENQ) und Kontrollzeichen (STX, ETX und BCC) zur Datenübertragung<br />
hinzufügt (siehe auch Kapitel 7.1).<br />
Die beiden unten gezeigten Ablaufdiagramme beschreiben ein Roboterkommunikationsprogramm, daß<br />
das BASIC-Protokoll nutzt. Kreieren Sie ein auf diesen Ablaufdiagrammen basierendes Programm,<br />
wenn Sie numerische Daten zwischen den Robotern übertragen wollen.<br />
Ablaufdiagramm 1: Um Daten mit Hilfe des BASIC-Protokolls zu senden<br />
111
112<br />
Nachdem ein ENQ-Code gesendet wurde, wartet die sendende Seite auf die Rückgabe eines ACK-Codes.<br />
Wird der ACK-Code nicht innerhalb einer bestimmten Zeitspanne zurückgesendet, tritt ein<br />
Timeoutfehler auf. Wird jedoch ein ACK-Code zurückgegeben, dann schickt die sendende Seite eine<br />
Datenkette, die von STX- und ETX-Codes umgeben ist und von einem BCC-Code ergänzt wird.<br />
Schließlich akzeptiert die sendende Seite den ACK-Code und beendet die Übertragung (normaler<br />
Abschluß). Wird der ACK-Code jedoch nicht zurückgeschickt, versucht die sendende Seite dreimal, die<br />
von STX- und ETX-Codes umgebenden Daten zu übermitteln.<br />
Wenn, nachdem ein ENQ-Code gesendet wurde, ein ENQ- anstatt eines ACK-Codes zurückgegeben<br />
wurde, ereignet sich ein Übertragungsfehler. In diesem Fall überträgt die sendende Seite einen NAK-<br />
Code. Handelt es sich um eine Primärstation, wird nach dem Empfang des NAK-Codes erneut ein ENQ-<br />
Code gesendet. Handelt es sich jedoch um eine Sekundärstation, erhält sie von der Primärstation alle<br />
übertragenen Daten und sendet dann einen weiteren ENQ-Code.<br />
Ablaufdiagramm 2: Um Daten mit Hilfe des BASIC-Protokolls zu erhalten<br />
Die empfangende Seite wartet auf einen ENQ-Code. Erhält sie ihn, sendet sie einen ACK. Dann erhält<br />
die empfangende Seite Daten, die von STX- und ETX-Codes umgeben sind und verwendet den BCC-<br />
Prüfsummen-Code für die Fehlerkontrolle. Wurden keine Fehler gefunden, sendet diese Seite einen<br />
ACK-Code und beendet die Tätigkeit. Weist der BCC-Prüfsummen-Code auf einen Fehler hin, überträgt<br />
sie einen NAK-Code und wartet auf eine weitere, von STX- und ETX-Codes umgebende Datenkette, die<br />
gesendet werden soll.<br />
Werden in einer bestimmten Zeitspanne keine Daten gesendet, tritt ein Timeoutfehler auf. Wenn der<br />
ETX-Code nicht empfangen wurde, tritt der Timeoutfehler oder der Speicherüberlauffehler auf.
Beispiel für ein BASIC-Programm<br />
Das folgende ist ein Kommunikationsprogramm, das in der BASIC-Programmiersprache geschrieben<br />
wurde und das BASIC-Protokoll verwendet. Um Daten zu senden, stellt dieses Programm die<br />
Datenübertragung auf die Zeichenkette „SEND$“ ein und ruft ein Übertragungsunterprogramm auf, das<br />
in der Zeile 2000 startet.<br />
Um Daten zu empfangen, ruft dieses Programm ein Empfangsunterprogramm auf, das in der Zeile <strong>300</strong>0<br />
beginnt und die empfangenen Daten auf die Zeichenkette „RCVCHR$“ einstellt.<br />
<br />
113
7.4 Die Kommunikation zwischen Hauptrechner und Roboter<br />
114<br />
Bei der Konfiguration eines Systems, das einen oder mehr Roboter einschließt, kann es sein, daß der<br />
Roboter nicht nur mit der Anwendereinrichtung kommunizieren können muß (z.B. Übertragung<br />
numerischer Daten), sondern auch mit einem Computer, der als Hauptrechner fungiert und dadurch<br />
Tätigkeiten des Roboters (wie die folgenden) steuert.<br />
• Aktivierung und Abschalten des Roboters<br />
• Programmübertragung<br />
• Lesen des Roboterstatus‘, etc.<br />
Dieses Kapitel beschreibt, wie ein Programm hergestellt wird, daß den Computer befähigt, als<br />
Hauptrechner zu funktionieren.<br />
Die Konsole<br />
Um den Computer zu befähigen, als Hauptrechner zu funktionieren, muß der Computer als Konsole<br />
(Haupteinrichtung für die Ein- und Ausgabe) im AUTO-Modus spezifiziert werden. In diesem Fall<br />
bedeutet „Konsole“ einfach die Einrichtung, um den Roboter zu steuern. Weitere Informationen erhalten<br />
Sie in Kapitel 1.4 „Modus“ in der Einführung zur Konsole.<br />
���� HINWEIS<br />
Der Hauptrechner sollte über die RS-232C-Schnittstelle Nr. 20 oder 21 der<br />
Steuerung angeschlossen sein. Dazu müssen Sie die Schnittstelle mit dem PC als<br />
Konsole anschließen.<br />
Die bedingten Erweiterungen der RS-232C-Schnittstelle (Schnittstellen Nr. 22 und 23) können nicht für<br />
die Konsole verwendet werden.<br />
Das Folgende ist ein Beispielablauf, um die RS-232C-Schnittstelle (Nr. 20 oder 21) als Konsole<br />
zuzuweisen.<br />
Zuweisungsablauf für die RS-232C-Schnittstelle Nr. 20 als eine Konsole<br />
1. Verwenden Sie den SPEL-Editor oder SPEL für Windows, um die Konfiguration der RS-232C-<br />
Schnittstelle für die Konsole einzurichten.<br />
>CONFIG #20,2,1,3,0 ′Der Wert nach #20 ist abhängig vom PC.<br />
2. Spezifizieren Sie die Konsole für den AUTO-Modus.<br />
>CONSOLE #20<br />
3. Verbinden Sie den Hauptrechner mit der RS-232C-Schnittstelle Nr.20, stellen Sie den<br />
Betriebsmodus der Steuerung auf AUTO ein. Dann ist die Konsole der RS-232C-Schnittstelle Nr.<br />
20 zugewiesen. In diesem Fall wird der Modus als S.NET bezeichnet.<br />
4.<br />
Warnung<br />
Führen Sie die Einrichtung nicht aus, wenn der PC an die RS-232C-Schnittstellen<br />
Nr. 20 oder 21 angeschlossen ist, weil der Notschalter in diesem Fall nicht als<br />
Notschalter funktioniert. Unter diesen Umständen ist es gefährlich, den Roboter<br />
zu bewegen.<br />
Während des Debuggens eines Programms mit dem PC, der mit der RS-232C-<br />
Schnittstelle Nr. 20 oder 21 verbunden ist, wenn Sie den Roboter bewegen, ist es<br />
erforderlich, das Handprogrammiergerät (TP-<strong>320</strong>/TP-<strong>320</strong>J) oder die OPU-<strong>300</strong>,<br />
welche an die TEACH-Schnittstelle angeschlossen sind, in der Hand zu halten,<br />
um im Notfall den NOT-AUS-Schalter drücken zu können.
Der Unterschied zwischen S.NET und dem TEACH-Modus<br />
Es gibt keine Unterschiede zwischen dem S.NET-Modus und dem TEACH-Modus, solange der Roboter<br />
durch Befehle vom PC gesteuert wird. Wurde jedoch der S.Net-Modus für den AUTO-Modus bestimmt,<br />
unterscheiden sich Merkmale, die die Sicherheit betreffen wie z.B. Spannungszustand, Pausenzustand<br />
und Sicherheitsabschrankung. Im S.NET-Modus kann das Programm nicht mit geöffneter<br />
Sicherheitsabschrankung ausgeführt werden. Die Eingabe von PAUSE ausgehend von REMOTE ist<br />
gültig. (Siehe auch die folgende Tabelle.)<br />
Eingang Sicherheitsabschrankung<br />
TEACH-Modus S.NET<br />
Der Roboter kann im Low-Power-Modus<br />
betrieben werden.<br />
PAUSE-Status<br />
NOT-AUS-Schalter des PC-Kabels Möglich Nicht möglich<br />
Eingabe von PAUSE von der OPU-<br />
<strong>300</strong> aus<br />
Eingabe von PAUSE von REMOTE<br />
aus<br />
<strong>Robotersteuerung</strong>sprogramm<br />
Nicht möglich Möglich<br />
Nicht möglich Möglich<br />
Soll ein Roboter über einen Hauptrechner kontrolliert werden, so muß ein Kommunikationsprogramm<br />
erstellt werden, um die Datenübertragung zwischen Hauptrechner und Roboter zu ermöglichen.<br />
Folgende 8 Punkte beschreiben diese Art eines Roboterkontrollprogramms.<br />
• Zurücksetzen<br />
• Grundablauf<br />
• Steuerungscodes<br />
• Ablauf der LIST-, PLIST- und DIR-Befehle<br />
• Ablauf der SAVE- und MERGE-Befehle<br />
• Schnellspeicherung mit SAVE<br />
• LOAD-Ablauf<br />
• Zufuhr per JOG-Verfahren<br />
• Zurücksetzen<br />
Senden Sie folgenden RESET-Code, um die Steuerung zurückzusetzen.<br />
(SOH) (DC3) = (&H01) (&H13)<br />
Diese Methode funktioniert unabhängig vom aktuellen Zustand der Steuerung. Die Steuerung sendet<br />
folgenden Code zurück, nachdem sie zurückgesetzt wurde.<br />
(>) = (&H3E)<br />
Der RESET-Code sendet sich selbst, ohne andere Kontrollzeichen wie z.B. CR, ENQ, STX oder ETX.<br />
Der RESET-Code ist nur dann wirksam, wenn er von der Konsole gesendet wurde.<br />
Dieses RESET-Verfahren kann genutzt werden, um die Programmausführung anzuhalten,<br />
Ausgabeschnittstellen einzurichten, den E/A-Speicher auf OFF zu stellen und die SPEED- und ACCEL-<br />
Einstellungen zu initialisieren. Dieses Verfahren kann jedoch nicht für Fehlerbehebung und das<br />
Löschen des NOT-AUS-Zustands verwendet werden. Führen Sie den RESET-Befehl aus, wenn<br />
Fehlerbeseitigung und/oder das Löschen des NOT-AUS-Zustands notwendig ist. (Siehe auch<br />
„Grundablauf“ auf der nächsten Seite.)<br />
115
116<br />
• Grundablauf<br />
Um die Funktionen der Steuerung auszuführen (SPEL III-Befehle), muß jeder Befehl im ASCII-Code an<br />
die Steuerung gesendet werden. Die Steuerung übersetzt den ASCII-Code, den sie erhält und führt die<br />
entsprechenden Befehle aus.<br />
Entweder kann TTY (kein Protokoll) oder das BASIC-Protokoll verwendet werden. Letzteres wird<br />
jedoch aufgrund seiner höheren Verläßlichkeit empfohlen.<br />
Ablaufdiagramm 3 zeigt den Grundablauf, um Steuerungsmeldungen abzustimmen.<br />
Zuerst wird ein Befehl über den Computer eingegeben und als ASCII-Code an die Steuerung gesendet.<br />
Der Computer wartet dann auf eine Meldung von der Steuerung. Ist die Meldung „>“, wartet die<br />
Steuerung auf Eingaben vom Computer. Wenn die Meldung nicht „>“ ist, akzeptiert der Computer die<br />
Meldung und wartet auf weitere Eingaben von der Steuerung.<br />
Verwenden Sie für die „Befehlsübertragung an die Steuerung“ (siehe Ablaufdiagramm) das<br />
Sendeprogramm und für die „Meldungseingabe von der Steuerung“ das Empfangsprogramm. Beide<br />
Programme sind in Kapitel 7.3 beschrieben.<br />
Ablaufdiagramm 3: Grundablauf, um Kontrollmeldungen zu kommunizieren
Senden des RUN-Befehls an den Roboter<br />
TTY-Protokoll (kein Protokoll)<br />
BASIC-Protokoll<br />
117
118<br />
• Steuerungscodes<br />
Steuerungscodes werden gesendet, um die Programmausführung zu stoppen und neu zu starten. Die<br />
folgenden Steuerungscodes müssen gesendet werden, wenn entweder die „TTY-Protokoll“-Methode oder<br />
die „BASIC-Protokoll“-Methode angewandt wird.<br />
Pause, Fortsetzung, Ausführung eines Schrittes oder Stop<br />
Um ein Programm, das ausgeführt wird, zu steuern, senden Sie bitte jeden der folgenden<br />
Steuerungscodes.<br />
Steuerungscode Beschreibung<br />
(DC3) (ESC) Programmpause<br />
(DC3) (A) Fortsetzung der Programmausführung nach einer Pause<br />
(DC3) (space) Ausführung eines Schrittes nach einer Pause<br />
(DC3) (Q) Stop der Programmausführung nach einer Pause<br />
Zustand von Übertragungsanforderung und Übertragungsantwort<br />
Der Zustand von Übertragungsanforderung und Übertragungsantwort entspricht der SPEL III-STAT( )-<br />
Funktion. Verwenden Sie den folgenden Ablauf, um das Senden des Zustandes an die Steuerung<br />
anzufordern.<br />
1. Der Hauptrechner sendet DC1 an die Steuerung.<br />
2. Wenn die Steuerung DC1 empfängt, sendet sie an den Hauptrechner den DC2-Code, der<br />
durch eine 6-Byte-Hexadezimal-Version der 3-Byte-Zustandsdaten ergänzt wird.<br />
Ändern des E/A-Speichers<br />
Das Ändern des E/A-Speichers entspricht den SPEL III-Befehlen ON #m, $n und OFF #m, $n.<br />
Verwenden Sie den folgenden Ablauf, um den E/A-Speicher der Steuerung zu verändern. Der<br />
Hauptrechner sendet DC4 (Daten) an die Steuerung. Die Daten bestehen aus einem Byte, dessen Bits<br />
folgende Bedeutung haben.<br />
(Daten) = (0A1BBBBB)<br />
���� HINWEIS<br />
A: Markierung, um zwischen ON und OFF unterscheiden zu können.<br />
ON: A = 1<br />
OFF: A = 0<br />
B: entspricht der E/A-Speicherbit-Nummer. Die fünf B-Bits drücken einen Zahlenwert von 0<br />
bis 31 aus.<br />
ON #20, $15 → (DC4)(6FH)<br />
OFF #20, $3 → (DC4)(23H)<br />
Sie können nur den Steuerungscode (00H bis 1FH), der in diesem Handbuch<br />
beschrieben wurde, und dessen Kombinationen verwenden.
• Ablauf von LIST-, PLIST- und DIR-Befehlen<br />
Das Ablaufdiagramm 4 zeigt den Ablauf von LIST-, PLIST- und DIR-Befehlen. Die Ausführung dieser<br />
Befehle kann zeitweise angehalten oder komplett gestoppt werden. Die zu übertragenden Daten müssen<br />
zeilenweise übertragen werden. Mit anderen Worten: Der Hauptrechner verwendet eine Handshaking-<br />
Prozedur, während er mit der Steuerung kommuniziert.<br />
Senden Sie folgende Codes, um den Handshaking-Modus einzurichten.<br />
(DC3) (ESC)<br />
Nach dem Senden dieser Codes, senden Sie einen Befehl wie z.B. LIST.<br />
Dann senden Sie ein Leerzeichen. Danach werden Sie eine Zeile des Programms (oder andere Daten)<br />
vom Roboter erhalten.<br />
Die Einrichtung ist abgeschlossen, wenn die empfangenen Daten „>“ sind. Wenn nicht „>“ erscheint,<br />
dann werden die empfangenen Daten auf dem Bildschirm des Hauptrechners angezeigt.<br />
Bevor das Leerzeichen gesendet wird, überprüft das Programm die Tasteneingabe. Diese Überprüfung<br />
der Tasteneingabe ist für die Steuerungsfunktionen von LIST wichtig (Pause, Fortsetzung, erzwungenes<br />
Ende, etc.).<br />
Ablaufdiagramm 4: Ablauf der LIST-, PLIST- und DIR-Befehle<br />
119
120<br />
• Ablauf von SAVE- und MERGE-Befehlen (Programmdownload)<br />
Das Ablaufdiagramm 5 zeigt den Ablauf von SAVE- und MERGE-Befehlen.<br />
In diesem Ablaufdiagramm wird zuerst der Befehl NEW geschickt. Nachdem der Programmbereich der<br />
Steuerung geleert ist, wird das Programm zeilenweise zur Steuerung geschickt. Ist die<br />
Programmübertragung abgeschlossen, wird die Übertragung der Positionsdaten gestartet.<br />
Wird die Übertragung der Befehle NEW und CLEAR ausgelassen oder unterdrückt, wird der Befehl<br />
MERGE ausgeführt.<br />
Diese Übertragungen können das TTY- oder das BASIC-Protokoll verwenden.<br />
Ablaufdiagramm 5: Ablauf des Befehls SAVE
• Schnellspeicherung mit SAVE<br />
Während der Speichervorgänge, wenn eine Zeile an die Steuerung gesendet wird, prüft die Steuerung<br />
die Zeilennummer des Programms und muß dann den Programmspeicherbereich nach einem freien<br />
Platz für diese Zeile durchsuchen, damit sie dort gespeichert werden kann. Dies ist ein zeitraubender<br />
Vorgang.<br />
Die Schnellspeicherung erhöht die Geschwindigkeit des Programmdownload durch Sicherstellen, daß<br />
Programme in der Reihenfolge ihrer Zeilennummern gesendet werden.<br />
Das Ablaufdiagramm 5 zeigt den Ablauf der Schnellspeicherung.<br />
In diesem Ablaufdiagramm wird zuerst der Befehl SSV_ gefolgt von einer Programmzeile geschickt.<br />
Der unterstrichene Teil (_) entspricht dem ASCII-Code „&H5F“. Wenn das komplette Programm<br />
übertragen wurde, wird der Befehl _END geschickt. Danach werden die Positionsdaten zeilenweise<br />
gesendet.<br />
Ablaufdiagramm 6: Ablauf der Schnellspeicherung<br />
121
122<br />
• Ablauf des LOAD-Befehls<br />
Das Ablaufdiagramm 7 zeigt den Ladevorgang.<br />
Der LIST-Befehl wird an die Steuerung geschickt, worauf die Steuerung das Programm zeilenweise<br />
erhält und das Programm im Programmspeicherbereich gespeichert wird. Das empfangene Programm<br />
wird im Programmspeicherbereich des Hauptrechners gespeichert.<br />
Dann wird der Befehl PLIST zum Roboter gesendet und die Positionsdaten werden genauso bearbeitet,<br />
wie die Programmdaten.<br />
Ablaufdiagramm 7: Ablauf des LOAD-Befehls
• Zufuhr per JOG-Verfahren<br />
Der Hauptrechner kann zum Programmieren des Roboters benutzt werden, um „JOG-Zufuhr“-<br />
Bewegungen zu verrichten. JOG-Zufuhr-Bewegungen sind Bewegungen zu einer definierten Position,<br />
die per Fernsteuerung, z.B. über die PC-Tastatur, ausgeführt werden können. Daher ist dies eine<br />
wichtige Einrichtfunktion.<br />
Die JOG-Methode ist wie folgt. Die gleiche JOG-Methode wird im SPEL Editor verwendet.<br />
Es gibt zwei verschiedene JOG-Verfahren:1. der Bewegungsmodus und 2. der<br />
Koordinatensystemmodus. Verwenden Sie beide Methoden in Kombination.<br />
Bewegungsmodus<br />
StpJog (Step Jog) schrittweise Zufuhr<br />
CntJog (Continuous Jog) Endloszufuhr<br />
Koordinatensystemmodus<br />
BASE Bewegung gemäß des Basiskoordinatensystems der Roboters<br />
JOINT Bewegung definiert für jedes Gelenk<br />
TOOL Bewegung gemäß den TOOL-Koordinaten<br />
Weitere Informationen zum JOG-Zufuhrverfahren erhalten Sie in Kapitel 6 im SPEL Editor Handbuch.<br />
Schrittweise Zufuhr (StpJog-Modus)<br />
Sowohl das TTY- wie auch das BASIC-Protokoll können hierfür verwendet werden. Der Schrittabstand<br />
kann durch Ausführen des SEL-Befehls festgelegt werden. Sie müssen jedoch beachten, daß sowohl der<br />
Schrittabstand, wie auch die Schrittrichtung in Abhängigkeit vom verwendeten Koordinatensystem<br />
variieren.<br />
Basiskoordinatensystem<br />
Code Beschreibung vorheriger Code (*1)<br />
PIJ 0 Positive Richtung entlang der X-Achse des Roboterkoordinatensystems PSX<br />
NIJ 0 Negative Richtung entlang der X-Achse des Roboterkoordinatensystems NGX<br />
P2J 0 Positive Richtung entlang der Y-Achse des Roboterkoordinatensystems PSY<br />
N2J 0 Negative Richtung entlang der Y-Achse des Roboterkoordinatensystems NGY<br />
P3J 0 Positive Richtung entlang der 3. Achse PSZ<br />
N3J 0 Negative Richtung entlang der 3. Achse NGZ<br />
P4J 0 Positive Richtung entlang der 4. Achse PSU<br />
N4J 0 Negative Richtung entlang der 4. Achse NGU<br />
(*1) Der vorheriger Code ist der Code, der mit den Steuerungen der Serie 42 verwendet wird.<br />
123
124<br />
JOINT-Koordinatensystem<br />
Code Beschreibung<br />
PIJ 1 Positive Richtung entlang der 1.Achse<br />
NIJ 1 Negative Richtung entlang der 1. Achse<br />
P2J 1 Positive Richtung entlang der 2. Achse d<br />
N2J 1 Negative Richtung entlang der 2. Achse<br />
P3J 1 Positive Richtung entlang der 3. Achse<br />
N3J 1 Negative Richtung entlang der 3. Achse<br />
P4J 1 Positive Richtung entlang der 4. Achse<br />
N4J 1 Negative Richtung entlang der 4. Achse<br />
TOOL-Koordinatensystem<br />
Code Beschreibung<br />
PIJ 2 Positive Richtung entlang der X-Achse des TOOL-Koordinatensystems<br />
NIJ 2 Negative Richtung entlang der X-Achse des TOOL-Koordinatensystems<br />
P2J 2 Positive Richtung entlang der Y-Achse des TOOL-Koordinatensystems<br />
N2J 2 Negative Richtung entlang der Y-Achse des TOOL-Koordinatensystems<br />
P3J 2 Positive Richtung entlang der 3. Achse<br />
N3J 2 Negative Richtung entlang der 3. Achse<br />
P4J 2 Rotation in positiver Richtung entlang der U-Achse und zentriert auf<br />
den Ursprung des TOOL-Koordinatensystems<br />
N4J 2 Rotation in negativer Richtung entlang der U-Achse und zentriert auf<br />
den Ursprung des TOOL-Koordinatensystems<br />
Endloszufuhr (CntJog-Modus)<br />
Für ununterbrochene JOG-Zufuhrvorgänge. Ablaufcodes werden ohne Verwendung eines Protokolls<br />
direkt gesendet.<br />
Auch hier werden zwei verschiedene Modi verwendet:<br />
Code Beschreibung<br />
Endlos-JOG-Startcode Code, der gesendet wird, um die Endloszufuhr zu starten.<br />
JOG-Richtungscode2 Code, der die Richtung der JOG-Zufuhr bestimmt.<br />
JOG-Koordinatensystem Code<br />
BASE DC3+‘0‘<br />
JOINT DC3+‘1‘<br />
TOOL DC3+‘2‘
Die JOG-Richtungcode werden unten aufgeführt:<br />
Bit 7 Bit 0<br />
X/Y-JOG-Richtungen 0 0 1 SP -Y +Y -X +X<br />
Bit 7 Bit 0<br />
Z/U-JOG-Richtungen 0 1 0 SP -U +U -Z +Z<br />
- Stellen Sie das Bit, das Sie für die Einstellung der Richtung benötigen, auf 1.<br />
- SP steht für „Speed“ (Geschwindigkeit). Ein Bitwert von 1 kennzeichnet eine hohe Geschwindigkeit.<br />
Sie setzen den Bitwert auf 1, indem Sie auf die [Shift]-Taste drücken.<br />
Drücken von „+X“ und „-Y“ sendet den Code „&H29“.<br />
Wenn die Endloszufuhr ausgeführt wird, senden Sie zuerst den entsprechenden Startcode und sofort<br />
danach den Richtungscode. Behalten Sie das Senden des Richtungscodes bei, um eine ununterbrochene<br />
Zufuhr zu ermöglichen. JOG-Verfahren enden, wenn der nächste Richtungscode nicht innerhalb von 20<br />
ms gesendet wird. Wenn das JOG-Verfahren einmal beendet ist, muß ein neuer Startcode eingegeben<br />
werden, um das JOG-Verfahren erneut zu starten.<br />
A: Startcode für das Endlosverfahren<br />
B: Richtungscode<br />
125
7.5 Erweiterte Funktionen<br />
SPEL III: Erweiterte Funktionsaufrufe<br />
126<br />
Zusätzlich zu den Funktionen, die sich auf die RS232C beziehen, gibt es auch einige erweiterte<br />
Funktionen.<br />
• Format der erweiterten Funktionen<br />
Format: EX_CALL (l,m,n)<br />
l: Funktionscode<br />
m: Parameter 1<br />
n: Parameter 2<br />
Funktionscode 2: Terminatorausgang ON/OFF<br />
Dies steuert die Terminatorausgang, wenn das Kommunikationsprotokoll der RS-232C das TTY-<br />
Protokoll ist.<br />
Eingabeparameter:<br />
l (Funktionscode): 2<br />
m (Nummer der Schnittstelle): 20 bis 23<br />
n (Kontrollmarkierung): Ist n=0: Terminatorausgang<br />
Rückgabewert<br />
Fehlercode (im Normalfall 0)<br />
���� HINWEIS<br />
Ist n=1: kein Terminatorausgang<br />
Diese Einstellung kann nicht gesichert werden. Ein Zurücksetzen hat das<br />
Wiederherstellen der Standardeinstellung (Terminatorausgang) zur Folge. Stellen<br />
Sie daher sicher, daß Sie diesen Befehl in Ihrem Programm integriert haben.<br />
100 B=EX_CALL(2,20,11) Keine Ausgabe an Terminator (#20)<br />
110 PRINT #20,123<br />
120 INPUT #20,A Eingang der numerischen Werte von #20<br />
Format: INKEY$(n)<br />
n: 20 oder 21 (Nummer der Schnittstelle)<br />
Diese Funktion gibt ein Zeichen der Dateneingabe der RS-232C-Schnittstelle zurück. Ein Wert CHR$(0)<br />
wird zurückgegeben, wenn ein Timeout auftritt (Die Timeout-Zeitspanne beträgt ca. zwei Sekunden.)<br />
���� HINWEIS<br />
Diese Funktion arbeitet nicht korrekt, solange sich die definierte Schnittstelle<br />
nicht im RAW-Modus befindet.
• erweiterte Funktionsbefehle<br />
Format: SETRAW #n<br />
n: 20 oder 21 (Nummer der Schnittstelle)<br />
���� HINWEIS Mit diesem Befehl stellen Sie für die definierte Schnittstelle den RAW-Modus ein.<br />
RAW-Modus<br />
Bei Verwendung des TTY-Protokolls werden Terminatoren nicht per PRINT-Befehl den<br />
Datenausgängen hinzugefügt. Auch der INPUT-Befehl kann nicht für Dateneingänge genutzt werden,<br />
anstatt dessen wird die Funktion INKEY$( ) genutzt, um ein Zeichen zurückzugeben.<br />
Format: COOKED #n<br />
���� HINWEIS<br />
COOKED-Modus<br />
n: 20 oder 21 (Nummer der Schnittstelle)<br />
Mit diesem Befehl stellen Sie für die definierte Schnittstelle den COOKED-Modus<br />
ein.<br />
Bei Verwendung des TTY-Protokolls werden Terminatoren per PRINT-Befehl den Datenausgängen<br />
hinzugefügt. Der INPUT-Befehl kann für Dateneingänge genutzt werden. Dies ist die<br />
Standardeinstellung.<br />
127
ASCII-Codetabelle<br />
128
7.6 Übertragungsfehler<br />
Übertragungsfehlercodes<br />
Die unten aufgeführten Fehlernummern zeigen die folgenden Übertragungsfehler auf:<br />
Fehlernummer Beschreibung<br />
30 Anzahl der empfangenen Daten und die der Variablen des INPUT-Befehls sind nicht<br />
identisch.<br />
31 Es ist nicht möglich eine Kommunikation mit dem Gerät, das über die RS232C- oder<br />
die TEACH-Schnittstelle angeschlossen ist, herzustellen.<br />
33 Daten ohne Terminator über die RS232C- Schnittstelle empfangen und<br />
Speicherüberlauf.<br />
34 Parity-, Überlauf- oder Ordnungsfehler in der RS232C-Schnittstellenkommunikation.<br />
36 Eingabe über RS232C übersteigt 80 Zeichen.<br />
Ursachen und Fehlerbeseitigung<br />
Fehler 31 Tritt auf, wenn die Spannungszufuhr ausgeschaltet ist oder wenn die Konfiguration<br />
nicht korrekt eingestellt ist.<br />
Fehler 30 bis 36 Wird gewöhnlich durch einen Programmeingabefehler verursacht.<br />
Fehler 33 Tritt auf, wenn eine große Menge von Daten übertragen wird.<br />
Fehler 34 Tritt auf, wenn die Übertragung von Störungen beeinflußt wird. Beseitigen Sie die<br />
Ursache der Störung (zu langes oder geknicktes Kabel oder störungserzeugendes<br />
Gerät in der Nähe) und starten Sie dann die Übertragung erneut.<br />
Wenn ein Übertragungsfehler auftritt, sollten Sie anhand des Flußdiagramms auf der nächsten Seite alle<br />
Schritte überprüfen und so die Fehlerursache nachvollziehen und beseitigen.<br />
129
130<br />
Ablaufdiagramm: Überprüfung von Kommunikationsfehlern