Vorwort
1
Beschreibung
2
KOP/FUP-Editor
3
KOP/FUP programmieren
4
Funktionen
5
Inbetriebnehmen (Software)
6
SoftwareDebuggen/Fehlerbehandlung
7
Anwendungsbeispiele
8
Anhang
A
SIMOTION SIMOTION SCOUT SIMOTION KOP/FUP
SIMOTION SIMOTION SCOUT SIMOTION KOP/FUP Programmier- und Bedienhandbuch
05/2009
Rechtliche Hinweise
Rechtliche Hinweise Warnhinweiskonzept
Dieses Handbuch enthält Hinweise, die Sie zu Ihrer persönlichen Sicherheit sowie zur Vermeidung von Sachschäden beachten müssen. Die Hinweise zu Ihrer persönlichen Sicherheit sind durch ein Warndreieck hervorgehoben, Hinweise zu alleinigen Sachschäden stehen ohne Warndreieck. Je nach Gefährdungsstufe werden die Warnhinweise in abnehmender Reihenfolge wie folgt dargestellt. GEFAHR bedeutet, dass Tod oder schwere Körperverletzung eintreten wird, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden. WARNUNG bedeutet, dass Tod oder schwere Körperverletzung eintreten kann, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden. VORSICHT mit Warndreieck bedeutet, dass eine leichte Körperverletzung eintreten kann, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden. VORSICHT ohne Warndreieck bedeutet, dass Sachschaden eintreten kann, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden. ACHTUNG bedeutet, dass ein unerwünschtes Ergebnis oder Zustand eintreten kann, wenn der entsprechende Hinweis nicht beachtet wird. Beim Auftreten mehrerer Gefährdungsstufen wird immer der Warnhinweis zur jeweils höchsten Stufe verwendet. Wenn in einem Warnhinweis mit dem Warndreieck vor Personenschäden gewarnt wird, dann kann im selben Warnhinweis zusätzlich eine Warnung vor Sachschäden angefügt sein.
Qualifiziertes Personal Das zugehörige Gerät/System darf nur in Verbindung mit dieser Dokumentation eingerichtet und betrieben werden. Inbetriebsetzung und Betrieb eines Gerätes/Systems dürfen nur von qualifiziertem Personal vorgenommen werden. Qualifiziertes Personal im Sinne der sicherheitstechnischen Hinweise dieser Dokumentation sind Personen, die die Berechtigung haben, Geräte, Systeme und Stromkreise gemäß den Standards der Sicherheitstechnik in Betrieb zu nehmen, zu erden und zu kennzeichnen.
Bestimmungsgemäßer Gebrauch von Siemens-Produkten Beachten Sie Folgendes: WARNUNG Siemens-Produkte dürfen nur für die im Katalog und in der zugehörigen technischen Dokumentation vorgesehenen Einsatzfälle verwendet werden. Falls Fremdprodukte und -komponenten zum Einsatz kommen, müssen diese von Siemens empfohlen bzw. zugelassen sein. Der einwandfreie und sichere Betrieb der Produkte setzt sachgemäßen Transport, sachgemäße Lagerung, Aufstellung, Montage, Installation, Inbetriebnahme, Bedienung und Instandhaltung voraus. Die zulässigen Umgebungsbedingungen müssen eingehalten werden. Hinweise in den zugehörigen Dokumentationen müssen beachtet werden.
Marken Alle mit dem Schutzrechtsvermerk ® gekennzeichneten Bezeichnungen sind eingetragene Marken der Siemens AG. Die übrigen Bezeichnungen in dieser Schrift können Marken sein, deren Benutzung durch Dritte für deren Zwecke die Rechte der Inhaber verletzen kann.
Haftungsausschluss Wir haben den Inhalt der Druckschrift auf Übereinstimmung mit der beschriebenen Hard- und Software geprüft. Dennoch können Abweichungen nicht ausgeschlossen werden, so dass wir für die vollständige Übereinstimmung keine Gewähr übernehmen. Die Angaben in dieser Druckschrift werden regelmäßig überprüft, notwendige Korrekturen sind in den nachfolgenden Auflagen enthalten.
Siemens AG Industry Sector Postfach 48 48 90026 NÜRNBERG DEUTSCHLAND
Copyright © Siemens AG 2009. Änderungen vorbehalten
Inhaltsverzeichnis 1
2
3
Vorwort .................................................................................................................................................... 11 1.1
Gültigkeitsbereich ........................................................................................................................11
1.2
Informationsblöcke des Handbuchs.............................................................................................12
1.3
SIMOTION Dokumentation ..........................................................................................................13
1.4
Hotline und Internetadressen.......................................................................................................14
Beschreibung........................................................................................................................................... 17 2.1
Beschreibung ...............................................................................................................................17
2.2
Was ist KOP?...............................................................................................................................17
2.3
Was ist FUP? ...............................................................................................................................18
2.4
Unit, Programmorganisationseinheit (POE) und Programmquelle ..............................................19
KOP/FUP-Editor ...................................................................................................................................... 21 3.1
Der KOP/FUP-Editor in der Workbench ......................................................................................21
3.2
Arbeitsbereich und Detailanzeige maximieren ............................................................................22
3.3
Editorbereich für die graphische Darstellung vergrößern und verkleinern ..................................22
3.4
KOP/FUP-Editor in den Vordergrund holen.................................................................................23
3.5
Deklarationstabelle aus-/einblenden............................................................................................23
3.6
Deklarationstabelle vergrößern/verkleinern .................................................................................23
3.7 3.7.1 3.7.2 3.7.3 3.7.4 3.7.5 3.7.6 3.7.7 3.7.8 3.7.9 3.7.10 3.7.11 3.7.12 3.7.13
Bedienung ....................................................................................................................................24 Bedienung des KOP/FUP-Editors................................................................................................24 Menüleiste....................................................................................................................................24 Kontextmenü ................................................................................................................................24 Funktionsleisten ...........................................................................................................................24 Tastenkombinationen...................................................................................................................26 Drag&Drop von Variablen ............................................................................................................26 Drag&Drop aus den Deklarationstabellen ...................................................................................26 Drag&Drop in der Deklarationstabelle .........................................................................................27 Drag&Drop von KOP/FUP-Elementen.........................................................................................27 Drag&Drop von Befehlsaufrufen ..................................................................................................27 Drag&Drop von Befehlsnamen ....................................................................................................28 Drag&Drop von Elementen in einem Netzwerk ...........................................................................28 Drag&Drop von Funktionen und Funktionsbausteinen anderer Quellen .....................................28
3.8 3.8.1 3.8.2 3.8.3 3.8.4 3.8.5 3.8.6 3.8.7 3.8.8
Einstellungen................................................................................................................................29 Einstellung des KOP/FUP-Editors ...............................................................................................29 Automatische Symbolprüfung und Typaktualisierung aktivieren .................................................29 Beispiel für Typaktualisierung ......................................................................................................31 Beispiel für Symbolprüfung ..........................................................................................................33 Automatische Symbolprüfung und Typaktualisierung deaktivieren .............................................34 Symbolprüfung und Typaktualisierung zu einem bestimmten Zeitpunkt durchführen.................34 Einstellung der Datentyp-Liste der Deklarationstabelle...............................................................34 Operand- und Kommentarfelder ändern......................................................................................35
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
3
Inhaltsverzeichnis
3.8.9 3.8.10 3.8.11 3.8.12 3.8.13 4
4
Schriftarten ändern...................................................................................................................... 35 Farben ändern............................................................................................................................. 36 On-the-fly Variablendeklaration aktivieren .................................................................................. 36 Standardsprache einstellen......................................................................................................... 37 Aufruf der Online-Hilfe im KOP/FUP-Editor ................................................................................ 37
KOP/FUP programmieren........................................................................................................................ 39 4.1
Software-Programmieren ............................................................................................................ 39
4.2 4.2.1 4.2.2 4.2.3 4.2.4 4.2.5 4.2.6 4.2.7
KOP/FUP-Quelle verwalten ........................................................................................................ 39 Neue KOP/FUP-Quelle einfügen ................................................................................................ 40 Vorhandene KOP/FUP-Quelle öffnen ......................................................................................... 42 KOP/FUP-Quelle übernehmen und übersetzen.......................................................................... 42 Geöffnete KOP/FUP-Quelle schließen ....................................................................................... 43 KOP/FUP-Quelle ausschneiden / kopieren / löschen ................................................................. 43 Ausgeschnittene / kopierte KOP/FUP-Quelle einfügen .............................................................. 43 Know-how-Schutz für KOP/FUP-Quellen ................................................................................... 43
4.3 4.3.1 4.3.2 4.3.3 4.3.4 4.3.5 4.3.6
KOP/FUP-Quellen exportieren und importieren.......................................................................... 44 KOP/FUP-Quelle im XML-Format exportieren............................................................................ 44 KOP/FUP-Quellen als XML-Daten importieren........................................................................... 44 POE als XML-Format exportieren............................................................................................... 45 POE aus XML-Format importieren.............................................................................................. 45 KOP/FUP-Quelle im EXP-Format exportieren ............................................................................ 45 EXP-Daten in KOP/FUP-Quelle importieren............................................................................... 46
4.4 4.4.1 4.4.2 4.4.3 4.4.3.1 4.4.3.2
KOP/FUP-Quellen - Eigenschaften festlegen ............................................................................. 47 Eigenschaften einer KOP/FUP-Quelle festlegen ........................................................................ 47 Umbenennen von KOP/FUP-Quellen ......................................................................................... 47 Einstellungen für den Compiler vornehmen................................................................................ 48 Globale Einstellungen des Compilers ......................................................................................... 48 Lokale Einstellungen des Compilers........................................................................................... 49
4.5 4.5.1 4.5.2 4.5.3 4.5.4 4.5.5 4.5.6 4.5.7
KOP/FUP-Programme verwalten................................................................................................ 52 Neues KOP/FUP-Programm einfügen ........................................................................................ 52 Vorhandenes KOP/FUP-Programm öffnen................................................................................. 54 Reihenfolge der KOP/FUP-Programme in der KOP/FUP-Quelle festlegen ............................... 54 KOP/FUP-Programm kopieren ................................................................................................... 54 KOP/FUP-Programm übernehmen und übersetzen ................................................................... 55 KOP/FUP-Programm schließen.................................................................................................. 56 KOP/FUP-Programm löschen ..................................................................................................... 56
4.6 4.6.1 4.6.2
KOP/FUP-Programme - Eigenschaften festlegen ...................................................................... 57 Umbenennen eines KOP/FUP-Programms ................................................................................ 57 Erstelltyp des KOP/FUP-Programms ändern.............................................................................. 58
4.7 4.7.1 4.7.2 4.7.3 4.7.4 4.7.5 4.7.6
Quellen und Programme drucken ............................................................................................... 59 Deklarationstabelle drucken........................................................................................................ 60 Netzwerkbereich drucken............................................................................................................ 60 Kommentare drucken.................................................................................................................. 60 Druckvariante definieren ............................................................................................................. 61 Netzwerke platzieren................................................................................................................... 62 Leere Seiten................................................................................................................................ 62
4.8 4.8.1 4.8.2 4.8.3 4.8.4
KOP/FUP-Netzwerke und -Elemente.......................................................................................... 63 Netzwerke einfügen .................................................................................................................... 64 Netzwerke markieren .................................................................................................................. 64 Nummerierung der Netzwerke .................................................................................................... 65 Titel/Kommentar eingeben .......................................................................................................... 66 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Inhaltsverzeichnis
4.8.5 4.8.6 4.8.7 4.8.8
Sprungmarke ein-/ausblenden.....................................................................................................67 Netzwerke kopieren/ausschneiden/einfügen ...............................................................................68 Aktionen Rückgängig/Wiederholen..............................................................................................68 Netzwerke löschen.......................................................................................................................68
4.9 4.9.1 4.9.2 4.9.3 4.9.4
Darstellung der KOP/FUP-Elemente ...........................................................................................69 KOP-Grafik...................................................................................................................................69 Bedeutung von EN/ENO ..............................................................................................................70 FUP-Grafik ...................................................................................................................................71 Umschaltung zwischen KOP- und FUP-Darstellung....................................................................72
4.10 4.10.1 4.10.2 4.10.3 4.10.4 4.10.5 4.10.6 4.10.7 4.10.8 4.10.9 4.10.10 4.10.11
KOP/FUP-Elemente bearbeiten...................................................................................................74 KOP/FUP-Elemente einfügen ......................................................................................................74 Syntaxprüfung in KOP .................................................................................................................75 KOP/FUP-Elemente markieren....................................................................................................75 KOP/FUP-Elemente kopieren/ausschneiden/löschen .................................................................76 KOP/FUP-Elemente - Parameter festlegen (beschriften)............................................................76 KOP/FUP-Elemente mit der Symboleingabehilfe beschriften .....................................................77 Darstellung der KOP/FUP-Elemente einstellen ...........................................................................77 Aufrufparameter für einen Einzelparameter einstellen ................................................................78 Aufrufparameter einstellen...........................................................................................................79 Suchen im Projekt........................................................................................................................80 Suchen und Ersetzen im Projekt..................................................................................................81
4.11 4.11.1 4.11.2 4.11.3 4.11.4
Befehlsbibliothek..........................................................................................................................83 KOP/FUP-Funktionen in der Befehlsbibliothek............................................................................83 Elemente/Funktionen aus der Befehlsbibliothek einfügen...........................................................84 Nichtverwendbare Funktionen in der Befehlsbibliothek...............................................................84 Besonderheiten in der Befehlsbibliothek .....................................................................................85
4.12 4.12.1 4.12.2 4.12.3 4.12.4 4.12.4.1 4.12.4.2 4.12.4.3
Allgemeines zu Variablen und Datentypen..................................................................................86 Überblick der Variablentypen.......................................................................................................86 Reichweite der Deklarationen ......................................................................................................89 Regeln für Bezeichner .................................................................................................................89 Häufig verwendete Felder bei Deklarationen...............................................................................90 Feldlänge und Feldelement .........................................................................................................90 Anfangswert .................................................................................................................................91 Kommentar...................................................................................................................................91
4.13 4.13.1 4.13.2 4.13.2.1 4.13.2.2 4.13.2.3 4.13.3 4.13.3.1 4.13.3.2 4.13.3.3 4.13.3.4 4.13.4 4.13.4.1 4.13.4.2 4.13.5
Datentypen...................................................................................................................................92 Allgemeines..................................................................................................................................92 Elementare Datentypen ...............................................................................................................93 Wertebereichsgrenzen elementarer Datentypen .........................................................................95 Allgemeine Datentypen................................................................................................................96 Elementare Systemdatentypen....................................................................................................97 Abgeleitete Datentypen................................................................................................................98 Abgeleitete Datentypen (UDT) definieren....................................................................................98 Reichweite der Datentypdeklaration ............................................................................................98 Strukturen definieren....................................................................................................................98 Aufzählungen definieren ..............................................................................................................99 Datentypen der Technologieobjekte ..........................................................................................100 Beschreibung der Datentypen der Technologieobjekte.............................................................100 Vererbung der Eigenschaften bei Achsen .................................................................................101 Systemdatentypen .....................................................................................................................101
4.14 4.14.1 4.14.2
Variablen ....................................................................................................................................102 Schlüsselwörter für Variablentypen ...........................................................................................102 Variablen definieren ...................................................................................................................103
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
5
Inhaltsverzeichnis
4.14.2.1 4.14.2.2 4.14.2.3 4.14.2.4
6
4.14.3 4.14.3.1 4.14.3.2 4.14.3.3 4.14.3.4 4.14.3.5 4.14.3.6 4.14.3.7
Verwendung von geräteglobalen Variablen .............................................................................. 103 Unit-Variable in der Quelle deklarieren ..................................................................................... 104 Lokale Variable deklarieren....................................................................................................... 106 Globale Anwendervariable und lokale Variable im Dialogfenster Variablendeklaration definieren................................................................................................................................... 107 Zeitpunkt der Variableninitialisierung ........................................................................................ 109 Initialisierung remanenter globaler Variablen............................................................................ 109 Initialisierung nicht remanenter globaler Variablen................................................................... 111 Initialisierung lokaler Variablen ................................................................................................. 113 Initialisierung statischer Variablen von Programmen................................................................ 114 Initialisierung von Instanzen von Funktionsbausteinen (FB) .................................................... 115 Initialisierung von Systemvariablen der Technologieobjekte .................................................... 116 Versionskennung globaler Variablen und deren Initialisierung beim Download....................... 117
4.15 4.15.1 4.15.2 4.15.3 4.15.3.1 4.15.3.2 4.15.3.3 4.15.3.4 4.15.4 4.15.4.1 4.15.4.2 4.15.4.3 4.15.4.4 4.15.4.5 4.15.4.6 4.15.5
Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)................................................. 119 Überblick Zugriff auf Ein- und Ausgänge .................................................................................. 119 Wichtige Eigenschaften von Direktzugriff und Prozessabbild................................................... 120 Direktzugriff und Prozessabbild der zyklischen Tasks.............................................................. 122 Regeln für I/O-Adressen für Direktzugriff und das Prozessabbild der zyklischen Tasks ......... 124 I/O-Variable für Direktzugriff oder Prozessabbild der zyklischen Tasks erstellen .................... 125 Syntax für Eingabe der I/O-Adressen ....................................................................................... 127 Mögliche Datentypen der I/O-Variablen.................................................................................... 128 Zugriffe auf festes Prozessabbild der BackgroundTask ........................................................... 128 Absoluter Zugriff auf das feste Prozessabbild der BackgroundTask (Absoluter PA-Zugriff).... 130 Syntax für den Bezeichner für einen absoluten PA-Zugriff....................................................... 130 Symbolischen Zugriff auf das feste Prozessabbild der BackgroundTask definieren................ 131 Mögliche Datentypen des symbolischen PA-Zugriffs ............................................................... 132 Beispiel: Symbolischen Zugriff auf festes Prozessabbild der BackgroundTask definieren ...... 132 I/O-Variable für Zugriff auf das feste Prozessabbild der BackgroundTask erstellen ................ 133 Auf I/O-Variablen zugreifen....................................................................................................... 134
4.16 4.16.1 4.16.1.1 4.16.1.2 4.16.2
Verbindungen zu anderen Programmquellen oder zu Bibliotheken ......................................... 135 Verbindungen definieren ........................................................................................................... 136 So definieren Sie Verbindungen zu anderen Units (Programmquellen)................................... 136 So definieren Sie Verbindungen zu Bibliotheken...................................................................... 137 Namensraum verwenden .......................................................................................................... 138
4.17 4.17.1 4.17.2 4.17.2.1 4.17.3 4.17.3.1 4.17.3.2 4.17.4 4.17.4.1 4.17.4.2 4.17.4.3 4.17.4.4 4.17.4.5 4.17.5 4.17.6
Unterprogramm ......................................................................................................................... 139 Funktion (FC) oder Funktionsbaustein (FB) einfügen............................................................... 142 Unterprogrammaufruf in das KOP/FUP-Programm einfügen und parametrieren..................... 142 Parameterübersicht................................................................................................................... 144 Beispiel: Funktion (FC).............................................................................................................. 146 Funktion (FC) erstellen und programmieren ............................................................................. 146 Unterprogrammaufruf der Funktion (FC) .................................................................................. 148 Beispiel: Funktionsbaustein (FB) .............................................................................................. 151 Funktionsbaustein (FB) erstellen und programmieren.............................................................. 151 Unterprogrammaufruf des Funktionsbausteins (FB)................................................................. 152 So legen Sie eine Instanz des Funktionsbausteins an ............................................................. 153 So programmieren Sie den Unterprogrammaufruf des Funktionsbausteins ............................ 155 So greifen Sie nachträglich auf die Ausgangsparameter des Funktionsbausteins zu.............. 157 Einschränkungen bei der Signalvorverschaltung...................................................................... 158 Schnittstellenabgleich bei FB/FC .............................................................................................. 159
4.18 4.18.1 4.18.1.1 4.18.1.2
Referenzdaten........................................................................................................................... 162 Querverweisliste........................................................................................................................ 162 Querverweisliste erzeugen........................................................................................................ 162 Inhalt der Querverweisliste........................................................................................................ 163
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Inhaltsverzeichnis
4.18.1.3 4.18.1.4 4.18.2 4.18.2.1 4.18.3 4.18.3.1 5
Mit der Querverweisliste umgehen ............................................................................................165 Querverweisliste filtern...............................................................................................................165 Programmstruktur ......................................................................................................................166 Inhalt der Programmstruktur ......................................................................................................167 Codeattribute..............................................................................................................................168 Inhalt der Codeattribute .............................................................................................................168
Funktionen............................................................................................................................................. 169 5.1 5.1.1 5.1.2 5.1.3 5.1.4 5.1.5 5.1.6 5.1.7 5.1.8 5.1.9 5.1.10 5.1.11 5.1.12 5.1.13 5.1.14 5.1.15 5.1.16
KOP-Bitverknüpfungsoperationen .............................................................................................170 ---| |--- Schließerkontakt .............................................................................................................171 ---| / |--- Öffnerkontakt ................................................................................................................172 XOR EXKLUSIV-ODER verknüpfen ..........................................................................................173 ---|NOT|--- Signalzustand invertieren.........................................................................................174 ---( ) Relaisspule, Ausgang ........................................................................................................175 ---( # )--- Konnektor (KOP) .........................................................................................................176 ---( R ) Ausgang rücksetzen (KOP)............................................................................................177 ---( S ) Ausgang setzen (KOP)...................................................................................................178 RS Flipflop vorrangig rücksetzen ...............................................................................................179 SR Flipflop vorrangig setzen......................................................................................................180 --( N )-- Flanke 1 -> 0 abfragen (KOP).......................................................................................181 --( P )-- Flanke 0 -> 1 abfragen (KOP) .......................................................................................182 NEG Flankenerkennung (fallend) ..............................................................................................183 POS Flankenerkennung (steigend) ...........................................................................................184 Verzweigung auf ........................................................................................................................185 Verzweigung zu .........................................................................................................................186
5.2 5.2.1 5.2.2 5.2.3 5.2.4 5.2.5 5.2.6 5.2.7 5.2.8 5.2.9 5.2.10 5.2.11 5.2.12 5.2.13 5.2.14 5.2.15
FUP-Bitverknüpfungsoperationen..............................................................................................187 & UND-Box.................................................................................................................................188 >=1 ODER-Box ..........................................................................................................................189 XOR EXKLUSIV-ODER-Box......................................................................................................190 --| Binäreingang einfügen...........................................................................................................191 --o| Binäreingang negieren ........................................................................................................192 [=] Zuweisung.............................................................................................................................193 [#] Konnektor (FUP) ...................................................................................................................194 [R] Zuweisung rücksetzen (FUP) ...............................................................................................195 [S] Zuweisung setzen (FUP) ......................................................................................................196 RS Flipflop vorrangig rücksetzen ...............................................................................................197 SR Flipflop vorrangig setzen......................................................................................................198 [N] Flanke 1 -> 0 abfragen (FUP) ..............................................................................................199 [P] Flanke 0 -> 1 abfragen (FUP)...............................................................................................200 NEG Flankenerkennung (fallend) ..............................................................................................201 POS Flankenerkennung (steigend) ...........................................................................................202
5.3 5.3.1 5.3.2
Vergleichsoperatoren.................................................................................................................203 Vergleichsoperationen Übersicht...............................................................................................203 CMP Zahlen vergleichen............................................................................................................203
5.4 5.4.1 5.4.2 5.4.3
Umwandler .................................................................................................................................207 TRUNC Ganze Zahl erzeugen...................................................................................................207 Numerische Datentypen und Bitdatentypen erzeugen ..............................................................208 Datum und Zeit erzeugen ..........................................................................................................212
5.5 5.5.1 5.5.2
Flankenerkennung .....................................................................................................................213 Erkennung der steigenden Flanke R_TRIG...............................................................................213 Erkennung der fallenden Flanke F_TRIG ..................................................................................214
5.6 5.6.1
Zähleroperationen......................................................................................................................215 Zähleroperationen Übersicht......................................................................................................215
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
7
Inhaltsverzeichnis
6
8
5.6.2 5.6.3 5.6.4 5.6.5 5.6.6 5.6.7 5.6.8 5.6.9 5.6.10
Aufwärtszähler CTU .................................................................................................................. 215 Aufwärtszähler CTU_DINT........................................................................................................ 216 Aufwärtszähler CTU_UDINT ..................................................................................................... 217 Abwärtszähler CTD ................................................................................................................... 218 Abwärtszähler CTD_DINT......................................................................................................... 219 Abwärtszähler CTD_UDINT ...................................................................................................... 220 Auf-/Abwärtszähler CTUD......................................................................................................... 221 Auf-/Abwärtszähler CTUD_DINT .............................................................................................. 223 Auf-/Abwärtszähler CTUD_UDINT............................................................................................ 224
5.7 5.7.1 5.7.2 5.7.3 5.7.4
Sprungoperationen.................................................................................................................... 225 Sprungoperationen Übersicht ................................................................................................... 225 ---( JMP ) Springe im Baustein wenn 1 (bedingt)...................................................................... 226 ---( JMPN ) Springe im Baustein wenn 0 (bedingt) ................................................................... 227 LABEL Sprungmarke ................................................................................................................ 228
5.8
Nichtbinäre Logik ...................................................................................................................... 229
5.9
Arithmetische Operatoren ......................................................................................................... 230
5.10 5.10.1 5.10.2 5.10.3
Numerische Standardfunktionen............................................................................................... 232 Allgemeine numerische Standardfunktionen ............................................................................ 232 Logarithmische Standardfunktionen ......................................................................................... 233 Trigonometrische Standardfunktionen ...................................................................................... 234
5.11 5.11.1
Verschieben .............................................................................................................................. 235 MOVE Wert übertragen............................................................................................................. 235
5.12 5.12.1 5.12.2 5.12.3
Schiebeoperationen .................................................................................................................. 236 Schiebeoperationen - Übersicht................................................................................................ 236 SHL Bit links schieben .............................................................................................................. 237 SHR Bit rechts schieben ........................................................................................................... 238
5.13 5.13.1 5.13.2 5.13.3
Rotieroperationen...................................................................................................................... 239 Rotieroperationen Übersicht ..................................................................................................... 239 ROL Bit links rotieren ................................................................................................................ 239 ROR Bit rechts rotieren ............................................................................................................. 241
5.14 5.14.1 5.14.2
Programmsteuerung ................................................................................................................. 243 Leerbox aufrufen ....................................................................................................................... 243 RET Springe zurück .................................................................................................................. 244
5.15 5.15.1 5.15.2 5.15.3
Zeitoperationen ......................................................................................................................... 245 Puls TP...................................................................................................................................... 245 Einschaltverzögerung TON ....................................................................................................... 246 Ausschaltverzögerung TOF ...................................................................................................... 247
5.16 5.16.1 5.16.2 5.16.3 5.16.4 5.16.5
Selektierfunktionen.................................................................................................................... 248 SEL Binäre Auswahl ................................................................................................................. 248 MAX Maximum-Funktion........................................................................................................... 249 MIN Minimum-Funktion ............................................................................................................. 250 LIMIT Begrenzungsfunktion ...................................................................................................... 251 MUX Multiplexfunktion .............................................................................................................. 252
Inbetriebnehmen (Software) .................................................................................................................. 253 6.1
Inbetriebnehmen ....................................................................................................................... 253
6.2
Programm einer Task zuordnen ............................................................................................... 253
6.3
Ablaufebenen und Tasks in SIMOTION.................................................................................... 255
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Inhaltsverzeichnis
7
8
6.4
Startreihenfolge der Tasks.........................................................................................................257
6.5
Programme in das Zielsystem laden .........................................................................................258
Software-Debuggen/Fehlerbehandlung ................................................................................................. 259 7.1 7.1.1 7.1.2 7.1.3
Betriebsarten für Programmtest.................................................................................................259 Betriebsarten der SIMOTION Geräte ........................................................................................259 Wichtige Hinweise zur Lebenszeichenüberwachung ................................................................261 Parameter Lebenszeichenüberwachung ...................................................................................263
7.2 7.2.1 7.2.2
Symbol-Browser.........................................................................................................................264 Eigenschaften ............................................................................................................................264 Symbol-Browser einsetzen ........................................................................................................264
7.3 7.3.1
Watchtabelle ..............................................................................................................................268 Variablen in Watchtabelle beobachten ......................................................................................268
7.4
Trace ..........................................................................................................................................270
7.5 7.5.1 7.5.2 7.5.3
Programm-Durchlauf..................................................................................................................270 Programm-Durchlauf: Anzeige von Codestelle und Aufrufpfad.................................................270 Parameter Callstack Programm-Durchlauf ................................................................................271 Funktionsleiste Programm-Durchlauf ........................................................................................271
7.6 7.6.1
Status Programm (Programmablauf beobachten) .....................................................................272 Beobachten des Programmablaufs starten und stoppen ..........................................................272
7.7 7.7.1 7.7.2 7.7.3 7.7.4 7.7.5 7.7.6 7.7.7 7.7.8 7.7.9
Haltepunkte (WS).......................................................................................................................275 Allgemeine Vorgehensweise zum Setzen von Haltepunkten ....................................................275 Debug-Modus einstellen ............................................................................................................276 Debug-Taskgruppe festlegen.....................................................................................................277 Haltepunkte setzen ....................................................................................................................279 Funktionsleiste Haltepunkte.......................................................................................................281 Aufrufpfad für einen einzelnen Haltepunkt festlegen .................................................................282 Aufrufpfad für alle Haltepunkte festlegen...................................................................................284 Haltepunkte aktivieren ...............................................................................................................286 Call-Stack anzeigen ...................................................................................................................289
Anwendungsbeispiele............................................................................................................................ 291 8.1
Beispiele.....................................................................................................................................291
8.2
Beispielprogramme erstellen .....................................................................................................291
8.3 8.3.1 8.3.2 8.3.3 8.3.4 8.3.5 8.3.6 8.3.7 8.3.8 8.3.9 8.3.10 8.3.11 8.3.12 8.3.13 8.3.14 8.3.15
Programm Blinker ......................................................................................................................292 KOP/FUP-Quelle einfügen.........................................................................................................293 KOP/FUP-Programm einfügen ..................................................................................................296 Variablen in die Deklarationstabelle eintragen ..........................................................................299 Programmtitel eingeben.............................................................................................................299 Netzwerk einfügen .....................................................................................................................300 Leerbox einfügen .......................................................................................................................301 Box-Typ auswählen ...................................................................................................................302 Parametrierung des ADD-Aufrufs ..............................................................................................303 Vergleicher einfügen ..................................................................................................................304 Vergleicher beschriften ..............................................................................................................305 Spule initialisieren ......................................................................................................................306 Nächstes Netzwerk einfügen .....................................................................................................306 Detailanzeige .............................................................................................................................307 Übersetzen.................................................................................................................................307 Beispielprogramm einer Ablaufebene zuordnen........................................................................309
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
9
Inhaltsverzeichnis
A
8.3.16
Beispielprogramm starten ......................................................................................................... 310
8.4 8.4.1 8.4.2 8.4.3 8.4.4 8.4.5 8.4.6 8.4.7 8.4.8 8.4.9 8.4.10 8.4.11 8.4.12
Programm Achse positionieren................................................................................................. 312 KOP/FUP-Quelle einfügen ........................................................................................................ 313 KOP/FUP-Programm einfügen ................................................................................................. 314 TO-spezifischen Befehl einfügen .............................................................................................. 316 Beschaltung der Freigabeeingänge .......................................................................................... 319 Variablen in die Deklarationstabelle eintragen.......................................................................... 322 Parametrierung der Schließer ................................................................................................... 323 Aufrufparameter für den Befehl _mc_power einstellen ............................................................. 324 Aufrufparameter für den Befehl _mc_moverelative einstellen .................................................. 326 Detailanzeige ............................................................................................................................ 328 Übersetzen ................................................................................................................................ 328 Beispielprogramm einer Ablaufebene zuordnen....................................................................... 328 Beispielprogramm starten ......................................................................................................... 329
Anhang .................................................................................................................................................. 331 A.1
Tastenkombinationen................................................................................................................ 331
A.2
Geschützte und reservierte Bezeichner.................................................................................... 333
Index...................................................................................................................................................... 335
10
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
1
Vorwort 1.1
Gültigkeitsbereich Das vorliegende Dokument ist Bestandteil des Dokumentationspaketes SIMOTION Programmieren. Das Dokument ist gültig für SIMOTION SCOUT, das Engineering System der Produktfamilie SIMOTION, in der Produktstufe V4.1 Service Pack 4 in Verbindung mit: ● Einem SIMOTION Gerät mit einem SIMOTION Kernel folgender Versionen: – V4.1 SP4 – V4.1 SP2 – V4.1 SP1 – V4.0 – V3.2 – V3.1 – V3.0 ● Folgenden SIMOTION Technologiepaketen in der zum jeweiligen Kernel passenden Version – Cam – Path (ab Kernel V4.1) – Cam_ext (ab Kernel V3.2) – TControl – Gear, Position und Basic MC (nur bei Kernel V3.0).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
11
Vorwort 1.2 Informationsblöcke des Handbuchs
1.2
Informationsblöcke des Handbuchs Nachstehende Informationsblöcke beschreiben den Zweck und den Nutzen des Handbuches. ● Beschreibung (Kapitel 1) Dieser Abschnitt definiert kurz die Programmiersprachen KOP und FUP. ● KOP/FUP Editor (Kapitel 2) Hier lernen Sie die verschiedenen Bedienmöglichkeiten im KOP/FUP-Editor kennen. ● Software-Programmieren (Kapitel 3) Dieser Abschnitt zeigt auf, wie Sie beim Programmieren vorgehen sollen. ● Funktionen (Kapitel 4) Dieser Abschnitt beschreibt den Einsatz und die Wirkungsweise der einzelnen KOP/FUPBefehle. ● Software-Debuggen/Fehlerbehandlung (Kapitel 5) Dieses Kapitel beschreibt, wie Sie ein Programm testen und wie Sie in erstellten Programmen Fehler suchen können. ● Anwendungsbeispiele (Kapitel 6) Anhand von einfachen Beispielen werden Sie in die Programmiersprachen KOP und FUP eingeführt. ● Anhang – Tastenkombinationen Hier finden Sie die Tastenkombinationen für häufig genutzte Befehle. ● Index Stichwortverzeichnis zum Finden der Informationen
12
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Vorwort 1.3 SIMOTION Dokumentation
1.3
SIMOTION Dokumentation Einen Überblick zur SIMOTION Dokumentation erhalten Sie in einem separaten Literaturverzeichnis. Diese Dokumentation ist als elektronische Dokumentation im Lieferumfang von SIMOTION SCOUT enthalten. Die SIMOTION Dokumentation besteht aus 9 Dokumentationspaketen, die etwa 80 SIMOTION Dokumente und Dokumente zu zugehörigen Systemen (z. B. SINAMICS) enthalten. Zur SIMOTION Produktstufe V4.1 SP4 stehen folgende Dokumentationspakete zur Verfügung: ● SIMOTION Engineering System Handhabung ● SIMOTION System- und Funktionsbeschreibungen ● SIMOTION Service und Diagnose ● SIMOTION Programmieren ● SIMOTION Programmieren - Referenzen ● SIMOTION C ● SIMOTION P350 ● SIMOTION D4xx ● SIMOTION Ergänzende Dokumentation
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
13
Vorwort 1.4 Hotline und Internetadressen
1.4
Hotline und Internetadressen
Siemens Internet-Adresse Ständig aktuelle Informationen zu den SIMOTION Produkten, Produkt Support, FAQs finden Sie im Internet unter: ● allgemeine Informationen: – http://www.siemens.de/simotion (deutsch) – http://www.siemens.com/simotion (international) ● Dokumentation downloaden Weiterführende Links für den Download von Dateien aus Service & Support. http://support.automation.siemens.com/WW/view/en/10805436 ● Dokumentation auf Basis der Siemens Inhalte individuell zusammenstellen mit dem My Documentation Manager (MDM), siehe http://www.siemens.com/mdm Der My Documentation Manager bietet Ihnen eine Reihe von Features zur Erstellung Ihrer eigenen Dokumentation. ● FAQs Informationen zu FAQs (frequently asked questions) finden Sie über http://support.automation.siemens.com/WW/view/en/10805436/133000.
Weitere Unterstützung Um Ihnen den Einstieg in die Arbeitsweise mit SIMOTION zu erleichtern, bieten wir Kurse an. Wenden Sie sich dazu bitte an Ihr regionales Trainings-Center oder an das zentrale Trainings-Center in D-90027 Nürnberg Informationen über das Trainingsangebot finden Sie unter www.sitrain.com
14
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Vorwort 1.4 Hotline und Internetadressen
Technical Support Bei technischen Fragen wenden Sie sich bitte an folgende Hotline: Europa / Afrika Telefon
+49 180 5050 222 (gebührenpflichtig)
Fax
+49 180 5050 223
0,14 €/Min. aus dem deutschen Festnetz, abweichende Mobilfunkpreise möglich. Internet
http://www.siemens.com/automation/support-request
Amerika Telefon
+1 423 262 2522
Fax
+1 423 262 2200
E-Mail
mailto:
[email protected]
Asien / Pazifik Telefon
+86 1064 757575
Fax
+86 1064 747474
E-Mail
mailto:
[email protected]
Hinweis Landesspezifische Telefonnummern für technische Beratung finden Sie im Internet: http://www.automation.siemens.com/partner
Fragen zur Dokumentation Bei Fragen zur Dokumentation (Anregungen, Korrekturen) senden Sie bitte ein Fax oder eine E-Mail an folgende Adresse: Fax
+49 9131- 98 2176
E-Mail
mailto:
[email protected]
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
15
2
Beschreibung 2.1
Beschreibung Dieses Kapitel gibt Ihnen einen kurzen Überblick darüber, was der Kontaktplan (KOP) und der Funktionsplan (FUP) ist.
2.2
Was ist KOP? KOP steht für Kontaktplan. KOP ist eine graphische Programmiersprache. Die Syntax der Anweisungen entspricht einem Stromlaufplan. KOP ermöglicht Ihnen eine einfache Verfolgung des Signalflusses zwischen Stromschienen über Eingänge, Ausgänge und Operationen. Die KOP-Anweisungen bestehen aus Elementen und Boxen, die grafisch zu Netzwerken verbunden werden (für die Anzeige eines Netzwerks gilt die Norm IEC 61131-3). Die KOPOperationen arbeiten nach den Regeln der Boolschen Logik.
Bild 2-1
Darstellung eines Netzwerks in KOP
Das KOP-Programm kann auch als FUP-Programm dargestellt werden.
Die Programmiersprache KOP Die Programmiersprache KOP stellt Ihnen alle Elemente zur Verfügung, die für die Erstellung eines Anwenderprogramms erforderlich sind. KOP hat einen umfangreichen Befehlssatz. Dazu gehören die verschiedenen Grundoperationen mit einer umfassenden Palette an Operanden und deren Adressierung. Das Konzept der Funktionen und Funktionsbausteine ermöglicht es Ihnen, das KOP-Programm übersichtlich zu strukturieren.
Das Programmierpaket Das KOP-Programmierpaket ist integrierter Bestandteil der Basissoftware SIMOTION. Damit stehen Ihnen nach der Installation Ihrer SIMOTION-Software alle Editor-, Compiler- und Testfunktionen für KOP zur Verfügung.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
17
Beschreibung 2.3 Was ist FUP?
2.3
Was ist FUP? FUP steht für Funktionsplan. FUP ist eine graphische Programmiersprache und benutzt zur Darstellung der Logik die von der Boolschen Algebra bekannten logischen Boxen (für die Anzeige eines Netzwerks gilt die Norm IEC 61131-3). Außerdem können komplexe Funktionen (z. B. mathematische Funktionen) direkt in Verbindung mit den logischen Boxen dargestellt werden.
Bild 2-2
Darstellung eines Netzwerks in FUP
Das FUP-Programm kann in der Regel auch als KOP-Programm dargestellt werden.
Die Programmiersprache FUP Die Programmiersprache FUP stellt Ihnen alle Elemente zur Verfügung, die für die Erstellung eines Anwenderprogramms erforderlich sind. FUP hat einen umfangreichen Befehlssatz. Dazu gehören die verschiedenen Grundoperationen mit einer umfassenden Palette an Operanden und deren Adressierung. Das Konzept der Funktionen und Funktionsbausteine ermöglicht es Ihnen, das FUP-Programm übersichtlich zu strukturieren.
Das Programmierpaket Das FUP-Programmierpaket ist integrierter Bestandteil der Basissoftware SIMOTION. Damit stehen Ihnen nach der Installation Ihrer SIMOTION-Software alle Editor-, Compiler- und Testfunktionen für FUP zur Verfügung.
18
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Beschreibung 2.4 Unit, Programmorganisationseinheit (POE) und Programmquelle
2.4
Unit, Programmorganisationseinheit (POE) und Programmquelle Der Begriff "Unit" steht für eine Programmquelle. Der Begriff "Programmorganisationseinheit (POE)" bzw. "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln. Der Begriff "Programmquelle" dient als Sammelbegriff, d. h. es kann sich dabei um eine KOP/FUP-Quelle, eine MCC-Quelle oder eine ST-Quelle handeln.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
19
3
KOP/FUP-Editor 3.1
Der KOP/FUP-Editor in der Workbench Die Workbench stellt den Rahmen für den SIMOTION SCOUT dar. Mit deren Werkzeugen können Sie alle nötigen Schritte durchführen, um eine Maschine zu konfigurieren, zu optimieren und zu programmieren, damit sie die gewünschte Aufgabe ausführen kann.
Bild 3-1
Elemente der Workbench an einem KOP/FUP-Programm
Die Workbench enthält folgende Elemente: ● (1) Projektnavigator Im Projektnavigator sehen Sie das gesamte Projekt und dessen Elemente in einer Baumstruktur. ● (2) Menüleiste Die Menüleiste enthält Menübefehle, mit denen Sie die Workbench steuern, Werkzeuge aufrufen können, etc. SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
21
KOP/FUP-Editor 3.2 Arbeitsbereich und Detailanzeige maximieren ● (3) Funktionsleisten Sie können viele der vorhandenen Menübefehle mit einem Klick auf das entsprechende Symbol in einer der Funktionsleisten ausführen. ● (4) Deklarationstabellen Deklarationstabellen gibt es für KOP/FUP-Quellen und -Programme. In den Deklarationstabellen legen Sie Variablen und Konstanten fest. ● (5) Arbeitsbereich In diesem Bereich führen Sie aufgabenspezifische Arbeiten durch. Der Arbeitsbereich enthält ein KOP/FUP-Programm eine Deklarationstabelle und einen Editorbereich für graphische Darstellungen. ● (6) Detailanzeige Zu den im Projektnavigator ausgewählten Elementen sehen Sie nähere Informationen, z. B. die Fenster Symbolbrowser, Ausgabe übersetzen / prüfen.
3.2
Arbeitsbereich und Detailanzeige maximieren Die Fenster Arbeitsbereich und Detailanzeige können auf maximale Größe eingestellt werden. Die Anwahl erfolgt mit den Menüpunkten: ● Ansicht > Arbeitsbereich maximiert (z. B. bei Programmerstellung) oder ● Ansicht > Detailanzeige maximiert (z. B. Beobachten globaler Variablen).
3.3
Editorbereich für die graphische Darstellung vergrößern und verkleinern Die Größe des graphischen Bereichs des KOP/FUP-Editors, d. h. die Größe der Elemente in diesem Bereich, wird mit der Liste Zoom der Funktionsleiste Zoomfaktor oder den Menüpunkten Ansicht > Vergrößern bzw. Ansicht > Verkleinern verändert. Wählen Sie in der Liste Zoom einen Faktor aus der Liste oder tragen Sie einen beliebigen ganzzahligen Wert ein. Die Änderung wirkt immer auf den aktiven KOP/FUP-Editor. Die Einstellung wird beim Speichern nicht mitgespeichert.
22
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.4 KOP/FUP-Editor in den Vordergrund holen
3.4
KOP/FUP-Editor in den Vordergrund holen Sind mehrere KOP/FUP-Editoren im Arbeitsbereich geöffnet, liegen diese meist übereinander. Dadurch ist nur der oberste KOP/FUP-Editor sichtbar. Verdeckte Editoren können auf verschiedene Weise in den Vordergrund geholt werden. So holen Sie den Editor in den Vordergrund: 1. Wählen Sie die entsprechende Registerkarte unterhalb des Arbeitsfensters - oder Wählen Sie im Menü Fenster den entsprechenden Programmnamen.
3.5
Deklarationstabelle aus-/einblenden Bei Platzbedarf können Sie den Deklarationsbereich Interface (exportierte Deklaration) und/oder den Deklarationsbereich an einem KOP/FUP-Programm ganz ausblenden So blenden Sie die Deklarationstabelle aus und ein: 1. Doppelklicken Sie auf die Trennlinie, um die Deklarationstabelle auszublenden. 2. Um den Deklarationsbereich wieder einzublenden, doppelklicken Sie erneut auf die Trennlinie.
3.6
Deklarationstabelle vergrößern/verkleinern So verändern Sie die Größe der Deklarationstabelle: 1. Bewegen Sie den Mauszeiger auf die Trennlinie bis der Mauszeiger sich zu einer Doppellinie verändert. 2. Halten Sie die linke Maustaste gedrückt und verschieben Sie die Trennlinie nach oben, um den Deklarationsbereich zu verkleinern. - oder Verschieben Sie die Trennlinie nach unten, um den Deklarationsbereich zu vergrößern.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
23
KOP/FUP-Editor 3.7 Bedienung
3.7
Bedienung
3.7.1
Bedienung des KOP/FUP-Editors Der KOP/FUP-Editor bietet dem Programmierer verschiedene Bedienmöglichkeiten. Einzelne Bedienschritte können wahlweise ausgeführt werden: ● über die Menüleiste ● über Kontextmenüs ● über Funktionsleisten ● über Tastenkombinationen ● Texte und Variablen können aus dem Projektnavigator, den Deklarationstabellen, dem Symbolbrowser oder der Befehlsbibliothek mit Drag&Drop in das Eingabefeld gezogen werden.
3.7.2
Menüleiste Über die Menüleiste haben Sie Zugriff auf alle Funktionen für die Programmierung. Der Eintrag KOP/FUP-Programm in der Menüleiste ist nur vorhanden, wenn ein KOP/FUPProgramm im Arbeitsbereich aktiv ist.
3.7.3
Kontextmenü So verwenden Sie das Kontextmenü zu einem Objekt: 1. Markieren Sie mit der linken Maustaste das entsprechende Objekt. 2. Drücken Sie kurz die rechte Maustaste. 3. Klicken Sie mit der linken Maustaste auf den entsprechenden Menüeintrag.
3.7.4
Funktionsleisten Die dynamischen Funktionsleisten enthalten Symbole für wichtige und häufig verwendete Funktionen wie z. B. Speichern oder das Einfügen von Elementen. Je nachdem, welcher Arbeitsbereich aktiv/markiert ist z.B. MCC Chart, ST-Programm oder KOP/FUP-Programm, ändert sich die "Dynamische Toolbar". Die Funktionsleisten können innerhalb der Workbench beliebig platziert werden. Sie können nach dem Verschieben unter Ansicht > Funktionsleisten ein- oder ausgeblendet werden. Die Funktionsleiste KOP/FUP-Editor enthält alle KOP/FUP-Befehle. Die Befehlsleiste wird angezeigt, wenn der Arbeitsbereich zu einem Programm aktiv oder geöffnet ist.
24
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.7 Bedienung
①
KOP/FUP-Quelle einfügen
②
Übernehmen und Übersetzen
③
KOP/FUP-Programm einfügen
Bild 3-2
Ansicht der Funktionsleiste der KOP/FUP-Quelle
①
KOP/FUP-Programm einfügen
⑧
Schließer einfügen
②
Übernehmen und Übersetzen
⑨
Öffner einfügen
③
Status Programm
⑩
Spule einfügen
④
Symbolprüfung und Typaktualisierung
⑪
Verzweigung auf
⑤
Wechseln nach FUP
⑫
Verzweigung zu
⑥
Netzwerk einfügen
⑬
Vergleicher einfügen
⑦
Sprungmarke ein/aus
⑭
Leerbox einfügen
Bild 3-3
Ansicht der Funktionsleiste des KOP-Editors
①
KOP/FUP-Programm einfügen
⑧
UND-Box einfügen
②
Übernehmen und Übersetzen
⑨
ODER-Box einfügen
③
Status Programm
⑩
Zuweisung einfügen
④
Symbolprüfung und Typaktualisierung
⑪
Binäreingang
⑤
Wechseln nach KOP
⑫
Binäreingang negieren
⑥
Netzwerk einfügen
⑬
Vergleicher einfügen
⑦
Sprungmarke ein/aus
⑭
Leerbox einfügen
Bild 3-4
Ansicht der Funktionsleiste des FUP-Editors
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
25
KOP/FUP-Editor 3.7 Bedienung
3.7.5
Tastenkombinationen Eine schnelle Bedienung im KOP/FUP-Editor wird durch die Verwendung von Tastenkombinationen erreicht. Die im KOP/FUP-Editor verfügbaren Tastenkombinationen (Seite 331) sind im Anhang aufgelistet.
3.7.6
Drag&Drop von Variablen Variablen werden mit Drag&Drop aus der Detailanzeige (Register Symbolbrowser) in das Eingabefeld eingefügt. So fügen Sie Variablen mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste auf die Zeilennummer der Variablen. Die Zeile mit der Variablen wird markiert. 2. Ziehen Sie mit gedrückter linker Maustaste die Zeilennummer in das Eingabefeld der Parametermaske. 3. Lassen Sie die linke Maustaste los. Die Variable wird an der entsprechenden Position eingefügt.
3.7.7
Drag&Drop aus den Deklarationstabellen Aus einer Deklarationstabelle können Variablennamen mit Drag&Drop in ein KOP/FUPNetzwerk eingefügt werden. So fügen Sie Variablennamen mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste auf die Zeilennummer mit dem gewünschten Variablennamen. Die Zeile wird schwarz hinterlegt. 2. Ziehen Sie mit gedrückter linker Maustaste den Variablennamen in ein beliebiges Eingabefeld. 3. Lassen Sie die linke Maustaste los. Der Variablenname wird an der entsprechenden Position eingefügt.
26
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.7 Bedienung
3.7.8
Drag&Drop in der Deklarationstabelle Sie können die Reihenfolge der Variablendeklaration in der Deklarationstabelle ändern. So verändern Sie die Reihenfolge mit Drag&Drop: 1. Klicken Sie mit der linken Maustaste auf die Zeilennummer der Variablen, die Sie verschieben möchten. Die Zeile wird schwarz hinterlegt. 2. Drücken Sie die Shift-Taste und ziehen Sie mit gedrückter linker Maustaste die Zeile an die gewünschte Stelle in der Deklarationstabelle. Eine rote Linie zeigt die Einfügestelle. 3. Lassen Sie die linke Maustaste los. Die Zeile wird an die entsprechende Stelle verschoben. Hinweis Mit gedrückter Shift-Taste können Sie mehrere zusammenhängende Zeilen markieren, um sie dann gemeinsam zu verschieben.
3.7.9
Drag&Drop von KOP/FUP-Elementen KOP/FUP-Elemente werden mit Drag&Drop aus dem Projektnavigator (Register Befehlsbibliothek) in das KOP/FUP-Netzwerk eingefügt. So fügen Sie KOP/FUP-Elemente mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste das gewünschte KOP/FUP-Element an. 2. Ziehen Sie mit gedrückter linker Maustaste das KOP/FUP-Element auf den Strompfad des KOP/FUP-Netzwerks. 3. Lassen Sie die linke Maustaste los. Das KOP/FUP-Element wird an der entsprechenden Position eingefügt.
3.7.10
Drag&Drop von Befehlsaufrufen Die meisten in der Befehlsbibliothek enthaltenen Befehle können in KOP/FUP-Programme eingefügt werden. Ausnahmen siehe unter "Nichtverwendbare Funktionen in der Befehlsbibliothek (Seite 84)". So fügen Sie Befehlsaufrufe mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste auf den gewünschten Befehlsaufruf. 2. Ziehen Sie mit gedrückter linker Maustaste den Befehlsaufruf ins KOP/FUP-Programm. 3. Lassen Sie die linke Maustaste los. Der Befehlsaufruf wird an der entsprechenden Position eingefügt.
Siehe auch Nichtverwendbare Funktionen in der Befehlsbibliothek (Seite 84)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
27
KOP/FUP-Editor 3.7 Bedienung
3.7.11
Drag&Drop von Befehlsnamen Befehlsnamen können mit Drag&Drop aus dem Projektnavigator in das Eingabefeld (Register Befehlsbibliothek) einer bereits erzeugten Leerbox eingefügt werden. So fügen Sie Befehlsnamen mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste den gewünschten Befehlsnamen an. 2. Ziehen Sie mit gedrückter linker Maustaste den Befehlsnamen in das Eingabefeld einer Leerbox. 3. Lassen Sie die linke Maustaste los. Der Befehlsname wird an der entsprechenden Position eingefügt.
3.7.12
Drag&Drop von Elementen in einem Netzwerk So fügen Sie Elemente in einem Netzwerk mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste das gewünschte Element an. 2. Um ein Element zu Verschieben: Ziehen Sie mit gedrückter linker Maustaste das Element an die gewünschte Stelle im Strompfad. 3. Um ein Element zu Kopieren: Halten Sie die Strg-Taste gedrückt und ziehen Sie mit gedrückter linker Maustaste das Element an die gewünschte Stelle im Strompfad. 4. Lassen Sie die linke Maustaste los. Das Element wird an der entsprechenden Stelle eingefügt.
3.7.13
Drag&Drop von Funktionen und Funktionsbausteinen anderer Quellen Alle fehlerfrei kompilierten Funktionen und Funktionsbausteine anderer Quellen können aus dem Projektnavigator in einem Strompfad eingefügt werden. Die Verbindung zur "Urquelle" wird automatisch im Register Verbindungen der aktuellen Quelle eingetragen. So fügen Sie Funktionen und Funktionsbausteine mit Drag&Drop ein: 1. Klicken Sie mit der linken Maustaste den gewünschten FC/FB an. 2. Ziehen Sie mit gedrückter linker Maustaste den FC/FB in das Eingabefeld einer Leerbox. 3. Lassen Sie die linke Maustaste los. Eine Aufrufbox des FC/FB wird eingefügt.
28
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.8 Einstellungen
3.8
Einstellungen
3.8.1
Einstellung des KOP/FUP-Editors Sie können für die Programmerstellung in der Programmiersprache KOP/FUP das Layout festlegen. Die automatische Symbolprüfung und Typaktualisierung ist standardmäßig im KOP/FUP-Editor eingestellt. 1. Um die Einstellungen zu ändern, wählen Sie den Menüpunkt Extras > Einstellungen > KOP/FUP-Editor.
3.8.2
Automatische Symbolprüfung und Typaktualisierung aktivieren Um die automatische Symbolprüfung und Typaktualisierung zu aktivieren, gehen Sie folgendermaßen vor: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Aktivieren Sie die Checkbox Automatische Symbolprüfung und Typaktualisierung. 4. Bestätigen Sie mit OK. Hinweis Die automatische Symbolprüfung und Typaktualisierung ist im KOP/FUP-Editor standardmäßig aktiviert. Bei eingeschalteter Symbolprüfung erfolgt für ein KOP/FUP-Programm die automatische Symbolprüfung und Typaktualisierung wenn folgende Voraussetzungen zutreffen: ● es sind Änderungen (siehe untere Auflistung) im Projekt erfolgt, die sich auf das KOP/FUP-Programm auswirken ● das KOP/FUP-Programm erhält den Fokus, d. h. es wird im KOP/FUP-Editor geöffnet bzw. der KOP/FUP-Editor des schon geöffneten KOP/FUP-Programms wird in den Vordergrund (Seite 23) geholt Bei folgenden Änderungen in einem Projekt erfolgt für ein KOP/FUP-Programm die automatische Symbolprüfung und Typaktualisierung, wenn sich die jeweilige Änderung auf das KOP/FUP-Programm auswirkt:
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
29
KOP/FUP-Editor 3.8 Einstellungen ● Eine Programmquelle wird geändert z. B. gelöscht, umbenannt. Die Änderungen sind für verbundene Programmquellen und deren KOP/FUP-Programme erst bekannt, wenn die geänderte Programmquelle übersetzt wurde. D. h. damit die automatische Symbolprüfung und Typaktualisierung erfolgen kann, muss die geänderte Programmquelle übersetzt werden bevor ein KOP/FUP-Programm einer verbundenen Programmquelle den Fokus erhält. ● Die Deklarationstabellen der KOP/FUP-Quelle und/oder von KOP/FUP-Programmen innerhalb der KOP/FUP-Quelle werden geändert. Die Symbolprüfung/Typaktualisierung erfolgt für ein zur KOP/FUP-Quelle gehörendes KOP/FUP-Programm, wenn sich die Änderungen auf dieses KOP/FUP-Programm auswirken. Folgende Fälle sind möglich: – Die Änderung einer Deklarationstabelle erfolgt in einem KOP/FUP-Programm. Die automatische Symbolprüfung und Typaktualisierung erfolgt erst nach dem Wechsel von der Deklarationstabelle in das Netzwerk. – Die Änderung einer Deklarationstabelle erfolgt in einem KOP/FUP-Programm und hat Auswirkung auf ein anderes KOP/FUP-Programm in derselben Programmquelle. Die automatische Symbolprüfung und Typaktualisierung erfolgt, wenn dieses andere KOP/FUP-Programm den Fokus erhält. – Die Änderung einer Deklarationstabelle erfolgt in einer Programmquelle und hat Auswirkung auf ein KOP/FUP-Programm in einer anderen Programmquelle. Die automatische Symbolprüfung und Typaktualisierung für das KOP/FUP-Programm einer anderen Programmquelle kann erst erfolgen, wenn die geänderte Programmquelle übersetzt wurde. ● Ein vom KOP/FUP-Programm verwendetes Technologieobjekt (z. B. eine Achse) wird geändert. Die automatische Symbolprüfung und Typaktualisierung erfolgt, wenn das KOP/FUP-Programm den Fokus erhält. Hinweis Der Begriff "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln. Wenn Sie nach erfolgter Symbolprüfung/Typaktualisierung mit dem Mauszeiger auf die jeweilige Stelle (Boxparameter, Eingabefeld, rot gefärbtes Symbol) im Netzwerk gehen, zeigt der Tooltip folgendes an: ● den erwarteten Datentyp bei den Boxparametern ● den Datentyp der Variable bei beschrifteten Eingabefeldern ● die Fehlerursache bei rot gefärbten Symbolen, wobei die Symbolfehler unter anderem folgende Gründe haben können: – das angegebene Symbol existiert nicht – das angegebene Symbol ist im aktuellen Kontext nicht sichtbar (falsche oder fehlende Eingabe der Verbindungen in der Deklarationstabelle) – die angegebene Variable hat nicht den passenden Typ
30
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.8 Einstellungen
Hinweis Die Symbolprüfung wird automatisch aktualisiert, sobald die Deklarationstabelle nach einer Bearbeitung verlassen wird. Alle Fehler, auch die in der Deklarationstabelle, werden in der Detailanzeige ausgegeben.
3.8.3
Beispiel für Typaktualisierung
Einführung Bei der Typaktualisierung werden alle verwendeten Datentypen aktualisiert: ● die Liste der erlaubten Datentypen eines Eingabefeldes ● der Box-Typ eines KOP/FUP-Programms bezüglich seines Typs d. h. des gewählten Erstelltyps (Programm, FB oder FC) des KOP/FUP-Programms ● die Schnittstelle einer Box bezüglich der Liste der erlaubten Datentypen pro Boxparameter ● sonstige Datentypen (Strukturen, Aufzählungen etc.) Beispielsweise wird eine Struktur AAA {a : BOOL} in einem KOP/FUP-Programm verwendet. Wenn diese Struktur geändert wird z. B. AAA {a : BOOL, b : LREAL}, dann wird bei der Typaktualisierung diese Änderung vom KOP/FUP-Programm übernommen.
Ausgangssituation Es sind vorhanden: ● eine ST-Quelle ST_1 mit einem Funktionsbaustein FB_1 ● eine ST-Quelle ST_2 mit einem Funktionsbaustein FB_2 ● eine KOP/FUP-Quelle KOPFUP_1 mit einem KOP/FUP-Programm PROGRAM_1 ● innerhalb von ST_2 wird FB_1 aufgerufen, d. h. es muss in der Deklarationstabelle von ST_2 eine Verbindung (Seite 135) nach ST_1 deklariert sein ● innerhalb von PROGRAM_1 wird FB_1 aufgerufen, d. h. es muss in der Deklarationstabelle von KOPFUP_1 eine Verbindung (Seite 135) nach ST_1 deklariert sein ● innerhalb von PROGRAM_1 wird FB_2 aufgerufen, d. h. es muss in der Deklarationstabelle von KOPFUP_1 eine Verbindung (Seite 135) nach ST_2 deklariert sein
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
31
KOP/FUP-Editor 3.8 Einstellungen
Funktionsweise der Typaktualisierung Es handelt sich hier um den Sonderfall, dass eine Programmquelle (hier KOPFUP_1) eine andere Programmquelle (hier ST_1) sowohl explizit importiert als auch über den Weg der Vererbung importiert. Die Vererbung erfolgt durch eine weitere importierte Programmquelle (hier ST_2), die wiederum andere Quellen (hier ST_1) importiert. 674XHOOH67B )%B 674XHOOH67B
)%B .23)834XHOOH.23)83B
$XIUXI)%B
352*5$0B
$XIUXI)%B $XIUXI)%B
①
KOPFUP_1 importiert explizit ST_1
②
KOPFUP_1 importiert per Vererbung ST_1 (ST_1 → ST_2 → KOPFUP_1)
Bild 3-5
Sonderfall expliziter Import und Vererbung
Es werden nun Änderungen an der Schnittstelle des FB_1 vorgenommen z. B. ein/mehrere Ein-/Ausgangsparamter werden hinzugefügt (siehe auch Schnittstellenabgleich bei FB/FC (Seite 159)) und ST_1 neu übersetzt. Beim Öffnen von PROGRAM_1 im KOP/FUP-Editor erfolgt eine automatische Aktualisierung des Aufrufs von FB_1, d. h. es erfolgt eine Typaktualisierung durch welche die geänderte Schnittstelle aktualisiert wird. Trotz fehlerfreier Typaktualisierung erfolgt beim Übersetzen von KOPFUP_1 eine Fehlermeldung des Compilers, da der Import von ST_1 per Vererbung über die importierte ST_2 voraussetzt, dass ST_2 ebenfalls neu übersetzt wird. Um ST_2 fehlerfrei neu übersetzen zu können, muss innerhalb von ST_2 die geänderte Schnittstelle des Aufrufs von FB_1 manuell aktualisiert werden. Hinweis Werden Programmquellen importiert, welche selber andere Programmquellen importieren (Vererbung), so kann die Übersetzung der importierenden Programmquelle auch bei fehlerfreier Typaktualisierung zu einer Fehlermeldung des Compilers führen.
32
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.8 Einstellungen
3.8.4
Beispiel für Symbolprüfung
Einführung Bei der Symbolprüfung werden die im Netzwerk verwendeten Symbole im Kontext geprüft. Beispielsweise sei eine Box mit einem Eingang vom Typ BOOL im Netzwerk vorhanden. Diesem Eingang wird nun eine Variable vom Typ LREAL zugewiesen wird. Die Symbolprüfung erkennt, dass diese Variable in diesem Kontext nicht verwendbar ist, und stellt diese Variable in roter Färbung dar.
Ausgangssituation Es sind vorhanden: ● eine ST-Quelle ST_1 mit der Unit-Variable VAR_1 ● eine KOP/FUP-Quelle KOPFUP_1 mit einem KOP/FUP-Programm PROGRAM_1 ● innerhalb von PROGRAM_1 wird die Unit-Variable VAR_1 verwendet, d. h. es muss in der Deklarationstabelle von KOPFUP_1 eine Verbindung (Seite 136) nach ST_1 deklariert sein
Funktionsweise der Symbolprüfung Es wird nun die Unit-Variable VAR_1 geändert z. B. der Name wird abgeändert. Wird nach dieser Änderung ST_1 neu übersetzt, wird die Unit-Variable VAR_1 in KOPFUP_1 ungültig. Beim Öffnen von PROGRAM_1 im KOP/FUP-Editor erfolgt eine automatische Symbolprüfung, d. h. die geänderte Variable wird in roter Schrift dargestellt. In PROGRAM_1 muss die geänderte Variable manuell aktualisiert werden.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
33
KOP/FUP-Editor 3.8 Einstellungen
3.8.5
Automatische Symbolprüfung und Typaktualisierung deaktivieren Die automatische Aktualisierung der Symbolprüfung und der Typdatenbank sollte nur aus Leistungsgründen des Rechners abgeschaltet werden, z. B. falls auf einem langsamen Rechner größere Projekte bearbeitet werden und der Anwender nach jeder Änderung in der Deklarationstabelle oder in referenzierten externen Quellen die Sanduhr sieht. So deaktivieren Sie Symbolprüfung und Typaktualisierung: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Deaktivieren Sie die Checkbox Automatische Symbolprüfung und Typaktualisierung. 4. Bestätigen Sie mit OK. Hinweis Bei abgeschalteter automatischer Symbolprüfung kann es zu einer falschen Anzeige kommen. Z. B. nach dem Einfügen eines externen Aufrufs kann die Schnittstelle der Aufruf-Box nicht oder falsch (nicht aktuell) angezeigt werden, weil die aktuellen Infos dem KOP/FUP-Editor erst nach Drücken des Symbol Symbolprüfung und Typaktualisierung oder der entsprechenden Menüauswahl bekannt werden.
3.8.6
Symbolprüfung und Typaktualisierung zu einem bestimmten Zeitpunkt durchführen So führen Sie eine Symbolprüfung zu einem bestimmten Zeitpunkt durch: 1. Wählen Sie den Menüpunkt KOP/FUP-Programm > Automatische Symbolprüfung und Typaktualisierung. - oder Klicken Sie auf das Symbol Symbole überprüfen.
3.8.7
Einstellung der Datentyp-Liste der Deklarationstabelle Im Deklarationsbereich werden standardmäßig in der Liste der Datentypen alle im Programm nicht verwendeten Funktionsbausteine des Projektes angeboten. Um die Übersichtlichkeit zu verbessern, können Sie einstellen, dass nur die Funktionsbausteine angezeigt werden, zu denen auch ein Eintrag im Register Verbindungen existiert. So stellen Sie die Anzeige der Datentypen ein: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Klicken Sie auf die Checkbox Nur bekannte Typen bei Typangabelisten. 4. Bestätigen Sie mit OK.
34
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.8 Einstellungen
3.8.8
Operand- und Kommentarfelder ändern So können Sie die Darstellungsmöglichkeiten von Operand und Kommentar ändern: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Geben Sie die Anzahl der Zeichen pro Zeile für die Operand- und Kommentarfelder ein. 4. Geben Sie die Anzahl der Zeilen für die Operand- und Kommentarfelder ein. 5. Bestätigen Sie mit OK.
3.8.9
Schriftarten ändern So können Sie die Schriftarten des KOP/FUP-Editors ändern: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Klicken Sie auf die Schaltfläche Schriftarten und Farben. Das Dialogfenster Schriftarten und Farben mit dem Register Schriftarten wird geöffnet. 4. Wählen Sie die gewünschte Schriftart, Schriftgrad, Art oder Darstellung.
Bild 3-6
Dialogfenster Schriftarten und Farben
5. Bestätigen Sie mit OK.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
35
KOP/FUP-Editor 3.8 Einstellungen
3.8.10
Farben ändern So können Sie die Farben des KOP/FUP-Editors ändern: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Klicken Sie auf die Schaltfläche Schriftarten und Farben. Das Dialogfenster Schriftarten und Farben wird geöffnet. 4. Klicken Sie auf das Register Farben. 5. Wählen Sie die gewünschte Farbe.
Bild 3-7
Dialogfenster Schriftarten und Farben
6. Bestätigen Sie mit OK.
3.8.11
On-the-fly Variablendeklaration aktivieren Bei eingeschalteter Variablendeklaration wird beim Eingeben eines unbekannten Symbols in der KOP- oder FUP-Grafik ein Dialogfenster eingeblendet. So aktivieren Sie die on-the-fly Variablendeklaration: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Markieren Sie die Checkbox on-the-fly Variablendeklaration. 4. Bestätigen Sie mit OK.
36
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP-Editor 3.8 Einstellungen
3.8.12
Standardsprache einstellen So stellen Sie die Standardsprache ein: 1. Wählen Sie den Menüpunkt Extras > Einstellungen. 2. Wählen Sie das Register KOP/FUP-Editor. 3. Wählen Sie die Standardsprache z.B. KOP. 4. Bestätigen Sie mit OK. Beim Erstellen eines neuen KOP/FUP-Programms wird dann die ausgewählte Sprache KOP eingestellt.
3.8.13
Aufruf der Online-Hilfe im KOP/FUP-Editor Für viele Bedienschritte steht Ihnen eine Online-Hilfe zur Verfügung. Der Aufruf erfolgt über: ● Menü Hilfe – Hilfethemen – Hilfe zum Kontext – Erste Schritte ● Allgemeine Hilfe mit der Taste F1 ● Button Hilfe bei geöffnetem Dialogfenster ● Kontextsensitive Hilfe mit der Tastenkombination Shift+F1 oder dem Symbol Pfeil mit Fragezeichen (auch für KOP/FUP-Elemente in einem Netzwerk).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
37
KOP/FUP programmieren 4.1
4
Software-Programmieren Dieses Kapitel beschreibt die verschiedenen Bedienmöglichkeiten im KOP/FUP-Editor und das grundsätzliche Vorgehen bei der KOP/FUP-Programmierung.
4.2
KOP/FUP-Quelle verwalten Die KOP/FUP-Quellen sind dem SIMOTION Gerät zugeordnet, auf dem sie später ablaufen sollen (z. B. SIMOTION C230). Sie werden im Projektnavigator unter dem SIMOTION Gerät im Ordner PROGRAMME oder in Bibliotheken abgelegt. Unter einer KOP/FUP-Quelle werden die einzelnen Programmorganisationseinheiten (POE) abgelegt. Hinweis Es werden auch ST-Quellen oder MCC-Quellen abgelegt. Eine Beschreibung der Programmiersprachen ST (Structured Text) und MCC (Motion Control Chart) finden Sie in den Programmieranleitungen SIMOTION ST und SIMOTION MCC.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
39
KOP/FUP programmieren 4.2 KOP/FUP-Quelle verwalten
4.2.1
Neue KOP/FUP-Quelle einfügen Sie haben mehrere Möglichkeiten eine KOP/FUP-Quelle einzufügen. So fügen Sie eine KOP/FUP-Quelle ein: 1. Doppelklicken Sie im Projektnavigator im Ordner PROGRAMME auf das Element KOP/FUP-Quelle einfügen. - oder Wählen Sie den Menüpunkt Einfügen >Programm >KOP/FUP-Quelle einfügen. - oder Wählen Sie im Kontextmenü (Ordner PROGRAMM muss markiert sein) Neues Objekt einfügen > KOP/FUP-Quelle einfügen. 2. Geben Sie den Namen der KOP/FUP-Quelle ein. Namen für Programmquellen müssen den Regeln für Bezeichner genügen: Sie sind aus Buchstaben (A … Z, a … z), Ziffern (0 … 9) oder einzelnen Unterstrichen (_) in beliebiger Reihenfolge zusammengesetzt, wobei das erste Zeichen ein Buchstabe oder ein Unterstrich sein muss. Zwischen Groß- und Kleinbuchstaben wird nicht unterschieden. Die zulässige Länge der Namen ist abhängig von der Version des SIMOTION Kernels: – Ab Version V4.1 des SIMOTION Kernels: maximal 128 Zeichen. – Bis Version V4.0 des SIMOTION Kernels: maximal 8 Zeichen. Namen müssen innerhalb des SIMOTION Geräts eindeutig sein. Geschützte oder reservierte Bezeichner (Seite 333) sind nicht erlaubt. Bisher vorhandene KOP/FUPProgramme werden angezeigt. 3. Markieren Sie im Register Compiler die Checkbox Status Programm ermöglichen, um die Online-Statusanzeige zu benutzen. 4. Zusätzlich können Sie Autor, Version und einen Kommentar eingeben.
40
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.2 KOP/FUP-Quelle verwalten 5. Markieren Sie die Checkbox Editor automatisch öffnen.
Bild 4-1
Dialogfenster KOP/FUP-Quelle einfügen
6. Bestätigen Sie mit OK. Es öffnet sich das Dialogfenster Deklarationstabellen.
Bild 4-2
Deklarationstabellen für exportierte und quellinterne Deklarationen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
41
KOP/FUP programmieren 4.2 KOP/FUP-Quelle verwalten
4.2.2
Vorhandene KOP/FUP-Quelle öffnen Alle vorhandenen KOP/FUP-Quellen befinden sich im Projektnavigator im Ordner PROGRAMME. So öffnen Sie eine KOP/FUP-Quelle: 1. Doppelklicken Sie auf den Namen der Quelle. - oder Markieren Sie die KOP/FUP-Quelle und wählen Sie im Kontextmenü den Menüpunkt Öffnen. Die KOP/FUP-Quelle (Deklarationstabellen) wird im Arbeitsfenster geöffnet. Es können mehrere KOP/FUP-Quellen geöffnet werden.
4.2.3
KOP/FUP-Quelle übernehmen und übersetzen
Voraussetzung: Stellen Sie sicher, dass die KOP/FUP-Quelle oder eines der zugehörigen KOP/FUPProgramme das aktive Fenster in der Workbench ist. So übernehmen Sie eine KOP/FUP-Quelle mit allen zugehörigen KOP/FUP-Programmen in das Projekt und starten deren Übersetzung: 1. Wählen Sie in der Funktionsleiste des KOP/FUP-Editors das Symbol Übernehmen und Übersetzen - oder Wählen Sie den Menüpunkt KOP/FUP-Quelle > Übernehmen und übersetzen - oder Markieren Sie die KOP/FUP-Quelle oder ein KOP/FUP-Programm im Projektnavigator und wählen Sie im Kontextmenü Übernehmen und Übersetzen. Hinweis Mit Übernehmen und Übersetzen werden die Änderungen der KOP/FUP-Quelle und der zugehörigen KOP/FUP-Programme nur in das Projekt übernommen. Das Speichern der Daten auf dem Datenträger erfolgt erst zusammen mit dem Projekt durch Projekt > Speichern oder Projekt > Speichern und alles übersetzen. Eine KOP/FUP-Quelle kann auch außerhalb des Projektes gespeichert (exportiert) werden. Fehlermeldungen und Warnungen beim Übersetzen werden im Register Ausgabe übersetzen / prüfen der Detailanzeige angezeigt.
42
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.2 KOP/FUP-Quelle verwalten
4.2.4
Geöffnete KOP/FUP-Quelle schließen So schließen Sie eine im Arbeitsfenster geöffnete KOP/FUP-Quelle: 1. Klicken Sie auf den Button x in der Titelzeile des Dialogfensters der KOP/FUP-Quelle (Kreuz) - oder Wählen Sie den Menüpunkt KOP/FUP-Quelle > Schließen - oder Wählen Sie den Menüpunkt Fenster > alle Fenster schließen Wurden die Änderungen noch nicht in das Projekt übernommen, können Sie die Änderungen in das Projekt übernehmen, verwerfen oder das Schließen abbrechen.
4.2.5
KOP/FUP-Quelle ausschneiden / kopieren / löschen Eine KOP/FUP-Quelle können Sie mit allen zugehörigen KOP/FUP-Programmen ausschneiden bzw. kopieren und unter dem gleichen oder einem anderen SIMOTION Gerät einfügen. Eine gelöschte KOP/FUP-Quelle können Sie nicht mehr einfügen. So können Sie ausschneiden, kopieren oder löschen: 1. Markieren Sie im Projektnavigator die KOP/FUP-Quelle. 2. Wählen Sie im Kontextmenü den entsprechenden Eintrag (Ausschneiden, Kopieren oder Löschen). 3. Ändern Sie ggf. den Namen (siehe dazu unten "Siehe auch").
Siehe auch Umbenennen von KOP/FUP-Quellen (Seite 47)
4.2.6
Ausgeschnittene / kopierte KOP/FUP-Quelle einfügen So fügen Sie eine ausgeschnittene oder kopierte KOP/FUP-Quelle ein: 1. Markieren Sie unter dem SIMOTION Gerät den Ordner PROGRAMME. 2. Wählen Sie im Kontextmenü Einfügen. Die KOP/FUP-Quelle wird unter einem neuen Namen eingefügt. 3. Ändern Sie ggf. den Namen.
4.2.7
Know-how-Schutz für KOP/FUP-Quellen Sie können KOP/FUP-Quellen gegen unbefugten Zugriff durch Dritte schützen. Geschützte KOP/FUP-Quellen und alle zugehörigen KOP/FUP-Programme können Sie dann nur unter Angabe des Kennworts öffnen oder einsehen. Weitere Informationen zum Know-how-Schutz finden Sie in der SIMOTION Online-Hilfe.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
43
KOP/FUP programmieren 4.3 KOP/FUP-Quellen exportieren und importieren
4.3
KOP/FUP-Quellen exportieren und importieren Exportieren und Importieren bietet die Möglichkeit, eine KOP/FUP-Quelle unabhängig vom Projekt auf der Festplatte zu speichern, um es von dort in ein anderes Projekt einzufügen.
4.3.1
KOP/FUP-Quelle im XML-Format exportieren Hinweis Ab Version V4.1 des SIMOTION Kernels ist die Verwendung von Strukturen möglich (z. B. mehrere POEs in einer Quelle, Binärvorverschaltung). Diese Strukturen können von den Vorgängerversionen u. U. nicht verarbeitet werden. Mit dem XML-Export können Sie eine KOP/FUP-Quelle in einem Verzeichnis außerhalb des Projekts versions- und plattformunabhängig speichern. So exportieren Sie ein KOP/FUP-Quelle im XML-Format: 1. Markieren Sie im Projektnavigator die KOP/FUP-Quelle. 2. Wählen Sie im Kontextmenü Experte > Projekt speichern und Objekt exportieren oder das Menü Projekt > Speichern und exportieren. 3. Wählen Sie das Verzeichnis für den XML-Export aus und bestätigen Sie mit OK. Hinweis Auch mit Know-how-Schutz versehene KOP/FUP-Quellen können im XML-Format exportiert werden Der Know-how-Schutz bleibt beim Import erhalten.
4.3.2
KOP/FUP-Quellen als XML-Daten importieren So importieren Sie eine KOP/FUP-Quelle im XML-Format: 1. Markieren Sie im Projektnavigator den Eintrag PROGRAMME oder eine KOP/FUPQuelle. 2. Wählen Sie im Kontextmenü Objekt importieren bzw. Experte > Objekt importieren. 3. Wählen Sie die zu importierenden XML-Daten und bestätigen Sie mit OK. Die KOP/FUP-Quelle wird eingefügt.
44
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.3 KOP/FUP-Quellen exportieren und importieren
4.3.3
POE als XML-Format exportieren Hinweis Ab Version V4.1 des SIMOTION Kernels ist die Verwendung von Strukturen möglich (z. B. mehrere POEs in einer Quelle, Binärvorverschaltung). Diese Strukturen können von den Vorgängerversionen u. U. nicht verarbeitet werden. Mit dem XML-Export können Sie einzelne Programmorganisationseinheiten in einem Verzeichnis außerhalb des Projekts versions- und plattformunabhängig speichern. So exportieren Sie ein POE als XML-Format: 1. Markieren Sie im Projektnavigator in der KOP/FUP-Quelle, die POE, die Sie exportieren wollen. 2. Wählen Sie im Kontextmenü Exportieren als XML. 3. Wählen Sie das Verzeichnis für den XML-Export aus und bestätigen Sie mit OK.
4.3.4
POE aus XML-Format importieren So importieren Sie eine POE im XML-Format: 1. Markieren Sie im Projektnavigator den Eintrag PROGRAMME oder eine KOP/FUPQuelle. 2. Wählen Sie im Kontextmenü Objekt importieren. 3. Wählen Sie die zu importierenden XML-Daten und bestätigen Sie mit OK. Die POE wird eingefügt.
4.3.5
KOP/FUP-Quelle im EXP-Format exportieren So exportieren Sie eine KOP/FUP-Quelle im EXP-Format: 1. Markieren Sie im Projektnavigator die KOP/FUP-Quelle. 2. Wählen Sie das Kontextmenü Experte > Exportieren als .EXP. 3. Tragen Sie den Pfad und den Namen für den EXP-Export ein. 4. Klicken Sie auf Speichern. Unter dem angegebenen Pfad und Namen wird eine EXP-Datei gespeichert.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
45
KOP/FUP programmieren 4.3 KOP/FUP-Quellen exportieren und importieren
4.3.6
EXP-Daten in KOP/FUP-Quelle importieren So importieren Sie EXP-Daten in eine KOP/FUP-Quelle: 1. Markieren Sie im Projektnavigator das KOP/FUP-Programm. 2. Wählen Sie das Kontextmenü Experte > Importieren aus .EXP. 3. Wählen Sie die zu importierenden EXP-Datei. Hinweis Folgende Besonderheiten sind beim Importieren von EXP-Daten zu beachten: • Das Importieren von XOR nach FUP ist möglich • Vorverschaltung mit einfachen Datentypen (Signalverschaltung) wird generell nicht unterstützt. • Beim Import aus EXP-Dateien wird die ursprüngliche Struktur übernommen. Wenn die Struktur wegen Typkonflikten nicht kompilierbar ist, werden die entsprechenden Parameter rot dargestellt. Durch eine manuelle Überarbeitung kann ein Typkonflikt aber behoben werden.
46
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.4 KOP/FUP-Quellen - Eigenschaften festlegen
4.4
KOP/FUP-Quellen - Eigenschaften festlegen
4.4.1
Eigenschaften einer KOP/FUP-Quelle festlegen Die Eigenschaften einer KOP/FUP-Quelle werden bereits bei deren Einfügen festgelegt. So können Sie die Eigenschaften ansehen und ändern: 1. Markieren Sie die KOP/FUP-Quelle im Projektnavigator. 2. Wählen Sie im Kontextmenü Eigenschaften.
Bild 4-3
4.4.2
Eigenschaften einer KOP/FUP-Quelle
Umbenennen von KOP/FUP-Quellen So ändern Sie den Namen einer KOP/FUP-Quelle: 1. Öffnen Sie das Eigenschaftsfenster der KOP/FUP-Quelle. 2. Klicken Sie auf den Button
.
3. Bestätigen Sie den Hinweis mit OK und geben Sie im Dialogfenster Name ändern im Eingabefeld Neuer Name den neuen Namen ein. 4. Bestätigen Sie Ihre Eingabe mit Übernehmen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
47
KOP/FUP programmieren 4.4 KOP/FUP-Quellen - Eigenschaften festlegen
4.4.3
Einstellungen für den Compiler vornehmen Sie können die Einstellungen des Compilers folgendermaßen festlegen: ● global für das SIMOTION Projekt, gültig für alle Programmiersprachen, siehe Globale Einstellungen des Compilers (Seite 48) ● lokal für eine einzelne KOP/FUP-Quelle innerhalb des SIMOTION Projekts, siehe Lokale Einstellungen des Compilers (Seite 49)
4.4.3.1
Globale Einstellungen des Compilers Die globalen Einstellungen sind innerhalb des SIMOTION Projekts für alle Programmiersprachen gültig.
Vorgehensweise 1. Wählen Sie das Menü Extras > Einstellungen. 2. Wählen Sie das Register Compiler. 3. Nehmen Sie die Einstellungen entsprechend der nachfolgenden Tabelle vor. 4. Bestätigen Sie mit OK.
Bild 4-4
Globale Einstellungen des Compilers
Parameter Weitere Hinweise für die Parameterbeschreibung der globalen Einstellungen des Compilers finden Sie im Programmier- und Bedienhandbuch SIMOTION ST.
48
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.4 KOP/FUP-Quellen - Eigenschaften festlegen
4.4.3.2
Lokale Einstellungen des Compilers Die lokalen Einstellungen werden für jede KOP/FUP-Quelle einzeln vorgenommen und überschreiben die globalen Einstellungen.
Vorgehensweise So wählen Sie die Compileroptionen: 1. Öffnen Sie das Eigenschaftsfenster der KOP/FUP-Quelle (siehe Eigenschaften einer KOP/FUP-Quelle festlegen (Seite 47)). 2. Wählen Sie das Register Compiler. 3. Nehmen Sie Einstellungen vor. 4. Bestätigen Sie mit OK.
Bild 4-5
Lokale Einstellungen des Compilers für KOP/FUP-Quellen im Eigenschaftsfenster
Die aktuellen Compileroptionen (die derzeit gültige Kombination von globalen und lokalen Compilereinstellungen) der Programmquelle werden im Register Weitere Einstellungen angezeigt. Die beim letzten Übersetzen der Programmquelle verwendeten Compileroptionen sind im Register Übersetzung einsehbar. Weitere Informationen zur Bedeutung der Compileroptionen finden Sie im Programmier- und Bedienhandbuch SIMOTION ST.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
49
KOP/FUP programmieren 4.4 KOP/FUP-Quellen - Eigenschaften festlegen Tabelle 4- 1
Lokale Einstellungen des Compilers
Parameter
Beschreibung
Globale Einstellungen ignorieren
Siehe Beschreibung unter Wirksamkeit der globalen oder lokalen Einstellungen.
Warnungen unterdrücken
Der Compiler kann zusätzlich zu Fehlermeldungen Warnungen ausgeben. Sie können den Umfang der auszugebenden Warnmeldungen einstellen: Aktiv: Der Compiler gibt die Warnmeldungen entsprechend der Auswahl in den globalen Einstellungen der Warnung-Klassen aus. Die Checkboxen für die Warnung-Klassen sind nicht mehr anwählbar. Inaktiv: Der Compiler gibt die Warnmeldungen entsprechend der Auswahl der WarnungKlassen aus.
Warnung-Klassen1
Nur bei Warnungen unterdrücken = Inaktiv. Aktiv: Der Compiler gibt Warnmeldungen der ausgewählten Klasse aus. Inaktiv: Der Compiler unterdrückt Warnmeldungen der jeweiligen Klasse. Grau hinterlegt: Die angezeigte globale Einstellung wird übernommen (nur bei Globale Einstellungen ignorieren = Inaktiv). Zur Bedeutung der Warnungs-Klassen siehe Programmier- und Bedienhandbuch SIMOTION ST. Hinweis: Bei "Warnungen unterdrücken" = Aktiv sind die Checkboxen sind nicht mehr anwählbar und werden als aktiviert mit grauem Hintergrund dargestellt.
Selektives Linken1
Aktiv: Unbenutzter Code wird aus dem lauffähigen Programm entfernt. Inaktiv: Unbenutzter Code bleibt im lauffähigen Programm erhalten. Grau hinterlegt: Die angezeigte globale Einstellung wird übernommen (nur bei Globale Einstellungen ignorieren = Inaktiv).
Preprozessor verwenden1
Aktiv: Preprozessor wird verwendet (siehe Programmierhandbuch SIMOTION ST). Inaktiv: Preprozessor wird nicht verwendet. Grau hinterlegt: Die angezeigte globale Einstellung wird übernommen (nur bei Globale Einstellungen ignorieren = Inaktiv).
Status Programm ermöglichen1
Aktiv: Zusätzlicher Programmcode wird erzeugt, der die Beobachtung der Programmvariablen (auch lokaler Variablen) ermöglicht (siehe Status Programm (Programmablauf beobachten (Seite 272)). Inaktiv: Status Programm nicht möglich. Grau hinterlegt: Die angezeigte globale Einstellung wird übernommen (nur bei Globale Einstellungen ignorieren = Inaktiv).
Spracherweiterungen zulassen1
Aktiv: Es sind Sprachelemente zulässig, die nicht konform zur IEC 61131-3 sind. • Direkter Bitzugriff auf Variablen eines Bitdatentyps (siehe Beispiel für Programmiersprache ST). • Außerhalb eines Funktionsbausteins auf dessen Eingangsparameter zugreifen (siehe Beispiel für Programmiersprache ST). • Aufruf eines Programms innerhalb eines anderen Programms (siehe Beispiel für Programmiersprache ST). Inaktiv: Nur Sprachelemente zulässig, die konform zur Norm IEC 61131-3 sind. Grau hinterlegt: Die angezeigte globale Einstellung wird übernommen (nur bei Globale Einstellungen ignorieren = Inaktiv).
50
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.4 KOP/FUP-Quellen - Eigenschaften festlegen Parameter
Beschreibung
Programminstanzdaten nur einmal anlegen1
Aktiv: Die lokalen Variablen eines Programms werden nur einmal im Anwenderspeicher der Unit abgelegt. Die Einstellung ist nötig beim Aufruf eines Programms innerhalb eines anderen Programms. Inaktiv: Die lokalen Variablen eines Programms werden entsprechend der Taskzuordnung im Anwenderspeicher der jeweiligen Task abgelegt. Grau hinterlegt: Die angezeigte globale Einstellung wird übernommen (nur bei Globale Einstellungen ignorieren = Inaktiv). Siehe Speicherbereiche der Variablentypen.
OPC-XML ermöglichen
Aktiv: Symbolinformationen der Unit-Variablen der ST-Quelle stehen im SIMOTION Gerät zur Verfügung (notwendig für die Funktionen _exportUnitDataSet und _importUnitDataSet, siehe Funktionshandbuch SIMOTION Basisfunktionen. Inaktiv: Symbolinformationen werden nicht erzeugt.
Auch globale Einstellung möglich (Menü Extras > Einstellungen > Compiler), siehe Globale Einstellungen des Compilers (Seite 48). Siehe auch Beschreibung zur Wirksamkeit der globalen oder lokalen Einstellungen des Compilers.
1
Siehe auch Bedeutung der Warnung-Klassen Eigenschaften einer KOP/FUP-Quelle festlegen (Seite 47) Status Programm (Programmablauf beobachten) (Seite 272) Globale Einstellungen des Compilers (Seite 48) Direkter Bitzugriff auf Variablen eines Bitdatentyps Wirksamkeit der lokalen oder globalen Compilereinstellungen Außerhalb eines Funktionsbausteins auf dessen Eingangsparameter zugreifen Aufruf eines Programms innerhalb eines anderen Programms Speicherbereiche der Variablentypen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
51
KOP/FUP programmieren 4.5 KOP/FUP-Programme verwalten
4.5
KOP/FUP-Programme verwalten KOP/FUP-Programme sind die einzelnen Programmorganisationseinheiten (Programm, Funktion, Funktionsbaustein) in einer KOP/FUP-Quelle. Sie werden im Projektnavigator unter der KOP/FUP-Quelle abgelegt.
4.5.1
Neues KOP/FUP-Programm einfügen So fügen Sie ein neues KOP/FUP-Programm ein: : 1. Öffnen Sie im Projektnavigator das entsprechende SIMOTION Gerät. 2. Öffnen Sie den Ordner PROGRAMME und eine KOP/FUP-Quelle. 3. Doppelklicken Sie auf den Eintrag KOP/FUP-Programm einfügen. 4. Tragen Sie im Dialogfenster KOP/FUP-Programm einfügen den Namen des Programms ein. Die Namen müssen innerhalb einer Quelle eindeutig sein. Geschützte oder reservierte Bezeichner (Seite 333) sind nicht erlaubt. Bisher vorhandene KOP/FUP-Programme der gleichen Quelle werden angezeigt. 5. Wählen Sie als Erstelltyp Programm, Funktion oder Funktionsbaustein, siehe Erstelltyp des KOP/FUP-Programms ändern (Seite 58). 6. Tragen Sie den Namen des KOP/FUP-Programms ein. Der Name eines KOP/FUP-Programms kann bis zu 25 Zeichen lang sein. Der Name der im KOP/FUP-Programmobjekt implementierten Programmorganisationseinheit (POE) kann somit mit dieser Einschränkung eingegeben werden. Im KOP/FUP-Programm ist nur eine Programmorganisationseinheit pro Programmobjekt möglich. 7. Nur bei Erstelltyp Funktion: Wählen Sie als Rückgabetyp den Datentyp des Rückgabewerts ( für keinen Rückgabewert). 8. Aktivieren Sie ggf. Exportierbar, wenn das KOP/FUP-Programm auch in anderen Programmquellen (KOP/FUP-, MCC- oder ST-Quellen) oder im Ablaufsystem verfügbar sein soll. 9. Markieren Sie die Checkbox Editor automatisch öffnen. 10.Bestätigen Sie mit OK.
52
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.5 KOP/FUP-Programme verwalten
Bild 4-6
Dialogfenster KOP/FUP-Programm einfügen
①
Name der KOP/FUP-Quelle
②
Name des KOP/FUP-Programms
Bild 4-7
Darstellung des Quell- und Programmnamens im Projektnavigator
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
53
KOP/FUP programmieren 4.5 KOP/FUP-Programme verwalten
4.5.2
Vorhandenes KOP/FUP-Programm öffnen Alle KOP/FUP-Programme zu einer KOP/FUP-Quelle befinden sich im Projektnavigator unterhalb der betreffenden KOP/FUP-Quelle. So öffnen Sie ein vorhandenes Programm: 1. Öffnen Sie im Projektnavigator den Teilbaum des entsprechenden SIMOTION Geräts. 2. Öffnen Sie im Ordner PROGRAMME die gewünschte KOP/FUP-Quelle. 3. Markieren Sie das gewünschte KOP/FUP-Programm. 4. Wählen Sie im Kontextmenü Öffnen. Das KOP/FUP-Programm wird im Arbeitsbereich geöffnet. Es können mehrere KOP/FUP-Programme geöffnet werden.
4.5.3
Reihenfolge der KOP/FUP-Programme in der KOP/FUP-Quelle festlegen KOP/FUP-Programme in der KOP/FUP-Quelle werden in der Reihenfolge übersetzt und abgearbeitet, wie sie im Projektnavigator angezeigt werden. Deshalb ist es u.U. notwendig die Reihenfolge der KOP/FUP-Programme zu ändern. Eine POE (z. B. Funktion) muss definiert sein, bevor sie verwendet wird. So können Sie die Reihenfolge ändern: 1. Markieren Sie im Projektnavigator ein KOP/FUP-Programm. 2. Wählen Sie im Kontextmenü Nach oben / Nach unten.
4.5.4
KOP/FUP-Programm kopieren So kopieren Sie ein KOP/FUP-Programm: . 1. Markieren Sie in Ihrer KOP/FUP-Quelle die POE, die Sie kopieren wollen. 2. Wählen Sie im Kontextmenü Kopieren. 3. Markieren Sie die KOP/FUP-Quelle, in die POE eingefügt werden soll. 4. Wählen Sie im Kontextmenü den Eintrag Einfügen. Das KOP/FUP-Programm wird eingefügt.
54
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.5 KOP/FUP-Programme verwalten
4.5.5
KOP/FUP-Programm übernehmen und übersetzen In der Titelzeile des Projekts wird an den Namen eines geänderten aber noch nicht gespeicherten Programms ein Sternchen angefügt. Hinweis Die ganze Quelle mit ihren POEs wird übernommen und übersetzt So übernehmen Sie das KOP/FUP-Programm und starten die Übersetzung: 1. Klicken Sie auf das Symbol Übernehmen und Übersetzen in der Funktionsleiste KOP/FUP-Editor. - oder Wählen Sie den Menüpunkt KOP/FUP-Programm > Übernehmen und Übersetzen. - oder Markieren Sie das KOP/FUP-Programm im Projektnavigator und wählen Sie im Kontextmenü Übernehmen und Übersetzen. - oder Wenn Sie alle vorhandenen KOP/FUP-Programme speichern und übersetzen wollen, wählen Sie den Menüpunkt Projekt > Speichern und alles übersetzen. Treten beim Übersetzen Fehler auf, werden die Fehlerstellen in der Detailanzeige angezeigt. 2. Um den Fehler zu beheben, doppelklicken Sie in der Detailanzeige im Register Ausgabe übersetzen / prüfen auf eine Fehlermeldung. Das fehlerhafte Element wird markiert und im Fenster positioniert. Hinweis Rückwärtskompatibilität Diese SCOUT Programm-Version ermöglicht Strukturen (z.B. mehrere POEs in einer Quelle, Binärvorverschaltung), die von den Vorgängerversionen u.U. nicht verarbeitet werden können.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
55
KOP/FUP programmieren 4.5 KOP/FUP-Programme verwalten
4.5.6
KOP/FUP-Programm schließen So schließen Sie ein im Arbeitsfenster geöffnetes KOP/FUP-Programm: 1. Klicken Sie auf den Button x in der Titelzeile des Dialogfensters des KOP/FUPProgramms (Kreuz) - oder Wählen Sie den Menüpunkt KOP/FUP-Programm > Schließen - oder Wählen Sie den Menüpunkt Fenster > Alle schließen Wurden die Änderungen noch nicht gespeichert, können Sie die Änderungen speichern, verwerfen oder das Schließen abbrechen.
4.5.7
KOP/FUP-Programm löschen So löschen Sie ein KOP/FUP-Programm: 1. Markieren Sie im Projektnavigator das KOP/FUP-Programm. 2. Wählen Sie im Kontextmenü den Eintrag Löschen. Hinweis Ein gelöschtes KOP/FUP-Programm können Sie nicht mehr einfügen.
56
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.6 KOP/FUP-Programme - Eigenschaften festlegen
4.6
KOP/FUP-Programme - Eigenschaften festlegen Die Eigenschaften eines KOP/FUP-Programms werden bereits bei dessen Einfügen festgelegt. So können Sie diese Eigenschaften ansehen und ändern: 1. Öffnen Sie unter dem SIMOTION Gerät den Ordner PROGRAMME und die gewünschte KOP/FUP-Quelle. 2. Markieren Sie das gewünschte KOP/FUP-Programm. 3. Wählen Sie im Kontextmenü Eigenschaften. Es öffnet sich das Dialogfenster Objekt Eigenschaften.
4.6.1
Umbenennen eines KOP/FUP-Programms So ändern Sie den Namen eines KOP/FUP-Programms: 1. Öffnen Sie das Eigenschaftsfenster des KOP/FUP-Programms. 2. Klicken Sie auf den Button
.
3. Bestätigen Sie den Hinweis mit OK und geben Sie im Dialogfenster Name ändern im Eingabefeld Neuer Name den neuen Namen ein. 4. Bestätigen Sie Ihre Eingabe mit Übernehmen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
57
KOP/FUP programmieren 4.6 KOP/FUP-Programme - Eigenschaften festlegen
4.6.2
Erstelltyp des KOP/FUP-Programms ändern So ändern Sie den Erstelltyp des KOP/FUP-Programms: 1. Wählen Sie den neuen Erstelltyp: Programm Programme sind mit den Funktionsbausteinen vergleichbar. Hier können lokale Variablen statisch oder temporär angelegt werden. Programme können im Gegensatz zu FB und FC im SIMOTION SCOUT einer Task bzw. einer Ablaufebene zugeordnet werden. Programme können nicht mit Parametern aufgerufen werden. Sie besitzen deshalb auch keine Formalparameter wie FB und FC. Funktionsbaustein (FB) Ein Funktionsbaustein (FB) ist ein Programm mit statischen Daten, d. h. lokale Variablen behalten ihren Wert bei, wenn der Funktionsbaustein abgearbeitet ist. Nur explizit als temporär deklarierte Variablen verlieren ihren Wert zwischen zwei Aufrufen. Vor der Verwendung eines FB muss eine Instanz definiert werden: Sie definieren eine Variable (VAR oder VAR_GLOBAL) und tragen als Datentyp den Namen des FB ein. In dieser Instanz werden die statischen Daten des FB gespeichert. Sie können mehrere Instanzen eines FB definieren, jede Instanz ist unabhängig von den anderen. Die statischen Daten einer FB-Instanz bleiben bis zum nächsten Aufruf dieser Instanz erhalten; sie werden neu initialisiert, wenn der Variablentyp der FB-Instanz neu initialisiert wird. Die Datenübergabe an den FB erfolgt über Eingangs- oder Durchgangsparameter; die Datenrückgabe aus dem FB erfolgt über Durchgangs- und Ausgangsparameter. Funktion (FC) Eine Funktion (FC) ist ein Funktionsbaustein ohne statische Daten, d. h. alle lokalen Variablen verlieren ihren Wert, wenn die Funktion abgearbeitet ist. Sie werden beim nächsten Start der Funktion neu initialisiert. Die Datenübergabe an die Funktion erfolgt über Eingangsparameter; die Ausgabe eines Funktionswertes (Rückgabewert) ist möglich.
58
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.7 Quellen und Programme drucken
4.7
Quellen und Programme drucken Sie können allgemeine Informationen der KOP/FUP-Quellen und -Programme drucken. Für den Druck können Druckoptionen eingestellt werden. So drucken Sie KOP/FUP-Quellen und -Programme: 1. Markieren Sie eine KOP/FUP-Quelle oder -Programm. 2. Wählen Sie im Kontextmenü Drucken oder Druckvorschau. Es erscheint das Dialogfenster Drucken, in dem Sie verschiedene Druckoptionen einstellen können.
Bild 4-8
Dialogfenster zum Einstellen der Druckoptionen
3. Klicken Sie auf die Schaltfläche Drucken. Die Quelle bzw. das KOP/FUP-Programm wird mit den gewählten Optionen gedruckt. Im Druckbild werden die allgemeinen Informationen, die Deklarationstabelle und die Grafik dargestellt.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
59
KOP/FUP programmieren 4.7 Quellen und Programme drucken
4.7.1
Deklarationstabelle drucken So drucken Sie die Deklarationstabelle: 1. Markieren Sie die Checkbox Deklarationstabelle drucken. 2. Wählen Sie Spaltenbreiten nach Bildschirm. Der Inhalt der Deklarationstabelle wird mit den eingestellten Spaltenbreiten gedruckt. - oder Wählen Sie Spaltenbreiten default.
4.7.2
Netzwerkbereich drucken So drucken Sie einen Netzwerkbereich: 1. Markieren Sie die Checkbox Netzwerkbereich drucken. 2. Wählen Sie alle Netzwerke. - oder Wählen Sie nur ausgewählte Netzwerke. Nur die im Editor ausgewählten Netzwerke (blaue Markierung am linken Rand) werden gedruckt.
4.7.3
Kommentare drucken Sie können diese Option nur dann wählen, wenn Sie vorher die Option Netzwerkbereich drucken gewählt haben. So drucken Sie Kommentare: 1. Markieren Sie die Checkbox Kommentare drucken. 2. Um ein kürzeres und übersichtliches Druckbild zu erhalten, demarkieren Sie die Option Kommentare drucken.
60
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.7 Quellen und Programme drucken
4.7.4
Druckvariante definieren So definieren Sie die Druckvariante: 1. Markieren Sie die Checkbox. 2. Markieren Sie Grafik auf Seitenbreite anpassen. Das Druckbild wird so skaliert, dass das KOP/FUP-Netzwerk mit der größten Breite auf eine Seitenbreite passt. Das Druckbild wird eine Seite breit und abhängig von der Größe des Programms eine oder mehrere Seiten hoch. - oder Markieren Sie Grafik auf Seitenhöhe anpassen. Das Druckbild wird so skaliert, dass die gesamte Grafik auf eine Seitenhöhe passt. Das Druckbild wird eine Seite hoch und abhängig von der Breite der Netzwerke eine oder mehrere Seiten breit. - oder Markieren Sie Grafik auf eine Seite anpassen. Das Druckbild wird soweit verkleinert, dass alle Netzwerke auf eine Seite passen. - oder Markieren Sie Grafik in 100%. Das Drucken erfolgt in originaler Größe. Das Druckbild kann horizontal oder vertikal aus mehreren Seiten bestehen. - oder Markieren Sie Zoomfaktor vom Bildschirm übernehmen. Das Drucken wird entsprechend des im Editor eingestellten Zoomfaktors durchgeführt. Das Druckbild kann horizontal oder vertikal aus mehreren Seiten bestehen. Hinweis Sind mehrere Seiten vorhanden, wird eine Indexseite zur Übersicht gedruckt.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
61
KOP/FUP programmieren 4.7 Quellen und Programme drucken
4.7.5
Netzwerke platzieren Mit Netzwerk platzieren legen Sie fest, wie Netzwerke beim Drucken auf die Seiten aufgeteilt werden. So platzieren Sie Netzwerke: 1. Markieren Sie die Checkbox Netzwerke platzieren. 2. Wählen Sie kontinuierlich. Die Netzwerke werden direkt aufeinander folgend gedruckt. Seitenumbrüche werden dabei nicht berücksichtigt. - oder Wählen Sie alle auf neue Seite. Alle Netzwerke werden auf einer neuen Seite beginnend gedruckt. Wenn ein Netzwerk länger als eine Seite ist, wird es auf die nächsten Seiten gedruckt. - oder Wählen Sie optimiert. Die horizontale Unterbrechung der Netzwerke wird dadurch minimiert und gleichzeitig wird mehr Platz gespart. Z.B.: passt ein Netzwerk nicht mehr auf die aktuelle Seite und ist nicht länger als eine Seite, wird dieses Netzwerk auf die nächste Seite gedruckt. Ist das Netzwerk länger als eine Seite, ist die Unterbrechung unumgänglich.
4.7.6
Leere Seiten Sie können das Drucken von leeren Seiten beeinflussen. Das Layout wird auf der Indexseite angezeigt. Die mit X gekennzeichneten Seiten werden weglassen. So stellen Sie den Druck leerer Seiten ein: 1. Markieren Sie die Checkbox Leere Seiten. 2. Wählen Sie alle drucken. Alle leeren Seiten werden ausgedruckt. - oder Wählen Sie am Ende weglassen. Leere Seiten am Ende werden nicht gedruckt. Leere Seiten in der Mitte bleiben erhalten. - oder Wählen Sie alle weglassen. Leere Seiten werden weder in der Mitte noch am Ende gedruckt.
62
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.8 KOP/FUP-Netzwerke und -Elemente
4.8
KOP/FUP-Netzwerke und -Elemente Das KOP/FUP-Programm ist in Netzwerken organisiert, die im Editorbereich dargestellt sind. Ein Netzwerk enthält eine Logik, die den Strompfad repräsentiert. Für die Anzeige eines Netzwerks gelten die in der Norm IEC 61131-3 beschriebenen Regeln für den Aufbau eines Netzwerks. In einem Netzwerk können Sie mehrere KOP/FUPElemente und Boxen einfügen, kopieren oder löschen.
①
Name des Programms und Kommentarbereich
⑤
Netzwerk 2
②
Aufrufbox
⑥
Markiertes KOP-Element
③
KOP-Element
⑦
Name des Netzwerks und Kommentarbereich
④
Netzwerk 1
⑧
Markiertes Netzwerk
Bild 4-9
Darstellung der Netzwerke im KOP/FUP-Editor
Siehe auch Nummerierung der Netzwerke (Seite 65)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
63
KOP/FUP programmieren 4.8 KOP/FUP-Netzwerke und -Elemente
4.8.1
Netzwerke einfügen So fügen Sie ein Netzwerk ein: 1. Markieren Sie ein schon vorhandenes Netzwerk oder klicken Sie in das Arbeitsfenster des geöffnetes KOP/FUP-Programms. 2. Wählen Sie im Kontextmenü Netzwerk einfügen. - oder Wählen Sie den Menüpunkt KOP/FUP-Programm > Netzwerk einfügen. - oder Klicken Sie auf das Symbol Netzwerk einfügen. Das neue Netzwerk wird direkt nach dem aktuell markierten Netzwerk eingefügt. Wurde kein Netzwerk markiert, dann wird das neue Netzwerk am Anfang eingefügt.
Siehe auch KOP/FUP-Netzwerke und -Elemente (Seite 63)
4.8.2
Netzwerke markieren Um Netzwerke beispielsweise zu kopieren, müssen diese vorher markiert werden. So markieren Sie Netzwerke: 1. Klicken Sie auf das gewünschte Netzwerk. Das Netzwerk ist markiert (siehe Abbildung). - oder Wenn Sie mehrere zusammenhängende Netzwerke markieren wollen, klicken Sie auf das erste entsprechende Netzwerk und klicken Sie mit gedrückter Shift-Taste auf das letzte gewünschte Netzwerk. - oder Wenn Sie mehrere nicht zusammenhängende Netzwerke markieren wollen, klicken Sie mit gedrückter Strg-Taste auf das jeweils gewünschte Netzwerk. Markierte Netzwerke sind erkennbar durch einen hellblauen Rand an der linken Netzwerkseite. Die Farbe der Markierung können Sie über das Register KOP/FUP-Editor im Dialogfenster Einstellungen selbst bestimmen.
64
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.8 KOP/FUP-Netzwerke und -Elemente
Bild 4-10
Markiertes Netzwerk
Siehe auch Einstellung des KOP/FUP-Editors (Seite 29)
4.8.3
Nummerierung der Netzwerke Beim Einfügen eines Netzwerks wird dieses automatisch mit einer laufenden Nummer versehen. Diese Nummer ist eindeutig und dient zum Identifizieren des Netzwerks. Hinweis Sie können die Nummerierung nicht ändern. Nach dem Löschen eines Netzwerks, wird die Nummerierung automatisch angepasst.
Siehe auch KOP/FUP-Netzwerke und -Elemente (Seite 63)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
65
KOP/FUP programmieren 4.8 KOP/FUP-Netzwerke und -Elemente
4.8.4
Titel/Kommentar eingeben
Titel und Kommentare Standardmäßig enthält das KOP/FUP-Programm bzw. das Netzwerk eine Titel- und eine Kommentarzeile. Die Titel- und Kommentartexte sind sprachabhängig.
Sprachabhängige Texte Mit dem Menüpunkt Projekt > Sprachabhängige Texte können Sie für KOP/FUPNetzwerkkommentare und Symbolbrowserkommentare (I/0 Variablen, Geräteglobale Variablen) sprachabhängige ASCII-Dateien für die Übersetzung ex- und importieren. Die exportierten Dateien (Button Export) können Sie nach dem Übersetzungsvorgang durch die Importfunktion (Button Import), wieder in das Projekt importieren. Nach einer Sprachumschaltung, sind auch die benutzerdefinierten Kommentare im Projekt in der jeweiligen übersetzten Sprache vorhanden.
Titel vergeben Der Titel/Name wird zur Dokumentation des KOP/FUP-Programms bzw. des Netzwerks verwendet. Er ist mit dem Namen "Titel" vorbelegt. So geben Sie den Titel ein: 1. Klicken Sie in die Titelzeile. 2. Tragen Sie einen anderen Titel/Namen in das aufgeblendete Fenster ein. Die Textlänge ist unbegrenzt. Die am Bildschirm sichtbare Textlänge ist abhängig von Schriftgröße, Schriftart und Auflösung des Bildschirms.
Kommentare eingeben/ändern Sie können in jedem Programm/Netzwerk einen Kommentar eingeben. So geben Sie Kommentare ein: 1. Klicken Sie in die Kommentarzeile. 2. Tragen Sie den Text des Kommentars in das aufgeblendete Fenster ein. 3. Um einen vorhandenen Kommentar zu ändern, doppelklicken Sie auf den vorhandenen Kommentar. 4. Überschreiben Sie den jetzt markierten Text
66
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.8 KOP/FUP-Netzwerke und -Elemente
Kommentarzeile ein-/ausblenden Sie können in jedem Programm/Netzwerk den eingegebenen Kommentar ausblenden. So blenden Sie Kommentare ein und aus: 1. Klicken Sie in das Arbeitsfenster des geöffnetes KOP/FUP-Programms. 2. Wählen Sie im Kontextmenü Anzeige > Kommentare ein/aus. - oder Wählen Sie den Menüpunkt KOP/FUP-Programm > Anzeige > Kommentare ein/aus. Die Einstellung wird beim Speichern mit gespeichert.
4.8.5
Sprungmarke ein-/ausblenden Sie können in jedem Netzwerk eine Sprungmarke einfügen. So fügen Sie Sprungmarken ein bzw. blenden diese aus: 1. Markieren Sie das Netzwerk, in dem Sie die Sprungmarke einfügen wollen. 2. Wählen Sie im Kontextmenü des Netzwerks Sprungmarke ein/aus. 3. Tragen Sie den Text der Sprungmarke in das aufgeblendete Fenster ein. Bei der Eingabe sind nur alphanumerische Zeichen und Unterstriche erlaubt. Die Textlänge eines Labels ist auf 480 Zeichen begrenzt. Hinweis Die Sprungmarke wird bei fehlerhafter Eingabe gelöscht und kann nicht korrigiert werden. 4. Wenn Sie eine Sprungmarke ausblenden wollen, markieren Sie die gewünschte Sprungmarke und wählen Sie im Kontextmenü Sprungmarke ein/aus.
Siehe auch Sprungoperationen Übersicht (Seite 225)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
67
KOP/FUP programmieren 4.8 KOP/FUP-Netzwerke und -Elemente
4.8.6
Netzwerke kopieren/ausschneiden/einfügen Wenn Sie ein Netzwerk kopieren bzw. ausschneiden und anschließend wieder einfügen, werden alle enthaltenen KOP/FUP-Elemente mitgenommen. So kopieren Sie ein Netzwerk: 1. Markieren Sie das gewünschte Netzwerk. 2. Wählen Sie im Kontextmenü Kopieren oder Ausschneiden. - oder Wählen Sie den Menüpunkt Bearbeiten > Kopieren oder Bearbeiten > Ausschneiden. Das kopierte Netzwerk können Sie an einer beliebigen Stelle oder auch in andere KOP/FUP-Programme wieder einfügen. Ein neues/kopiertes oder ausgeschnittenes Netzwerk wird immer nach dem markierten Netzwerk eingefügt. Ist kein Netzwerk markiert, wird das neue Netzwerk als erstes Netzwerk platziert.
4.8.7
Aktionen Rückgängig/Wiederholen Hinweis Folgende Aktionen können nicht rückgängig gemacht werden: - Speichern - Speichern und übersetzen So werden Aktionen rückgängig gemacht bzw. wiederholt: 1. Wählen Sie den Menüpunkt Bearbeiten > Rückgängig oder das Symbol Rückgängig. Die Aktionen werden in umgekehrter Reihenfolge rückgängig gemacht. 2. Sollen eine oder mehrere rückgängig gemachte Aktionen erneut ausgeführt werden, wählen Sie den Menüpunkt Bearbeiten > Wiederholen oder das Symbol Wiederholen.
4.8.8
Netzwerke löschen So löschen Sie ein Netzwerk: 1. Klicken Sie im geöffnetem KOP/FUP-Programm in ein Netzwerk. 2. Wählen Sie im Kontextmenü Netzwerk löschen.
68
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.9 Darstellung der KOP/FUP-Elemente
4.9
Darstellung der KOP/FUP-Elemente
4.9.1
KOP-Grafik
KOP-Grafik Die KOP-Grafik entspricht der Norm IEC 61131-3 und organisiert sich um den binären Strompfad. Der Strompfad beginnt mit einer vertikalen Linie (Stromschiene) und endet mit einer Spule, Aufruf (Box) oder mit einem Sprung in ein anderes Netzwerk. Dazwischen befinden sich spezielle KOP-Elemente (Schließer, Öffner, Konnektor), allgemeine logische Elemente (SR, RS-FlipFlop) und Aufrufe von Systemkomponenten (z. B. arithmetische Operationen) und Anwender-Funktionen, bzw. -Funktionsbausteine.
Regeln für die Eingabe von KOP-Anweisungen ● Anfang eines KOP-Netzwerks Der Ausgangspunkt eines Netzwerks ist die linke Stromschiene. In einer KOP-Grafik sind keine Linienkreuzungen erlaubt. Folgende Elemente sind am Anfang eines Netzwerks nicht erlaubt: (P), (N), (#). ● Abschluss eines KOP-Netzwerks Jedes KOP-Netzwerk muss einen Abschluss in Form einer Spule oder einer Box haben. Mehrfachausgänge sind möglich. Folgende KOP-Elemente dürfen Sie nicht als Abschluss eines Netzwerks verwenden: – (P), – (N), – POS, – NEG, – Vergleicher. ● Platzierung von Leerboxen Leerboxen können an jeder beliebigen Stelle eines Netzwerks platziert werden, außer am rechten Rand und im Parallelzweig. Vorverschaltung an Binäreingängen sind möglich. ● Platzierung von Spulen Spulen werden automatisch an den rechten Rand des Netzwerks platziert, wo sie den Abschluss eines Zweigs bilden.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
69
KOP/FUP programmieren 4.9 Darstellung der KOP/FUP-Elemente ● Parallele Verzweigungen Parallelzweige werden – nach unten geöffnet und nach oben geschlossen. – hinter dem markierten KOP-Element geöffnet. – hinter dem markierten KOP-Element geschlossen. Zwischen zwei Parallelzweigen kann ein weiterer Zweig eingefügt werden. Um einen Parallelzweig zu löschen, müssen Sie alle KOP-Elemente dieses Zweiges löschen. Beim Entfernen des letzten KOP-Elements der Verzweigung wird der Rest der Verzweigung ebenfalls entfernt. Folgende Elemente sind im Parallelzweig nicht erlaubt: – (P), – (N), – (#), – Leerbox. Folgende Elemente sind im Parallelzweig erlaubt: – Kontakte, – Vergleicher, – Flankenerkennung (POS, NEG). Parallelzweige, die direkt von der Stromschiene abzweigen, bilden eine Ausnahme von diesen Platzierungsregeln: hier können alle Elemente platziert werden. ● Konstanten und Enums Binäre Verknüpfungen können auch mit Konstanten (z. B. TRUE oder FALSE) belegt werden. Parameter von FB/FC können mit Konstanten, die dem Datentyp des Parameters entsprechen beschaltet werden. Soll ein Parameter mit einem projektweit nicht eindeutigen Enum-Wert beschaltet werden, so ist dem Enum-Wert der Enum-Typ getrennt durch # voranzustellen.
4.9.2
Bedeutung von EN/ENO
Freigabeeingang (EN) und Freigabeausgang (ENO) der KOP-Box Die Parameter des Freigabeeingangs (EN) und des Freigabeausgangs (ENO) der KOP-Box funktionieren nach den folgenden Prinzipien: . . ● Wird EN nicht aktiviert (d. h. der Signalzustand ist "0"), dann führt die Box ihre Funktion nicht aus, und ENO wird nicht aktiviert (d. h. der Signalzustand ist auch "0"). ● Wird EN aktiviert (d. h. der Signalzustand ist "1") und führt die entsprechende Box ihre Funktion aus, dann wird ENO auch aktiviert (d. h. der Signalzustand ist auch "1").
70
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.9 Darstellung der KOP/FUP-Elemente
4.9.3
FUP-Grafik
FUP-Grafik Die FUP-Grafik entspricht der Norm IEC 61131-3. Der Haupt-Binär-Signalpfad beginnt mit einer Logikbox (links oben) und endet mit einer Zuweisung, Aufruf (Box) oder mit einem Sprung in ein anderes Netzwerk. Dazwischen befinden sich Logik-Elemente (UND-, ODER-Box) allgemeine logische Elemente (SR, RS-FlipFlop) und Aufrufe von Systemkomponenten (z. B. arithmetische Operationen) und von Anwender-Funktionen, bzw. -Funktionsbausteinen.
Regeln für die Eingabe von FUP-Anweisungen ● Platzierung von Boxen An Boxen mit binären Verknüpfungen (&, >=1, XOR) können Leerboxen (FlipFlops, Zähler, Zeiten, Rechenoperationen, gerätespezifische Befehle, TO-spezifische Befehle usw.) angefügt werden. Vorverschaltungen an Binäreingängen (z.B. S-Eingang am FlipFlop) sind erlaubt. In einem Netzwerk können keine voneinander getrennten Verknüpfungen mit separaten Ausgängen programmiert werden. Abzweigungen sind nicht möglich.
Bild 4-11
FUP mit binärer Vorverschaltung
● &, >=1, XOR-Boxen An diesen Boxen können Binäreingänge eingefügt, gelöscht bzw. negiert werden. ● Freigabeeingang/-Freigabeausgang Die Beschaltung des Freigabeeingangs EN bzw. des Freigabeausgangs ENO von Boxen ist möglich. ● Konstanten und Enums Binäre Verknüpfungen können auch mit Konstanten (z. B. TRUE oder FALSE) belegt werden. Parameter von FB/FC können mit Konstanten, die dem Datentyp des Parameters entsprechen beschaltet werden. Soll ein Parameter mit einem projektweit nicht eindeutigen Enum-Wert beschaltet werden, so ist dem Enum-Wert der Enum-Typ getrennt durch # voranzustellen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
71
KOP/FUP programmieren 4.9 Darstellung der KOP/FUP-Elemente
4.9.4
Umschaltung zwischen KOP- und FUP-Darstellung
Von KOP- nach FUP-Darstellung umschalten So schalten Sie von KOP- in die FUP-Darstellung: 1. Öffnen Sie ein vorhandenes KOP-Projekt. 2. Wählen Sie den Menüpunkt KOP/FUP-Programm > Wechseln nach FUP. - oder Klicken Sie in der Funktionsleiste des KOP-Editors auf die Schaltfläche nach FUP" (Tastenkürzel Strg+3).
für "Wechseln
Das Projekt wird in der Programmiersprache FUP dargestellt.
Bild 4-12
Umschalten von KOP nach FUP
Hinweis Eine Umwandlungskette KOP - FUP - KOP produziert immer das originale Netzwerk. Was in KOP erzeugt wurde, lässt sich immer in FUP-Form darstellen.
72
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.9 Darstellung der KOP/FUP-Elemente
Von FUP- nach KOP-Darstellung umschalten So schalten Sie von FUP- in die KOP-Darstellung: 1. Öffnen Sie ein vorhandenes FUP-Projekt. 2. Wählen Sie den Menüpunkt KOP/FUP-Programm > Wechseln nach KOP. - oder Klicken Sie in der Funktionsleiste des FUP-Editors auf die Schaltfläche nach KOP"(Tastenkürzel Strg+1).
für "Wechseln
Das Projekt wird in der Programmiersprache KOP dargestellt.
Bild 4-13
Umschalten von FUP nach KOP, Beispiel ODER-Box
Hinweis Eine Umwandlungskette FUP- KOP- FUP produziert nur dann das originale KOPNetzwerk, wenn die FUP-Struktur nach KOP konvertiert werden kann. Was in FUP erzeugt wurde, lässt sich nicht immer in KOP-Form darstellen.
Beispiel für eine nichtkonvertierbare FUP-Struktur
Bild 4-14
FUP-Struktur mit binärer XOR-Box
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
73
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10
KOP/FUP-Elemente bearbeiten
4.10.1
KOP/FUP-Elemente einfügen KOP/FUP-Elemente werden in der Regel rechts von der markierten Position im Netzwerk eingefügt. FUP-Elemente werden in der Regel an einem boolschen Eingang eines Bausteins bzw. an einer Zuweisung (links) eingefügt Sonderfall: Ist der rechte Rand eines Netzwerks bzw. eine Spule (KOP) oder eine Zuweisung (FUP) markiert, so wird das nächste Element links davon in das Netzwerk eingefügt. So fügen Sie KOP/FUP-Elemente ein: 1. Markieren Sie die gewünschte Stelle in einem Netzwerk, hinter der ein KOP/FUPElement eingefügt werden soll. 2. Fügen Sie ein KOP/FUP-Element ein: – über die Symbole in der Funktionsleiste – über den Menüpunkt z. B. KOP/FUP-Programm > Element einfügen > Leerbox – durch Drag&Drop aus dem Register Befehlsbibliothek – durch Doppelklick auf das Element im Register Befehlsbibliothek – durch Markieren des Elements im Register Befehlsbibliothek und Bestätigen mit der Enter-Taste Das ausgewählte KOP/FUP-Element wird eingefügt, wobei für die Variablen und Parameter die Platzhalter und ... eingefügt werden. Hinweis Die rot dargestellte Zeichenfolge ??? kennzeichnet die Pflichtparameter, die beschaltet werden müssen. Die schwarz dargestellte Zeichenfolge ... kennzeichnet die optionalen Parameter, die beschaltet werden können. Wenn Sie den Mauszeiger über den Parameterbezeichner bewegen, wird der erwartete Datentyp angezeigt.
74
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10.2
Syntaxprüfung in KOP Mit einer automatischen Syntaxprüfung während der Eingabe wird das ungültige Platzieren von Elementen verhindert. ● NOT in Parallelzweig ● FB/FC-Aufruf in Parallelzweig ● Konnektor in Parallelzweig ● Flanke 0 -> 1 abfragen und Flanke 1 -> 0 abfragen in Parallelzweig ● XOR im Parallelzweig
Bild 4-15
4.10.3
Syntaxprüfung
KOP/FUP-Elemente markieren Um KOP/FUP-Elemente beispielsweise zu löschen, müssen diese vorher markiert werden. So markieren Sie KOP/FUP-Elemente: 1. Klicken Sie auf das gewünschte KOP/FUP-Element. Das KOP/FUP-Element ist markiert (siehe nachfolgende Abbildung). - oder Wenn Sie mehrere KOP/FUP-Elemente markieren wollen, klicken Sie mit gedrückter Shift-Taste auf die gewünschten KOP/FUP-Elemente. Markierte KOP/FUP-Elemente sind erkennbar durch eine dicke blaue Umrandung. Die Farbe der Markierung können Sie über das Register KOP/FUP-Editor im Dialogfenster Einstellungen selbst bestimmen.
Bild 4-16
Markierte KOP/FUP-Elemente
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
75
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10.4
KOP/FUP-Elemente kopieren/ausschneiden/löschen So können Sie kopieren/ausschneiden/löschen: 1. Markieren Sie ein KOP/FUP-Element. 2. Wählen Sie im Kontextmenü oder im Menü Bearbeiten z. B. den Eintrag Kopieren. Das kopierte/ausgeschnittene KOP/FUP-Element kann in andere KOP/FUP-Programme wieder eingefügt werden. Wenn Sie eine FB/FC-Box mit binären Vorverschaltungen löschen, dann entstehen mehrere offene Zweige (in KOP) oder Teilnetzwerke (in FUP), die weiter verschaltet werden können.
4.10.5
KOP/FUP-Elemente - Parameter festlegen (beschriften) So beschriften Sie die Elemente: 1. Klicken Sie auf den Parameter. 2. Beschriften Sie den Parameter: – Wählen Sie den entsprechenden Parameter aus dem Pull-Down-Menü (nur beim BoxTyp). - oder – Tragen Sie die entsprechende Variable ein. - oder – Ziehen Sie die entsprechende Variable per Drag&Drop aus der Deklarationstabelle. 3. Drücken Sie die Return-Taste, um die Eingabe zu bestätigen.
Siehe auch Aufrufparameter einstellen (Seite 79) Globale Anwendervariable und lokale Variable im Dialogfenster Variablendeklaration definieren (Seite 107)
76
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10.6
KOP/FUP-Elemente mit der Symboleingabehilfe beschriften So beschriften Sie die Elemente mit der Symboleingabehilfe: 1. Markieren Sie den Parameter, den Sie beschriften wollen. 2. Klicken Sie mit der rechten Maustaste, um das Kontextmenü zu öffnen. 3. Klicken Sie auf das Menü Symbol Eingabehilfe. - oder Rufen Sie die Symboleingabehilfe mit dem Tastenkürzel STRG+H auf. Es öffnet sich das Dialogfenster Symboleingabehilfe. In der Baumstruktur werden alle Variablen angezeigt, die im Projekt vorhanden sind und verwendet werden können. 4. Markieren Sie die gewünschte Variable und bestätigen Sie mit OK. Die Beschriftung wird im markierten Parameter eingetragen.
4.10.7
Darstellung der KOP/FUP-Elemente einstellen Um bei größeren Aufrufboxen noch die Übersicht zu behalten, können Sie die Darstellungsart der KOP/FUP-Elemente einstellen. So stellen Sie die Darstellung der KOP/FUP-Elemente ein: 1. Klicken Sie in den Editorbereich des KOP/FUP-Programms. 2. Wählen Sie die gewünschte Darstellungsart aus: – Wählen Sie im Kontextmenü Anzeige > Keine Boxparameter oder den Menüpunkt KOP/FUP-Programm > Anzeige > Keine Boxparameter. - oder – Wählen Sie im Kontextmenü Anzeige > Nur belegte Boxparameter oder den Menüpunkt KOP/FUP-Programm > Anzeige > Nur belegte Boxparameter. - oder – Wählen Sie im Kontextmenü Anzeige > Pflicht- und belegte Boxparameter oder den Menüpunkt KOP/FUP-Programm > Anzeige > Pflicht- und belegte Boxparameter. - oder – Wählen Sie im Kontextmenü Anzeige > Alle Boxparameter oder den Menüpunkt KOP/FUP-Programm > Anzeige > Alle Boxparameter. Die Einstellung der Boxparameter wird beim Speichern mit gespeichert. Hinweis Wenn eine Aufrufbox nicht dargestellte Parameter hat, wird dies durch ... an der unteren Boxseite kennzeichnet.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
77
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10.8
Aufrufparameter für einen Einzelparameter einstellen So stellen Sie einen einzelnen Aufrufparameter ein: 1. Doppelklicken Sie auf den Ein-/Ausgang des Parameters, den Sie einstellen wollen. Das Dialogfenster Aufrufparameter Eingeben für Einzelparameter wird eingeblendet.
Bild 4-17
Dialogfenster zum Einstellen eines einzelnen Aufrufparameters
2. Ordnen Sie dem Parametern aus der Liste Werte eine Variable oder einen Wert zu. 3. Bestätigen Sie Ihre Auswahl zweimal mit der Entertaste, um das Dialogfenster wieder zuschließen.
78
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10.9
Aufrufparameter einstellen So stellen Sie Aufrufparameter ein: 1. Beschriften Sie den Typparameter der Box. 2. Doppelklicken Sie auf die Box. - oder Wählen Sie im Kontextmenü Aufruf parametrieren .... Das Dialogfenster Aufrufparameter Eingeben wird eingeblendet. Es werden nur bereits deklarierte Variablen oder vom System bereitgestellte Symbole/Variablen zur Auswahl angeboten.
Bild 4-18
Dialogfenster zum Einstellen der Aufrufparameter
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
79
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten 3. Tragen Sie ein: – Rückgabewert Hier weisen Sie den Rückgabewert der Funktion einer Variablen des aufrufenden Programms zu. – Instanz Hier tragen Sie die Instanz des Funktionsbausteins ein. – Wert Hier ordnen Sie den Parametern aktuelle Variablen oder Werte zu. 4. Bestätigen Sie mit OK. Hinweis In der Liste Wert werden alle im aktuellen Ziel sichtbaren Symbole (Variablen, Enum-Werte, usw.) angeboten, deren Typ zu dem Parameter passt. Dabei wird auch die implizite Datentypkonvertierung berücksichtigt. Sie können ein Symbol aus der Liste wählen oder selber eintippen. Der Wert von String-Konstanten muss in Hochkommas eingeben werden (z.B. 'st_until')
4.10.10
Suchen im Projekt
Elemente im Projekt suchen So suchen Sie Elemente im Projekt: 1. Wählen Sie im Menü Bearbeiten den Menüpunkt Suchen im Projekt. 2. Es öffnet sich das Dialogfenster Suchen im Projekt. 3. Geben Sie Ihren Suchbegriff ein. 4. Schränken Sie Ihre Suche ggf. mit einem Filter oder der Beschränkung auf bestimmte Objekte ein. 5. Starten Sie die Suche, indem Sie auf die Schaltfläche Suchen klicken. Das Suchergebnis wird in der Workbench in der Tabelle Suchergebnis angezeigt. 6. Wenn Sie auf ein Suchergebnis doppelklicken, wird das gefundene Element im Editor angezeigt.
80
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
4.10.11
Suchen und Ersetzen im Projekt
Elemente im Projekt suchen und ersetzen In KOP/FUP kann man ersetzen: ● die Variablennamen ● sämtliche Elemente, die im Eigenschaftendialog erscheinen, z. B. Rückgabewert eines FCs usw. So suchen und ersetzen Sie Elemente im Projekt: 1. Wählen Sie im Menü Bearbeiten den Menüpunkt Ersetzen im Projekt. 2. Es öffnet sich das Dialogfenster Ersetzen im Projekt. 3. Geben Sie Ihren Suchbegriff ein. 4. Geben Sie den Ausdruck ein, der den gesuchten Begriff ersetzen soll. 5. Schränken Sie Ihre Suche ggf. mit einem Filter oder der Beschränkung auf bestimmte Objekte ein. 6. Starten Sie die Suche, indem Sie auf die Schaltfläche Suchen klicken. Das Suchergebnis wird in der Workbench in der Tabelle Suchergebnis angezeigt. Die Elemente, die ersetzt werden können, sind mit einem Haken gekennzeichnet. 7. Wenn Sie alle gekennzeichneten Elemente ersetzen wollen, klicken Sie im Suchergebnis auf die Schaltfläche Ersetzen. Alle Elemente werden durch den Ausdruck, mit dem Sie das gesuchte Element ersetzen wollen, ersetzt. 8. Wenn Sie nur bestimmte Elemente ersetzen wollen, demarkieren Sie die anderen Elemente und klicken Sie dann auf die Schaltfläche Ersetzen. Nur die markierten Elemente werden ersetzt. Hinweis Wenn Sie ein Element mit einem ungültigen Element ersetzen wollen, gibt KOP/FUP eine Fehlermeldung in der Ausgabeliste, d.h. das Element wird zwar gefunden, in der Liste aufgelistet, doch das Ersetzen wird untersagt. Sie können das Häkchen in der Checkbox nicht setzen.
Einschränkungen Im Allgemeinen gilt, dass man ein Element mit einem neuen Element nicht ersetzen kann, wenn das neue Element nicht eingegeben werden kann, z.B. in der Deklarationstabelle kann man VAR_GLOBAL nicht durch VAR ersetzen, da man dort VAR händisch nicht eingeben kann.
Einschränkungen in der Deklarationstabelle: ● VAR, VAR_TEMP und VAR_GLOBAL können nicht frei gegeneinander ausgetauscht werden
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
81
KOP/FUP programmieren 4.10 KOP/FUP-Elemente bearbeiten
Einschränkungen in den POEs: ● Die in der Befehlsbibliothek aufgelisteten KOP- und FUP-Elemente können nicht frei ersetzt werden. ● Vergleicher können nur untereinander ausgetauscht werden, z.B. "kleiner gleich" kann mit "größer gleich" oder "gleich" ersetzt werden, nicht aber mit einer "XOR-Box", usw. ● Der Typ der Anwender-FBs / FCs kann nur mit einem schon vorhandenen anderem Typ von Anwender-FBs / FCs ersetzt werden. ● Mathematische Funktionen können nur mit solchen ersetzt werden, die man auch händisch eingeben könnte (z.B. sin kann mit cos ersetzt werden, nicht aber mit cmp) ● "..." und "???" werden generell nicht ersetzt.
82
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.11 Befehlsbibliothek
4.11
Befehlsbibliothek
4.11.1
KOP/FUP-Funktionen in der Befehlsbibliothek Die Befehlsbibliothek wird automatisch als Register des Projektnavigators eingeblendet. Nach dem Schließen des Programmierfensters bleibt die Befehlsbibliothek geöffnet.
Bild 4-19
Register Befehlsbibliothek des Projektnavigators
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
83
KOP/FUP programmieren 4.11 Befehlsbibliothek
4.11.2
Elemente/Funktionen aus der Befehlsbibliothek einfügen So fügen Sie Elemente/Funktionen in ein Programmierfenster ein:: 1. Klicken Sie in der Befehlsbibliothek mit der linken Maustaste auf die gewünschte Funktion, ziehen Sie mit gedrückter linker Maustaste die Funktion auf das Editorfenster und lassen Sie die linke Maustaste los. - oder Doppelklicken Sie auf die gewünschte Funktion. - oder Markieren Sie die gewünschte Funktion und drücken Sie die Eingabetaste. KOP/FUP-Elemente werden in der Regel rechts von der markierten Position im Netzwerk eingefügt. FUP-Elemente werden in der Regel an einem boolschen Eingang eines Bausteins bzw. an einer Zuweisung (links) eingefügt.
4.11.3
Nichtverwendbare Funktionen in der Befehlsbibliothek In der Programmiersprache KOP/FUP sind nicht alle Funktionen der ST-Programmierung identisch nutzbar. Deshalb gibt es neue Funktionen mit anderem Parameter (statt "Task" wird "TaskId" verwendet), die in der nachfolgenden Tabelle aufgeführt sind. Die neuen Befehle sind auch bibliotheksfähig. : Die Funktionen in der linken Spalte können in ST und KOP/FUP verwendet werden. (Erweiterung des ST-Funktionsnamens durch "id". Beispiel: _alarmsc wird zu _alarmscid). Die ST-Funktionen in der rechten Spalte können in der Programmiersprache KOP/FUP nicht benutzt werden. Die Funktionen sind nach Aufrufsyntax gruppiert. Tabelle 4- 2
Liste der kompatiblen Funktionen
ST und KOP/FUP-Funktionen
ST-Funktionen
Funktionen zur Tasksteuerung _getstateoftaskid
_getstateoftask
_resettaskid
_resettask
_restarttaskid
_restarttask
_resumetaskid
_resumetask
Funktionen zur Laufzeitmessung
84
_getmaximaltaskidruntime
_getmaximaltaskruntime
_getminimaltaskidruntime
_getminimaltaskruntime
_getcurrenttaskidruntime
_getcurrenttaskruntime
_getaveragetaskidruntime
_getaveragetaskruntime
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.11 Befehlsbibliothek
Funktionen zur Meldungsprojektierung
4.11.4
_retriggertaskidcontroltime
_retriggertaskcontroltime
_starttaskid
_starttask
_suspendtaskid
_suspendtask
_alarmsid
_alarms
_alarmsqid
_alarmsq
_alarmscid
_alarmsc
Besonderheiten in der Befehlsbibliothek
Besonderheiten Folgende ST Befehle haben keine entsprechende KOP/FUP-taugliche Funktion: ● BOOL := _checkequaltask([IN]TASK, [IN]TASK) Zwei StructTaskID oder zwei StructAlarmID können mit einem Vergleicher verglichen werden. ● StructAlarmID := _getalarmid([IN]ALARM) Die Alarmbefehle befinden sich unter dem Namensraum _alarm (_alarm.myalarm). ● StructTaskID := _gettaskid([IN]TASK id:=TaskIdThis) Die Taskbefehle befinden sich unter dem Namensraum _task (_task.backgroundtask).
Beispiele für Parameter vom Typ _alarmid und _starttaskid
Bild 4-20
Beispiel für StructAlarmID
Bild 4-21
Beispiel für StructTaskID
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
85
KOP/FUP programmieren 4.12 Allgemeines zu Variablen und Datentypen
4.12
Allgemeines zu Variablen und Datentypen
4.12.1
Überblick der Variablentypen Die folgenden Tabellen zeigen alle Variablentypen, die Ihnen bei der Programmierung zur Verfügung stehen. ● Systemvariablen des SIMOTION Geräts und der Technologieobjekte ● Globale Anwendervariablen (I/O-Variablen, Geräteglobale Variablen, Unit-Variablen) ● Lokale Anwendervariablen (Variable innerhalb eines Programms, einer Funktion oder eines Funktionsbaustein)
Systemvariablen Variablentyp
Bedeutung
Systemvariablen des SIMOTION Geräts
Jedes SIMOTION Gerät und jedes Technologieobjekt hat spezifische Systemvariablen. Auf diese können Sie zugreifen: • innerhalb des SIMOTION Geräts von allen Programmen • von HMI-Geräten
Systemvariablen der Technologieobjekte
Systemvariablen können Sie im Symbol-Browser beobachten.
86
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.12 Allgemeines zu Variablen und Datentypen
Globale Anwendervariablen Variablentyp
Bedeutung
I/O-Variablen
Sie können den I/O-Adressen des SIMOTION Geräts oder der Peripherie symbolische Variablennamen zuordnen. Dies ermöglicht Ihnen folgende Direktzugriffe auf die Peripherie: • innerhalb des SIMOTION Geräts von allen Programmen • von HMI-Geräten Diese Variablen legen Sie im Symbol-Browser an, nachdem Sie im Projektnavigator das Element I/O markiert haben. I/O-Variablen können Sie im Symbol-Browser beobachten.
Geräteglobale Variablen
Anwenderdefinierte Variablen, auf die alle Programme des SIMOTION Geräts sowie HMIGeräte zugreifen können. Diese Variablen legen Sie im Symbol-Browser an, nachdem Sie im Projektnavigator das Element GERÄTEGLOBALE VARIABLEN markiert haben. Geräteglobale Variablen können Sie als remanent deklarieren. Sie bleiben dann auch nach Ausschalten des SIMOTION Geräts gespeichert. Geräteglobale Variablen können Sie im Symbol-Browser beobachten.
Unit-Variablen
Anwenderdefinierte Variablen, auf die alle Programme/Charts (Programme, Funktionsbausteine und Funktionen) innerhalb einer Unit (Quelle) zugreifen können. Diese Variablen deklarieren Sie in der Deklarationstabelle der Quelle: • im Interfaceabschnitt: Diese Variablen stehen nach Verbinden (siehe Verbindungen definieren (Seite 136)) auch in anderen Units (z. B. MCC-Quellen, ST-Quellen, KOP/FUP-Quellen) sowie auch auf HMI-Geräten zur Verfügung (maximale Größe des Interfaceabschnitts: 64 kByte). • im Implementationsabschnitt: Auf diese Variablen können Sie nur innerhalb der Quelle zugreifen. Unit-Variablen können Sie als remanent deklarieren. Sie bleiben dann auch nach Ausschalten des SIMOTION Geräts gespeichert. Unit-Variablen können Sie im Symbol-Browser beobachten.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
87
KOP/FUP programmieren 4.12 Allgemeines zu Variablen und Datentypen
Lokale Anwendervariablen Variablentyp
Bedeutung Anwenderdefinierte Variablen, auf die nur innerhalb des Programms/Charts (Programm, Funktion, Funktionsbaustein) zugegriffen werden kann, in dem sie definiert wurden.
Variable eines Programms (Programmvariable)
Variable wird in einem Programm deklariert. Nur innerhalb dieses Programms kann auf sie zugegriffen werden. Es wird zwischen statischen und temporären Variablen unterschieden: • Statische Variablen werden gemäß dem Speicherbereich initialisiert, in dem sie abgelegt werden. Diesen Speicherbereich legen durch eine Compileroption fest. Standardmäßig werden die statischen Variablen in Abhängigkeit der Task initialisiert, der das Programm zugeordnet wird, (siehe Funktionshandbuch SIMOTION Basisfunktionen). •
Statische Variablen können Sie im Symbol-Browser beobachten. Temporäre Variablen werden bei jedem Aufruf des Programms in einer Task initialisiert. Temporäre Variablen können nicht im Symbol-Browser beobachtet werden.
Variable einer Funktion (FC-Variable)
Variable wird in einer Funktion (FC) deklariert. Nur innerhalb dieser FC kann auf sie zugegriffen werden. FC-Variablen sind temporär, sie werden bei jedem Aufruf der FC initialisiert. Sie können nicht im Symbol-Browser beobachtet werden.
Variable eines Funktionsbausteins (FB-Variable)
Variable wird in einem Funktionsbaustein (FB) deklariert. Nur innerhalb dieses FB kann auf sie zugegriffen werden. Es wird zwischen statischen und temporären Variablen unterschieden: • Statische Variablen behalten beim Beenden des FB ihren Wert. Sie werden nur initialisiert, wenn die Instanz des FB initialisiert wird, Dies ist abhängig vom Variablentyp, mit der die Instanz des FB deklariert wurde. •
Statische Variablen können Sie im Symbol-Browser beobachten. Temporäre Variablen verlieren beim Beenden des FB ihren Wert. Beim nächsten Aufruf des FB werden sie neu initialisiert. Temporäre Variablen können nicht im Symbol-Browser beobachtet werden.
88
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.12 Allgemeines zu Variablen und Datentypen
4.12.2
Reichweite der Deklarationen
Reichweite der Variablen- und Datentypdeklaration in Abhängigkeit vom Ort der Deklaration Ort der Deklaration
Deklarierbar
Symbolbrowser
• •
Geräteglobale Variablen I/O-Variablen
Reichweite Die deklarierten Variablen sind in allen Units (z. B. ST-Quellen, MCC-Quellen, KOP/FUP-Quellen) des SIMOTION Geräts gültig. Alle Programme, Funktionsbausteine und Funktionen in allen Units des Geräts können darauf zugreifen.
Interfaceabschnitt der Unit1
• • •
Unit-Variablen Datentypen Symbolische Zugriffe auf das feste Prozessabbild der BackgroundTask
Die deklarierten Variablen, Datentypen usw. sind in der gesamten Unit (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) gültig; alle Programme, Funktionsbausteine und Funktionen innerhalb der Unit können darauf zugreifen. Außerdem stehen sie nach Verbinden (siehe Verbindungen definieren (Seite 136)) auch in anderen Units zur Verfügung.
Implementationsabschnitt der Unit1
• • •
Unit-Variablen Datentypen Symbolische Zugriffe auf das feste Prozessabbild der BackgroundTask
Die deklarierten Variablen, Datentypen usw. sind in der gesamten Unit (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) gültig; alle Programme, Funktionsbausteine und Funktionen innerhalb der Quelle können darauf zugreifen.
POE (Programm/ Funktionsbaustein/ Funktion)2
• • •
Lokale Variablen Datentypen Symbolische Zugriffe auf das feste Prozessabbild der BackgroundTask
Auf die deklarierten Variablen, Datentypen usw. kann nur innerhalb der POE zugegriffen werden, in der sie deklariert werden.
1
Bei Programmiersprachen MCC und KOP/FUP: in der Deklarationstabelle der jeweiligen Quelle.
2
Bei Programmiersprachen MCC und KOP/FUP: in der Deklarationstabelle des jeweiligen Charts/Programms.
4.12.3
Regeln für Bezeichner Namen für Variablen, Datentypen, Charts/Programme müssen folgenden Regeln für Bezeichner entsprechen: 1. Sie werden aus Buchstaben (A .. Z, a .. z), Ziffern (0 .. 9) und Unterstrich ( _ ) zusammengesetzt. 2. Das erste Zeichen muss ein Buchstabe oder ein Unterstrich sein. 3. Danach können Sie beliebig oft und in beliebiger Reihenfolge Buchstaben, Ziffern oder den Unterstrich verwenden. 4. Ausnahme: Mehrere Unterstriche dürfen nicht aufeinander folgen. 5. Sowohl Groß- wie Kleinbuchstaben sind erlaubt. Eine Unterscheidung zwischen Großund Kleinschreibung findet nicht statt (Anna und AnNa werden also zum Beispiel als identisch betrachtet).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
89
KOP/FUP programmieren 4.12 Allgemeines zu Variablen und Datentypen
4.12.4
Häufig verwendete Felder bei Deklarationen
4.12.4.1
Feldlänge und Feldelement Ein Feld ist eine Aneinanderreihung von Variablen des gleichen Typs, welche mit dem gleichen Namen und verschiedenen Indizes angesprochen werden. :: Durch Eingabe einer Feldlänge N legen Sie die Variable als Feld [0..N-1] an. Für die Eingabe der Feldlänge haben Sie folgende Möglichkeiten: ● Sie können einen konstanten positiven ganzzahligen Wert angeben. ● Sie können einen Wertebereich getrennt durch ".." angeben. ● Sie können einen Konstantenausdruck vom Datentyp DINT (bzw. von einem Datentyp der implizit nach DINT konvertierbar ist) angeben. Ist das Feld leer, wird kein Feld, sondern eine einfache Variable angelegt.
Beispiel für Definition eines Feldes in der Deklarationstabelle
Bild 4-22
Definition der Feldlänge eines Feldes
Beispiel für Verwendung der Feldelemente in einer Variablenzuweisung
Bild 4-23
90
Verwendung der Feldelemente in einer Variablenzuweisung
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.12 Allgemeines zu Variablen und Datentypen
4.12.4.2
Anfangswert In dieser Spalte können Sie einen Initialisierungswert vorgeben. Diesen Initialisierungswert können Sie als Konstante oder als Ausdruck angeben, zulässig sind: ● Konstanten ● arithmetische Operationen ● Bitschiebe- und Datenkonvertierungsfunktionen Tabelle 4- 3
Vorbelegung von Feldelementen
10(1)
10 Feldelemente [0..9] werden mit demselben Wert "1" vorbelegt.
1,2,3,4,5
5 Feldelemente [0..4] werden mit den unterschiedlichen Werten "1", "2", "3", "4" und "5" vorbelegt.
5(3), 10(99),3(7),2(1)
5 Feldelemente [0..4] werden mit demselben Wert "3" vorbelegt. 10 Feldelemente [5..14] werden mit demselben Wert "99" vorbelegt. 3 Feldelemente [15..17] werden mit demselben Wert "7" vorbelegt. 2 Feldelemente [18..19] werden mit demselben Wert "1" vorbelegt.
Die Definition dieser Initialisierungswerte in der Deklarationstabelle:
Bild 4-24
Definition der Initialisierungswerte eines Feldes
Variablen mit Datentypen von Technologieobjekten werden immer mit TO#NIL initialisiert. Bei Variablen vom Datentyp followingAxis wählen Sie hier das zugehörige Gleichlaufobjekt aus (Variable vom Datentyp follingObjectType).
4.12.4.3
Kommentar In diese Spalte kann ein Kommentar eingegeben werden. Es sind alle Zeichen und Sonderzeichen erlaubt.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
91
KOP/FUP programmieren 4.13 Datentypen
4.13
Datentypen
4.13.1
Allgemeines Mit Hilfe eines Datentyps wird festgelegt, wie der Wert einer Variablen oder Konstanten in einer Programmquelle verwendet werden soll. Dem Anwender stehen folgende Arten von Datentypen zur Verfügung: ● Elementare Datentypen ● Anwenderdefinierte Datentypen (UDT) – Aufzählungen (Enumeratoren) – Strukturen (Struct) ● Datentypen von Technologieobjekten ● Systemdatentypen
92
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.13 Datentypen
4.13.2
Elementare Datentypen Elementare Datentypen definieren die Struktur von Daten, die nicht in kleinere Einheiten zerlegt werden können. Ein elementarer Datentyp beschreibt einen Speicherbereich mit fester Länge und steht für Bitdaten, Ganzzahlen, Gleitpunktzahlen, Zeitdauer, Uhrzeit, Datum und Zeichenstrings. Eine Aufstellung aller elementaren Datentypen sehen Sie in der folgenden Tabelle:
Tabelle 4- 4
Bitbreiten und Wertebereiche der elementaren Datentypen
Typ
Reserv. Wort
Bitbreite
Wertebereich
Bitdatentyp Daten dieses Typs umfassen entweder 1 Bit, 8 Bit, 16 Bit oder 32 Bit. Der Initialisierungswert einer Variablen dieses Datentyps ist 0. Bit
BOOL
1
0, 1 oder FALSE, TRUE
Byte
BYTE
8
16#0 bis 16#FF
Wort
WORD
16
16#0 bis 16#FFFF
Doppelwort
DWORD
32
16#0 bis 16#FFFF_FFFF
Numerische Typen Sie stehen für die Verarbeitung numerischer Werte zur Verfügung. Der Initialisierungswert einer Variablen dieses Datentyps ist 0 (alle Ganzzahlen) bzw. 0.0 (alle Gleitpunktzahlen). Kurze Ganzzahl
SINT
8
-128 bis 127 (-2**7 bis 2**7-1)
Vorzeichenlose kurze Ganzzahl
USINT
8
0 bis 255 (0 bis 2**8-1)
Ganzzahl (Integer)
INT
16
-32_768 bis 32_767 (-2**15 bis 2**15-1)
Vorzeichenlose Ganzzahl
UINT
16
0 bis 65_535 (0 bis 2**16-1)
Ganzzahl doppelter Breite
DINT
32
-2_147_483_648 bis 2_147_483_647 (-2**31 bis 2**31-1)
Vorzeichenlose Ganzzahl doppelter Breite
UDINT
32
0 bis 4_294_96_7295 (0 bis 2**32-1)
Gleitpunktzahl (gemäß IEEE-754)
REAL
32
-3.402_823_466E+38 bis -1.175_494_351E-38, 0.0, +1.175_494_351E-38 bis +3.402_823_466E+38 Genauigkeit: Mantisse 23 Bit (entspricht 6 Dezimalstellen), Exponent 8 Bit, Vorzeichen 1 Bit.
Lange Gleitpunktzahl (gemäß IEEE-754)
LREAL
64
-1.797_693_134_862_315_8E+308 bis -2.225_073_858_507_201_4E-308, 0.0, +2.225_073_858_507_201_4E-308 bis +1.797_693_134_862_315_8E+308 Genauigkeit: Mantisse 52 Bit (entspricht 15 Dezimalstellen), Exponent 11 Bit, Vorzeichen 1 Bit.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
93
KOP/FUP programmieren 4.13 Datentypen Typ Zeittypen
Reserv. Wort
Bitbreite
Wertebereich
Daten dieses Typs repräsentieren die unterschiedlichen Zeit- und Datumswerte. Zeitdauer in Schritten von 1 ms
TIME
32
T#0d_0h_0m_0s_0ms bis T#49d_17h_2m_47s_295ms Maximal 2 Stellen für die Werte Tag, Stunde, Minute, Sekunde; maximal 3 Stellen für Millisekunden. Initialisierung mit T#0d_0h_0m_0s_0ms
Datum in Schritten von DATE 1 Tag
32
D#1992-01-01 bis D#2200-12-31 Schaltjahre sind berücksichtigt, Jahreszahl ist vierstellig, Monat und Tag zweistellig. Initialisierung mit D#0001-01-01
Uhrzeit in Schritten von 1 ms
TIME_OF_DAY (Kürzel TOD)
32
TOD#0:0:0.0 bis TOD#23:59:59.999 Maximal 2 Stellen für die Werte Stunde, Minute, Sekunde; maximal 3 Stellen für Millisekunden. Initialisierung mit TOD#0:0:0.0
Datum und Uhrzeit
DATE_AND_TI ME (Kürzel DT)
64
DT#1992-01-01-0:0:0.0 bis DT#2200-12-31-23:59:59.999 DATE_AND_TIME besteht aus den Datentypen DATE und TIME. Initialisierung mit DT#0001-01-01-0:0:0.0
String-Typ Daten dieses Typs repräsentieren Zeichenketten, bei denen jedes Zeichen mit der angegebenen Anzahl von Bytes verschlüsselt wird. Die Länge des Strings kann bei der Deklaration vorgegeben werden Geben Sie hierzu die Länge in "[" und "]" an, z. B. STRING[100]. Die Voreinstellung beträgt 80 Zeichen. Die Anzahl der belegten (initialisierten) Zeichen kann kleiner als die deklarierte Länge sein. String mit 1 Byte/Zeichen
STRING
8
Alle Zeichen mit ASCII-Code $00 bis $FF sind zulässig. Vorbelegung mit ’ ’ (Leerer String)
ACHTUNG Beim Export der Variablen in andere Systeme sind die Wertebereiche der entsprechenden Datentypen im Zielsystem zu beachten.
Siehe auch Wertebereichsgrenzen elementarer Datentypen (Seite 95) Allgemeine Datentypen (Seite 96) Elementare Systemdatentypen (Seite 97)
94
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.13 Datentypen
4.13.2.1
Wertebereichsgrenzen elementarer Datentypen Die Grenzen der Wertebereiche einiger elementarer Datentypen sind als Konstanten verfügbar: Tabelle 4- 5
Symbolische Konstanten für die Wertebereichsgrenzen elementarer Datentypen
Symbolische Konstante
Datentyp
Wert
Hex-Darstellung
SINT#MIN
SINT
-128
16#80
SINT#MAX
SINT
127
16#7F
INT#MIN
INT
-32768
16#8000
INT#MAX
INT
32767
16#7FFF
DINT#MIN
DINT
-2147483648
16#8000_0000
DINT#MAX
DINT
2147483647
16#7FFF_FFFF
USINT#MIN
USINT
0
16#00
USINT#MAX
USINT
255
16#FF
UINT#MIN
UINT
0
16#0000
UINT#MAX
UINT
65535
16#FFFF
UDINT#MIN
UDINT
0
16#0000_0000
UDINT#MAX
UDINT
4294967295
16#FFFF_FFFF
T#MIN TIME#MIN
TIME
T#0ms
16#0000_00001
T#MAX TIME#MAX
TIME
T#49d_17h_2m_47s_295ms
16#FFFF_FFFF1
TOD#MIN TIME_OF_DAY#MIN
TOD
TOD#00:00:00.000
16#0000_00001
TOD#MAX TOD TIME_OF_DAY#MAX
TOD#23:59:59.999
16#0526_5BFF1
1
Nur interne Darstellung
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
95
KOP/FUP programmieren 4.13 Datentypen
4.13.2.2
Allgemeine Datentypen Allgemeine Datentypen werden oft bei den Eingangs- und Ausgangsparametern von Systemfunktionen und Systemfunktionsbausteinen verwendet. Das Unterprogramm kann mit Variablen jeden Datentyps aufgerufen werden, der im allgemeinen Datentyp enthalten ist. Die nachfolgende Tabelle zeigt die verfügbaren allgemeinen Datentypen: Tabelle 4- 6
Allgemeine Datentypen
Allgemeiner Datentyp
Enthaltene Datentypen
ANY_BIT
BOOL, BYTE, WORD, DWORD
ANY_INT
SINT, INT, DINT, USINT, UINT, UDINT
ANY_REAL
REAL, LREAL
ANY_NUM
ANY_INT, ANY_REAL
ANY_DATE
DATE, TIME_OF_DAY (TOD), DATE_AND_TIME (DT)
ANY_ELEMENTARY
ANY_BIT, ANY_NUM, ANY_DATE, TIME, STRING
ANY
ANY_ELEMENTARY, anwenderdefinierte Datentypen (UDT), Systemdatentypen, Datentypen der Technologieobjekte
Hinweis Allgemeine Datentypen können Sie nicht als Typbezeichner in Variablen- oder Typdeklarationen verwenden. Der allgemeine Datentyp bleibt erhalten, wenn ein anwenderdefinierter Datentyp (UDT) direkt von einem elementaren Datentyp abgeleitet wird (nur bei der Programmiersprache SIMOTION ST möglich).
96
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.13 Datentypen
4.13.2.3
Elementare Systemdatentypen Im SIMOTION System werden die in der Tabelle angegebenen Datentypen ähnlich wie elementare Datentypen behandelt. Sie werden bei vielen Systemfunktionen verwendet. Tabelle 4- 7
Elementare Systemdatentypen und ihre Verwendung
Bezeichner
Bitbreite
Verwendung
StructAlarmId
32
Datentyp der AlarmId für die projektweit eindeutige Kennung der Meldungen. Die AlarmId wird bei der Meldungsgenerierung verwendet. Siehe Funktionshandbuch SIMOTION Basisfunktionen. Initialisierung mit STRUCTALARMID#NIL
StructTaskId
32
Datentyp der TaskId für die projektweit eindeutige Kennung der Tasks im Ablaufsystem. Siehe Funktionshandbuch SIMOTION Basisfunktionen. Initialisierung mit STRUCTTASKID#NIL
Tabelle 4- 8
Symbolische Konstanten für ungültige Werte elementarer Systemdatentypen
Symbolische Konstante
Datentyp
Bedeutung
STRUCTALARMID#NIL
StructAlarmId
Ungültige AlarmId
STRUCTTASKID#NIL
StructTaskId
Ungültige TaskId
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
97
KOP/FUP programmieren 4.13 Datentypen
4.13.3
Abgeleitete Datentypen
4.13.3.1
Abgeleitete Datentypen (UDT) definieren In Quellen und Programmen können Sie abgeleitete Datentypen erstellen: ● Strukturen ● Aufzählungen Die Reichweite der Datentypendeklaration ist vom Ort der Deklaration abhängig.
4.13.3.2
Reichweite der Datentypdeklaration Abgeleitete Datentypen erstellen Sie in den Deklarationstabellen der Quelle oder des Programms/Charts. Vom Ort der Deklaration ist die Reichweite der Datentypdeklaration abhängig: ● Quelle Abschnitt Interface (exportierte Deklaration) der Deklarationstabelle: Der Datentyp ist in der gesamten Quelle gültig; alle Programme/Charts (Programme, Funktionsbausteine und Funktionen) innerhalb der Quelle können darauf zugreifen. Außerdem stehen diese Variablen nach Verbinden (siehe Verbindungen definieren (Seite 136)) auch in anderen Quellen (oder anderen Units) zur Verfügung. ● Quelle Abschnitt Implementation (Quell-interne Deklaration) der Deklarationstabelle: Der Datentyp ist nur in der Quelle gültig; alle Programme/Charts (Programme, Funktionsbausteine und Funktionen) innerhalb der Quelle können darauf zugreifen. ● in der Deklarationstabelle des Programms: Auf den Datentyp kann nur innerhalb des Programms/Charts zugegriffen werden, in dem er deklariert wird.
4.13.3.3
Strukturen definieren Strukturen definieren Sie in den Deklarationstabellen der Quelle oder des Programms/Charts. Vom Ort der Deklaration ist die Reichweite (Seite 98) der Strukturen abhängig. So definieren Sie Strukturen: 1. Wählen Sie die Deklarationstabelle und ggf. ihren Abschnitt für die gewünschte Reichweite. 2. Wählen Sie das Register Strukturen. 3. Tragen Sie den Namen der Struktur ein. 4. Ergänzen Sie in der gleichen Zeile: – den Namen des ersten Elements – dessen Datentyp – weitere Kennzeichnungen (Feldlänge, Anfangswert).
98
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.13 Datentypen 5. Fügen Sie in den folgenden Zeilen weitere Elemente der Struktur hinzu; das Feld Name Struktur lassen Sie leer. 6. Beginnen Sie die Definition einer neuen Struktur, indem Sie einen neuen Namen in das Feld Name Struktur eintragen.
4.13.3.4
Aufzählungen definieren Aufzählungen definieren Sie in den Deklarationstabellen der Quelle oder des Programms/Charts. Vom Ort der Deklaration ist die Reichweite (Seite 98) der Aufzählungen abhängig. So definieren Sie Aufzählungen: 1. Wählen Sie die Deklarationstabelle und ggf. ihren Abschnitt für die gewünschte Reichweite. 2. Wählen Sie das Register Aufzählungen. 3. Tragen Sie den Namen der Aufzählung ein. 4. Ergänzen Sie in der gleichen Zeile: – den Namen des ersten Elements – optional den Initialisierungswert des Aufzählungsdatentyps 5. Weitere Elemente der Aufzählung fügen Sie in den folgenden Zeilen hinzu; das Feld Name Aufzählung lassen Sie leer. 6. Die Definition einer neuen Aufzählung beginnen Sie, indem Sie einen neuen Namen in das Feld Name Aufzählung eintragen.
Beispiel Dieses Beispiel zeigt die Definition eines Aufzählungsdatentyps mit dem Namen Farbe und den Aufzählungselementen Rot, Blau und Grün sowie dem Initialisierungswert (Anfangswert) Grün. Wenn bei der Definition der Aufzählung (Datentypdeklaration) kein Initialisierungswert angegeben ist, dann wird der erste Wert der Aufzählung dem Datentyp zugewiesen. D. h. in diesem Beispiel würde Rot für die Initialisierung verwendet, da es als erstes Aufzählungselement definiert ist.
Bild 4-25
Definition eines Aufzählungsdatentyps
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
99
KOP/FUP programmieren 4.13 Datentypen
4.13.4
Datentypen der Technologieobjekte
4.13.4.1
Beschreibung der Datentypen der Technologieobjekte Sie können Variablen mit dem Datentyp eines Technologieobjekts (TO) deklarieren. Die nachfolgende Tabelle zeigt die Datentypen für die verfügbaren Technologieobjekte in den einzelnen Technologiepaketen. Beispielsweise können Sie eine Variable mit dem Datentyp posaxis deklarieren und ihr eine entsprechende Instanz einer Positionierachse zuweisen. Eine solche Variable wird oft als Referenz bezeichnet. Tabelle 4- 9
Datentypen von Technologieobjekten (TO-Datentyp)
Technologieobjekt
Datentyp
enthalten im Technologiepaket
Drehzahlachse
driveAxis
CAM1 2, PATH, CAM_EXT
Externer Geber
externalEncoderType
CAM1 2, PATH, CAM_EXT
Messtaster
measuringInputType
CAM1 2, PATH, CAM_EXT
Nocken
outputCamType
CAM1 2, PATH, CAM_EXT
Nockenspur (ab V3.2)
_camTrackType
CAM, PATH, CAM_EXT
Positionierachse
posAxis
CAM1 3, PATH, CAM_EXT
Gleichlaufachse
followingAxis
CAM1 4, PATH, CAM_EXT
Gleichlaufobjekt
followingObjectType
CAM1 4, PATH, CAM_EXT
Kurvenscheibe
camType
CAM, PATH, CAM_EXT
Bahnachse (ab V4.1)
_pathAxis
PATH, CAM_EXT
Bahnobjekt (ab V4.1)
_pathObjectTpye
PATH, CAM_EXT
Festes Getriebe (ab V3.2)
_fixedGearType
CAM_EXT
Addierobjekt (ab V3.2)
_additionObjectType
CAM_EXT
Formelobjekt (ab V3.2)
_formulaObjectType
CAM_EXT
Sensor (ab V3.2)
_sensorType
CAM_EXT
Reglerobjekt (ab V3.2)
_controllerObjectType
CAM_EXT
Temperaturkanal
temperatureControllerType
TControl
allgemeiner Datentyp, dem jedes TO zuwiesen werden kann
ANYOBJECT
1) Ab Version V3.1 entfallen die Technologiepakete BasicMC, Position und Gear. 2) Bei Version V3.0 auch in den Technologiepaketen BasicMC, Position und Gear enthalten. 3) Bei Version V3.0 auch in den Technologiepaketen Position und Gear enthalten. 4) Bei Version V3.0 auch im Technologiepaket Gear enthalten.
Über Strukturen können Sie auf die Elemente von Technologieobjekten, Konfigurationsdaten und Systemvariablen zugreifen (siehe Funktionshandbuch SIMOTION Basisfunktionen). Tabelle 4- 10 Symbolische Konstanten für ungültige Werte der Datentypen von Technologieobjekten Symbolische Konstante TO#NIL
Datentyp ANYOBJECT
Bedeutung Ungültiges Technologieobjekt
Siehe auch Vererbung der Eigenschaften bei Achsen (Seite 101)
100
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.13 Datentypen
4.13.4.2
Vererbung der Eigenschaften bei Achsen Vererbung bei den Achsen bedeutet, dass alle Datentypen, Systemvariablen und Funktionen des TO Drehzahlachse vollständig im TO Positionierachse enthalten sind. Die Positionierachse ist wiederum vollständig im TO Gleichlaufachse enthalten, die Gleichlaufachse im TO Bahnachse. Dies hat z. B. folgende Auswirkungen: ● Wenn eine Funktion oder ein Funktionsbaustein einen Eingangsparameter vom Datentyp driveAxis (Drehzahlachse) erwartet, können Sie beim Aufruf auch eine Positionierachse oder eine Gleichlaufachse oder eine Bahnachse verwenden. ● Wenn eine Funktion oder ein Funktionsbaustein einen Eingangsparameter vom Datentyp posAxis (Positionierachse) erwartet, können Sie beim Aufruf auch eine Gleichlaufachse oder eine Bahnachse verwenden.
4.13.5
Systemdatentypen Es stehen Ihnen eine Vielzahl von Systemdatentypen zur Verfügung, die Sie ohne vorherige Deklaration benutzen können. Auch jedes importierte Technologiepaket stellt eine Bibliothek von Systemdatentypen bereit. Weitere Systemdatentypen (vorwiegend Aufzählungs- und STRUCT-Datentypen finden Sie ● bei Parametern zu den allgemeinen Standardfunktionen (siehe Funktionshandbuch SIMOTION Basisfunktionen) ● bei Parametern zu den allgemeinen Standardfunktionsbausteinen (siehe Funktionshandbuch SIMOTION Basisfunktionen) ● bei Systemvariablen der SIMOTION Geräte (siehe entsprechende Listenhandbücher) ● bei Parametern zu den Systemfunktionen der SIMOTION Geräte (siehe entsprechende Listenhandbücher) ● bei Systemvariablen und Konfigurationsdaten der Technologieobjekte (siehe entsprechende Listenhandbücher) ● bei Parametern zu den Systemfunktionen der Technologieobjekte (siehe entsprechende Listenhandbücher)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
101
KOP/FUP programmieren 4.14 Variablen
4.14
Variablen Variablen sind ein wichtiger Bestandteil der Programmierung und dienen zum Strukturieren von Programmen. Sie sind Platzhalter, denen Werte zugewiesen werden können, auf die im Programm mehrfach zugriffen werden kann. Variablen haben ● ein bestimmtes Initialisierungsverhalten und einen bestimmten Gültigkeitsbereich. ● einen Datentyp und Operationen, die für diesen Datentyp definiert sind. Es wird zwischen Anwender- und Systemvariablen unterschieden. Anwendervariablen können selbst definiert werden. Systemvariablen werden vom System zur Verfügung gestellt.
4.14.1
Schlüsselwörter für Variablentypen Die verschiedenen Schlüsselwörter für Variablentypen werden in der nachfolgenden Tabelle angezeigt.
Beschreibung der Schlüsselwörter für Variablentypen Schlüsselwort
Beschreibung
Verwendung
Globale Anwendervariablen (Deklaration im Interface- oder Implementationsabschnitt der Unit1) VAR_GLOBAL
Unit-Variable; auf sie können alle POE innerhalb der Quelle zugreifen. Wenn die Variable im Interfaceabschnitt deklariert wurde, kann sie in einer anderen Quelle verwendet werden, nachdem in deren Deklarationstabelle eine Verbindung definiert wurde (siehe Verbindungen definieren (Seite 136)).
FB, FC, Programm
VAR_GLOBAL RETAIN
Remanente Unit-Variable; bleibt nach Stromausfall erhalten.
FB, FC, Programm
VAR_GLOBAL CONSTANT
Unit-Konstante; kann aus dem Programm nicht verändert werden.
FB, FC, Programm
Lokale Anwendervariablen (Deklaration innerhalb einer POE2) VAR
Lokale Variable (statisch bei FB und Programm, temporär bei FC)
FB, FC, Programm
VAR_TEMP
Temporäre lokale Variable
FB, Programm
VAR_INPUT
Eingangsparameter: lokale Variable, Wert wird von außen geliefert und ist im FB bzw. in der FC nur lesbar.
FB, FC
VAR_OUTPUT
Ausgangsparameter: lokale Variable, Wert wird vom FB nach außen geliefert und kann nach dem FB-Aufruf als Instanz-Variable gelesen werden (FB-Instanzname.Variablenname).
FB
VAR_IN_OUT
Durchgangsparameter; der FB bzw. die FC greift auf diese Variable direkt (über Referenz) zu und kann diese unmittelbar ändern.
FB, FC
VAR CONSTANT
Lokale Konstante; kann aus dem Programm nicht verändert werden.
FB, FC, Programm
1
Bei Programmiersprachen MCC und KOP/FUP: in der Deklarationstabelle der jeweiligen Quelle.
2
Bei Programmiersprachen MCC und KOP/FUP: in der Deklarationstabelle des jeweiligen Charts/Programms.
102
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.2
Variablen definieren Die Definition der Variablen erfolgt im Symbol-Browser oder in der Deklarationstabelle der Quelle oder des Charts/Programms. Die nachfolgende Tabelle gibt einen Überblick, wo die entsprechende Variable definiert wird.
Definition von Variablen
4.14.2.1
Variablentyp
Definition erfolgt …
Geräteglobale Anwendervariable
im Symbol-Browser
Unit-Variable
in der Deklarationstabelle der Quelle als VAR_GLOBAL, VAR_GLOBAL RETAIN oder VAR_GLOBAL CONSTANT
Lokale Variable
in der Deklarationstabelle des Programms/Charts als: • VAR, VAR_TEMP oder VAR CONSTANT • zusätzlich bei Funktionsbausteinen als VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT • zusätzlich bei Funktionen als VAR_INPUT, VAR_IN_OUT
I/O-Variable
im Symbol-Browser
Symbolischer Zugriff auf festes Prozessabbild der BackgroundTask
• •
in der Deklarationstabelle der Quelle in der Deklarationstabelle des Programms/Charts (nur Programme und FB)
Verwendung von geräteglobalen Variablen Geräteglobale Variablen sind anwenderdefinierte Variablen, auf die Sie aus allen Programmquellen (z. B. ST-Quellen, MCC-Quellen) eines SIMOTION Gerätes zugreifen können. Geräteglobale Variablen erstellen Sie im Register Symbolbrowser der Detailanzeige; Sie müssen sich hierzu im Offline-Modus befinden. Hier in Kurzform die Vorgehensweise: 1. Markieren Sie im Projektnavigator des SIMOTION SCOUT das Element GERÄTEGLOBALE VARIABLEN im Teilbaum des SIMOTION Geräts. 2. Wählen Sie in der Detailanzeige das Register Symbolbrowser und scrollen Sie bis zum Ende der Variablentabelle (leere Zeile).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
103
KOP/FUP programmieren 4.14 Variablen 3. Geben Sie in die letzte (leere) Zeile der Tabelle ein oder wählen Sie: – Name der Variablen – Datentyp der Variablen (nur elementare Datentypen zulässig) 4. Optional können Sie noch eingeben: – Aktivierung der Checkbox Retain (Hiermit wird die Variable als remanent deklariert; ihr Wert bleibt nach Spannungsausfall erhalten.) – Feldlänge (Größe des Arrays.) – Anfangswert (bei Arrays für jedes Element) – Anzeigeformat (bei Arrays für jedes Element) Sie können nun mit dem Symbol-Browser oder jedem Programm des SIMOTION Geräts auf diese Variable zugreifen. In ST-Quellen können Sie eine geräteglobale Variable wie jede andere Variable verwenden. Hinweis Wenn Sie Unit-Variablen oder lokale Variablen gleichen Namens (z. B. var-name) deklariert haben, spezifizieren Sie die geräteglobale Variable mit _device.var-name. Eine Alternative zu geräteglobalen Variablen ist die Deklaration von Unit-Variablen in einer eigenen Unit, die in andere Units importiert wird. Dies bietet folgende Vorteile: 1. Es können Variablen-Strukturen verwendet werden. 2. Die Initialisierung der Variablen beim Übergang STOP-RUN ist möglich (über Programm in StartupTask). 3. Bei neu angelegten globalen Unit-Variablen ist auch ein Download im RUN möglich. Siehe Funktionshandbuch SIMOTION Basisfunktionen.
4.14.2.2
Unit-Variable in der Quelle deklarieren Die Deklaration der Unit-Variablen erfolgt in der Quelle. Die Gültigkeitsbereich (Reichweite) der Variable ist abhängig vom Abschnitt der Deklarationstabelle, in dem die Variable deklariert wird: ● im Interfaceabschnitt der Deklarationstabelle (INTERFACE): Die Unit-Variable ist in der gesamten Quelle gültig; alle Programme/Charts (Programme, Funktionsbausteine und Funktionen) innerhalb der Quelle können darauf zugreifen. Außerdem stehen diese Variablen auch auf HMI-Geräten zur Verfügung sowie nach Verbinden (siehe Verbindungen definieren (Seite 136)) auch in anderen Quellen (oder anderen Units). Die Gesamtgröße aller Unit-Variablen im Interfaceabschnitt ist auf maximal 64 kByte beschränkt. ● im Implementationsabschnitt der Deklarationstabelle (IMPLEMENTATION): Die Unit-Variable ist nur in der Quelle gültig; alle Programme/Charts (Programme, Funktionsbausteine und Funktionen) innerhalb der Quelle können darauf zugreifen.
104
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen So gehen Sie vor; die Quelle (Deklarationstabelle) ist geöffnet (siehe Vorhandene Programmquelle öffnen (Seite 42)): 1. Wählen Sie innerhalb der Deklarationstabelle den Abschnitt für die gewünschte Reichweite. 2. Wählen Sie dort das Register Parameter. 3. Geben Sie ein: – Name der Variablen – Variablentyp Siehe auch: Schlüsselwörter für Variablentypen (Seite 102) – Datentyp der Variablen Elementare Datentypen (siehe Elementare Datentypen (Seite 93)) können sie auswählen, andere Datentypen müssen Sie in das entsprechende Feld eintragen. Siehe auch: Strukturen definieren (Seite 98) Aufzählungen definieren (Seite 99) – optional Feldlänge (Hier legen Sie die Größe des Arrays fest) Siehe auch: Feldlänge und Feldelement (Seite 90) – optional Anfangswert (Initialisierungswert) Siehe auch: Anfangswert (Seite 91) Damit ist die Variable deklariert und kann sofort verwendet werden.
Bild 4-26
Beispiel: Unit-Variable in der Quelle deklarieren
Hinweis Die Deklarationstabelle der Quelle wird bei jeder Parametrierung eines Befehls gelesen. Inkonsistente Daten innerhalb der Deklarationstabelle können deshalb zu unerwarteten Fehlermeldungen bei der Parametrierung führen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
105
KOP/FUP programmieren 4.14 Variablen
4.14.2.3
Lokale Variable deklarieren Auf eine lokale Variable kann nur innerhalb des Programms/Charts (Programm, Funktion, Funktionsbaustein) zugegriffen werden, in dem sie deklariert wird. So gehen Sie vor; das Programm/Chart mit der Deklarationstabelle ist geöffnet (siehe Vorhandene Programmquelle öffnen (Seite 42)): 1. Wählen Sie in der Deklarationstabelle das Register Parameter/Variablen. 2. Geben Sie ein: – Name der Variablen – Variablentyp der Variablen Siehe auch: Schlüsselwörter für Variablentypen (Seite 102) – Elementare Datentypen (siehe Elementare Datentypen (Seite 93)) können sie auswählen, andere Datentypen müssen Sie in das entsprechende Feld eintragen. Siehe auch: Strukturen definieren (Seite 98) Aufzählungen definieren (Seite 99) – optional Feldlänge (Hier legen Sie die Größe des Arrays fest) Siehe auch: Feldlänge und Feldelement (Seite 90) – optional Anfangswert (Initialisierungswert) Siehe auch: Anfangswert (Seite 91) Damit ist die Variable deklariert und kann sofort verwendet werden.
Bild 4-27
Beispiel: Lokale Variable im Chart/Programm deklarieren
Hinweis Die Deklarationstabelle des Programms/Charts wird bei jeder Parametrierung eines Befehls gelesen. Inkonsistente Daten innerhalb der Deklarationstabelle können deshalb zu unerwarteten Fehlermeldungen bei der Parametrierung führen.
106
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.2.4
Globale Anwendervariable und lokale Variable im Dialogfenster Variablendeklaration definieren Sobald Sie eine noch nicht bekannte Variable in einer KOP- oder FUP-Grafik eingeben, wird das Dialogfenster Variablendeklaration eingeblendet.
Bild 4-28
Dialogfenster Variablendeklaration
So definieren Sie Variablen im Dialogfenster Variablendeklaration: 1. Geben Sie den Namen der Variablen in der KOP- oder FUP-Grafik ein. 2. Drücken Sie die Return-Taste. Das Dialogfenster Variablendeklaration wird eingeblendet. 3. Tragen Sie ein: – ggf. einen anderen Variablennamen – Absolutbezeichner In Register I/O-Symbole der Deklarationstabelle erscheint der eingetragene Absolutbezeichner. Sobald Sie den Absolutbezeichner eingetragen haben, können Sie im Dialogfenster Variablendeklaration die Felder Variablentyp, Feldlänge und Anfangswert nicht mehr anwählen. – Datentyp der Variablen Wählen Sie den Datentyp im Pull-Down-Menü aus. Falls der Datentyp eines I/OSymbols nicht ANY_BIT oder ANY_INT ist, können Sie keinen Absolutbezeichner eingeben. Wenn Sie als Typ eine globale Variable wählen (z.B. VAR_GLOBAL) wählen wird die Checkbox exportierbar aktiv.
Bild 4-29
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Beispiel: Variablendeklaration (Absolutbezeichner)
107
KOP/FUP programmieren 4.14 Variablen
Bild 4-30
Beispiel: Variablendeklaration
Bestätigen Sie mit OK. Die Variable ist definiert und wird in die Deklarationstabelle der Quelle oder des Programms übernommen, abhängig vom gewählten Variablentyp und der Exportierbar. Hinweis Damit das Dialogfenster Variablendeklaration eingeblendet wird, muss im Dialogfenster Einstellungen die Kontrollbox on-the-fly Variablendeklaration aktiviert sein. Wenn Sie das Dialogfenster Variablendeklaration mit Abbrechen verlassen, bleibt die Eingabe stehen und die Variable wird nicht angelegt.
108
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.3
Zeitpunkt der Variableninitialisierung Der Zeitpunkt der Variableninitialisierung wird bestimmt: ● durch den Speicherbereich, dem die Variable zugeordnet ist ● durch Bedienhandlungen (z. B. durch den Download der Quelle ins Zielsystem) ● durch das Ablaufverhalten der Task (sequentiell, zyklisch), welcher das Programm zugeordnet wurde. Alle Variablentypen und den Zeitpunkt der Variableninitialisierung zeigen Ihnen die folgenden Tabellen. Grundsätzliches zu den Tasks finden Sie im Funktionshandbuch SIMOTION Basisfunktionen. Das Verhalten bzgl. der Variableninitialisierung während des Downloads ist einstellbar: Wählen Sie hierzu zur Voreinstellung das Menü Extras > Einstellungen und das Register Download bzw. legen Sie die Einstellung während des aktuellen Downloads fest. Hinweis Sie können Werte von Unit-Variablen oder geräteglobalen Variablen aus dem SIMOTION Gerät in SIMOTION SCOUT hochladen (Upload) und im XML-Format speichern. 1. Speichern Sie mit der Funktion _saveUnitDataSet die gewünschten Datensegmente der Unit-Variablen oder geräteglobalen Variablen als Datensatz. 2. Wenden Sie in SIMOTION SCOUT die Funktion Variablen sichern an. Mit der Umkehrfunktion Variablen wiederherstellen können Sie diese Datensätze und Variablen wieder in das SIMOTION Gerät laden (Download). Weitere Informationen siehe Projektierungshandbuch SIMOTION SCOUT. Damit ist es z. B. möglich, diese Daten zu erhalten, obwohl Sie durch einen Download des Projekts initialisiert oder unbrauchbar werden (z. B. bei Versionswechsel des SIMOTION SCOUT).
4.14.3.1
Initialisierung remanenter globaler Variablen Remanente Variablen behalten bei Spannungsausfall ihren letzten Wert. Alle anderen Daten werden beim Wiedereinschalten neu initialisiert. Remanente globale Variablen werden initialisiert: ● Bei Ausfall der Stützung bzw. Pufferung der remanenten Daten. ● Bei Firmware-Update. ● Beim Urlöschen (MRES). ● Mit Funktion Restart (Del. SRAM) bei SIMOTION P350. ● Durch Anwenden der Funktion _resetUnitData (ab Kernel V3.2), selektiv für verschiedene Datensegmente der remanenten Daten möglich. ● Beim Download gemäß nachfolgender Beschreibung.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
109
KOP/FUP programmieren 4.14 Variablen Tabelle 4- 11 Initialisierung remanenter globaler Variablen beim Download Variablentyp
Zeitpunkt der Variableninitialisierung
Remanente geräteglobale Variablen
Das Verhalten beim Download ist abhängig von der Einstellung Initialisierung aller remanenten geräteglobalen Variablen und Programmdaten 1: • Ja2: Alle remanenten geräteglobalen Variablen werden initialisiert. • Nein3: – Ab Version V3.2 des SIMOTION Kernels:
–
Getrennte Versionskennung für remanente geräteglobale Variablen. Bei Änderung dieser Versionskennung werden die remanenten geräteglobalen Variablen initialisiert. Bis Version V3.1 des SIMOTION Kernels: Gemeinsame Versionskennung für alle geräteglobalen Variablen (remanente und nicht remanente). Bei Änderung dieser Versionskennung werden alle geräteglobalen Variablen initialisiert.
Siehe: Versionskennung globaler Variablen und deren Initialisierung beim Download (Seite 117). Remanente Unit-Variablen
Das Verhalten beim Download ist abhängig von der Einstellung Initialisierung aller remanenten geräteglobalen Variablen und Programmdaten 1: • Ja2: Alle remanenten Unit-Variablen (aller Units) werden initialisiert. • Nein3: – Ab Version V3.2 des SIMOTION Kernels:
–
Getrennte Versionskennung für jeden einzelnen Datenblock ( = Deklarationsblock)4 der remanenten Unit-Variablen im Interface- bzw. Implementationsabschnitt. Bei Änderung der Versionskennung wird nur der betreffende Datenblock initialisiert5. Bis Version V3.1 des SIMOTION Kernels: Gemeinsame Versionskennung für alle Unit-Variablen (remanente und nicht remanente, im Interface- und Implementationsabschnitt) einer Unit. Bei Änderung dieser Versionskennung werden alle Unit-Variablen dieser Unit initialisiert.
Siehe: Versionskennung globaler Variablen und deren Initialisierung beim Download (Seite 117). Voreinstellung im Menü Extras > Einstellungen, Register Download, bzw. aktuelle Einstellung beim Download. 1
2
Entsprechende Checkbox ist aktiv.
3
Entsprechende Checkbox ist inaktiv.
Mehrere Datenblöcke für remanente Unit-Variablen im Interface- bzw. Implementationsabschnitt können nur in der Programmiersprache SIMOTION ST deklariert werden. Bei den Programmiersprachen SIMOTION MCC und SIMOTION KOP/FUP wird im Interface- bzw. Implementationsabschnitt jeweils nur 1 Datenblock für remanente UnitVariablen erzeugt. 4
5 Auch beim Download im RUN, sofern die Voraussetzungen hierzu erfüllt sind und beim jeweiligen Deklarationsblock innerhalb eines Pragmas das folgende Attribut angegeben ist (nur Programmiersprache SIMOTION ST): { BlockInit_OnChange := TRUE; }. Zum Download im RUN siehe Funktionshandbuch SIMOTION Basisfunktionen.
110
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.3.2
Initialisierung nicht remanenter globaler Variablen Nicht remanente globale Variablen verlieren ihren Wert bei Spannungsausfall. Sie werden initialisiert: ● Bei der Initialisierung remanenter globaler Variablen (Seite 109) , z. B. bei FirmwareUpdate oder beim Urlöschen (MRES). ● Beim Einschalten ● Durch Anwenden der Funktion _resetUnitData (ab Kernel V3.2), selektiv für verschiedene Datensegmente der nicht remanenten Daten möglich ● Beim Download gemäß der Beschreibung in nachfolgender Tabelle ● Nur ab Version V4.1 des SIMOTION Kernels und bei nicht remanenten Unit-Variablen: Beim Übergang in den Betriebszustand RUN, wenn beim jeweiligen Deklarationsblock innerhalb eines Pragmas das nachstehende Attribut angegeben ist (nur Programmiersprache SIMOTION ST): { BlockInit_OnDeviceRun := ALWAYS; }
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
111
KOP/FUP programmieren 4.14 Variablen Tabelle 4- 12 Initialisierung nicht remanenter globaler Variablen beim Download Variablentyp
Zeitpunkt der Variableninitialisierung
Nicht remanente geräteglobale Variablen
Das Verhalten beim Download ist abhängig von der Einstellung Initialisierung aller nicht remanenten geräteglobalen Variablen und Programmdaten1: • Ja2: Alle nicht remanenten geräteglobalen Variablen werden initialisiert. • Nein3: – Ab Version V3.2 des SIMOTION Kernels:
–
Getrennte Versionskennung für nicht remanente geräteglobale Variablen. Bei Änderung dieser Versionskennung werden die nicht remanenten geräteglobalen Variablen initialisiert. Bis Version V3.1 des SIMOTION Kernels: Gemeinsame Versionskennung für alle geräteglobalen Variablen (remanente und nicht remanente). Bei Änderung dieser Versionskennung werden alle geräteglobalen Variablen initialisiert.
Siehe: Versionskennung globaler Variablen und deren Initialisierung beim Download (Seite 117). Nicht remanente Unit-Variablen
Das Verhalten beim Download ist abhängig von der Einstellung Initialisierung aller nicht remanenten geräteglobalen Variablen und Programmdaten 1: • Ja2: Alle nicht remanenten Unit-Variablen (aller Units) werden initialisiert. • Nein3: – Ab Version V3.2 des SIMOTION Kernels:
–
Getrennte Versionskennung für jeden einzelnen Datenblock ( = Deklarationsblock)4 der nicht remanenten Unit-Variablen im Interface- bzw. Implementationsabschnitt. Bei Änderung der Versionskennung wird nur der betreffende Datenblock initialisiert5. Bis Version V3.1 des SIMOTION Kernels: Gemeinsame Versionskennung für alle Unit-Variablen (remanente und nicht remanente, im Interface- und Implementationsabschnitt) einer Unit. Bei Änderung dieser Versionskennung werden alle Unit-Variablen dieser Unit initialisiert.
Siehe: Versionskennung globaler Variablen und deren Initialisierung beim Download (Seite 117). Voreinstellung im Menü Extras > Einstellungen, Register Download, bzw. aktuelle Einstellung beim Download. 1
2
Entsprechende Checkbox ist aktiv.
3
Entsprechende Checkbox ist inaktiv.
Mehrere Datenblöcke für nicht remanente Unit-Variablen im Interface- bzw. Implementationsabschnitt können nur in der Programmiersprache SIMOTION ST deklariert werden. Bei den Programmiersprachen SIMOTION MCC und SIMOTION KOP/FUP wird im Interface- bzw. Implementationsabschnitt jeweils nur 1 Datenblock für nicht remanente UnitVariablen erzeugt. 4
5 Auch beim Download im RUN, sofern die Voraussetzungen hierzu erfüllt sind und beim jeweiligen Deklarationsblock innerhalb eines Pragmas das folgende Attribut angegeben ist (nur Programmiersprache SIMOTION ST): { BlockInit_OnChange := TRUE; }. Zum Download im RUN siehe Funktionshandbuch SIMOTION Basisfunktionen.
112
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.3.3
Initialisierung lokaler Variablen Lokale Variablen werden initialisiert: ● Bei der Initialisierung remanenter Unit-Variablen (Seite 109) ● Bei der Initialisierung nicht remanenter Unit-Variablen (Seite 111) ● Zusätzlich gemäß nachfolgender Beschreibung
Tabelle 4- 13 Initialisierung lokaler Variablen Variablentyp
Zeitpunkt der Variableninitialisierung
Lokale Variablen von Programmen
Lokale Variablen von Programmen werden unterschiedlich initialisiert: • Statische Variablen (VAR) werden gemäß dem Speicherbereich initialisiert, in dem sie abgelegt werden. •
Lokale Variablen von Funktionsbausteinen (FB)
Lokale Variablen von Funktionsbausteinen werden unterschiedlich initialisiert: • Statische Variablen (VAR, VAR_IN, VAR_OUT) werden nur dann initialisiert, wenn die Instanz des FB initialisiert wird. •
Lokale Variablen von Funktionen (FC)
Siehe: Initialisierung statischer Variablen von Programmen (Seite 114). Temporäre Variablen (VAR_TEMP) werden bei jedem Aufruf des Programms in der Task initialisiert.
Siehe: Initialisierung von Instanzen von Funktionsbausteinen (FB) (Seite 115). Temporäre Variablen (VAR_TEMP) werden bei jedem Aufruf der Instanz des FB initialisiert.
Lokale Variablen von Funktionen sind temporär, sie werden bei jedem Aufruf der Funktion initialisiert.
Hinweis Informationen über den Speicherbedarf einer POE auf dem Lokaldatenstack können Sie mit der Funktion Programmstruktur (Seite 166) erhalten.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
113
KOP/FUP programmieren 4.14 Variablen
4.14.3.4
Initialisierung statischer Variablen von Programmen Die folgenden Ausführungen betreffen folgende statische Variablen: ● mit VAR deklarierte lokale Variablen der Programme einer Unit, ● mit VAR innerhalb der Programme einer Unit deklarierte Instanzen von Funktionsbausteinen einschließlich der zugehörigen statischen Variablen (VAR, VAR_INPUT, VAR_OUTPUT). Das Initialisierungsverhalten wird bestimmt vom Speicherbereich, in der die statischen Variablen abgelegt werden. Dies wird über die Compileroption (Seite 48) "Programminstanzdaten nur einmal anlegen" bestimmt. ● Bei nicht aktivierter Compileroption "Programminstanzdaten nur einmal anlegen" (Standard): Die statischen Variablen werden im Anwenderspeicher jeder Task abgelegt, der das Programm zugeordnet ist. Die Initialisierung der Variablen ist deshalb abhängig vom Ablaufverhalten der Task, der das Programm zugeordnet ist (siehe Funktionshandbuch SIMOTION Basisfunktionen): – Sequentielle Tasks (MotionTasks, UserInterruptTasks, SystemInterruptTasks, StartupTask, ShutdownTask): Die statischen Variablen werden bei jedem Start der Task initialisiert. – Zyklische Tasks (BackgroundTask, SynchronousTasks, TimerInterruptTasks): Die statischen Variablen werden nur beim Übergang in den Betriebszustand RUN initialisiert. ● Bei aktivierter Compileroption "Programminstanzdaten nur einmal anlegen": Diese Einstellung ist z. B. nötig, wenn ein Programm innerhalb eines Programms aufgerufen werden soll. Die statischen Variablen aller Programme der betreffenden Programmquelle (Unit) werden nur einmal im Anwenderspeicher der Unit abgelegt. – Sie werden deshalb zusammen mit den nicht remanenten Unit-Variablen initialisiert, siehe Initialisierung nicht remanenter globaler Variablen (Seite 111). – Nur ab Version V4.1 des SIMOTION Kernels: Zusätzlich können sie beim Übergang in den Betriebszustand RUN initialisiert werden. Im jeweiligen Deklarationsblock muss hierzu innerhalb eines Pragmas das nachstehende Attribut angegeben werden (nur Programmiersprache SIMOTION ST): { BlockInit_OnDeviceRun := ALWAYS; }.
114
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.3.5
Initialisierung von Instanzen von Funktionsbausteinen (FB) Die Initialisierung einer Instanz eines Funktionsbausteins wird vom Ort ihrer Deklaration bestimmt: ● Globale Deklaration (innerhalb VAR_GLOBAL / END_VAR im Interface- oder Implementationsabschnitt): Initialisierung wie nicht remanente Unit-Variable, siehe Initialisierung nicht remanenter globaler Variablen (Seite 111). ● Lokale Deklaration in einem Programm (innerhalb VAR / END_VAR): Initialisierung wie statische Variable von Programmen, siehe Initialisierung statischer Variablen von Programmen (Seite 114). ● Lokale Deklaration in einem Funktionsbaustein (innerhalb VAR / END_VAR): Initialisierung wie eine Instanz dieses Funktionsbausteins. ● Deklaration als Durchgangsparameter in einem Funktionsbaustein oder einer Funktion (innerhalb VAR_IN_OUT / END_VAR): Bei der Initialisierung der POE wird nur die Referenz (Zeiger) initialisiert, die Instanz des Funktionsbausteins bleibt unverändert. Hinweis Informationen über den Speicherbedarf einer POE auf dem Lokaldatenstack können Sie mit der Funktion Programmstruktur (Seite 166) erhalten.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
115
KOP/FUP programmieren 4.14 Variablen
4.14.3.6
Initialisierung von Systemvariablen der Technologieobjekte Die Systemvariablen eines Technologieobjekts sind in der Regel nicht remanent. Abhängig vom Technologieobjekt werden einige wenige Systemvariablen im remanenten Speicherbereich abgelegt (z. B. Absolutwertgeberjustage). Das Initialisierungsverhalten entspricht (außer beim Download) dem für remanente bzw. nicht remanente globale Variablen. Siehe Initialisierung remanenter globaler Variablen (Seite 109) und Initialisierung nicht remanenter globaler Variablen (Seite 111). Das Verhalten beim Download ist nachfolgend dargestellt für: ● Nicht remanente Systemvariablen ● Remanente Systemvariablen
Tabelle 4- 14 Initialisierung der Systemvariablen der Technologieobjekte beim Download Variablentyp
Zeitpunkt der Variableninitialisierung
Nicht remanente Systemvariablen
Verhalten beim Download, abhängig von der Einstellung Initialisierung aller nicht remanenten Daten von Technologieobjekten1: • Ja2: Alle Technologieobjekte werden initialisiert. – Alle Technologieobjekte werden neu aufgebaut, alle nicht remanenten Systemvariablen werden initialisiert. – Alle Technologischen Alarme werden gelöscht. • Nein3: Nur in SIMOTION SCOUT veränderte Technologieobjekte werden initialisiert. – Die betreffenden Technologieobjekte werden neu aufgebaut, alle nicht remanenten Systemvariablen werden initialisiert. – Alle Alarme, die an den betreffenden Technologieobjekten anstehen, werden gelöscht. – Wenn an einem nicht zu initialisierenden Technologieobjekt ein Alarm ansteht, der nur mit Power On quittiert werden kann, wird der Download abgebrochen.
Remanente Systemvariablen
Nur wenn ein Technologieobjekt in SIMOTION SCOUT verändert wurde, werden dessen remanente Systemvariablen initialisiert. Die remanenten Systemvariablen aller anderen Technologieobjekte bleiben erhalten (z. B. Absolutwertgeberjustage)
Voreinstellung im Menü Extras > Einstellungen, Register Download, bzw. aktuelle Einstellung beim Download. 1
2
Entsprechende Checkbox ist aktiv.
3
Entsprechende Checkbox ist inaktiv.
116
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.14 Variablen
4.14.3.7
Versionskennung globaler Variablen und deren Initialisierung beim Download
Tabelle 4- 15 Versionskennung globaler Variablen und deren Initialisierung beim Download Datensegment
ab Version V3.2 des SIMOTION Kernels
bis Version V3.1 des SIMOTION Kernels
Geräteglobale Variablen Remanente geräteglobale Variablen
• •
Nicht remanente geräteglobale Variablen
•
•
•
Eigene Versionskennung für jedes Datensegment der geräteglobalen Variablen Die Versionskennung eines Datensegments ändert sich bei: – Hinzufügen oder Entfernen einer Variablen innerhalb des Datensegments – Änderung des Bezeichners oder des Datentyps einer Variablen innerhalb des Datensegments Keine Änderung dieser Versionskennung bei: – Änderungen im anderen Datensegment – Änderung von Initialisierungswerten1 Beim Download2 gilt: Initialisierung eines Datensegments nur dann, wenn sich dessen Versionskennung geändert hat Anwendung der Funktionen zur Datensicherung und -initialisierung möglich
•
Mehrere Datenblöcke ( = Deklarationsblöcke)3 in jedem Datensegment möglich Eigene Versionskennung für jeden Datenblock Die Versionskennung eines Datenblocks ändert sich bei: – Hinzufügen oder Entfernen einer Variablen im betreffenden Deklarationsblock – Änderung des Bezeichners oder des Datentyps einer Variablen im betreffenden Deklarationsblock – Änderung einer Datentypdefinition (aus eigener oder
•
•
•
•
Gemeinsame Versionskennung für alle Datensegmente der geräteglobalen Variablen Diese Versionskennung ändert sich bei einer Änderung der Variablendeklaration in einem Datensegment Beim Download2 gilt: Initialisierung aller Datensegmente bei Änderung der Versionskennung Anwendung der Funktionen zur Datensicherung nicht möglich
Unit-Variablen einer Unit Remanente UnitVariablen im Interfaceabschnitt Remanente UnitVariablen im Implementationsabschnitt Nicht remanente Unit-Variablen im Interfaceabschnitt
• • •
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
•
•
1 Datenblock in jedem Datensegment (auch bei mehreren Deklarationsblöcken)3 Gemeinsame Versionskennung für alle globalen Deklarationen in einer Unit Diese Versionskennung ändert sich bei folgenden Änderungen: – Variablendeklaration in
117
KOP/FUP programmieren 4.14 Variablen Datensegment
ab Version V3.2 des SIMOTION Kernels
Nicht remanente Unit-Variablen im Implementationsabschnitt •
•
•
importierter4 Unit), die im betreffenden Deklarationsblock verwendet wird – Hinzufügen oder Entfernen von Deklarationsblöcken innerhalb desselben Datensegments vor dem betreffenden Deklarationsblock Keine Änderung dieser Versionskennung bei: – Hinzufügen oder Entfernen von Deklarationsblöcken in anderen Datensegmenten – Hinzufügen oder Entfernen von Deklarationsblöcken innerhalb desselben Datensegments hinter dem betreffenden Deklarationsblock – Änderungen in anderen Deklarationsblöcken – Änderung von Initialisierungswerten1 – Änderungen von Datentypdefinitionen, die im betreffenden Deklarationsblock nicht verwendet werden – Änderungen von Funktionen Beim Download2 gilt: Initialisierung eines Datenblocks nur dann, wenn sich dessen Versionskennung geändert hat5 Funktionen zur Datensicherung und -initialisierung berücksichtigen die Versionskennung der Datenblöcke
•
•
bis Version V3.1 des SIMOTION Kernels einem Datensegment – Deklaration globaler Datentypen in der Unit – Deklaration im Interfaceabschnitt einer importierten4 Unit Beim Download2 gilt: Initialisierung aller Datensegmente bei Änderung der Versionskennung Anwendung der Funktionen zur Datensicherung nur möglich für: Nicht remanente Unit-Variablen im Interfaceabschnitt
1 Geänderte Initialisierungswerte werden erst wirksam, wenn der betreffende Datenblock bzw. Datensegment initialisiert wird.
Bei Einstellung Initialisierung aller remanenten geräteglobalen Variablen und Programmdaten = Nein und Initialisierung aller nicht remanenten geräteglobalen Variablen und Programmdaten = Nein.
2
Bei anderen Einstellungen: siehe die Abschnitte "Initialisierung remanenter globaler Variablen (Seite 109)" bzw. "Initialisierung nicht remanenter globaler Variablen (Seite 111)".
Mehrere Deklarationsblöcke pro Datensegment sind nur in der Programmiersprache SIMOTION ST möglich. Bei den Programmiersprachen SIMOTION MCC und SIMOTION KOP/FUP wird nur jeweils 1 Deklarationsblock pro Datensegment erzeugt.
3
4
Der Import von Units ist abhängig von der Programmiersprache, siehe den entsprechenden Abschnitt (Seite 136).
Auch beim Download im RUN, sofern die Voraussetzungen hierzu erfüllt sind und beim jeweiligen Deklarationsblock innerhalb eines Pragmas das nachstehende Attribut angegeben ist (nur Programmiersprache SIMOTION ST): { BlockInit_OnChange := TRUE; }. Zum Download im RUN siehe Funktionshandbuch SIMOTION Basisfunktionen. 5
118
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15
Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.1
Überblick Zugriff auf Ein- und Ausgänge Sie können auf die Ein- und Ausgänge des SIMOTION Geräts sowie der zentralen und dezentralen Peripherie zugreifen: ● über Direktzugriff mit I/O-Variablen Sie definieren eine I/O-Variable (Name und I/O-Adresse). Der gesamte Adressbereich ist nutzbar. Den Direktzugriff verwenden Sie bevorzugt bei sequentieller Programmierung (in MotionTasks); hier ist der Zugriff auf den aktuellen Wert der Ein- und Ausgänge zu einem bestimmten Zeitpunkt besonders wichtig. ( ● über das Prozessabbild der zyklischen Tasks mit I/O-Variablen Speicherbereich im RAM des SIMOTION Geräts, auf dem der Adressraum der SIMOTION Geräts gespiegelt ist. Dieses Spiegelbild wird mit der zugeordneten Task aktualisiert und ist während deren gesamten Zyklus konsistent. Es wird bevorzugt bei der Programmierung der zugeordneten Task (zyklische Programmierung) eingesetzt. Sie definieren eine I/O-Variable (Name und I/O-Adresse) und ordnen ihr eine Task zu. Der gesamte Adressbereich des SIMOTION Geräts ist nutzbar. Der Direktzugriff auf diese I/O-Variable ist dennoch möglich: Spezifizieren Sie den Direktzugriff mit _direct.var-name. ● mit dem festen Prozessabbild der BackgroundTask Speicherbereich im RAM des SIMOTION Geräts, auf dem eine Untermenge der I/O-Adressraums gespiegelt ist. Dieses Spiegelbild wird mit der BackgroundTask aktualisiert und ist während deren gesamten Zyklus konsistent. Es wird bevorzugt bei der Programmierung der BackgroundTask (zyklische Programmierung) eingesetzt. Der Adressbereich 0 .. 63 ist nutzbar, außer beim Prozessabbild der zyklischen Tasks Hinweis Der Zugriff über das Prozessabbild ist performanter als der Direktzugriff.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
119
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.2
Wichtige Eigenschaften von Direktzugriff und Prozessabbild
Tabelle 4- 16 Wichtige Eigenschaften von Direktzugriff und Prozessabbild Direktzugriff
Zugriff auf Prozessabbild der zyklischen Tasks
Zugriff auf festes Prozessabbild der BackgroundTask
Gesamter Adressbereich des SIMOTION Geräts
0 .. 63,
Ausnahme: I/O-Variablen, die mehrere Bytes umfassen, dürfen die Adressen 63 und 64 nicht zusammenhängend enthalten (Beispiel: PIW63 oder PQD62 sind nicht erlaubt.).
außer beim Prozessabbild der zyklischen Tasks verwendete Adressen.
Verwendete Adressen müssen in der Peripherie vorhanden und entsprechend projektiert sein.
Es können auch in der Peripherie nicht vorhandene oder projektierte Adressen verwendet werden.
Zugeordnete Task
Keine.
Zyklische Task wählbar: • SynchronousTasks, • TimerInterruptTasks, • BackgroundTask.
BackgroundTask.
Aktualisierung
•
Die Aktualisierung erfolgt mit der zugeordneten Task: • Die Eingänge werden vor Start der zugeordneten Task gelesen und in das Prozessabbild der Eingänge übertragen. • Das Prozessabbild der Ausgänge wird nach Beenden der zugeordneten Task auf die Ausgänge geschrieben.
Die Aktualisierung erfolgt mit der BackgroundTask: • Die Eingänge werden vor Start der BackgroundTask gelesen und in das Prozessabbild der Eingänge übertragen. • Das Prozessabbild der Ausgänge wird nach Beenden der BackgroundTask auf die Ausgänge geschrieben.
Während des gesamten Zyklus der zugeordneten Task.
Während des gesamten Zyklus der BackgroundTask.
Ausnahme: Direktzugriff auf Ausgang erfolgt.
Ausnahme: Direktzugriff auf Ausgang erfolgt.
Zulässiger Adressbereich
•
Bei der Onboard-Peripherie der SIMOTION Geräte C230-2, C240 und P350: Die Aktualisierung erfolgt in einem Takt von 125 µs. Bei Peripherie über PROFIBUS DP, PROFINET, P-Bus, DRIVECLiQ sowie OnboardPeripherie der SIMOTION Geräte D4xx: Die Aktualisierung erfolgt im Lageregler-Takt.
Die Eingänge werden zu Beginn des Takts gelesen. Die Ausgänge werden am Ende des Takts geschrieben. Konsistenz
–
Die Konsistenz ist nur für elementare Datentypen gewährleistet. Bei der Verwendung von Arrays hat der Anwender selbst für die Konsistenz der Daten zu sorgen. Verwendung
120
bevorzugt in MotionTasks
bevorzugt in der zugeordneten Task
bevorzugt in der BackgroundTask
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen) Direktzugriff
Zugriff auf Prozessabbild der zyklischen Tasks
Zugriff auf festes Prozessabbild der BackgroundTask
Deklaration als Variable
Notwendig, geräteglobal im Symbolbrowser
Möglich, nicht notwendig: • geräteglobal im Symbolbrowser, • als Unit-Variable, • als lokale statische Variable in einem Programm.
Schreibschutz für Ausgänge
Möglich; Status Nur Lesen wählbar.
Nicht möglich.
Deklaration von Arrays
Möglich.
Verhalten im Fehlerfall
Fehler beim Zugriff aus Anwenderprogramm, Reaktion wählbar: • CPU-Stop1 • Ersatzwert • Letzter Wert
Nicht möglich.
Nicht möglich. Fehler beim Bilden des Prozessabbilds, Reaktion wählbar: • CPU-Stop1 • Ersatzwert • Letzter Wert
Fehler beim Bilden des Prozessabbilds, Reaktion: CPU-Stop1. Ausnahme: Wenn auf dieselbe Adresse ein Direktzugriff erstellt wurde, gilt das dort eingestellte Verhalten.
Siehe Funktionsbeschreibung SIMOTION Basisfunktionen Verwenden der absoluten Adresse
Nicht möglich.
Möglich
Zugriffe •
im Betriebszustand RUN
Uneingeschränkt möglich.
Uneingeschränkt möglich.
•
während der StartupTask
Eingeschränkt möglich: • Eingänge können gelesen werden. • Ausgänge werden erst am Ende der StartupTask geschrieben.
Eingeschränkt möglich: Eingeschränkt möglich: • Eingänge werden zu Beginn • Eingänge werden zu Beginn der StartupTask gelesen. der StartupTask gelesen. • Ausgänge werden erst am • Ausgänge werden erst am Ende der StartupTask Ende der StartupTask geschrieben. geschrieben.
•
während der ShutdownTask
Uneingeschränkt möglich.
Eingeschränkt möglich: • Eingänge behalten den Status der letzten Aktualisierung • Ausgänge werden nicht mehr geschrieben.
1 Aufruf
Uneingeschränkt möglich.
Eingeschränkt möglich: • Eingänge behalten den Status der letzten Aktualisierung • Ausgänge werden nicht mehr geschrieben.
der PeripheralFaultTask.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
121
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.3
Direktzugriff und Prozessabbild der zyklischen Tasks
Eigenschaft Der Direktzugriff auf Ein- und Ausgänge und der Zugriff auf das Prozessabbild der zyklischen Tasks erfolgt immer über I/O-Variablen. Der gesamte Adressbereich des SIMOTION Geräts (siehe Tabelle unten) ist nutzbar. Eine Gegenüberstellung der wichtigsten Eigenschaften auch im Vergleich zum festen Prozessabbild der BackgroundTask (Seite 128) finden Sie in "Wichtige Eigenschaften von Direktzugriff und Prozessabbild (Seite 120)".
Direktzugriff Mit dem Direktzugriff greifen Sie direkt auf die entsprechende I/O-Adresse zu. Den Direktzugriff verwenden Sie bevorzugt bei sequentieller Programmierung (in MotionTasks). Hier ist der Zugriff auf den aktuellen Wert der Ein- und Ausgänge zu einem bestimmten Zeitpunkt besonders wichtig. Für den Direktzugriff definieren Sie eine I/O-Variable (Seite 125), ohne ihr eine Task zuzuordnen. Hinweis Der Zugriff über das Prozessabbild ist performanter als der Direktzugriff.
Prozessabbild der zyklischen Task Das Prozessabbild der zyklischen Tasks ist ein Speicherbereich im RAM des SIMOTION Geräts, auf dem der gesamte I/O-Adressraum des SIMOTION Geräts gespiegelt ist. Das Spiegelbild jeder I/O-Adresse ist einer zyklischen Task zugeordnet und wird mit dieser aktualisiert. Es ist während des gesamten Zyklus der Task konsistent. Dieses Prozessabbild wird bevorzugt bei der Programmierung der zugeordneten Task (zyklische Programmierung) eingesetzt. Hier ist die Konsistenz während des gesamten Zyklus der Task besonders wichtig. Für das Prozessabbild der zyklischen Tasks definieren Sie eine I/O-Variable (Seite 125) und ordnen ihr eine Task zu. Der Direktzugriff auf diese I/O-Variable ist dennoch möglich: Spezifizieren Sie den Direktzugriff mit _direct.var-name.
122
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
Adressbereich der SIMOTION Geräte Nachfolgend ist der Adressbereich der SIMOTION Geräte in Anhängigkeit von der Version des SIMOTION Kernels angegeben. Bei Direktzugriff und Prozessabbild der zyklischen Tasks ist der gesamte Adressbereich nutzbar. Tabelle 4- 17 Adressbereich der SIMOTION Geräte in Abhängigkeit von der Version des SIMOTION Kernels SIMOTION Gerät
Adressbereich bei Version des SIMOTION Kernels V3.0
V3.1, V3.2
ab V4.0
C230-2
0 .. 1023
0 .. 2047 4
0 .. 2047 4
C240
–
–
0 .. 4096 4
C240 PN 1
–
–
0 .. 4096 5
D410 2
–
–
0 .. 16383 4 5
D425 3
–
D435
0 .. 1023
4095 4
0 ..
0 .. 16383 4 5
0 .. 4095 4
0 .. 16383 4 5
4095 4
0 .. 16383 4 5
D445 3
–
D445-1 1
–
–
0 .. 16383 4 5
P350
0 .. 1023
0 .. 2047 4
0 .. 4095 4
1
Ab V4.1 SP2 HF4 verfügbar.
2
Ab V4.1 verfügbar.
3
Ab V3.2 verfügbar.
0 ..
Für die dezentrale Peripherie über PROFIBUS DP ist der Übertragungsumfang auf 1024 Bytes je PROFIBUS DP-Strang beschränkt.
4
Für die dezentrale Peripherie über PROFINET ist der Übertragungsumfang auf 4096 Bytes je PROFINET-Segment beschränkt
5
Hinweis Beachten Sie die Regeln für I/O-Adressen für Direktzugriff und das Prozessabbild der zyklischen Tasks (Seite 124).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
123
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.3.1
Regeln für I/O-Adressen für Direktzugriff und das Prozessabbild der zyklischen Tasks ACHTUNG Bei den Adressen für I/O-Variablen für Direktzugriff und das Prozessabbild der zyklischen Task (Seite 122) müssen Sie folgende Regeln beachten. Die Einhaltung der Regeln wird bei der Konsistenzprüfung des SIMOTION Projekt (z. B. beim Download) überprüft. 1. Für I/O-Variablen verwendete Adressen müssen in der Peripherie vorhanden und in HW-Konfig entsprechend projektiert sein. 2. I/O-Variablen, die mehrere Bytes umfassen, dürfen die Adressen 63 und 64 nicht zusammenhängend enthalten. Folgende I/O-Adressen sind nicht erlaubt: – Eingänge: PIW63, PID61, PID62, PID63 – Ausgänge: PQW63, PQD61, PQD62, PQD63 3. Alle Adressen einer I/O-Variablen, die mehrere Bytes umfasst, müssen innerhalb eines in HW Konfig projektierten Adressbereichs liegen. 4. Eine I/O-Adresse (Eingang bzw. Ausgang) kann nur von einer einzigen I/O-Variablen vom Datentyp BYTE, WORD oder DWORD bzw. einem Array dieser Datentypen verwendet werden. Zugriffe auf einzelne Bits mit I/O-Variablen vom Datentyp BOOL sind möglich. 5. Wenn mehrere Prozesse (z. B. I/O-Variable, Technologieobjekt, PROFIdriveTelegramm) auf eine I/O-Adresse zugreifen, gilt: – Auf eine I/O-Adresse eines Ausgangs (Datentyp BYTE, WORD oder DWORD) kann nur ein einziger Prozess schreibend zugreifen. Lesender Zugriff mit einer I/O-Variablen auf einen Ausgang, der von einem anderen Prozess schreibend genutzt wird, ist möglich. – Alle Prozesse müssen mit dem gleichen Datentyp (BYTE, WORD, DWORD oder ARRAY dieser Datentypen) auf diese I/O-Adresse zugreifen. Zugriffe auf einzelne Bits sind unabhängig davon möglich. Achten Sie z. B. darauf, wenn Sie mit einer I/O-Variable das zum Antrieb bzw. vom Antrieb übertragene PROFIdrive-Telegramm lesen wollen: Die Länge der I/OVariablen muss der Länge des Telegramms entsprechen. – Schreibender Zugriff auf verschiedene Bits einer Adresse ist von mehreren Prozessen aus möglich; ein schreibender Zugriff mit den Datentypen BYTE, WORD oder DWORD ist dann nicht möglich. Hinweis Bei Zugriffen auf das feste Prozessabbild der BackgroundTask (Seite 128) gelten diesen Regeln nicht. Diese Zugriffe werden bei einer Konsistenzprüfung des Projekts (z. B. beim Download) nicht berücksichtigt.
124
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.3.2
I/O-Variable für Direktzugriff oder Prozessabbild der zyklischen Tasks erstellen I/O-Variablen für Direktzugriff oder Prozessabbild der zyklischen Tasks erstellen Sie im Symbol-Browser der Detailanzeige; Sie müssen sich hierzu im Offline-Modus befinden. Hier in Kurzform die Vorgehensweise: 1. Markieren Sie im Projektnavigator des SIMOTION SCOUT das Element "I/O" im Teilbaum des SIMOTION Geräts. 2. Wählen Sie in der Detailanzeige das Register "Symbolbrowser" und scrollen Sie bis zum Ende der Variablentabelle (leere Zeile). 3. Geben Sie in die letzte (leere) Zeile der Tabelle ein oder wählen Sie: – Name der Variablen. – I/O-Adresse gemäß "Syntax für Eingabe der I/O-Adressen (Seite 127)". – optional bei Ausgängen: Markieren Sie die Checkbox "Nur lesen", wenn Sie auf den Ausgang nur lesend zugreifen wollen. Sie können dann einen Ausgang lesen, der bereits durch einen anderen Prozess beschrieben wird (z. B. Ausgang eines Nockens, PROFIdrive-Telegramm). Eine nur lesbare Ausgangsvariable kann dem Prozessabbild einer zyklischen Task nicht zugeordnet werden. – Datentyp der Variablen gemäß "Mögliche Datentypen der I/O-Variablen (Seite 128)". 4. Optional können Sie noch eingeben oder wählen (nicht bei Datentyp BOOL): – Feldlänge (Größe des Arrays) – Prozessabbild oder Direktzugriff: Die Zuordnung ist nur möglich, wenn die Checkbox "Nur lesen" deaktiviert ist. Für Prozessabbild wählen Sie die zyklische Task, der Sie die I/O-Variable zuordnen wollen. Damit Sie eine Task auswählen können, muss sie im Ablaufsystem aktiviert sein. Für Direktzugriff wählen Sie den leeren Eintrag. – Strategie für das Verhalten im Fehlerfall (siehe Funktionshandbuch SIMOTION Basisfunktionen). – Ersatzwert (bei Arrays für jedes Element). – Anzeigeformat (bei Arrays für jedes Element), wenn Sie die Variable im SymbolBrowser beobachten. Sie können nun mit dem Symbol-Browser oder jedem Programm des SIMOTION Geräts auf diese Variable zugreifen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
125
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
ACHTUNG Beachten Sie beim Prozessabbild für zyklische Tasks: • Eine Variable kann nur einer einzigen Task zugeordnet werden. • Jedes Byte eines Ein- oder Ausgangs kann nur einer einzigen I/O-Variablen zugeordnet werden. Beachten Sie beim Datentyp BOOL • Das Prozessabbild für zyklische Tasks und eine Strategie für den Fehlerfall können nicht definiert werden. Es gilt das Verhalten, das mittels einer I/O-Variablen für das gesamte Byte definiert wurde (Voreinstellung: Direktzugriff bzw. CPU-Stop). • Zugriffe auf die einzelnen Bits einer I/O-Variablen sind auch mit Hilfe der Bitzugriffsfunktionen möglich. Beachten Sie bei Änderungen innerhalb der I/O-Variablen (z. B. Einfügen und Löschen von I/O-Variablen, Namensänderungen, Adressänderungen): • Die interne Adressierung anderer I/O-Variablen kann sich unter Umständen ändern; alle I/O-Variablen werden dadurch inkonsistent. • Alle Programmquellen, die Zugriffe, auf I/O-Variablen enthalten, müssen gegebenenfalls neu übersetzt werden.
Hinweis I/O-Variablen können Sie nur im Offline-Modus anlegen. Sie legen sie im SIMOTION SCOUT an und verwenden sie in Ihren Programmquellen (z. B. ST-Quellen, MCC-Quellen, KOP/FUP-Quellen). Ausgänge können Sie lesen und beschreiben, Eingänge jedoch nur lesen. Bevor Sie neue oder aktualisierte I/O-Variablen beobachten und steuern können, müssen Sie das Projekt ins Zielsystem laden. Sie können eine I/O-Variable wie jede andere Variable verwenden, siehe "Auf I/O-Variablen zugreifen (Seite 134)".
126
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.3.3
Syntax für Eingabe der I/O-Adressen Für die Eingabe der I/O-Adresse bei der Definition einer I/O-Variablen für Direktzugriff oder Prozessabbild der zyklischen Tasks (Seite 122) verwenden Sie die nachstehende Syntax. Hierdurch spezifizieren Sie neben der Adresse zugleich den Datentyp des Zugriffs und die Art des Zugriffs (Eingang/Ausgang).
Tabelle 4- 18 Syntax für Eingabe der I/O-Adressen für Direktzugriff oder Prozessabbild der zyklischen Tasks Datentyp
Syntax für Eingang
Zulässiger Adressbereich
Ausgang
Direktzugriff
BOOL
PIn.x
PQn.x
n: x:
0 .. MaxAddr 0 .. 7
BYTE
PIBn
PQBn
n:
0 .. MaxAddr
WORD
PIWn
PQWn
n:
DWORD
PIDn
PQDn
n:
Prozessabbild
z. B. Direktzugriff D435 V4.1
-1
n: x:
0 .. 16383 0 .. 7
n:
0 .. MaxAddr
n:
0 .. 16383
0 .. 62 64 .. MaxAddr - 1
n:
0 .. 62 64 .. MaxAddr - 1
n:
0 .. 62 64 .. 16382
0 .. 60 64 .. MaxAddr - 3
n:
0 .. 60 64 .. MaxAddr - 3
n:
0 .. 60 64 .. 16380
n= logische Adresse x= Bitnummer
MaxAddr =
Maximale I/O-Adresse des SIMOTION Geräts in Abhängigkeit von der Version des SIMOTION Kernels, siehe Adressbereich der SIMOTION Geräte in "Direktzugriff und Prozessabbild der zyklischen Tasks (Seite 122)".
1 Für den Datentyp BOOL kann das Prozessabbild für zyklische Tasks nicht definiert werden. Es gilt das Verhalten, das mittels einer I/O-Variablen für das gesamte Byte definiert wurde (Voreinstellung: Direktzugriff).
Beispiele: Eingang an logischer Adresse 1022, Datentyp WORD: PIW1022. Ausgang an logischer Adresse 63, Bit 3, Datentyp BOOL: PQ63.3. Hinweis Beachten Sie die Regeln für I/O-Adressen für Direktzugriff und das Prozessabbild der zyklischen Tasks (Seite 124).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
127
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.3.4
Mögliche Datentypen der I/O-Variablen Den I/O-Variablen für Direktzugriff und Prozessabbild der zyklischen Tasks (Seite 122) können nachstehende Datentypen zugeordnet werden. Die Breite des Datentyps muss der Breite des Datentyps der I/O-Adresse entsprechen. Wenn Sie der I/O-Variablen einen numerischen Datentyp zuordnen, können Sie auf diese Variable als Ganzzahl zugreifen. Tabelle 4- 19 Mögliche Datentypen der I/O Variablen für Direktzugriff und Prozessabbild der zyklischen Tasks Datentyp der I/O-Adresse
Mögliche Datentypen der IO-Variablen
BOOL (PIn.x, PQn.x)
BOOL
BYTE (PIBn, PQBn)
BYTE, SINT, USINT
WORD (PIWn, PQWn)
WORD, INT, UINT
DWORD (PIDn, PQDn)
DWORD, DINT, UDINT
Zum Datentyp der I/O-Adresse siehe auch "Syntax für Eingabe der I/O-Adressen (Seite 127)".
4.15.4
Zugriffe auf festes Prozessabbild der BackgroundTask Das feste Prozessabbild der BackgroundTask ist ein Speicherbereich im RAM des SIMOTION Geräts, auf dem eine Untermenge der I/O-Adressraums des SIMOTION Geräts gespiegelt ist. Es wird bevorzugt bei der Programmierung der BackgroundTask (zyklische Programmierung) eingesetzt, da es während deren gesamten Zyklus konsistent ist. Die Größe des festen Prozessabbilds der BackgroundTask beträgt für alle SIMOTION Geräte 64 Byte (Adressbereich 0 .. 63). Eine Gegenüberstellung der wichtigsten Eigenschaften im Vergleich zum Direktzugriff und Prozessabbild der zyklischen Tasks (Seite 122) finden Sie in "Wichtige Eigenschaften von Direktzugriff und Prozessabbild (Seite 120)". ACHTUNG I/O-Adressen, auf die mit dem Prozessabbild der zyklischen Tasks zugegriffen wird, dürfen nicht verwendet werden. Diese Adressen können mit dem festen Prozessabbild der BackgroundTask nicht gelesen oder beschrieben werden. Hinweis Die Regeln für I/O-Adressen für Direktzugriff und das Prozessabbild der zyklischen Tasks (Seite 124) gelten nicht. Die Zugriffe auf das feste Prozessabbild der BackgroundTask werden bei einer Konsistenzprüfung des Projekts (z. B. beim Download) nicht berücksichtigt. In der Peripherie nicht vorhandene oder in HW-Konfig nicht projektierte Adressen werden wie normale Speicheradressen behandelt.
128
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen) Auf das feste Prozessabbild der BackgroundTask können Sie zugreifen: ● Mittels eines absoluten PA-Zugriffs (Seite 130): der Bezeichner des absoluten PAZugriffs enthält die Adresse des Ein-/Ausgangs sowie den Datentyp. ● Mittels eines symbolischen PA-Zugriffs (Seite 131): Sie deklarieren eine Variable die auf den entsprechenden absoluten PA-Zugriff verweist: – eine Unit-Variable, – eine statische lokale Variable in einem Programm. ● Mittels einer I/O-Variablen (Seite 133): Sie definieren im Symbolbrowser eine geräteglobal gültige I/O-Variable, die auf den entsprechenden absoluten PA-Zugriff verweist. ACHTUNG Beachten Sie, wenn Ein- und Ausgänge mit der Byte-Anordnung Little Endian arbeiten (z. B. die integrierten Digitaleingänge der SIMOTION Geräte C230-2, C240 oder C240 PN) und folgende Bedingungen erfüllt sind: 1. Die Ein- und Ausgänge sind auf eine Adresse 0 .. 62 konfiguriert. 2. Eine I/O-Variable für Direktzugriff (Datentyp WORD, INT oder UINT) ist für diese Einund Ausgänge angelegt. 3. Sie greifen auch über das feste Prozessabbild der BackgroundTask auf diese Ein- und Ausgänge zu. Dann gilt: • Der Zugriff mit Datentyp WORD liefert über die I/O-Variable und das feste Prozessabbild der BackgroundTask das gleiche Ergebnis. • Der Zugriff auf die einzelnen Bytes mit der Funktion _getInOutByte (siehe Funktionshandbuch SIMOTION Basisfunktionen) liefert diese in der Anordnung Little Endian. • Der Zugriff auf die einzelnen Bytes oder Bits mit dem festen Prozessabbild der BackgroundTask liefert diese in der Anordnung Big Endian. Zum Anordnung der Bytes Little Endian und Big Endian: siehe Funktionshandbuch
SIMOTION Basisfunktionen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
129
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.4.1
Absoluter Zugriff auf das feste Prozessabbild der BackgroundTask (Absoluter PA-Zugriff) Sie greifen absolut auf das feste Prozessabbild der BackgroundTask (Seite 128) zu, indem Sie direkt den Bezeichner für die Adresse (mit implizitem Datentyp) verwenden. Die Syntax des Bezeichners (Seite 130) ist im nachfolgenden Abschnitt beschrieben. Sie können den Bezeichner für den absoluten PA-Zugriff wie eine normale Variable verwenden. Hinweis Ausgänge können Sie lesen und beschreiben, Eingänge nur lesen.
4.15.4.2
Syntax für den Bezeichner für einen absoluten PA-Zugriff Für den absoluten Zugriff auf das feste Prozessabbild der BackgroundTask (Seite 130) verwenden Sie nachstehende Syntax. Hierdurch spezifizieren Sie neben der Adresse zugleich den Datentyp des Zugriffs und die Art des Zugriffs (Eingang/Ausgang). Diese Bezeichner verwenden Sie auch: ● bei der Deklaration eines symbolischen Zugriffs auf das feste Prozessabbild der BackgroundTask (Seite 131). ● beim Erstellen einer I/O-Variablen für den Zugriff auf das feste Prozessabbild der BackgroundTask (Seite 133). Tabelle 4- 20 Syntax für den Bezeichner für einen absoluten PA-Zugriff Syntax für
Datentyp
Eingang BOOL
Zulässiger Adressbereich
Ausgang
%In.x oder %IXn.x 1
%Qn.x oder %QXn.x 1
n:
0 .. 63 2
x:
0 .. 7
BYTE
%IBn
%QBn
n:
0 .. 63
WORD
%IWn
%QWn
n:
0 .. 63 2
DWORD
%IDn
%QDn
n:
0 .. 63 2
2
n= logische Adresse x= Bitnummer
130
1
Die Syntax %IXn.x bzw. %QXn.x ist bei der Definition von I/O-Variablen nicht zulässig.
2
Außer beim Prozessabbild der zyklischen Tasks verwendete Adressen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
Beispiele Eingang an logischer Adresse 62, Datentyp WORD: %IW62. Ausgang an logischer Adresse 63, Bit 3, Datentyp BOOL: %Q63.3. ACHTUNG Adressen, auf die mit dem Prozessabbild der zyklischen Tasks zugegriffen wird, dürfen nicht verwendet werden. Diese Adressen können mit dem festen Prozessabbild der BackgroundTask nicht gelesen oder beschrieben werden. Hinweis Die Regeln für I/O-Adressen für Direktzugriff und das Prozessabbild der zyklischen Tasks (Seite 124) gelten nicht. Die Zugriffe auf das feste Prozessabbild der BackgroundTask werden bei einer Konsistenzprüfung des Projekts (z. B. beim Download) nicht berücksichtigt. In der Peripherie nicht vorhandene oder in HW-Konfig nicht projektierte Adressen werden wie normale Speicheradressen behandelt.
4.15.4.3
Symbolischen Zugriff auf das feste Prozessabbild der BackgroundTask definieren Symbolische Zugriffe auf das feste Prozessabbild der BackgroundTask erstellen Sie in den Deklarationstabellen der Quelle oder des MCC-Chart bzw. KOP/FUP-Programms (nur bei Programmen). Vom Ort der Deklaration ist die Reichweite des symbolischen Prozessabbildzugriffs abhängig: ● im Interfaceabschnitt der Deklarationstabelle der Quelle (INTERFACE): Der symbolische Prozessabbildzugriff verhält sich wie eine Unit-Variable; er ist in der gesamten Quelle gültig; alle MCC-Charts bzw. KOP/FUP-Programme (Programme, Funktionsbausteine und Funktionen) innerhalb der Quelle können darauf zugreifen. Außerdem stehen diese Variablen auch auf HMI-Geräten zur Verfügung sowie nach Verbinden auch in anderen Quellen (oder anderen Units). Die Gesamtgröße aller Unit-Variablen im Interfaceabschnitt ist auf maximal 64 kByte beschränkt. ● im Implementationsabschnitt der Deklarationstabelle der Quelle (IMPLEMENTATION): Der symbolische Prozessabbildzugriff verhält sich wie eine Unit-Variable; er ist nur in der Quelle gültig; alle MCC--Chart bzw. KOP/FUP-Programme (Programme, Funktionsbausteine und Funktionen) innerhalb der Quelle können darauf zugreifen. ● in der Deklarationstabelle des MCC-Chart bzw. KOP/FUP-Programms (nur bei Programmen): Der symbolische Prozessabbildzugriff verhält sich wie eine lokale Variable; auf ihn kann nur innerhalb des MCC-Chart bzw. KOP/FUP-Programms zugegriffen werden, in dem er deklariert wird. In Funktionen und Funktionsbausteinen kann kein symbolischer Prozessabbildzugriff deklariert werden.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
131
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen) So gehen Sie vor; die Quelle oder das MCC-Chart bzw. KOP/FUP-Programm (nur bei Programmen) mit der Deklarationstabelle ist geöffnet: 1. Wählen Sie die Deklarationstabelle und ggf. ihren Abschnitt für die gewünschte Reichweite. 2. Wählen Sie das Register I/O-Symbole. 3. Geben Sie ein: – Name des Symbols (Variablenname) – unter Absolutbezeichner den Bezeichner des absoluten Prozessabbildzugriffs (Seite 130). – Datentyp des Symbols (Seite 132) (muss mit der Länge des Prozessabbildzugriffs übereinstimmen).
4.15.4.4
Mögliche Datentypen des symbolischen PA-Zugriffs In folgenden Fällen kann dem festen Prozessabbild der BackgroundTask (Seite 128) ein Datentyp zugewiesen werde, der vom Datentyp des absoluten PA-Zugriffs abweicht. Die Breite des Datentyps muss der Breite des Datentyps des absoluten PA-Zugriffs entsprechen. ● bei der Deklaration eines symbolischen PA-Zugriffs (Seite 131). ● beim Erstellen einer I/O-Variablen (Seite 133). Wenn Sie dem symbolischen PA-Zugriff bzw. der I/O-Variablen einen numerischen Datentyp zuordnen, können Sie auf diese Variable als Ganzzahl zugreifen. Tabelle 4- 21 Mögliche Datentypen des symbolischen PA-Zugriffs Datentyp des absoluten PA-Zugriffs BOOL (%In.x, %IXn.x, %Qn.x. %QXn.x)
Mögliche Datentypen des symbolischen PA-Zugriffs BOOL
BYTE (%IBn, %QBn)
BYTE, SINT, USINT
WORD (%IWn, %QWn)
WORD, INT, UINT
DWORD (%IDn, %PQDn)
DWORD, DINT, UDINT
Zum Datentyp des absoluten PA-Zugriffs siehe auch "Syntax für den Bezeichner für einen absoluten PA-Zugriff (Seite 130)".
4.15.4.5
Beispiel: Symbolischen Zugriff auf festes Prozessabbild der BackgroundTask definieren
Bild 4-31
132
Beispiel: Symbolischen Zugriff auf festes Prozessabbild der BackgroundTask definieren
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.4.6
I/O-Variable für Zugriff auf das feste Prozessabbild der BackgroundTask erstellen I/O-Variablen für den Zugriff auf das feste Prozessabbild der BackgroundTask erstellen Sie im Symbol-Browser der Detailanzeige; Sie müssen sich hierzu im Offline-Modus befinden. Hier in Kurzform die Vorgehensweise: 1. Markieren Sie im Projektnavigator von SIMOTION SCOUT das Element "I/O" im Teilbaum des SIMOTION Geräts. 2. Wählen Sie in der Detailanzeige das Register Symbolbrowser und scrollen Sie bis zum Ende der Variablentabelle (leere Zeile). 3. Geben Sie in die letzte (leere) Zeile der Tabelle ein oder wählen Sie: – Name der Variablen. – Unter I/O-Adresse den absoluten PA-Zugriff gemäß "Syntax für den Bezeichner für einen absoluten PA-Zugriff (Seite 130)" (Ausnahme: Die Syntax %IXn.x bzw. %QXn.x für den Datentyp BOOL ist nicht zulässig). – Datentyp der I/O-Variablen gemäß "Mögliche Datentypen des symbolischen PA-Zugriffs (Seite 132)". 4. Wählen Sie optional das Anzeigeformat, wenn Sie die Variable im Symbol-Browser beobachten. Sie können nun mit dem Symbol-Browser oder jedem Programm des SIMOTION Geräts auf diese Variable zugreifen. Hinweis I/O-Variablen können Sie nur im Offline-Modus anlegen. Sie legen sie im SIMOTION SCOUT an und verwenden sie in Ihren Programmquellen. Beachten Sie, dass Sie Ausgänge lesen und beschreiben, Eingänge jedoch nur lesen dürfen. Bevor Sie neue oder aktualisierte I/O-Variablen beobachten und steuern können, müssen Sie das Projekt ins Zielsystem laden.
Sie können eine I/O-Variable wie jede andere Variable verwenden, siehe "Auf I/O-Variablen zugreifen (Seite 134)".
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
133
KOP/FUP programmieren 4.15 Zugriff auf Ein- und Ausgänge (Prozessabbild, I/O-Variablen)
4.15.5
Auf I/O-Variablen zugreifen Sie haben eine I/O-Variable erstellt für: ● Direktzugriff oder Prozessabbild der zyklischen Tasks (Seite 122). ● Zugriff auf das feste Prozessabbild der BackgroundTask (Seite 128). Sie können diese I/O-Variable wie jede andere Variable verwenden. ACHTUNG Die Konsistenz ist nur für elementare Datentypen gewährleistet. Bei der Verwendung von Arrays hat der Anwender selbst für die Konsistenz der Daten zu sorgen.
Hinweis Wenn Sie Unit-Variablen oder lokale Variablen gleichen Namens (z. B. var-name) deklariert haben, spezifizieren Sie die I/O-Variable mit _device.var-name (vordefinierter Namensraum, siehe Tabelle "Vordefinierte Namensräume" in "Namensräume"). Der Direktzugriff auf eine I/O-Variable, die Sie als Prozessabbild einer zyklischen Task erstellt haben, ist möglich: Spezifizieren Sie den Direktzugriff mit _direct.var-name bzw. _device._direct.var-name.
Wenn Sie bei Fehlern bei Variablenzugriffen vom voreingestellten Verhalten abweichen wollen, können Sie die Funktionen _getSafeValue und _setSafeValue (siehe Funktionshandbuch SIMOTION Basisfunktionen) verwenden. Zu Fehlern beim Zugriff auf I/O-Variablen siehe Funktionshandbuch SIMOTION
Basisfunktionen.
134
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.16 Verbindungen zu anderen Programmquellen oder zu Bibliotheken
4.16
Verbindungen zu anderen Programmquellen oder zu Bibliotheken In den Deklarationstabellen an einer Quelle können Sie Verbindungen definieren zu: ● KOP/FUP-Quellen unter dem gleichen SIMOTION Gerät ● MCC-Quellen unter dem gleichen SIMOTION Gerät ● ST-Quellen unter dem gleichen SIMOTION Gerät ● Bibliotheken Sie können damit in dieser Quelle zugreifen auf: ● bei verbundenen Programmquellen dort definierte – Funktionen – Funktionsbausteine – Programme (optional) – Unit-Variablen – abgeleitete Datentypen (Strukturen, Aufzählungen) – symbolische Zugriffe auf das feste Prozessabbild der BackgroundTask ● bei verbundenen Bibliotheken dort definierte – Funktionen – Funktionsbausteine – Programme (optional) – abgeleitete Datentypen (Strukturen, Aufzählungen) Programmquellen und Bibliotheken müssen vorher übersetzt sein. Zum Bibliothekskonzept siehe auch Programmierhandbuch SIMOTION ST. Hinweis Bibliotheken können in allen Programmiersprachen (MCC, ST oder KOP/FUP) erstellt werden.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
135
KOP/FUP programmieren 4.16 Verbindungen zu anderen Programmquellen oder zu Bibliotheken
4.16.1
Verbindungen definieren
4.16.1.1
So definieren Sie Verbindungen zu anderen Units (Programmquellen) Die Definition der Verbindungen zu anderen Units (Programmquellen) erfolgt in der Deklarationstabelle der Quelle. Vom Abschnitt der Deklarationstabelle, in der die Verbindung definiert wird, ist ihre Wirkungsweise abhängig. ● im Interfaceabschnitt der Deklarationstabelle: Die importierten Funktionen, Variablen usw. werden weiter in andere Units und in HMIGeräte exportiert. Dies kann eventuell zu Namenskollisionen führen. Diese Einstellung ist z. B. notwendig, wenn im Interfaceabschnitt der Quelle UnitVariablen mit einem Datentyp deklariert werden, der in der importierten Programmquelle definiert ist. ● im Implementationsabschnitt der Deklarationstabelle: Die importierten Funktionen, Variablen usw. werden nicht weiter exportiert. Diese Einstellung ist meist ausreichend. So gehen Sie vor; die Quelle (Deklarationstabelle) ist geöffnet (siehe Vorhandene Programmquellen öffnen (Seite 42)): 1. Wählen Sie innerhalb der Deklarationstabelle den Abschnitt für die gewünschte Wirkungsweise. 2. Wählen Sie das Register Verbindungen. 3. Wählen Sie als Typ der Verbindung: Programm / Unit 4. Wählen Sie in der gleichen Zeile den Namen der zu verbindenden Unit: Units (Programmquellen) müssen vorher übersetzt sein.
136
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.16 Verbindungen zu anderen Programmquellen oder zu Bibliotheken
4.16.1.2
So definieren Sie Verbindungen zu Bibliotheken Die Definition der Verbindungen zu Bibliotheken erfolgt in der Deklarationstabelle der Quelle. So gehen Sie vor; die Quelle (Deklarationstabelle) ist geöffnet (siehe Vorhandene Programmquellen öffnen (Seite 42)): 1. Wählen Sie im Interfaceabschnitt der Deklarationstabelle das Register Verbindungen. 2. Wählen Sie als Typ der Verbindung: Bibliothek. 3. Wählen Sie in der gleichen Zeile den Namen der zu verbindenden Bibliothek. Bibliotheken müssen vorher übersetzt sein. 4. Optional können Sie einen Namensraum definieren (siehe Namensraum verwenden (Seite 138)): Geben Sie hierzu unter Namespace einen Namen ein. Hinweis Beim Programmieren des Befehls Unterprogrammaufruf (siehe Unterprogrammaufruf einfügen und parametrieren (Seite 142)) mit einer Bibliotheksfunktion bzw. funktionsbaustein wird die Verbindung zur Bibliothek automatisch in die Deklarationstabelle der Programmquelle eingetragen; als Namensraum wird der Name der Bibliothek zugewiesen. Die Bezeichnung des Namensraums können Sie nachträglich ändern.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
137
KOP/FUP programmieren 4.16 Verbindungen zu anderen Programmquellen oder zu Bibliotheken
4.16.2
Namensraum verwenden Sie können optional jeder verbundenen Bibliothek einen Namensraum (namespace) zuordnen. Die Bezeichnung des Namensraums definieren Sie beim Verbinden der Bibliothek (siehe So definieren Sie Verbindungen zu Bibliotheken (Seite 137)). Die Angabe des Namensraums ist wichtig, wenn im aktuellen KOP/FUPProgramm/MCC-Chart oder der Programmquelle gleichnamige Variablen, Datentypen, Funktionen oder Funktionsbausteine wie in der verbundenen Bibliothek vorhanden sind. Mit Hilfe des Namensraums können Sie nun gezielt auf die Variablen, Datentypen, Funktionen oder Funktionsbausteine der Bibliothek zugreifen. Auch Namenskonflikte zwischen verbundenen Bibliotheken lassen sich so beheben. Wenn Sie nun Variablen, Datentypen, Funktionen oder Funktionsbausteine aus der verbundenen Bibliothek in einem Befehl des KOP/FUP-Programms/MCC-Chart verwenden, stellen Sie die Bezeichnung des Namensraums durch einen Punkt getrennt dem Variablennamen usw. aus der Bibliothek voran (z. B. namespace.var_name, namespace.fc_name). Für geräte- und projektspezifische Variablen, für Direktzugriffe auf I/O-Variablen sowie für Variablen der TaskId und AlarmId sind Namensräume in der nachfolgenden Tabelle vordefiniert: Setzen Sie ggf. deren Bezeichnung durch Punkt getrennt vor den Variablennamen, z. B. _device.var_name oder _task.task_name. Tabelle 4- 22 Vordefinierte Namensräume Namenraum
Beschreibung
_alarm
Für AlarmId: Die Variable _alarm.name enthält die AlarmId der Meldung mit dem Bezeichner name – siehe Programmierhandbuch SIMOTION ST.
_device
Für gerätespezifische Variablen (geräteglobale Anwendervariablen, I/O-Variablen, Systemvariablen des SIMOTION Geräts)
_direct
Für Direktzugriff auf I/O-Variablen. Lokaler Namensraum zu _device. Die Schachtelung _device._direct.name ist zulässig.
_project
Für Namen der SIMOTION Geräte im Projekt; nur in Verwendung mit Technologieobjekten auf anderen Geräten. Bei projektweit eindeutigen Namen der Technologieobjekte auch für diese und deren Systemvariablen
138
_task
Für TaskId: Die Variable _task.name enthält die TaskId der Task mit dem Bezeichner name - siehe Programmier- und Bedienhandbuch SIMOTION ST.
_to
Für Technologieobjekte sowie deren Systemvariablen und Konfigurationsdaten siehe Programmier- und Bedienhandbuch SIMOTION ST.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
4.17
Unterprogramm Allgemeine wiederverwendbare Programmteile können als Unterprogramme erstellt werden. Bei einem Unterprogrammaufruf verzweigt die Bearbeitung in das Unterprogramm. Die Befehle im Unterprogramm werden abgearbeitet. Anschließend wird in die vorher aktive Task zurückgesprungen. Unterprogramme können von einem oder von mehreren KOP/FUP-Programmen des SIMOTION Geräts beliebig oft aufgerufen werden.
Unterprogramm als Funktion (FC), Funktionsbaustein (FB) oder Programm Der Erstelltyp eines Unterprogramms kann eine Funktion (FC), ein Funktionsbaustein (FB) oder optional auch ein Programm ("program in program") sein. ● Funktion Eine Funktion (FC) ist ein Unterprogramm ohne statische Daten, d. h. alle lokalen Variablen verlieren ihren Wert, wenn die Funktion abgearbeitet ist. Sie werden beim nächsten Start der Funktion neu initialisiert. Die Datenübergabe an die Funktion erfolgt über Eingangs- oder Durchgangsparameter; die Ausgabe eines Funktionswertes (Rückgabewert) ist möglich. ● Funktionsbaustein Ein Funktionsbaustein (FB) ist ein Unterprogramm mit statischen Daten, d. h. lokale Variablen behalten ihren Wert bei, wenn der Funktionsbaustein abgearbeitet ist. Nur explizit als temporär deklarierte Variablen verlieren ihren Wert. Vor der Verwendung eines FB muss eine Instanz definiert werden: Sie definieren eine Variable (VAR oder VAR_GLOBAL) und geben als Datentyp den Namen des FB ein. In dieser Instanz werden die statischen Daten des FB gespeichert. Sie können mehrere Instanzen eines FB definieren, jede Instanz ist unabhängig von den anderen. Die statischen Daten einer FB-Instanz bleiben bis zum nächsten Aufruf dieser Instanz erhalten; sie werden neu initialisiert, wenn der Variablentyp der FB-Instanz neu initialisiert wird (siehe Initialisierung von Instanzen von Funktionsbausteinen (FB) (Seite 115)). Die Datenübergabe an den FB erfolgt über Eingangs- oder Durchgangsparameter; die Datenrückgabe aus dem FB erfolgt über Durchgangs- oder Ausgangsparameter.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
139
KOP/FUP programmieren 4.17 Unterprogramm ● Programm ("program in program") Optional kann ein Programm auch innerhalb eines anderen Programms oder eines Funktionsbausteins aufgerufen werden. Hierzu müssen folgende Compileroptionen aktiviert sein (siehe Globale Einstellungen des Compilers (Seite 48) und Lokale Einstellungen des Compilers (Seite 49)): – "Spracherweiterungen zulassen" für die Programmquelle des aufrufenden Programms bzw. Funktionsbausteins und – "Programminstanzdaten nur einmal anlegen" für die Programmquelle des aufgerufenen Programms. Die statischen Daten des aufgerufenen Programms werden im Anwenderspeicher der Programmquelle (Unit) des aufgerufenen Programms abgelegt. Durch den Aufruf von Programmen innerhalb eines Programms kann die Zuordnung der Programme zu den Tasks weitgehend programmiert werden. Im Ablaufsystem muss nur jeweils ein aufrufendes Programm den betreffenden Tasks zugeordnet werden. Der Aufruf erfolgt ohne Parameter und Rückgabewert. Weitere Informationen zum Aufruf eines Programms im Programm finden Sie im Programmier- und Bedienhandbuch ST. ACHTUNG Die aktivierte Compileroption "Programminstanzdaten nur einmal anlegen" bewirkt: • Die statischen Variablen der Programme (Programminstanzdaten) werden im Anwenderspeicher der Programmquelle (Unit) (siehe Programmier- und Bedienhandbuch SIMOTION ST) abgelegt. Hierdurch ändert sich auch das Initialisierungsverhalten (siehe Programmier- und Bedienhandbuch SIMOTION ST). • Alle aufgerufenen Programme gleichen Namens verwenden dieselben Programminstanzdaten.
140
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
Informationsaustausch zwischen dem Unterprogramm und dem aufrufenden Programm Funktion (FC) und Funktionsbaustein (FB) als Unterprogramm Der Informationsaustausch zwischen dem Unterprogramm und dem aufrufenden Programm erfolgt mittels Übergabeparameter oder über globale Variablen (z. B. Unit-Variablen). Übergabeparameter können Eingangs-, Durchgangs- oder Ausgangsparameter sein. Sie werden in der Deklarationstabelle des Unterprogramms definiert: ● Eingangsparameter: als Variablentyp VAR_INPUT ● Durchgangsparameter: als Variablentyp VAR_IN_OUT ● Ausgangsparameter (nur bei FB): als Variablentyp VAR_OUTPUT Bei Funktionen ist die Rückgabe eines Funktionswertes möglich, den Datentyp des Rückgabewerts geben Sie beim Einfügen (Erstellen) der Funktion an (siehe Funktion (FC) oder Funktionsbaustein (FB) einfügen (Seite 142)). Beim Aufruf des Unterprogramms (FC oder Instanz des FB) weisen Sie den Eingangsund/oder Durchgangsparametern aktuelle Werte zu. Den Durchgangsparametern eines FB dürfen Sie nur selbst definierte Variablen zuweisen, da der aufgerufene FB direkt auf die zugewiesene Variable zugreift und diese somit ändern kann. Auf die Ausgangsparameter eines FB kann im aufrufenden Programm beliebig oft lesend zugegriffen werden. Eine Funktion enthält formell keine Ausgangsparameter, da hier dem Rückgabewert der Funktion das Ergebnis der Funktion zugewiesen wird. Siehe dazu auch die Beispiele zur Funktion (Seite 146) und zum Funktionsbaustein (Seite 151).
Programm als Unterprogramm ("program in program") Der Aufruf erfolgt ohne Parameter und Rückgabewert, d. h. ein Informationsaustausch zwischen dem aufrufenden Programm und dem aufgerufenen Programm (Unterprogramm) ist nur über globale Variablen (z. B. Unit-Variablen) möglich.
Siehe auch Unterprogrammaufruf in das KOP/FUP-Programm einfügen und parametrieren (Seite 142)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
141
KOP/FUP programmieren 4.17 Unterprogramm
4.17.1
Funktion (FC) oder Funktionsbaustein (FB) einfügen Der Erstelldialog ist ähnlich dem eines KOP/FUP-Programms: 1. KOP/FUP-Quelle muss bereits vorhanden sein (siehe KOP/FUP-Programme verwalten (Seite 52)). 2. Öffnen Sie im Projektnavigator die entsprechende KOP/FUP-Quelle. 3. Doppelklicken Sie auf den Eintrag KOP/FUP-Programm einfügen. Die Eingabemaske öffnet sich. – Geben Sie den Namen des KOP/FUP-Programms ein (siehe Regeln für Bezeichner (Seite 89)). – Wählen Sie als Erstelltyp Funktion oder Funktionsbaustein. – Nur beim Erstelltyp Funktion: Wählen Sie als Rückgabetyp den Datentyp des Rückgabewerts ( für keinen Rückgabewert). – Aktivieren Sie die Checkbox Exportierbar, wenn die Funktion oder der Funktionsbaustein in anderen Programmquellen (KOP/FUP-, MCC- oder ST-Quellen) verwendet werden soll. Bei deaktivierter Checkbox kann das KOP/FUP-Programm nur in der zugehörigen KOP/FUP-Quelle verwendet werden. – Zusätzlich können Sie Autor, Version und einen Kommentar eingeben. – Bestätigen Sie mit OK. 4. Programmieren Sie die Anweisungen in der Funktion oder im Funktionsbaustein. Weisen Sie dem Rückgabewert einer Funktion (= Name der Funktion) bzw. den Ausgangsparametern eines Funktionsbausteins einen Ausdruck zu. 5. Übernehmen und übersetzen Sie die KOP/FUP-Quelle. Dadurch wird das erstellte Unterprogramm beim Aufruf in der Liste angezeigt.
4.17.2
Unterprogrammaufruf in das KOP/FUP-Programm einfügen und parametrieren Der Aufruf eines Unterprogramms (Funktion, Funktionsbaustein oder Programm) setzt voraus, dass das jeweilige Unterprogramm aus dem Projektnavigator per Drag&Drop in das Netzwerk eines KOP/FUP-Programms eingefügt wurde. Wird beim Programmdurchlauf das ins Netzwerk eingefügte Unterprogramm erreicht, so wird dieses aufgerufen und die Bearbeitung verzweigt in das Unterprogramm. Sie können per Drag&Drop folgende FCs, FBs und Programme in ein KOP/FUP-Programm einfügen und als Unterprogramm aufrufen: ● Funktionen, Funktionsbausteine oder Programme der gleichen KOP/FUP-Quelle oder einer anderen Programmquelle (z. B. MCC-Quelle, ST-Quelle). ● Bibliotheksfunktionen oder Bibliotheksfunktionsbausteine aus einer Programmbibliothek. Die Parametrierung des Unterprogrammaufrufs, d. h. die Festlegung welche Variablen beim Aufruf des Unterprogramms übergeben werden sowie nach Abarbeitung des Unterprogramms zurückgegeben werden, erfolgt in der Parametermaske Aufrufparameter Eingeben.
142
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
Bild 4-32
Parametrierung des Unterprogrammaufrufs einer Funktion
ACHTUNG Achten Sie auf die Reihenfolge der KOP/FUP-Programme in einer KOP/FUP-Quelle. Ein Unterprogramm (Funktion, Funktionsbaustein oder Programm) muss definiert sein, bevor es verwendet wird. Dies erkennen Sie daran, dass das Unterprogramm im Projektnavigator über dem KOP/FUP-Programm angezeigt wird, in dem es verwendet wird. Sortieren Sie die KOP/FUP-Programme ggf. um. Siehe auch: Unterprogrammaufruf der Funktion (FC) (Seite 148) Hinweis Der Begriff "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
143
KOP/FUP programmieren 4.17 Unterprogramm
4.17.2.1
Parameterübersicht Folgende Parameter können Sie einstellen bei der Parametrierung des Unterprogrammaufrufs:
Parameterübersicht Unterprogrammaufruf Feld / Schaltfläche
Bedeutung / Anweisung
Unterprogrammtyp/ Unterprogramm
Hier wird der Typ und Name des Unterprogramms angezeigt: Funktion (Defaultwert) Eine Funktion ist ein Unterprogramm zur Berechnung, das aufgrund der eingegebenen Parameter ein definiertes Ergebnis als Rückgabewert zurückliefert. Funktionen haben kein Gedächtnis über den Aufruf hinaus. Funktionsbaustein Ein Funktionsbaustein ist ein Unterprogramm, das mehrere Rückgabewerte haben kann. Ein Funktionsbaustein entspricht einem Datentyp. Es werden Instanzen definiert. Diese beinhalten ein Gedächtnis, d. h. sie halten Instanzdaten eines Funktionsbausteins über mehrere Aufrufe hinweg. An der Instanz können auch die Rückgabewerte des Aufrufs abgefragt werden. Programm ("program in program") Optional kann ein Programm auch innerhalb eines anderen Programms oder Funktionsbausteins aufgerufen werden. Hierzu müssen folgende Compileroptionen aktiviert sein (siehe Globale Einstellungen des Compilers (Seite 48) und Lokale Einstellungen des Compilers (Seite 49)): • "Spracherweiterungen zulassen" für die Programmquelle des aufrufenden Programms bzw. Funktionsbausteins und • "Programminstanzdaten nur einmal anlegen" für die Programmquelle des aufgerufenen Programms. Die statischen Daten des aufgerufenen Programms werden im Anwenderspeicher der Programmquelle (Unit) des aufgerufenen Programms abgelegt. Bei jedem Aufruf des Programms werden dieselben Programminstanzdaten verwendet. Der Aufruf eines Programms erfolgt ohne Parameter und Rückgabewert.
Rückgabewert
Bei Unterprogrammtyp Funktion: Hier tragen Sie die Variable ein, in welcher der Rückgabewert abgelegt werden soll. Der Typ der Variablen muss mit dem Typ des Rückgabewertes übereinstimmen.
Typ
Bei Unterprogrammtyp Funktion: Der Datentyp des Rückgabewerts wird angezeigt.
Instanz
Bei Unterprogrammtyp Funktionsbaustein: Tragen Sie hier den Namen der Funktionsbaustein-Instanz ein. Die Instanz beinhaltet das Gedächtnis des Funktionsbausteins in Form der Instanzdaten. Die Instanz definieren Sie als Variable, deren Datentyp der Name des Funktionsbausteins ist: • in der Deklarationstabelle der KOP/FUP-Quelle als VAR_GLOBAL oder • in der Deklarationstabelle des KOP/FUP-Programms als VAR.
144
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm Feld / Schaltfläche Bedeutung / Anweisung Liste der Übergabeparameter Name
Hier wird der Name der Übergabeparameter angezeigt.
Ein / Aus
Hier wird der Variablentyp der Übergabeparameter angezeigt: VAR_INPUT Eingangsparameter (bei Funktionen und Funktionsbausteinen) VAR_IN_OUT Durchgangsparameter (bei Funktionen und Funktionsbausteinen) VAR_OUTPUT Ausgangsparameter (nur bei Funktionsbausteinen)
Datentyp
Hier wird der Datentyp der Übergabeparameter angezeigt.
Wert
Hier ordnen Sie den Übergabeparametern aktuelle Variablen oder Werte zu: • Eingangsparameter (Variablentyp VAR_INPUT):
•
Hier geben Sie einen Variablennamen oder einen Ausdruck ein. Die Zuordnung von Systemvariablen oder I/O-Variablen ist zulässig; Typumwandlung ist möglich. Durchgangsparameter (Variablentyp VAR_IN_OUT):
•
Geben Sie einen Variablennamen ein; die Variable muss direkt schreibund lesbar sein. Systemvariablen von SIMOTION Geräten und Technologieobjekten sowie I/O-Variablen sind nicht zulässig. Der Datentyp des Durchgangsparameters muss mit dem der zugeordneten Variablen übereinstimmen; die Anwendung von Typumwandlungsfunktionen ist nicht möglich. Ausgangsparameter (Variablentyp VAR_OUTPUT – nur bei FB): Die Zuordnung eines Ausgangsparameters zu einer Variablen in dieser Parametermaske ist optional; Sie können auf einen Ausgangsparameter auch nach Abarbeiten des Funktionsbausteins zugreifen. Bei Zuordnung in dieser Parametermaske: Geben Sie einen Variablennamen ein. Der Datentyp des Ausgangsparameters muss mit dem der zugeordneten Variablen übereinstimmen; die Anwendung von Typumwandlungsfunktionen ist nicht möglich.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
145
KOP/FUP programmieren 4.17 Unterprogramm
4.17.3
Beispiel: Funktion (FC) Es soll ein Unterprogramm mit einer Umfangsberechnung eines Kreises erstellt werden. Die Berechnung erfolgt in einer Funktion (FC). Diese erhält den Namen umfang. Dadurch kann die Berechnung des Kreisumfangs von jeder beliebigen Task als Unterprogramm aufgerufen werden. Formel zur Umfangsberechnung: Umfang = PI * 2 * Radius Die benötigten Variablen Radius und PI definieren Sie in der Deklarationstabelle der Funktion.
4.17.3.1
Funktion (FC) erstellen und programmieren 1. Öffnen Sie im Projektnavigator die KOP/FUP-Quelle, in der Sie die Funktion erstellen wollen. 2. Doppelklicken Sie auf den Eintrag KOP/FUP-Programm einfügen. – Geben Sie als Name umfang ein. – Wählen Sie als Erstelltyp Funktion. – Wählen Sie als Rückgabetyp (Datentyp des Rückgabewertes) REAL. – Bestätigen Sie mit OK. 3. In der Deklarationstabelle definieren Sie die Eingangsparameter radius, den Parameter durchmesser und die Konstante PI.
Bild 4-33
Variablen (z. B. Eingangsparameter) im KOP/FUP-Programm deklarieren
4. Klicken Sie in der Funktionsleiste des KOP-Editors auf die Schaltfläche Netzwerk einfügen. Es wird in die Funktion umfang ein Netzwerk eingefügt. 5. Fügen Sie aus der Befehlsbibliothek das KOP/FUP-Element MUL zweimal per Drag&Drop in das Netzwerk der Funktion umfang ein.
146
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm 6. Programmieren Sie die Berechnung des Umfangs für den Rückgabewert durch die entsprechende Zuweisung der Variablen an die Ein-/Ausgangsparameter der beiden KOP/FUP-Elemente MUL.
Bild 4-34
Unterprogramm umfang (z. B. Zuweisung an Rückgabewert) programmieren
7. Übernehmen und übersetzen Sie die KOP/FUP-Quelle. Damit ist die Funktion umfang fertig programmiert. Hinweis Der Begriff "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
147
KOP/FUP programmieren 4.17 Unterprogramm
4.17.3.2
Unterprogrammaufruf der Funktion (FC) Die Funktion (FC) wird im Beispiel aus einem Programm aufgerufen. 1. Erstellen Sie in der gleichen KOP/FUP-Quelle ein KOP/FUP-Programm als Programm (siehe Neues KOP/FUP-Programm einfügen (Seite 52)): – Geben Sie als Name programm_umfang ein. – Wählen Sie als Erstelltyp Programm. – Bestätigen Sie mit OK. 2. Deklarieren Sie in der KOP/FUP-Quelle oder im KOP/FUP-Programm: – die Variable myumfang. Dieser Variablen wird der Rückgabewert der Funktion "umfang" zugewiesen. – die Variable myradius. Diese Variable enthält den Radius und wird dem Eingangsparameter radius der Funktion umfang zugewiesen. Beachten Sie, dass der Gültigkeitsbereich der Variablen vom Deklarationsort abhängt (siehe Variablen definieren (Seite 103)).
① Die Variable myumfang kann im Programm weiter verwendet werden. Bild 4-35 Variable im KOP/FUP-Programm deklarieren
1. Klicken Sie in der Funktionsleiste des KOP-Editors auf die Schaltfläche Netzwerk einfügen. Es wird in das Programm programm_umfang ein Netzwerk eingefügt. 2. Fügen Sie aus dem Projektnavigator die Funktion umfang per Drag&Drop in das Netzwerk des Programms programm_umfang ein. 3. Markieren Sie die eingefügte Funktion umfang und wählen Sie im Kontextmenü den Befehl Aufruf parametrieren.
148
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm 4. Parametrieren Sie den Unterprogrammaufruf in der Parametermaske Aufrufparameter Eingeben.
Bild 4-36
Geöffnete Parametermaske für die Parametrierung des Unterprogrammaufrufs
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
149
KOP/FUP programmieren 4.17 Unterprogramm 5. Achten Sie auf die Reihenfolge der KOP/FUP-Programme in der KOP/FUP-Quelle. Im Projektnavigator muss das KOP/FUP-Programm mit der Funktion (FC) über dem KOP/FUP-Programm angezeigt werden, welches den Unterprogrammaufruf enthält. D. h. die Funktion umfang muss im Projektnavigator über dem Programm programm_umfang angeordnet sein. Sortieren Sie ggf. die KOP/FUP-Programme um, indem Sie das jeweilige KOP/FUPProgramm im Projektnavigator markieren und im Kontextmenü den Befehl Nach unten oder Nach oben wählen.
①
Funktion umfang
②
Programm programm_umfang, das den Unterprogrammaufruf der Funktion umfang enthält
Reihenfolge der KOP/FUP-Programme 6. Übernehmen und übersetzen Sie die KOP/FUP-Quelle. Damit ist der Unterprogrammaufruf fertig programmiert. Hinweis Der Begriff "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln.
150
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
4.17.4
Beispiel: Funktionsbaustein (FB) Es soll eine Schleppabstandsberechnung durchgeführt werden. Die Berechnung erfolgt in einem Funktionsbaustein (FB) mit dem Namen abstand. Dadurch kann die Schleppabstandsberechnung von jeder beliebigen Task als Unterprogramm aufgerufen werden. Formel zur Schleppabstandberechnung: Differenz = Sollposition – Istposition Definieren Sie die benötigten Eingangs- und Ausgangsparameter Sollposition, Istposition und Differenz (ggf. mit den weiteren Variablen) im KOP/FUP-Programm (Funktionsbaustein) oder in der KOP/FUP-Quelle.
4.17.4.1
Funktionsbaustein (FB) erstellen und programmieren 1. Öffnen Sie im Projektnavigator die KOP/FUP-Quelle, in der Sie den Funktionsbaustein erstellen wollen. 2. Doppelklicken Sie auf den Eintrag KOP/FUP-Programm einfügen. – Geben Sie als Name abstand ein. – Wählen Sie als Erstelltyp Funktionsbaustein. – Bestätigen Sie mit OK. 3. In der Deklarationstabelle definieren Sie die Variablen (z. B. Eingangs- und Ausgangsparameter).
Bild 4-37
Variablen (z. B. Eingans- und Ausgangsparameter) im KOP/FUP-Programm deklarieren
4. Klicken Sie in der Funktionsleiste des KOP-Editors auf die Schaltfläche Netzwerk einfügen. Es wird in den Funktionsbaustein abstand ein Netzwerk eingefügt. 5. Fügen Sie aus der Befehlsbibliothek das KOP/FUP-Element SUB per Drag&Drop in das Netzwerk des Funktionsbausteins abstand ein.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
151
KOP/FUP programmieren 4.17 Unterprogramm 6. Programmieren Sie die Schleppabstandsberechnung durch die entsprechende Zuweisung der Variablen an die Ein-/Ausgangsparameter des KOP/FUP-Elements SUB.
Bild 4-38
Schleppabstandsberechnung programmieren
7. Übernehmen und übersetzen Sie die KOP/FUP-Quelle. Damit ist der Funktionsbaustein abstand fertig programmiert. Hinweis Der Begriff "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln.
4.17.4.2
Unterprogrammaufruf des Funktionsbausteins (FB) Der Funktionsbaustein (FB) wird im Beispiel aus einem Programm aufgerufen. 1. Erstellen Sie ein KOP/FUP-Programm als Programm (siehe Neues KOP/FUP-Programm einfügen (Seite 52)). 2. Legen Sie eine Instanz des Funktionsbausteins an. – Deklarieren Sie in der KOP/FUP-Quelle oder im KOP/FUP-Programm die Instanzen des Funktionsbausteins zusammen mit den Variablen. Beachten Sie, dass der Gültigkeitsbereich der Instanz und der Variablen vom Deklarationsort abhängt (siehe Variablen definieren (Seite 103)). 3. Rufen Sie den Funktionsbaustein auf: – Programmieren Sie den Unterprogrammaufruf. 4. Nach Abarbeiten einer Instanz des Funktionsbausteins können Sie auf die Ausgangsparameter an jeder Stelle des aufrufenden Programms zugreifen. – Programmieren Sie den Befehl MOVE. 5. Übernehmen und übersetzen Sie das Programm. Der Unterprogrammaufruf ist fertig programmiert.
152
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
4.17.4.3
So legen Sie eine Instanz des Funktionsbausteins an Bevor Sie einen Funktionsbaustein verwenden können, müssen Sie eine Instanz definieren. Jede Instanz eines FB ist unabhängig von den anderen; nach Beenden der jeweiligen Instanz bleiben deren statische Variablen erhalten. Die Instanzen eines FB definieren Sie in den Deklarationstabellen der KOP/FUP-Quelle oder des KOP/FUP-Programms. Vom Ort der Deklaration ist die Reichweite der Instanz abhängig: ● im Interfaceabschnitt der Deklarationstabelle der KOP/FUP-Quelle: Die Instanz verhält sich wie eine Unit-Variable; sie ist in der gesamten KOP/FUP-Quelle gültig; alle KOP/FUP-Programme (Programme, Funktionsbausteine und Funktionen) innerhalb der KOP/FUP-Quelle können darauf zugreifen. Außerdem steht die Instanz auch auf HMI-Geräten zur Verfügung sowie nach Verbinden (siehe So definieren Sie Verbindungen zu anderen Units (Programmquellen) (Seite 136)) auch in anderen KOP/FUP-Quellen (oder anderen Units) Die Gesamtgröße aller Unit-Variablen im Interfaceabschnitt ist auf maximal 64 kByte beschränkt. ● im Implementationsabschnitt der Deklarationstabelle der KOP/FUP-Quelle: Die Instanz verhält sich wie eine Unit-Variable, die nur in der KOP/FUP-Quelle gültig ist; alle KOP/FUP-Programme (Programme, Funktionsbausteine und Funktionen) innerhalb der KOP/FUP-Quelle können darauf zugreifen. ● in der Deklarationstabelle des KOP/FUP-Programms (nur bei Programmen und Funktionsbausteinen): Die Instanz verhält sich wie eine lokale Variable; auf sie kann nur innerhalb des KOP/FUP-Programms zugegriffen werden, in dem sie deklariert wird. So gehen Sie vor; die KOP/FUP-Quelle bzw. das KOP/FUP-Programm mit der Deklarationstabelle ist geöffnet (siehe Vorhandene KOP/FUP-Quelle öffnen (Seite 42) bzw. Vorhandenes KOP/FUP-Programm öffnen (Seite 54)): 1. Wählen Sie die Deklarationstabelle und ggf. ihren Abschnitt für die gewünschte Reichweite. 2. Wählen Sie das Register Parameter. 3. Geben Sie ein oder wählen Sie: – Name der Instanz (Variablenname – siehe Regeln für Bezeichner (Seite 89)) – als Variablentyp entsprechend dem Deklarationsort entweder VAR (in KOP/FUPProgramm) oder VAR_GLOBAL (in KOP/FUP-Quelle) – als Datentyp die Bezeichnung des Funktionsbausteins.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
153
KOP/FUP programmieren 4.17 Unterprogramm 4. Deklarieren Sie die übrigen Variablen.
①
Der Variablen Ergebnis_2 wird im weiteren Ablauf des Programms der Ausgangsparameter Differenz zugewiesen. Die Variable Ergebnis_2 kann im Programm weiter verwendet werden.
②
Der Variablen Ergebnis wird im Unterprogrammaufruf der Ausgangsparameter Differenz zugewiesen. Die Variable Ergebnis kann im Programm weiter verwendet werden.
③
Instanz anlegen
④
Als Datentyp den gewünschten FB auswählen. Die angelegten Funktionsbausteine werden abhängig von den Einstellungen des KOP/FUPEditors (Seite 34) als Datentyp in der Auswahlliste angeboten: • nur Funktionsbausteine derselben Programmquelle oder von verbundenen Programmquellen bzw. Bibliotheken • alle im Projekt definierten Funktionsbaussteine
Bild 4-39
154
Instanz des Funktionsbausteins und Variablen im KOP/FUP-Programm oder in der KOP/FUP-Quelle definieren
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
4.17.4.4
So programmieren Sie den Unterprogrammaufruf des Funktionsbausteins 1. Fügen Sie aus dem Projektnavigator den Funktionsbaustein abstand per Drag&Drop in das Netzwerk des KOP/FUP-Programms programm_abstand ein. 2. Markieren Sie den eingefügten Funktionsbaustein abstand und wählen Sie im Kontextmenü den Befehl Anzeige > Alle Boxparameter. Alle Ein-/Ausgangsparameter des eingefügten Funktionsbaustein abstand werden eingeblendet. 3. Markieren Sie den eingefügten Funktionsbaustein abstand und wählen Sie im Kontextmenü den Befehl Aufruf parametrieren. 4. Parametrieren Sie den Unterprogrammaufruf in der Parametermaske Aufrufparameter eingeben: – Wählen Sie für den Ausgangsparameter differenz in der Spalte Wert die Variable Ergebnis. – Geben Sie im Feld Instanz die in der Deklarationstabelle definierte Instanz myabstand ein. Die Eingangs- und Durchgangsparameter des FB werden angezeigt.
Bild 4-40
Geöffnete Parametermaske für die Parametrierung des Unterprogrammaufrufs
5. Bestätigen Sie mit OK.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
155
KOP/FUP programmieren 4.17 Unterprogramm 6. Weisen Sie den Übergabeparametern die Aktualwerte zu: – Eingangsparameter: Variable oder Ausdruck – Durchgangsparameter: direkt schreib- und lesbare Variable – Ausgangsparameter (optional): Variable Unit-Variablen und Systemvariablen können Sie aus der Detailanzeige mit Drag&Drop den Ein-/Ausgangs-/Durchgangsparametern, der im KOP/FUP-Netzwerk eingefügten Instanz des Funktionsbaustein abstand, zuweisen.
Bild 4-41
Systemvariablen aus der Detailanzeige mit Drag&Drop den Übergabeparametern zuweisen
7. Achten Sie auf die Reihenfolge der KOP/FUP-Programme in der KOP/FUP-Quelle. Im Projektnavigator muss das KOP/FUP-Programm mit dem Funktionsbaustein über dem KOP/FUP-Programm angezeigt werden, welches das Programm mit dem Unterprogrammaufruf enthält. D. h. der Funktionsbaustein abstand muss im Projektnavigator über dem Programm programm_abstand angeordnet sein. Sortieren Sie ggf. die KOP/FUP-Programme um, indem Sie das jeweilige KOP/FUPProgramm im Projektnavigator markieren und im Kontextmenü den Befehl Nach unten oder Nach oben wählen. Siehe auch: Unterprogrammaufruf der Funktion (FC) (Seite 148). Hinweis Der Begriff "KOP/FUP-Programm" dient als Sammelbegriff, d. h. es kann sich dabei um ein Programm, eine Funktion (FC) oder einen Funktionsbaustein (FB) handeln.
156
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
4.17.4.5
So greifen Sie nachträglich auf die Ausgangsparameter des Funktionsbausteins zu Nach Abarbeiten einer Instanz des Funktionsbausteins bleiben die statischen Variablen des Funktionsbausteins (u. a. die Ausgangsparameter) erhalten. Auf die Ausgangsparameter können Sie an jeder Stelle des aufrufenden Programms zugreifen. Wenn Sie die Instanz des FB als VAR_GLOBAL definiert haben, können Sie auf den Ausgangsparameter auch in anderen KOP/FUP-Programmen zugreifen. 1. Fügen Sie den Befehl MOVE in das KOP/FUP-Programm ein. 2. Programmieren Sie den Befehl (siehe Bild).
①
Name der Instanz des FB
Bild 4-42
②
Ausgangsparameter
Variablenzuweisung programmieren
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
157
KOP/FUP programmieren 4.17 Unterprogramm
4.17.5
Einschränkungen bei der Signalvorverschaltung Einem Eingang eines KOP/FUP-Elements kann nur dann ein Ausgang eines anderen KOP/FUP-Elements vorgeschalten werden, wenn Eingang und Ausgang vom Datentyp BOOL sind. Dadurch sind in einem Netzwerk nur boolsche Signalvorverschaltungen möglich. Ein Ausgangsparameter eines FB bzw. Rückgabewert einer FC kann nicht auf einen Eingangsparameter eines anderen FB/FC verschalten werden, d. h. hier sind auch boolsche Signalvorverschaltungen nicht möglich. Die Realisierung von nicht-boolschen Signalvorverschaltungen und von Aus/Eingangsparameterverschaltungen bei FB/FC kann mit Hilfe eines weiteren Netzwerks und einer Zwischenvariablen erfolgen. In diesem zusätzlichen Netzwerk wird das KOP/FUP-Element eingefügt, dessen Ausgang nicht direkt dem Eingang des anderen KOP/FUP-Elements zugewiesen werden kann. Ausgang und Eingang wird dieselbe Zwischenvariable zugeordnet, so dass die Verschaltung von Aus- und Eingang über die Zwischenvariable erfolgt. Alternativ kann dies auch mit nur einem Netzwerk und einer Zwischenvariablen realisiert werden, so dass sich beide KOP/FUP-Elemente im gleichen Netzwerk befinden.
Beispiel für Aus-/Eingangsparameterverschaltung bei FB/FC In der Programmiersprache ST kann der Eingangsparameter "commandid" bei TO-Befehlen aus der Befehlsbibliothek direkt mit der Funktion _getcommandid belegt werden. Diese Aus-/Eingangsparameterverschaltung bei FB/FC kann in der Programmiersprache KOP/FUP mit einem weiteren Netzwerk für die Funktion _getcommandid und einer Zwischenvariablen realisiert werden. Die Funktion _getcommandid ist im oberen Netzwerk eingefügt und ihrem Ausgang "OUT" ist die Zwischenvariable "var_commandid" zugewiesen. Im unteren Netzwerk ist der TO-Befehl _pos eingefügt und seinem Eingang "commandid" ist ebenfalls die Zwischenvariable "var_commandid" zugewiesen. Die Verschaltung des Ausgangs "OUT" von _getcommandid und des Eingangs "commandid" von _pos erfolgt somit über die Zwischenvariable.
Bild 4-43
158
Aus-/Eingangsparameterverschaltung bei FB/FC
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
4.17.6
Schnittstellenabgleich bei FB/FC Wenn die Eigenschaften eines im Netzwerk eingefügten FB/FC verändert werden, erfolgt in den folgenden Fällen ein Schnittstellenabgleich: 1. Ein/mehrere neue Ein-/Ausgangsparameter werden hinzugefügt 2. Ein/mehrere nicht verwendete Ein-/Ausgangsparameter werden gelöscht 3. Ein/mehrere verwendete Ein-/Ausgangsparameter werden gelöscht In den Fällen 1 und 2 erfolgt eine sofortige Aktualisierung des Netzwerks wenn es im KOP/FUP-Editor geöffnet ist oder direkt nach dem Öffnen. Im Fall 3 wird der FB/FC-Aufruf im Netzwerk rot dargestellt und eine Aktualisierung muss manuell erfolgen. Eine vorhandene boolsche Vorverschaltung eines gelöschten Eingangsparameters wird nicht gelöscht, sondern nur abgetrennt und z. B. in der KOP-Darstellung als offener Strompfad im Netzwerk angezeigt.
Manuelle Aktualisierung eines bestimmten FB/FC-Aufrufs Um einen bestimmten FB/FC-Aufruf manuell zu aktualisieren, gehen Sie folgendermaßen vor: 1. Klicken Sie auf den gewünschten FB/FC-Aufruf. 2. Wählen Sie im Kontextmenü den Befehl Aufruf aktualisieren. Der FB/FC-Aufruf wird mit den aktuell vorhandenen Ein-/Ausgangsparametern dargestellt, d. h. ohne die gelöschten Ein-/Ausgangsparameter.
Manuelle Aktualisierung aller FB/FC-Aufrufe Um alle FB/FC-Aufrufe der aktuell im Arbeitsbereich angezeigten Programmorganisationseinheit (POE) manuell zu aktualisieren, gehen Sie folgendermaßen vor: 1. Klicken Sie auf eine leere Stelle im Netzwerk. 2. Wählen Sie im Kontextmenü den Befehl Alle Aufrufe aktualisieren für alle Netzwerke. Die FB/FC-Aufrufe werden mit den aktuell vorhandenen Ein-/Ausgangsparametern dargestellt, d. h. ohne die gelöschten Ein-/Ausgangsparameter. Für die folgenden Fälle steht kein Schnittstellenabgleich zur Verfügung, so dass die Aktualisierung durch manuelle Eingabe oder mit Suchen/Ersetzen (siehe Einschränkungen bei Suchen und Ersetzen im Projekt (Seite 81)) erfolgen muss: ● Änderung des Namens der Instanzvariable (gibt es nur bei FB) ● Änderung des Namens des Datentyps bzw. des Boxtyps des FB/FC-Aufrufs
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
159
KOP/FUP programmieren 4.17 Unterprogramm
①
Instanzvariable (Instanzname) Gibt es nur bei FB. In der Deklarationstabelle wird durch Angabe der Instanzvariable, mit dem Namen des FB als Datentyp, eine FBInstanz deklariert. Diese Instanzvariable (Instanzname) wird zum Aufruf des FB verwendet.
②
Datentyp Der Instanzvariable wird als Datentyp der jeweilige FB zugewiesen. Für einen korrekten FB-Aufruf müssen Datentyp und Box-Typ identisch sein, sonst wird der FB-Aufruf im Netz rot dargestellt.
③
Box-Typ, bestehend aus: • dem Typnamen z. B. MOVE, ADD etc. oder Namen von Anwender-Programmen/-FBs/-FCs • dem Typ d. h. des gewählten Erstelltyps (Programm, FB oder FC) des KOP/FUP-Programms
④
Instanzvariable (Instanzname) Gibt es nur bei FB.
⑤
Name des FB/FC (Typ eines (anwenderdefinierten) FB/FC) FB: Der Name des FB wird als Datentyp bei der FB-Instanzdeklaration in der Deklarationstabelle verwendet. FC: Der Name der FC wird als Box-Typ verwendet.
Bild 4-44
160
Übersicht bezüglich verwendeter FB-/FC-Begriffe
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.17 Unterprogramm
Anzeige in der Detailanzeige Ausschließlich im Fall 3 werden sofort nach der manuellen Aktualisierung in der Detailanzeige im Fenster Ausgabe übersetzen / prüfen die gelöschten Ein/Ausgangsparameter und ihre zugeordneten gelöschten Variablen angezeigt. Bei gelöschten Eingangsparametern mit boolscher Vorverschaltung erfolgt keine Anzeige, da die Vorverschaltung nur abgetrennt wird und daher weiterhin im Netzwerk vorhanden ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
161
KOP/FUP programmieren 4.18 Referenzdaten
4.18
Referenzdaten Mit Hilfe der Referenzdaten erhalten Sie einen Überblick: ● über verwendete Bezeichner mit Angabe Ihrer Deklaration und Verwendung (Querverweisliste (Seite 162)). ● über Funktionsaufrufe und deren Schachtelung (Programmstruktur (Seite 166)) ● über den Speicherbedarf verschiedener Datenbereiche der Programmquellen (Codeattribute (Seite 168))
4.18.1
Querverweisliste In der Querverweisliste sehen Sie alle Bezeichner in Programmquellen (z. B. ST-Quellen, MCC-Quellen): ● die als Variablen, als Datentypen oder als Programmorganisationseinheiten (Programm, Funktion, Funktionsbaustein) deklariert sind, ● die als vorher definierte Datentypen in Deklarationen verwendet werden, ● die als Variablen im Anweisungsabschnitt einer Programmorganisationseinheit verwendet werden. Die Querverweisliste können Sie erzeugen selektiv für: ● eine einzelne Programmquelle (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) ● alle Programmquellen eines SIMOTION Geräts ● alle Programmquellen und Bibliotheken des Projekts ● Bibliotheken (alle Bibliotheken, einzelne Bibliothek)
4.18.1.1
Querverweisliste erzeugen So erzeugen Sie die Querverweisliste: 1. Markieren Sie im Projektnavigator das entsprechende Element, dessen Querverweisliste Sie erzeugen wollen. 2. Wählen Sie Menü Bearbeiten > Referenzdaten > Erzeugen. Die Querverweisliste wird in einem eigenen Register der Detailanzeige angezeigt.
Hinweis Die erzeugte Querverweisliste wird automatisch gespeichert und kann nach Auswahl des entsprechenden Elements im Projektnavigator selektiv angezeigt werden. Wählen Sie hierzu das Menü Bearbeiten > Referenzdaten > Anzeigen > Querverweise. Beim erneuten Erzeugen einer Querverweisliste wird diese nur selektiv (entsprechend dem ausgewählten Element im Projektnavigator) erneuert. Weitere vorhandene Querverweisdaten bleiben erhalten und werden ggf. mit angezeigt.
162
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.18 Referenzdaten
4.18.1.2
Inhalt der Querverweisliste Die Querverweisliste enthält alle Bezeichner, die dem ausgewählten Element des Projektnavigators zugeordnet sind, sowie deren Verwendungen in Form einer Tabelle: Die Handhabung der Querverweisliste isi im Abschnitt "Mit der Querverweisliste umgehen (Seite 165)" beschrieben.
Tabelle 4- 23 Bedeutung der Spalten und ausgewählter Einträge in der Querverweisliste Spalte
Eintrag in Spalte
Name
Bedeutung Name des Bezeichners
Typ
Typ des Bezeichners
Name
• •
Datentyp einer Variablen (z. B. REAL, INT) Typ einer POE (z. B. PROGRAM, FUNCTION).
DERIVED
Abgeleiteter Datentyp
DERIVED ANY_OBJECT
TO-Datentyp
ARRAY …
Datentyp ARRAY
ENUM …
Aufzählungsdatentyp (Enumerator)
STRUCT …
Datentyp STRUCT
Name (Unit)
Deklaration in der Programmquelle Name
Name (LIB)
Deklaration in der Bibliothek Name
Name (TO)
Systemvariable des Technologieobjekts Name
Name (TP)
Deklaration in der angegebenen Standardbibliothek: • Technologiepaket Name • std_fct = IEC-Bibliothek • device = gerätespezifische Bibliothek
Name (DV)
Deklaration am SIMOTION Gerät Name (z. B,I/O-Variable oder geräteglobale Variable)
_project
Deklaration im Projekt (z. B. Technologieobjekt)
Deklaration
Ort der Deklaration
_device
Interne Variable am SIMOTION Gerät (z. B. Taskstartinfo)
_task
Task im Ablaufsystem
Verwendung
Verwendung des Bezeichners
CALL
Aufruf als Unterprogramm
ENUM Name
Als Element bei der Deklaration des Aufzählungsdatentyps Name.
I/O
Deklaration als I/O-Variable
R
Lesender Zugriff
R (TYPE)
Als Datentyp in einer Deklaration
R/W
Lesender und schreibender Zugriff
STRUCT Name
Als Komponente bei der Deklaration der Struktur Name.
TYPE
Deklaration als Datentyp oder POE
Variablentyp (z. B. VAR,
Deklaration als Variable des angegebenen Variablentyps
W
Schreibender Zugriff
VAR_GLOBAL)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
163
KOP/FUP programmieren 4.18 Referenzdaten Spalte Eintrag in Spalte Pfadangabe
Bedeutung Pfadangabe des SIMOTION Geräts bzw. der Programmquelle
Name
SIMOTION Gerät Name
Name1 / Name2
• •
Name / taskbind.hid
Ablaufsystem des SIMOTION Geräts Name
IMPLEMENTATION
Implementationsabschnitt der Programmquelle
INTERFACE
Inferfaceabschnitt der Programmquelle
POE-Typ Name (z. B. FUNCTION Name, PROGRAM Name)
Programmorganisationseinheit (POE) Name innerhalb der Programmquelle (auch MCC-Chart, KOP/FUP-Programm)
Bereich
Programmquelle Name2 an SIMOTION Gerät Name1 Programmquelle Name2 in Bibliothek Name1
Bereich innerhalb des SIMOTION Geräts oder der Programmquelle
I/O-Adresse
I/O-Variable
TASK Name
Zuordnung zur Task Name
_device
Geräteglobale Variable
Sprache
Programmiersprache der Programmquelle
Zeile/Block
Zeilennummer der Programmquelle (z. B. ST-Quelle) Bei MCC-Quellen bzw. MCC-Charts wird zusätzlich angezeigt: • Zahl: Laufende Nummerierung des Befehls (Blocknummer) bzw. • DT: Deklarationstabelle
Hinweis Eingeschaltete Einzelschrittverfolgung bei MCC-Programmierung Jeder Task sind jeweils zwei Variablen TSI#dwuser_1 und TSI#dwuser_2 zugeordnet, die gelesen und geschrieben werden können. Bei eingeschalteter Einzelschrittverfolgung werden diese Variablen vom Compiler für die Steuerung der Einzelschrittverfolgung verwendet, wenn mindestens ein MCC-Chart der jeweiligen Task zugeordnet ist. Vom Anwender dürfen diese Variablen dann nicht verwendet werden, da deren Inhalte von der Einzelschrittverfolgung überschrieben werden bzw. unerwünschte Nebeneffekte auftreten können.
164
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.18 Referenzdaten
4.18.1.3
Mit der Querverweisliste umgehen Sie können in der Querverweisliste: ● Innerhalb der Spalten alphabetisch sortieren: – Klicken Sie hierzu in den Kopf der jeweiligen Spalte. ● Nach einem Bezeichner oder Eintrag suchen: – Klicken Sie auf den Button "Suchen" und geben Sie den Suchbegriff ein. ● Die angezeigten Bezeichner und Einträge filtern (Seite 165). ● Den Inhalt in die Zwischenablage kopieren, um Sie z. B. in ein Tabellenkalkulationsprogramm zu übernehmen: – Markieren Sie die entsprechenden Zeilen und Spalten. – Drücken Sie die Tastenkombination STRG+C. ● Den Inhalt ausdrucken (Menü "Projekt" > "Drucken". ● Die referenzierte Programmquelle öffnen und den Cursor auf die zugehörige Zeile der ST-Quelle (bzw. MCC-Befehl oder KOP/FUP-Element) positionieren: – Doppelklicken Sie hierzu auf die entsprechende Zeile der Querverweisliste. oder – Setzen Sie den Cursor in die entsprechende Zeile der Querverweisliste und klicken Sie auf den Button "Gehe zur Verwendung". Näheres zur Handhabung der Querverweisliste finden Sie in der Online-Hilfe.
4.18.1.4
Querverweisliste filtern Sie können die Einträge in der Querverweisliste filtern, um nur die Anzeige auf relevante Einträge einzuschränken: 1. Klicken Sie auf den Button "Filtereinstellungen". Das Fenster "Filtereinstellungen für Querverweise" wird angezeigt. 2. Aktivieren Sie Checkbox "Filter aktiv". 3. Wenn Sie auch Systemvariablen und Systemfunktionen anzeigen wollen: – Deaktivieren Sie die Checkbox "Nur anwenderdefinierte Variablen anzeigen". 4. Setzen Sie für die entsprechenden Spalten das gewünschte Filterkriterium: – Wählen Sie den entsprechenden Eintrag aus der Auswahlliste oder geben Sie das Kriterium ein. – Wenn Sie nach einer Zeichenfolge innerhalb eines Eintrags suchen wollen: Deaktivieren Sie die Checkbox "Nur ganze Wörter". 5. Bestätigen Sie mit "OK". Die Querverweisliste wird gemäß den ausgewählten Filtereinstellungen angezeigt. Hinweis Nach Erzeugen der Querverweisliste ist ein Filter standardmäßig aktiviert.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
165
KOP/FUP programmieren 4.18 Referenzdaten
4.18.2
Programmstruktur In der Programmstruktur sehen Sie alle Funktionsaufrufe und deren Schachtelung innerhalb eines ausgewählten Elements. Nach erfolgreicher Bildung der Querverweisliste können Sie sich die Programmstruktur anzeigen lassen selektiv für: ● eine einzelne Programmquelle (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) ● alle Programmquellen eines SIMOTION Geräts ● alle Programmquellen und Bibliotheken des Projekts ● Bibliotheken (alle Bibliotheken, einzelne Bibliothek, einzelne Programmquelle innerhalb einer Bibliothek) So gehen Sie vor: 1. Markieren Sie im Projektnavigator das entsprechende Element, dessen Programmstruktur Sie anzeigen lassen wollen. 2. Wählen Sie Menü Bearbeiten > Referenzdaten > Anzeigen > Programmstruktur. An Stelle des Registers Querverweise wird nun das Register Programmstruktur in der Detailanzeige eingeblendet.
166
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
KOP/FUP programmieren 4.18 Referenzdaten
4.18.2.1
Inhalt der Programmstruktur Angezeigt werden in einer Baumstruktur: ● als Wurzel jeweils – die Programmorganisationseinheiten (Programme, Funktionen, Funktionsbausteine), die in der Programmquelle deklariert sind, oder – die verwendeten Tasks des Ablaufsystem ● darunter die in dieser Programmorganisationseinheit bzw. Task referenzierten Unterprogramme. Zur Struktur der Einträge siehe Tabelle: Tabelle 4- 24 Elemente der Anzeige für die Programmstruktur Element
Beschreibung
Wurzel (deklarierte POE bzw. verwendete Task))
Durch Komma getrennte Liste • Bezeichner der Programmorganisationseinheit (POE) bzw. der Task • Bezeichner der Programmquelle, in der die POE bzw. die Task deklariert wurde, mit Zusatz [UNIT] • Minimaler und maximaler Stackbedarf (Speicherbedarf der POE bzw. der Task auf dem Lokaldatenstack) in Byte [Min, Max] • Minimaler und Maximaler Gesamtstackbedarf (Speicherbedarf der POE bzw. der Task auf dem Lokaldatenstack einschließlich aller gerufenen POE) in Byte [Min, Max]
referenzierte POE
Durch Komma getrennte Liste: • Bezeichner der gerufenen POE • optional: Bezeichner der Programmquelle bzw. des Technologiepakets, in der die POE deklariert wurde: Zusatz (UNIT): Anwenderdefinierte Programmquelle Zusatz (LIB): Bibliothek • •
Zusatz (TP): Systemfunktion aus Technologiepaket nur bei Funktionsbausteinen: Bezeichner der Instanz nur bei Funktionsbausteinen: Bezeichner der Programmquelle, in der die Instanz deklariert wurde: Zusatz (UNIT): Anwenderdefinierte Programmquelle
•
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Zusatz (LIB): Bibliothek Zeile der (generierten) Quelle, in der die POE gerufen wird; mehrere Zeilen werden durch "|" getrennt.
167
KOP/FUP programmieren 4.18 Referenzdaten
4.18.3
Codeattribute Unter Codeattribute erhalten Sie Informationen über den Speicherbedarf verschiedener Datenbereiche der Programmquellen. Nach erfolgreicher Bildung der Querverweisliste können Sie sich die Codeattribute anzeigen lassen selektiv für: ● eine einzelne Programmquelle (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) ● alle Programmquellen eines SIMOTION Geräts ● alle Programmquellen und Bibliotheken des Projekts ● Bibliotheken (alle Bibliotheken, einzelne Bibliothek, einzelne Programmquelle innerhalb einer Bibliothek) So gehen Sie vor: 1. Markieren Sie im Projektnavigator das entsprechende Element, dessen Codeattribute Sie anzeigen lassen wollen. 2. Wählen Sie Menü Bearbeiten > Referenzdaten > Anzeigen > Codeattribute. An Stelle des Registers Querverweise wird nun das Register Codeattribute in der Detailanzeige eingeblendet.
4.18.3.1
Inhalt der Codeattribute In einer Tabelle werden für alle ausgewählten Programmquellen angezeigt: ● der Bezeichner der Programmquelle, ● der Speicherbedarf in Byte für folgende Datenbereiche der Programmquelle: – Dynamische Daten: alle Unit-Variablen (remanente und nicht remanente, im Interfaceund Implementationsabschnitt), – Retain-Daten: remanente Unit-Variablen im Interface- und Implementationsabschnitt, – Interfacedaten: Unit-Variablen (remanente und nicht remanente) im Interfaceabschnitt, ● die Anzahl der referenzierten Quellen.
168
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen
5
In diesem Kapitel werden die Befehle mit den Parametern ausführlich beschrieben. Die beschriebenen Befehle gelten sowohl für den KOP-Editor als auch für den FUP-Editor. Durch Beispiele werden die einzelnen Befehle in dem KOP- und FUP- Editor veranschaulicht. Bei Unterschieden wie z. B. Bitverknüpfung wird auf den entsprechenden KOP-Bitverknüpfungsoperationen (Seite 170) Editor hingewiesen. Hinweis In diesem Abschnitt nicht beschriebene Funktionen finden Sie in der Funktionsbeschreibung der Programmiersprache ST.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
169
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1
KOP-Bitverknüpfungsoperationen Bitverknüpfungsoperationen arbeiten mit den Zahlen 1 und 0. Diese Zahlen bilden die Basis des Dualsystems und werden Binärziffern oder kurz Bits genannt. Im Zusammenhang mit UND, ODER, XOR, NOT und Ausgängen steht eine 1 für logisch JA und eine 0 für logisch NEIN. Die Bitverknüpfungsoperationen interpretieren die Signalzustände 1 und 0 und verknüpfen sie entsprechend der Boolschen Logik. Folgende Bitverknüpfungsoperationen stehen Ihnen zur Verfügung: ● ---| |--- Schließerkontakt ● ---| / |--- Öffnerkontakt ● XOR EXKLUSIV-ODER verknüpfen ● ---( ) Relaisspule, Ausgang ● ---( # )--- Konnektor ● ---|NOT|--- Signalzustand invertieren Folgende Operationen reagieren auf einen Signalzustand von 1: ● ---( S ) Ausgang setzen ● ---( R ) Ausgang rücksetzen ● SR Flipflop vorrangig setzen ● RS Flipflop vorrangig rücksetzen Einige Operationen reagieren auf einen steigenden oder fallenden Flankenwechsel, so dass Sie damit eine der folgenden Funktionen ausführen können: ● --( N)-- Flanke 1 -> 0 abfragen ● --( P )-- Flanke 0 -> 1 abfragen ● NEG Flankenerkennung (fallend) ● POS Flankenerkennung (steigend)
170
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.1
---| |--- Schließerkontakt
Symbol ---| |--Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung ---| |--- (Schließerkontakt) wird geschlossen, wenn der Wert des abgefragten Bits, der am angegebenen gespeichert wird, gleich 1 ist. Andernfalls, wenn der Signalzustand am angegebenen 0 ist, ist der Kontakt geöffnet. Bei Reihenschaltungen wird der Kontakt ---| |--- durch UND verknüpft. Bei Parallelschaltungen wird der Kontakt durch ODER verknüpft.
Beispiel
Strom kann fließen, wenn: der Zustand an den Eingängen %I 0.0 UND %I 0.1 = 1 ist ODER der Zustand an Eingang %I 0.2 = 1 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
171
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.2
---| / |--- Öffnerkontakt
Symbol —| / |— Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung ---| / |--- (Öffnerkontakt) ist geschlossen, wenn der Wert des abgefragten Bits, der am angegebenen gespeichert wird, gleich 0 ist. Andernfalls, wenn der Signalzustand am angegebenen 1 ist, ist der Kontakt geöffnet. Bei Reihenschaltungen wird der Kontakt ---| / |--- bitweise durch UND verknüpft. Bei Parallelschaltungen wird der Kontakt durch ODER verknüpft.
Beispiel
Strom kann fließen, wenn: der Zustand an den Eingängen %I 0.0 UND %I 0.1 1 ist ODER der Zustand an Eingang %I 0.2 0 ist.
172
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.3
XOR EXKLUSIV-ODER verknüpfen
Symbol Für die Funktion XOR ist es erforderlich, ein Netzwerk von Öffnern und Schließern zu erstellen: 2SHUDQG!
2SHUDQG!
2SHUDQG!
2SHUDQG!
Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
BOOL
Abgefragtes Bit
Beschreibung Der Wert einer XOR (EXKLUSIV-ODER verknüpfen) Verknüpfung ist 1, wenn der Signalzustand der beiden angegebenen Bits unterschiedlich ist.
Beispiel
Ausgang %Q 4.0 ist 1, wenn (%I 0.0 = 0 UND %I 0.1 = 1) ODER (%I 0.0 = 1 UND %I 0.1 = 0).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
173
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.4
---|NOT|--- Signalzustand invertieren
Symbol ---|NOT|---
Beschreibung ---|NOT|--- (Signalzustand invertieren) invertiert das Signalbit.
Beispiel
Ausgang %Q 4.0 ist 0, wenn: der Zustand an Eingang %I 0.0 = 1 ODER der Zustand an %I 0.1 UND %I 0.2 = 1 ist.
174
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.5
---( ) Relaisspule, Ausgang
Symbol ---( ) Parameter
Datentyp
Beschreibung
BOOL
Zugeordnetes Bit
Beschreibung ---( ) (Relaisspule, Ausgang) funktioniert wie eine Spule in einem Stromlaufplan. Fließt Strom zur Spule, wird das Bit am auf 1 gesetzt. Fließt kein Strom zur Spule, wird das Bit am auf 0 gesetzt. Eine Ausgangsspule kann nur am rechten Ende eines Strompfads in einem Kontaktplan angeordnet werden. Ein negierter Ausgang kann mit der Operation ---|NOT|--- erstellt werden.
Beispiel
Ausgang %Q 4.0 ist 1, wenn: (der Zustand an Eingang %I 0.0 UND %I 0.1 = 1 ist) ODER der Zustand an Eingang %I 0.2 = 0 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
175
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.6
---( # )--- Konnektor (KOP)
Symbol ---( # )--Parameter
Datentyp
Beschreibung
BOOL
Zugeordnetes Bit
Beschreibung ---( # )--- (Konnektor) ist ein zwischengeschaltetes Element mit Zuordnungsfunktion, das den aktuellen Signalzustand des Signalflusses an einem angegebenen speichert. Dieses Zuordnungselement speichert die Bitverknüpfung der letzten geöffneten Verzweigung vor dem Zuordnungselement. Bei Reihenschaltung mit anderen Elementen wird die Operation ---( # )--- wie ein Kontakt eingefügt. Das Element ---( # )--- darf nie an die Stromschiene angeschlossen werden bzw. es darf nie direkt hinter einer Verzweigung angeordnet werden und kann nicht als Abschluss eines Zweiges eingesetzt werden. Ein negiertes Element ---( # )--- kann mit dem Element ---|NOT|--- (Signalzustand invertieren) erstellt werden.
Beispiel
176
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.7
---( R ) Ausgang rücksetzen (KOP)
Symbol ---( R ) Parameter
Datentyp
Beschreibung
BOOL
Zugeordnetes Bit
Beschreibung ---( R ) (Ausgang rücksetzen) wird nur ausgeführt, wenn der Signalzustand der vorherigen Operationen 1 ist (Signalfluss an der Spule). Fließt Strom zur Spule (Signalzustand ist 1), dann wird der angegebene des Elements auf 0 gesetzt. Ein Signalzustand von 0 (kein Signalfluss an der Spule) hat keine Auswirkungen, so dass der Signalzustand des angegebenen Operanden des Elements nicht verändert wird.
Beispiel
Ausgang %Q 4.0 wird nur zurückgesetzt, wenn: (der Zustand an Eingang %I 0.0 UND an Eingang %I 0.1 = 1 ist) ODER der Zustand an Eingang %I 0.2 = 0 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
177
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.8
---( S ) Ausgang setzen (KOP)
Symbol ---( S ) Parameter
Datentyp
Beschreibung
BOOL
Gesetztes Bit
Beschreibung ---( S ) (Ausgang setzen) wird nur ausgeführt, wenn der Signalzustand der vorherigen Operationen 1 ist (Signalfluss an der Spule). Ist der Signalzustand 1, wird der angegebene des Elements auf 1 gesetzt. Ein Signalzustand = 0 hat keine Auswirkungen, so dass der aktuelle Signalzustand des angegebenen Operanden des Elements nicht verändert wird.
Beispiel
Ausgang %Q 4.0 wird nur auf 1 gesetzt, wenn: (der Zustand an Eingang %I 0.0 UND an %I 0.1 = 1 ist) ODER der Zustand an Eingang %I 0.2 = 0 ist. Ist der Signalzustand 0, bleibt der Signalzustand von Ausgang %Q 4.0 gleich.
178
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.9
RS Flipflop vorrangig rücksetzen
Symbol 2SHUDQG YRP7\S56! 56 6
4
5
Parameter
Datentyp
Beschreibung
RS
Instanzvariable vom FB-Typ RS
S
BOOL
Setzen freigeben
R1
BOOL
Rücksetzen freigeben
Q1
BOOL
Signalzustand von
Beschreibung RS (Flipflop vorrangig rücksetzen) wird rückgesetzt, wenn am Eingang R1 der Zustand 1 ist und am Eingang S der Zustand 0 ist. Andernfalls, wenn am Eingang R1 der Zustand 0 und am Eingang S der Zustand 1 ist, wird das Flipflop gesetzt. Die Operationen S (Setzen) und R1 (Rücksetzen) werden nur ausgeführt, wenn das anliegende Signal = 1 ist. Ist das anliegende Signal = 0, werden diese Operationen nicht beeinflusst und der angegebene Operand wird nicht verändert. Ist das anliegende Signal an beiden Eingängen 1, wird das RS zurückgesetzt.
Beispiel
Wenn der Zustand an Eingang %I 0.0 = 1 und an Eingang %I 0.1 = 0 ist, wird der Zustandsmerker VAR1 gesetzt und %Q 4.0 ist 1. Andernfalls, wenn der Signalzustand an Eingang %I 0.0 = 0 und an %I 0.1 = 1 ist, wird der Zustandsmerker VAR1 zurückgesetzt und %Q 4.0 ist 0. Wenn beide Signalzustände 0 sind, wird nichts verändert. Wenn beide Signalzustände 1 sind, dominiert die Operation Rücksetzen. VAR1 wird zurückgesetzt und %Q 4.0 ist 0.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
179
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.10
SR Flipflop vorrangig setzen
Symbol 2SHUDQG YRP7\S65! 65 6
4
5
Parameter
Datentyp
Beschreibung
SR
Instanzvariable vom FB-Typ SR
S1
BOOL
Setzen freigeben
R
BOOL
Rücksetzen freigeben
Q1
BOOL
Signalzustand von
Beschreibung SR (Flipflop vorrangig setzen) wird gesetzt, wenn am Eingang S1 der Zustand 1 ist und am Eingang R der Zustand 0 ist. Andernfalls, wenn am Eingang S1 der Zustand 0 und am Eingang R der Zustand 1 ist, wird das Flipflop zurückgesetzt. Die Operationen S1 (Setzen) und R (Rücksetzen) werden nur ausgeführt, wenn das anliegende Signal = 1 ist. Ist das anliegende Signal = 0, werden diese Operationen nicht beeinflusst und der angegebene Operand wird nicht verändert. Ist das anliegende Signal an beiden Eingängen 1, wird das SR gesetzt.
Beispiel
Wenn der Zustand an Eingang %I 0.0 1 und an Eingang %I 0.1 = 0 ist, wird der Zustandsmerker VAR1 gesetzt und %Q 4.0 ist 1. Andernfalls, wenn der Signalzustand an Eingang %I 0.0 = 0 und an %I 0.1 = 1 ist, wird der Zustandsmerker VAR1 zurückgesetzt und %Q 4.0 ist 0. Wenn beide Signalzustände 0 sind, wird nichts verändert. Wenn beide Signalzustände 1 sind, dominiert die Operation Setzen. VAR1 wird gesetzt und %Q 4.0 ist 1.
180
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.11
--( N )-- Flanke 1 -> 0 abfragen (KOP)
Symbol ---( N )--Parameter
Datentyp
Beschreibung
BOOL
N-Konnektor Bit, speichert den vorherigen Signalzustand
Beschreibung ---( N )--- (Flanke 1 -> 0 abfragen) erkennt einen Wechsel des Signalzustands im Operanden von 1 nach 0 und zeigt dies nach der Operation mit Signalzustand = 1 an. Der aktuelle Signalzustand wird mit dem Signalzustand des Operanden, dem N-Konnektor, verglichen. Ist der Signalzustand des Operanden 1 und der Signalzustand vor der Operation 0, so ist das Signal nach der Operation 1 (Impuls), in allen anderen Fällen 0. Das Signal vor der Operation wird im Operanden gespeichert.
Beispiel
Der N-Konnektor speichert den Signalzustand des Ergebnisses der gesamten Bitverknüpfung. Wenn der Signalzustand von 1 nach 0 wechselt, wird der Sprung zur Sprungmarke CAS1 ausgeführt.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
181
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.12
--( P )-- Flanke 0 -> 1 abfragen (KOP)
Symbol ---( P )--Parameter
Datentyp
Beschreibung
BOOL
P-Konnektor Bit, speichert den vorherigen Signalzustand
Beschreibung ---( P )--- (Flanke 0 -> 1 abfragen) erkennt einen Wechsel des Signalzustands im Operanden von 0 nach 1 und zeigt dies nach der Operation mit Signalzustand = 1 an. Der aktuelle Signalzustand wird mit dem Signalzustand des Operanden, dem P-Konnektor, verglichen. Ist der Signalzustand des Operanden 0 und der Signalzustand vor der Operation 1, so ist das Signal nach der Operation 1 (Impuls), in allen anderen Fällen 0. Das Signal vor der Operation wird im Operanden gespeichert.
Beispiel
Der P-Konnektor speichert den Signalzustand des Ergebnisses der gesamten Bitverknüpfung. Wenn der Signalzustand von 0 nach 1 wechselt, wird der Sprung zur Sprungmarke CAS1 ausgeführt.
182
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.13
NEG Flankenerkennung (fallend)
Symbol 2SHUDQG! 1(* 4 2SHUDQG!
Parameter
0B%LW
Datentyp
Beschreibung
BOOL
Abgefragtes Signal
BOOL
Konnektor Bit, speichert den vorherigen Signalzustand von
Q
BOOL
Signalwechselerkennung
Beschreibung NEG (Flankenerkennung) vergleicht den Signalzustand von mit dem Signalzustand der vorherigen Abfrage, der in gespeichert ist. Wenn der aktuelle Zustand des Signals 0 ist, und der vorherige Zustand 1 war (Erkennung einer fallenden Flanke), ist der Ausgang Q nach dieser Funktion 1, in allen anderen Fällen 0.
Beispiel
Der Ausgang %Q 4.0 ist 1, wenn: (der Zustand an %I 0.0 UND an %I 0.1 UND an %I 0.2 = 1 ist) UND VAR1 eine fallende Flanke hat UND der Zustand an %I 0.4 = 1 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
183
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.14
POS Flankenerkennung (steigend)
Symbol 2SHUDQG! 326 4 2SHUDQG!
Parameter
0B%LW
Datentyp
Beschreibung
BOOL
Abgefragtes Signal
BOOL
Konnektor Bit, speichert den vorherigen Signalzustand von
Q
BOOL
Signalwechselerkennung
Beschreibung POS (Flankenerkennung) vergleicht den Signalzustand von mit dem Signalzustand der vorherigen Abfrage, der in gespeichert ist. Wenn der aktuelle Zustand des Signals 1 ist, und der vorherige Zustand 0 war (Erkennung einer steigenden Flanke), ist der Ausgang Q nach dieser Operation 1, in allen anderen Fällen 0.
Beispiel
Der Ausgang %Q 4.0 ist 1, wenn: (der Zustand an %I 0.0 UND an %I 0.1 UND an %I 0.2 = 1 ist) UND VAR1 eine steigende Flanke hat UND der Zustand an %I 0.4 = 1 ist.
184
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.15
Verzweigung auf Parallelzweige werden nach unten geöffnet. Parallelzweige werden immer hinter dem markierten KOP-Element geöffnet.
Vorgehensweise Um einen Parallelzweig nach unten zu öffnen, gehen Sie folgendermaßen vor: 1. Markieren Sie mit dem Cursor die Stelle, an der die Verzweigung geöffnet werden soll.
2. Klicken Sie in der Funktionsleiste des KOP-Editors auf die Schaltfläche F8).
(Tastenkürzel
Die Verzweigung wird nach dem markierten Element geöffnet.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
185
Funktionen 5.1 KOP-Bitverknüpfungsoperationen
5.1.16
Verzweigung zu Parallelzweige werden nach oben geschlossen. Parallelzweige werden immer hinter dem markierten KOP-Element geschlossen.
Vorgehensweise Um einen Parallelzweig nach oben zu schließen, gehen Sie folgendermaßen vor: 1. Markieren Sie mit dem Cursor die Stellen, an der die Verzweigung geschlossen werden soll.
2. Klicken Sie in der Funktionsleiste des KOP-Editors auf die Schaltfläche F9).
(Tastenkürzel
Die Verzweigung wird nach dem markierten Element geschlossen.
186
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2
FUP-Bitverknüpfungsoperationen
FUP-Bitverknüpfungsoperationen Bitverknüpfungsoperationen arbeiten mit den Zahlen 1 und 0. Diese Zahlen bilden die Basis des Dualsystems und werden Binärziffern oder kurz Bits genannt. Im Zusammenhang mit UND, ODER, XOR und Ausgängen steht eine 1 für logisch JA und eine 0 für logisch NEIN. Die Bitverknüpfungsoperationen interpretieren die Signalzustände 1 und 0 und verknüpfen sie entsprechend der Boolschen Logik. Folgende Bitverknüpfungsoperationen stehen Ihnen im FUP-Editor zur Verfügung: ● & UND-Box ● >=1 ODER-Box ● XOR Exclusiv ODER-Box ● [=] Zuweisung ● [#] Konnektor Folgende Operationen reagieren auf einen Signalzustand von 1: ● [R] Zuweisung rücksetzen ● [S] Zuweisung setzen ● RS Flipflop vorrangig rücksetzen ● SR Flipflop vorrangig setzen Einige Operationen reagieren auf einen steigenden oder fallenden Flankenwechsel, so dass Sie damit eine der folgenden Funktionen ausführen können: ● [N] Flanke 1 -> 0 abfragen ● [P] Flanke 0 -> 1 abfragen ● NEG Flankenerkennung (fallend) ● POS Flankenerkennung (steigend) Die übrigen Operationen beeinflussen die Signalzustände direkt: ● --| Binäreingang einfügen ● --o| Binäreingang negieren
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
187
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.1
& UND-Box
Symbol 2SHUDQG! 2SHUDQG!
Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung Mit der Operation UND können Sie die Signalzustände zweier oder mehr angegebener Operanden an den Eingängen einer UND-Box abfragen. Beträgt der Signalzustand aller Operanden 1, so ist die Bedingung erfüllt und die Operation liefert das Ergebnis 1. Beträgt der Signalzustand eines Operanden 0, ist die Bedingung nicht erfüllt und die Operation erzeugt das Ergebnis 0.
Beispiel
Ausgang %Q 4.0 ist gesetzt, wenn am Eingang %I 1.0 UND %I 1.1 der Signalzustand 1 ist.
188
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.2
>=1 ODER-Box
Symbol ! 2SHUDQG! 2SHUDQG!
Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung Mit der Operation ODER können Sie die Signalzustände zweier oder mehr angegebener Operanden an den Eingängen einer ODER-Box abfragen. Beträgt der Signalzustand eines der Operanden 1, so ist die Bedingung erfüllt und die Operation liefert das Ergebnis 1. Beträgt der Signalzustand aller Operanden 0, ist die Bedingung nicht erfüllt und die Operation erzeugt das Ergebnis 0.
Beispiel
Ausgang %Q 4.0 ist gesetzt, wenn am Eingang %I 1.0 ODER am Eingang %I 1.1 der Signalzustand 1 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
189
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.3
XOR EXKLUSIV-ODER-Box
Symbol ;25 2SHUDQG! 2SHUDQG!
Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung Bei einer EXKLUSIV-ODER-Box ist der Signalzustand 1, wenn der Signalzustand eines der beiden angegebenen Operanden 1 ist.
Beispiel
Am Ausgang %Q 4.0 ist der Signalzustand 1, wenn entweder EXKLUSIV am Eingang %I 0.0 ODER am Eingang %I 0.1 der Signalzustand 1 ist.
190
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.4
--| Binäreingang einfügen
Symbol ---| Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung Die Operation Binäreingang einfügen fügt an einer UND-, ODER- oder XOR-Box hinter der Markierung einen binären Eingang ein.
Beispiel
Ausgang %Q 4.0 ist 1, wenn der Zustand %I 1.0 UND %I 1.1 UND %I 1.2 = 1 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
191
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.5
--o| Binäreingang negieren
Symbol –o| Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Bit
Beschreibung Die Operation Binäreingang negieren negiert den Signalzustand. Alle Binäreingänge beliebiger Elemente können negiert werden.
Beispiel
Ausgang %Q 4.0 ist 1, wenn: ● der Signalzustand an %I 1.0 UND %I 1.1 NICHT 1 ist ● UND der Signalzustand an %I 1.2 UND %I 1.3 NICHT 1 ist ● ODER der Signalzustand an %I 1.4 = 1 ist.
192
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.6
[=] Zuweisung
Symbol 2SHUDQG!
Parameter
Datentyp
Beschreibung
BOOL
Zugeordnetes Bit
Beschreibung Die Operation Zuweisung liefert den Wert. Die Box am Ende der Verknüpfung führt entsprechend den folgenden Kriterien das Signal 1 bzw. 0: ● Der Ausgang führt das Signal 1, wenn die Bedingungen der Verknüpfung vor der Ausgangs-Box erfüllt sind. ● Der Ausgang führt das Signal 0, wenn die Bedingungen der Verknüpfung vor der Ausgangs-Box nicht erfüllt sind. Die FUP-Verknüpfung weist den Signalzustand dem Ausgang zu, der von der Operation angesprochen wird. Sind die Bedingungen der FUP-Verknüpfungen erfüllt, so ist der Signalzustand an der Ausgangs-Box 1. Andernfalls ist der Signalzustand 0.
Beispiel
Ausgang %Q 4.0 ist 1, wenn: ● an den Eingängen %I 0.0 UND %I 0.1 der Signalzustand 1 ist, ● ODER %I 0.2 = 0 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
193
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.7
[#] Konnektor (FUP)
Symbol 2SHUDQG!
Parameter
Datentyp
Beschreibung
BOOL
Zugeordnetes Bit
Beschreibung Die Operation Konnektor ist ein zwischengeschaltetes Zuordnungselement, das den Signalzustand speichert. Genauer gesagt speichert dieses Zuordnungselement die Bitverknüpfung der letzten geöffneten Verzweigung vor dem Zuordnungselement.
Beispiel
Die Konnektoren speichern die folgenden Verknüpfungsergebnisse: VAR4 speichert den negierten Signalzustand von %I1.0 %I1.1 VAR1 speichert den negierten Signalzustand von %I1.2 %I1.3 VAR2 speichert den Signalzustand von %I 1.4. VAR3 speichert den negierten Signalzustand der gesamten Bitverknüpfung.
194
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.8
[R] Zuweisung rücksetzen (FUP)
Symbol 2SHUDQG! 5
Parameter
Datentyp
Beschreibung
BOOL
Zugeordnetes Bit
Beschreibung Die Operation Zuweisung rücksetzen wird nur dann ausgeführt, wenn der Signalzustand = 1 ist. Ist der Signalzustand = 1, wird der angegebene Operand von der Operation auf 0 zurückgesetzt. Ist der Signalzustand = 0, beeinflusst die Operation den angegebenen Operanden nicht. Der Operand bleibt unverändert.
Beispiel
Der Signalzustand an Ausgang %Q 4.0 wird nur auf 0 zurückgesetzt, wenn: ● an den Eingängen %I 0.0 UND %I 0.1 Signalzustand 1 ist ● ODER der Signalzustand an Eingang %I 0.2 = 0 ist Wenn der Signalzustand der Verzweigung = 0 ist, wird der Signalzustand an Ausgang %Q 4.0 nicht verändert.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
195
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.9
[S] Zuweisung setzen (FUP)
Symbol 2SHUDQG! 6
Parameter
Datentyp
Beschreibung
BOOL
Gesetztes Bit
Beschreibung Die Operation Zuweisung setzen wird nur ausgeführt, wenn der Signalzustand = 1 ist. Ist der Signalzustand = 1, so wird der angegebene Operand von der Operation auf 1 gesetzt. Ist der Signalzustand = 0, beeinflusst die Operation den angegebenen Operanden nicht. Der Operand bleibt unverändert.
Beispiel
Der Signalzustand an Ausgang %Q 4.0 wird nur auf 1 gesetzt, wenn: ● an den Eingängen %I 0.0 UND %I 0.1 Signalzustand 1 ist ● ODER der Signalzustand an Eingang %I 0.2 = 0 ist Wenn der Signalzustand der Verzweigung = 0 ist, wird der Signalzustand von %Q 4.0 nicht verändert.
196
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.10
RS Flipflop vorrangig rücksetzen
Symbol 2SHUDQG YRP7\S56! 56 6
4
5
Parameter
Datentyp
Beschreibung
RS
Instanzvariable vom FB-Typ RS
S
BOOL
Setzen freigeben
R1
BOOL
Rücksetzen freigeben
Q1
BOOL
Signalzustand von
Beschreibung Die Operation Flipflop vorrangig rücksetzen führt Operationen wie Zuweisung setzen (S) oder Zuweisung rücksetzen (R) nur dann aus, wenn der Signalzustand = 1 ist. Ein Signalzustand von 0 beeinflusst diese Operationen nicht; der in der Operation angegebene Operand wird nicht verändert. Flipflop vorrangig rücksetzen wird zurückgesetzt, wenn der Signalzustand an Eingang R = 1 und an Eingang S = 0 ist. Ist Eingang R = 0 und Eingang S = 1, wird das Flipflop gesetzt. Ist der Signalzustand an beiden Eingängen 1, so wird das Flipflop zurückgesetzt.
Beispiel
Ist %I 0.0 = 1 und %I 0.1 = 0, wird die Variable VAR1 gesetzt und Ausgang %Q 4.0 ist 1. Ist %I 0.0 = 0 und %I 0.1 = 1, wird die Variable VAR1 rückgesetzt und Ausgang %Q 4.0 ist 0. Wenn beide Signalzustände 0 sind, kommt es zu keiner Änderung. Sind beide Signalzustände 1, dominiert aufgrund der Reihenfolge die Operation Rücksetzen. VAR1 wird zurückgesetzt und %Q 4.0 ist 0.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
197
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.11
SR Flipflop vorrangig setzen
Symbol 2SHUDQG YRP7\S65! 65 6
4
5
Parameter
Datentyp
Beschreibung
SR
Instanzvariable vom FB-Typ SR
S1
BOOL
Setzen freigeben
R
BOOL
Rücksetzen freigeben
Q1
BOOL
Signalzustand von
Beschreibung Die Operation Flipflop vorrangig setzen führt Operationen wie Setzen (S) oder Rücksetzen (R) nur dann aus, wenn der Signalzustand = 1 ist. Ein Signalzustand von 0 beeinflusst diese Operationen nicht; der in der Operation angegebene Operand wird nicht verändert. Flipflop vorrangig setzen wird gesetzt, wenn der Signalzustand an Eingang S = 1 und an Eingang R = 0 ist. Ist Eingang S = 0 und Eingang R = 1, wird das Flipflop zurückgesetzt. Ist der Signalzustand an beiden Eingängen 1, so wird das Flipflop gesetzt.
Beispiel
Ist %I 0.0 = 1 und %I 0.1 = 0, wird die Variable VAR1 gesetzt und %Q 4.0 ist 1. Ist %I 0.0 = 0 und %I 0.1 = 1, wird die Variable VAR1 zurückgesetzt und %Q 4.0 ist 0. Wenn beide Signalzustände 0 sind, wird nichts verändert. Wenn beide Signalzustände 1 sind, dominiert die Operation Setzen. VAR1 wird gesetzt und %Q 4.0 ist 1.
198
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.12
[N] Flanke 1 -> 0 abfragen (FUP)
Symbol 2SHUDQG! 1
Parameter
Datentyp
Beschreibung
BOOL
N-Konnektor Bit, speichert den vorherigen Signalzustand
Beschreibung Die Operation Flanke 1 -> 0 abfragen erkennt einen Wechsel im angegebenen Operanden von 1 auf 0 (fallende Flanke) und zeigt dies nach der Operation durch Signalzustand = 1 an. Der aktuelle Signalzustand wird mit dem Signalzustand des Operanden, der Flankenvariablen verglichen. Ist der Signalzustand des Operanden 1 und der Signalzustand vor der Operation 0, so ist der Signalzustand nach der Operation 1 (Impuls), in allen anderen Fallen 0. Der Signalzustand vor der Operation wird im Operanden gespeichert.
Beispiel
Die Variable VAR4 speichert den Signalzustand.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
199
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.13
[P] Flanke 0 -> 1 abfragen (FUP)
Symbol 2SHUDQG! 3
Parameter
Datentyp
Beschreibung
BOOL
P-Konnektor Bit, speichert den vorherigen Signalzustand
Beschreibung Die Operation Flanke 0 -> 1 abfragen erkennt einen Wechsel im angegeben Operanden von 0 auf 1 (steigende Flanke) und zeigt dies nach der Operation durch Signalzustand = 1 an. Der aktuelle Signalzustand wird mit dem Signalzustand des Operanden, der Flankenvariable verglichen. Ist der Signalzustand des Operanden 0 und der Signalzustand vor der Operation 1, so ist der Signalzustand nach der Operation 1, in allen anderen Fallen 0. Der Signalzustand vor der Operation wird im Operanden gespeichert.
Beispiel
Die Variable VAR1 speichert den Signalzustand.
200
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.14
NEG Flankenerkennung (fallend)
Symbol 2SHUDQG! 1(* 4 0B%,7
Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Signal
M_BIT
BOOL
Der Operand M_BIT gibt an, in welcher Variable der vorherige Signalzustand von NEG gespeichert ist.
Q
BOOL
Signalwechselerkennung
Beschreibung Die Operation Flankenerkennung (fallend) vergleicht den Signalzustand von mit dem Signalzustand der vorherigen Abfrage, der im Operand M_BIT gespeichert ist. Ist es zu einem Wechsel von 1 auf 0 gekommen, dann ist Ausgang Q = 1, in allen anderen Fällen 0.
Beispiel
Der Ausgang %Q 4.0 ist 1, wenn: ● Eingang %I 0.3 eine fallende Flanke hat ● UND an Eingang %I 0.4 der Signalzustand 1 ist.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
201
Funktionen 5.2 FUP-Bitverknüpfungsoperationen
5.2.15
POS Flankenerkennung (steigend)
Symbol 2SHUDQG! 326 4 0B%,7
Parameter
Datentyp
Beschreibung
BOOL
Abgefragtes Signal
M_BIT
BOOL
Der Operand M_BIT gibt an, in welcher Variable der vorherige Signalzustand von POS gespeichert ist.
Q
BOOL
Signalwechselerkennung
Beschreibung Die Operation Flankenerkennung (steigend) vergleicht den Signalzustand von mit dem Signalzustand der vorherigen Abfrage, der im Operand M_BIT gespeichert ist. Ist es zu einem Wechsel von 0 auf 1 gekommen, dann ist Ausgang Q = 1, in allen anderen Fällen 0.
Beispiel
Der Ausgang %Q 4.0 ist 1, wenn: ● Eingang %I 0.3 eine steigende Flanke hat ● UND an Eingang %I 0.4 der Signalzustand 1 ist.
202
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.3 Vergleichsoperatoren
5.3
Vergleichsoperatoren
5.3.1
Vergleichsoperationen Übersicht
Beschreibung Verglichen werden die Eingänge IN1 und IN2 entsprechend der folgenden Vergleichsarten: = IN1 ist gleich IN2 IN1 ist ungleich IN2 > IN1 ist größer als IN2 < IN1 ist kleiner als IN2 >= IN1 ist größer als oder gleich IN2 =, CMP = VAR2 ● UND an Eingang %I 0.0 der Signalzustand (1) ist. UND an Eingang %I 0.1 der Signalzustand (1) ist. UND an Eingang %I 0.2 der Signalzustand (1) ist.
206
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.4 Umwandler
5.4
Umwandler
5.4.1
TRUNC Ganze Zahl erzeugen
Symbol 7581& (1
(12
,1
287
Parameter
Datentyp
Beschreibung
EN
BOOL
Freigabeeingang
ENO
BOOL
Freigabeausgang
IN
ANY_REAL
Zahl, die umgewandelt werden soll
OUT
ANY_INT
Ganzzahliger Teil des Werts von IN
Beschreibung TRUNC (Ganze Zahl erzeugen) liest den Inhalt des Parameters IN als Gleitpunktzahl und wandelt diesen Wert in eine Ganzzahl (32 Bit) um. Das Ergebnis ist der ganzzahlige Anteil der Gleitpunktzahl, der vom Parameter OUT ausgegeben wird.
Beispiel
Darstellung im KOP-Editor
Darstellung im FUP-Editor Ist %I 0.0 = 1, dann wird der Inhalt von VAR1 als Gleitpunktzahl gelesen und in eine Ganzzahl (32 Bit) umgewandelt. Das Ergebnis ist der ganzzahlige Teil der Gleitpunktzahl, der in VAR2 gespeichert wird. Ausgang %Q 4.0 ist 1, wenn ein Überlauf eintritt oder die Anweisung nicht bearbeitet wird (%I 0.0 = 0).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
207
Funktionen 5.4 Umwandler
5.4.2
Numerische Datentypen und Bitdatentypen erzeugen
Symbol z. B. BOOL_TO_TYPE %22/B72B%= PV)
CV
Ausgang
INT
Zählerstand
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
215
Funktionen 5.6 Zähleroperationen
5.6.3
Aufwärtszähler CTU_DINT
Symbol ,QVWDQ]YDULDEOH YRP7\S&78B',17! &78B',17 &8
4
5 39
&9
Beschreibung Die Funktionsweise entspricht dem Aufwärtszähler CTU mit Ausnahme: Die Parameter CV und PV haben den Datentyp DINT, der Zählerstand kann deshalb maximal 2147483647 ( = 16#7FFF_FFFF) betragen. Tabelle 5- 18 Parameter für CTU_DINT
216
Bezeichner
Parameter
Datentyp
Beschreibung
CU
Eingang
BOOL
Aufwärtszählen, wenn Wert von FALSE auf TRUE wechselt (positive Flanke)
R
Eingang
BOOL
Rücksetzen des Zählers auf 0
PV
Eingang
DINT
Vergleichswert
Q
Ausgang
BOOL
Status des Zählers (CV >= PV)
CV
Ausgang
DINT
Zählerstand
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Funktionen 5.6 Zähleroperationen
5.6.4
Aufwärtszähler CTU_UDINT
Symbol ,QVWDQ]YDULDEOH YRP7\S&78B8',17! &78B8',17 &8
4
5 39
&9
Beschreibung Die Funktionsweise entspricht dem Aufwärtszähler CTU mit Ausnahme: Die Parameter CV und PV haben den Datentyp UDINT, der Zählerstand kann deshalb maximal 4294967295 ( =16# FFFF_FFFF) betragen. Tabelle 5- 19 Parameter für CTU_UDINT Bezeichner
Parameter
Datentyp
Beschreibung
CU
Eingang
BOOL
Aufwärtszählen, wenn Wert von FALSE auf TRUE wechselt (positive Flanke)
R
Eingang
BOOL
Rücksetzen des Zählers auf 0
PV
Eingang
UDINT
Vergleichswert
Q
Ausgang
BOOL
Status des Zählers (CV >= PV)
CV
Ausgang
UDINT
Zählerstand
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
217
Funktionen 5.6 Zähleroperationen
5.6.5
Abwärtszähler CTD
Symbol ,QVWDQ]YDULDEOH YRP7\S&7'! &7' &'
4
/9 39
&9
Beschreibung Mit dem Zähler CTD können Sie Abwärts-Zähloperationen durchführen. ● Wenn beim Aufruf des FB der Eingang LD = TRUE ist, wird der Ausgang CV auf den Anfangswert PV zurückgesetzt. ● Wenn beim Aufruf des FB der Eingang CD von FALSE auf TRUE (von 0 auf 1) wechselt ( = positive Flanke), wird der Ausgang CV um 1 abwärts gezählt. ● Der Ausgang Q gibt an, ob CV kleiner oder gleich 0 ist. Die Parameter CV und PV haben den Datentyp INT, der Zählerstand kann deshalb minimal -32768 ( = 16#8000) betragen. Tabelle 5- 20 Parameter für CTD
218
Bezeichner
Parameter
Datentyp
Beschreibung
CD
Eingang
BOOL
Abwärtszählen, wenn Wert von FALSE auf TRUE wechselt (positive Flanke)
LD
Eingang
BOOL
Rücksetzen des Zählers auf Anfangswert
PV
Eingang
INT
Anfangswert des Zählers
Q
Ausgang
BOOL
Status des Zählers (CV = PV)
QD
Ausgang
BOOL
Status als Abwärtszähler (CV >. 6. Wählen Sie das Register Taskkonfiguration und legen Sie dort ggf. weitere Einstellungen für die Task fest.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
253
Inbetriebnehmen (Software) 6.2 Programm einer Task zuordnen
254
Bild 6-1
Ablaufsystem konfigurieren
Bild 6-2
Programm einer Motion Task zuordnen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Inbetriebnehmen (Software) 6.3 Ablaufebenen und Tasks in SIMOTION
6.3
Ablaufebenen und Tasks in SIMOTION Tabelle 6- 1 Ablaufebene
Beschreibung
Zeitgesteuert
Zyklische Tasks: Sie werden nach Abarbeiten der zugeordneten Programme automatisch neu gestartet.
•
SynchronousTasks
Tasks werden synchron zum angegebenen Systemtakt periodisch gestartet. • ServoSynchronousTask: synchron zum Lagereglertakt • IPOsynchronousTask: synchron zum Interpolatortakt IPO • IPOsynchronousTask_2: synchron zum Interpolatortakt IPO_2 • PWMsynchronousTask: synchron zum PWM-Takt (für Technologiepaket TControl) • InputSynchronousTask_1: synchron zum Takt Input1 (für Technologiepaket TControl) • InputSynchronousTask_2: synchron zum Takt Input2 (für Technologiepaket TControl) • PostControlTask_1: synchron zum Takt Control1 (für Technologiepaket TControl) • PostControlTask_2: synchron zum Takt Control2 (für Technologiepaket TControl)
•
TimerInterruptTasks
Tasks werden in festem Zeitraster periodisch gestartet. Das Zeitraster muss ein Vielfaches des Interpolatortaktes IPO sein.
Interrupts
Sequentielle Tasks: Sie werden nach Start einmalig abgearbeitet und dann beendet.
•
SystemInterruptTasks
Sie werden bei Eintreten eines Systemereignisses gestartet: • ExecutionFaultTask: Fehler beim Verarbeiten eines Programms • PeripheralFaultTask: Fehler an der Peripherie • TechnologicalFaultTask: Fehler am Technologischen Objekt • TimeFaultBackgroundTask: Zeitüberlauf der BackgroundTask • TimeFaultTask: Zeitüberlauf einer TimerInterruptTask
•
UserInterruptTasks
Sie werden bei Eintreten eines anwenderdefinierten Ereignisses gestartet.
Round-Robin
•
MotionTasks
MotionTasks und BackgroundTask teilen sich die freie Zeit, die nach Abarbeiten der höherpriorigen System- und Anwendertasks bleibt. Das Verhältnis zwischen beiden Ebenen ist parametrierbar. Sequentielle Tasks: Sie werden nach Start einmalig abgearbeitet und dann beendet. Der Start erfolgt: • Explizit über einen Tasksteuerbefehl in einem Programm, das einer anderen Task zugeordnet ist. • Automatisch nach Erreichen des Betriebszustandes RUN, wenn bei der Taskkonfiguration das entsprechende Attribut gesetzt wurde. Die Priorität einer MotionTask kann mit den Funktionen Warte auf … temporär erhöht werden (siehe Warte auf Achse , Warte auf Signal , Warte auf Bedingung).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
255
Inbetriebnehmen (Software) 6.3 Ablaufebenen und Tasks in SIMOTION Ablaufebene •
BackgroundTask
StartupTask
Beschreibung Zyklische Task: Sie wird nach Abarbeiten der zugeordneten Programme automatisch neu gestartet. Die Zykluszeit der Task ist abhängig von der Laufzeit. Wird beim Übergang des Betriebszustandes STOP bzw. STOP U zu RUN einmalig ausgeführt. SystemInterruptTasks werden über ihr auslösendes Systemereignis gestartet.
ShutdownTask
Wird beim Übergang des Betriebszustandes RUN zu STOP bzw. STOP U einmalig ausgeführt. Der Betriebszustand STOP bzw. STOP U wird folgendermaßen erreicht: • Betätigen des Betriebszustandsschalters • Aufruf der entsprechenden Systemfunktion, z. B. MCC-Befehl Wechsle Betriebszustand • Auftreten einer Störung mit der entsprechenden Fehlerreaktion SystemInterruptTasks und PeripheralFaultTasks werden über ihr auslösendes Systemereignis gestartet.
Zum Verhalten sequentieller und zyklischer Tasks: • Bei der Initialisierung lokaler Programmvariablen: siehe Initialisierung lokaler Variablen (Seite 113). • Bei Verarbeitungsfehlern im Programm: siehe Funktionshandbuch SIMOTION Basisfunktionen. Mögliche Zugriffe auf das Prozessabbild und I/O-Variablen: siehe Wichtige Eigenschaften von Direktzugriff und Prozessabbild (Seite 120).
256
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Inbetriebnehmen (Software) 6.4 Startreihenfolge der Tasks
6.4
Startreihenfolge der Tasks Nach Ablauf der StartupTask ist der Betriebszustand RUN erreicht. Dann werden gestartet: ● die SynchronousTasks ● die TimerInterruptTasks ● die BackgroundTask ● die MotionTasks mit Startup-Attribut. Hinweis Die Reihenfolge, in der diese Tasks nach Erreichen des Betriebszustandes RUN erstmals gestartet werden, richtet sich nicht nach den Prioritäten der Tasks.
Bild 6-3
Taskkonfiguration einer Motion Task
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
257
Inbetriebnehmen (Software) 6.5 Programme in das Zielsystem laden
6.5
Programme in das Zielsystem laden Bevor Sie das Programm ausführen, müssen Sie es (zusammen mit den Technologieobjekten usw.) in das Zielsystem laden. So laden Sie das Programm ins Zielsystem: 1. Wählen Sie den Menüpunkt Projekt > Speichern und alles neu übersetzen. Das Projekt wird komplett neu, unter Berücksichtigung aller Abhängigkeiten, lokal auf der Festplatte gespeichert und übersetzt. 2. Wählen Sie den Menüpunkt Projekt > Konsistenz prüfen, um das Projekt auf Konsistenz zu prüfen. Dies ist nicht nötig, wenn unter dem Menüpunkt Extras > Einstellungen im Register Download die Option Konsistenz vor dem Laden prüfen aktiviert ist (diese Option ist standardmäßig aktiviert). Die Konsistenzprüfung erfolgt dadurch automatisch beim Laden ins Zielsystem (Download). 3. Wählen Sie den Menüpunkt Projekt > Mit Zielsystem verbinden oder betätigen Sie die . Schaltfläche Der Online-Modus wird hergestellt. 4. Wählen Sie den Menüpunkt Zielsystem > Laden ins Zielsystem oder betätigen Sie die . Schaltfläche Die Projektdaten (u. a. das Beispielprogramm) und die Daten der Hardwarekonfiguration werden in den RAM-Speicher des Zielsystems geladen. Weitere Hinweise zum Laden eines Programms ins Zielsystem finden Sie im Funktionshandbuch SIMOTION Basisfunktionen.
258
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.1
Betriebsarten für Programmtest
7.1.1
Betriebsarten der SIMOTION Geräte
7
Für den Programmtest stehen verschiedene Betriebsarten der SIMOTION Geräte zur Verfügung. So wählen Sie die Betriebsart eines SIMOTION Geräts: 1. Markieren Sie im Projektnavigator das SIMOTION Gerät. 2. Wählen Sie das Kontextmenü "Testbetrieb". 3. Wählen Sie die gewünschte Betriebsart (siehe nachstehende Tabelle). Wenn Sie "Debug-Modus" ausgewählt haben: – Akzeptieren Sie die Sicherheitshinweise. – Parametrieren Sie die Lebenszeichenüberwachung. Beachten Sie den nachfolgenden Abschnitt: Wichtige Hinweise zur Lebenszeichenüberwachung (Seite 261). 4. Bestätigen Sie mit "OK". Das SIMOTION Gerät wechselt in die ausgewählte Betriebsart. Wenn das SIMOTION Gerät in die Betriebsart "Debug-Modus" wechselt: – Es wird automatisch eine Verbindung zum Zielsystem hergestellt (Online-Modus), wenn SIMOTION SCOUT sich im Offline-Modus befindet. – Der aktivierte Debug-Modus wird in der Statuszeile angezeigt. – Die Funktionsleiste Haltepunkte (Seite 281) wird eingeblendet.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
259
Software-Debuggen/Fehlerbehandlung 7.1 Betriebsarten für Programmtest Tabelle 7- 1
Betriebsarten eines SIMOTION Geräts
Einstellung
Bedeutung
Prozessbetrieb
Der Programmablauf im SIMOTION Gerät ist optimiert für maximale System-Performance. Folgende Diagnosefunktionen stehen zur Verfügung, sie sind aber teilweise wegen der Optimierung auf maximale System-Performance nur eingeschränkt nutzbar: • Variablen im Symbol-Browser bzw. einer Watchtabelle beobachten • Status Programm (nur eingeschränkt): – Eingeschränkte Beobachtung von Variablen (z. B. Variablen in Schleifen, Rückgabewerte von Systemfunktionen). – ab Version V4.0 des SIMOTION Kernels:
–
•
Testbetrieb
Maximal 1 Programmquelle (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) pro Task kann beobachtet werden. bis Version V3.2 des SIMOTION Kernels:
Maximal 1 Programmquelle (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) kann beobachtet werden. Trace-Tool (nur eingeschränkt) mit Messfunktionen für Antriebe und Funktionsgenerator, siehe Online-Hilfe: – Maximal 1 Trace auf jedem SIMOTION Gerät
Die Diagnosefunktionen des Prozessbetriebs sind im vollen Umfang verfügbar: • Variablen im Symbol-Browser bzw. einer Watchtabelle beobachten • Status Programm: – Beobachtung aller Variablen möglich. – ab Version V4.0 des SIMOTION Kernels:
–
•
Mehrere Programmquellen (z. B. ST-Quellen, MCC-Quellen, KOP/FUP-Quellen) pro Task können beobachtet werden. bis Version V3.2 des SIMOTION Kernels:
Maximal 1 Programmquelle (z. B. ST-Quelle, MCC-Quelle, KOP/FUP-Quelle) pro Task kann beobachtet werden. Trace-Tool mit Messfunktionen für Antriebe und Funktionsgenerator, siehe Online-Hilfe: – Maximal 4 Trace auf jedem SIMOTION Gerät
Hinweis Mit zunehmender Nutzung von Diagnosefunktionen erhöht sich die Laufzeit und Speicherbelastung. Debug-Modus
Diese Betriebsart ist ab Version V3.2 des SIMOTION-Kernels verfügbar. Neben des Diagnosefunktionen des Testbetriebs können Sie folgende Funktion nutzen: • Haltepunkte
•
Innerhalb einer Programmquelle können Sie Haltepunkte (Seite 275) setzen. Bei Erreichen eines aktivierten Haltepunktes werden ausgewählte Tasks angehalten. MotionTasks steuern Im Register "Task Manager" der Gerätediagnose können Sie Tasksteuerbefehle auf MotionTasks anwenden, siehe Funktionshandbuch SIMOTION Basisfunktionen
Maximal 1 SIMOTION Gerät des Projekts kann in den Debug-Modus geschaltet werden. SIMOTION SCOUT ist im Online-Modus, d. h mit dem Zielsystem verbunden. Beachten Sie die den nachfolgenden Abschnitt: Wichtige Hinweise zur Lebenszeichenüberwachung (Seite 261).
260
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.1 Betriebsarten für Programmtest
7.1.2
Wichtige Hinweise zur Lebenszeichenüberwachung WARNUNG Beachten Sie unbedingt die einschlägigen Sicherheitsvorschriften. Verwenden Sie den Debug-Modus oder eine Steuertafel nur mit aktivierter Lebenszeichenüberwachung mit einer angemessen kurzen Überwachungszeit! Bei Problemen mit der Kommunikation zwischen PC und dem SIMOTION Gerät kann es sonst zu unkontrollierbaren Achsbewegungen kommen. Die Funktion ist ausschließlich zu Inbetriebnahme-, Diagnose- und Servicezwecken freigegeben. Die Funktion ist generell nur von befugtem Fachpersonal zu benutzen. Die Sicherheitsabschaltungen der übergeordneten Steuerung sind unwirksam. Deshalb ist auf eine hardwaremäßige Ausführung des NOT-AUS-Kreises zu achten. Hierzu sind vom Anwender die erforderlichen Maßnahmen zu treffen.
Sicherheitshinweise akzeptieren Nach Auswahl des Debug-Modus oder einer Steuertafel müssen Sie die Sicherheitshinweise akzeptieren. Außerdem können Sie die Lebenszeichenüberwachung parametrieren. Gehen Sie wie folgt vor: 1. Klicken Sie auf den Button Einstellungen. Das Fenster "Parameter Lebenszeichenüberwachung" öffnet. 2. Lesen Sie dort, wie nachfolgend beschrieben, die Sicherheitshinweise und parametrieren Sie die Lebenszeichenüberwachung.
Lebenszeichenüberwachung parametrieren Im Fenster "Parameter Lebenszeichenüberwachung" gehen Sie weiter wie folgt vor: 1. Lesen Sie den Warnhinweis! 2. Klicken Sie auf den Button Sicherheitshinweise, um das Fenster mit den ausführlichen Sicherheitshinweisen zu öffnen. 3. Lassen Sie die Voreinstellungen für die Lebenszeichenüberwachung unverändert. Änderungen sollten Sie nur in Ausnahmefällen und unter Beachtung aller Gefahrenhinweise vornehmen. 4. Bestätigen Sie mit Akzeptieren, dass Sie die Sicherheitshinweise gelesen haben und die Lebenszeichenüberwachung richtig parametriert haben.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
261
Software-Debuggen/Fehlerbehandlung 7.1 Betriebsarten für Programmtest
ACHTUNG Das Drücken der Leertaste oder der Wechsel in eine andere Windows-Anwendung bewirken: • Im Debug-Modus bei aktivierten Haltepunkten: – Das SIMOTION Gerät geht in den Betriebszustand STOP. – Die Ausgänge werden deaktiviert (ODIS). • Beim Steuern einer Achse oder eines Antriebs mit der Steuertafel (Steuerungshoheit beim PC): – Die Achse bzw. der Antrieb wird stillgesetzt. – Die Freigaben werden zurückgesetzt. WARNUNG Diese Funktion wird nicht in allen Betriebszuständen garantiert. Deshalb ist auf eine hardwaremäßige Ausführung des NOT-AUS-Kreises zu achten. Hierzu sind vom Anwender die erforderlichen Maßnahmen zu treffen.
262
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.1 Betriebsarten für Programmtest
7.1.3
Parameter Lebenszeichenüberwachung Tabelle 7- 2
Parameterbeschreibung Lebenszeichenüberwachung Feld
Lebenszeichenüberwachung
Beschreibung Das SIMOTION Gerät und SIMOTION SCOUT tauschen regelmäßig Lebenszeichen aus, um eine ordnungsgemäße Verbindung sicher zu stellen. Wenn der Austausch der Lebenszeichen länger unterbrochen ist als die eingestellte Überwachungszeit, tritt folgende Reaktion ein: • Im Debug-Modus bei aktivierten Haltepunkten: – Das SIMOTION Gerät geht in den Betriebszustand STOP. – Die Ausgänge werden deaktiviert (ODIS). • Beim Steuern einer Achse oder eines Antriebs mit der Steuertafel (Steuerungshoheit beim PC): – Die Achse wird stillgesetzt. – Die Freigaben werden zurückgesetzt. Folgende Parametrierungen sind möglich: • Checkbox Aktiv: Bei aktivierter Checkbox ist die Lebenszeichenüberwachung aktiv.
•
Das Deaktivieren der Lebenszeichenüberwachung ist nicht immer möglich. Überwachungszeit: Geben Sie die Überwachungszeit ein.
Vorsicht Lassen Sie die Voreinstellungen für die Lebenszeichenüberwachung möglichst unverändert. Änderungen sollten Sie nur in Ausnahmefällen und unter Beachtung aller Gefahrenhinweise vornehmen. Sicherheitshinweise
Beachten Sie unbedingt den Warnhinweis! Klicken Sie auf die Schaltfläche, um weitere Sicherheitshinweise zu erhalten. Siehe: Wichtige Hinweise zur Lebenszeichenüberwachung (Seite 261)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
263
Software-Debuggen/Fehlerbehandlung 7.2 Symbol-Browser
7.2
Symbol-Browser
7.2.1
Eigenschaften Im Symbol-Browser können Sie Name, Datentyp und Werte von Variablen betrachten und gegebenenfalls die Werte ändern. Im Einzelnen können Sie: folgende Variablen sehen: ● Unit-Variablen sowie statische Variablen eines Programms oder Funktionsbausteins ● Systemvariablen eines SIMOTION Geräts oder eines Technologieobjekts ● I/O-Variablen oder geräteglobale Variablen. Für diese Variablen können sie: ● eine Momentaufnahme der Variablenwerte betrachten, ● die laufende Veränderung der Variablenwerte beobachten, ● Variablenwerte ändern (steuern). Der Symbol-Browser kann die Variablenwerte jedoch nur dann anzeigen/ändern, wenn das Projekt in das Zielsystem geladen ist und eine Verbindung zum Zielsystem besteht.
7.2.2
Symbol-Browser einsetzen
Symbol-Browser aktivieren So aktivieren Sie den Symbol-Browser: 1. Stellen Sie sicher, dass eine Verbindung mit dem Zielsystem besteht und dass das Beispielprogramm ins Zielsystem geladen ist (siehe Programme in das Zielsystem laden (Seite 258)). Das Programm kann, muss aber nicht ausgeführt werden. Wenn es nicht ausgeführt wird, sehen Sie nur die Anfangswerte der Variablen. 2. Markieren Sie im Projektnavigator eine KOP/FUP-Quelle, falls dies noch nicht geschehen ist. 3. Klicken Sie auf das Register Symbol-Browser. Sie sehen alle im Programm verwendeten Unit-Variablen. In der Spalte Statuswert wird der aktuelle Wert der Variablen angezeigt und periodisch aktualisiert.
264
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.2 Symbol-Browser
Variablen im Anwenderspeicher der Unit oder im remanenten Speicher Sie können im Symbol-Browser die Variablen beobachten, die sich im Anwenderspeicher der Unit oder im remanenten Speicher befinden: ● Remanente und nicht remanente Unit-Variablen des Interfaceabschnitts einer Programmquelle (Unit), ● Remanente und nicht remanente Unit-Variablen des Implementationsabschnitts einer Programmquelle (Unit), ● Statische Variablen von Funktionsbausteinen, deren Instanzen als Unit-Variablen deklariert sind. ● Außerdem, wenn die Programmquelle (Unit) mit der Compileroption (Seite 48) "Programminstanzdaten nur einmal anlegen" übersetzt wurde: – Statische Variablen der Programme. – Statische Variablen von Funktionsbausteinen, deren Instanzen als statische Variablen von Programmen deklariert sind. So gehen Sie vor: 1. Markieren Sie im Projektnavigator die Programmquelle. 2. Klicken Sie in der Detailanzeige auf das Register Symbolbrowser. Sie sehen im Symbol-Browser alle Variablen der Programmquelle, die sich im Anwenderspeicher der Unit oder im remanenten Speicher befinden: ● Alle Unit-Variablen der Programmquelle. ● Nur wenn die Programmquelle mit der Compileroption "Programminstanzdaten nur einmal anlegen" übersetzt wurde: Die Programme der Programmquelle und darunter deren statische Variablen (einschließlich Instanzen von Funktionbausteinen).
Variablen im Anwenderspeicher der Task Sie können im Symbol-Browser die Variablen beobachten, die sich im Anwenderspeicher der jeweiligen Task befinden: Wenn die Programmquelle (Unit) ohne die Compileroption (Seite 48) "Programminstanzdaten nur einmal anlegen" (Standard) übersetzt wurde, befinden sich folgende Variablen im Anwenderspeicher derjenigen Task, der das Programm zugeordnet wurde: ● Statische Variablen der Programme. ● Statische Variablen von Funktionsbausteinen, deren Instanzen als statische Variablen von Programmen deklariert sind. So gehen Sie vor: 1. Markieren Sie im Projektnavigator des SIMOTION SCOUT das Element ABLAUFSYSTEM im Teilbaum des SIMOTION Geräts. 2. Klicken Sie in der Detailanzeige auf das Register Symbolbrowser.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
265
Software-Debuggen/Fehlerbehandlung 7.2 Symbol-Browser Sie sehen im Symbol-Browser alle im Ablaufsystem verwendetetenTasks mit den zugeordneten Programmen. Darunter sind jeweils die Variablen aufgeführt, die sich im Anwenderspeicher der Task befinden. Hinweis Temporäre Variablen können Sie (zusammen mit Unit-Variablen und statischen Variablen) mit Status Programm (siehe Status Programm (Seite 272)) beobachten.
Systemvariablen und geräteglobale Anwendervariablen Sie können im Symbol-Browser auch folgende Variablen beobachten: ● Systemvariablen der SIMOTION Geräte ● Systemvariablen der Technologieobjekte ● I/O-Variablen ● Geräteglobale Variablen So gehen Sie vor: 1. Markieren Sie im Projektnavigator des SIMOTION SCOUT das entsprechende Element. 2. Klicken Sie in der Detailanzeige auf das Register Symbolbrowser. Sie sehen im Symbol-Browser die entsprechenden Variablen.
Status und Steuern von Variablen In der Spalte Statuswert wird der aktuelle Wert der Variablen angezeigt und periodisch aktualisiert. Sie können den Wert einer oder mehrerer Variablen ändern. Gehen Sie bei den zu ändernden Variablen wie folgt vor: 1. Geben Sie in der Spalte Steuerwert einen Wert ein. 2. Aktivieren Sie die Checkbox in dieser Spalte 3. Klicken Sie auf die Schaltfläche Steuern sofort. Die von Ihnen eingegebenen Werte werden in die ausgewählten Variablen geschrieben. ACHTUNG Beachten Sie, wenn Sie die Werte mehrerer Variablen ändern: Die Werte werden sequentiell in die Variablen geschrieben. Es können mehrere Millisekunden vergehen, bis der nächste Wert geschrieben wird. Die Änderung der Variablen erfolgt im Symbol-Browser von oben nach unten. Die Konsistenz ist deshalb nicht gewährleistet.
266
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.2 Symbol-Browser
Anzeige fixieren Sie können die Anzeige des Symbol-Browsers für das aktive Objekt fixieren: 1. Klicken Sie hierzu auf das Symbol für Anzeige beibehalten des Symbol-Browsers. Das angezeigte Symbol wechselt zu
in der rechten oberen Ecke .
Im Symbol-Browser werden weiterhin die Variablen dieses Objekts angezeigt und aktualisiert, auch wenn Sie im Projektnavigator ein anderes Objekt auswählen. 2. Um die Anzeige zu lösen, klicken Sie erneut auf das Symbol . wechselt wieder zu
. Das angezeigte Symbol
Anzeige ungültiger Gleitpunktzahlen Ungültige Gleitpunktzahlen werden im Symbol-Browser (unabhängig vom SIMOTION Gerät) wie folgt angezeigt: Tabelle 7- 3
Anzeige ungültiger Gleitpunktzahlen
Anzeige
Bedeutung
1.#QNAN -1.#QNAN
Ungültiges Bitmuster nach IEEE 754, (NaN – Not a Number). Zwischen signalisierenden NaN (NaNs) und stillen NAN (NaNq) wird nicht unterschieden.
1.#INF -1.#INF
Bitmuster für + Unendlich (+ infinity) nach IEEE 754 Bitmuster für – Unendlich (– infinity) nach IEEE 754
-1.#IND
Bitmuster für Unbestimmt (indeterminate)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
267
Software-Debuggen/Fehlerbehandlung 7.3 Watchtabelle
7.3
Watchtabelle
7.3.1
Variablen in Watchtabelle beobachten
Möglichkeiten der Watchtabelle Mit dem Symbolbrowser sehen Sie Variablen nur zu einem Objekt in Ihrem Projekt, mit dem Status Programm nur zu einem frei wählbaren Beobachtungsbereich im Programm. Mit Watchtabellen hingegen können Sie ausgewählte Variablen unterschiedlicher Herkunft (z. B. Programmquellen, Technologieobjekte, SINAMICS Antriebe - auch auf verschiedenen Geräten) als Gruppe beobachten. Im Offline-Modus können Sie den Datentyp der Variablen sehen. Im Online-Modus sehen Sie den Wert der Variablen und können ihn auch steuern.
Watchtabelle anlegen So legen Sie eine Watchtabelle an und ordnen ihr Variablen zu: 1. Öffnen Sie im Projektnavigator den Ordner Beobachten. 2. Doppelklicken Sie auf den Eintrag Watchtabelle einfügen, um eine Watchtabelle zu erzeugen, und geben Sie den Namen der Watchtabelle ein. Eine Watchtabelle mit diesem Namen wird im Ordner Beobachten angelegt. 3. Klicken Sie auf das Objekt im Projektnavigator, von dem Sie Variablen in die Watchtabelle verschieben möchten. 4. Wählen Sie im Symbol-Browser die entsprechende Variablenzeile aus, indem Sie in der linken Spalte auf deren Nummer klicken. 5. Wählen Sie im Kontextmenü den Eintrag In Watchtabelle aufnehmen und die entsprechende Watchtabelle, z. B. Watchtabelle_1. 6. Wenn Sie auf die Watchtabelle klicken, sehen Sie im Register Watchtabelle der Detailansicht, dass sich die ausgewählte Variable in der Watchtabelle befindet. 7. Wiederholen Sie die Schritte 3 bis 6, um Variablen verschiedener Objekte beobachten zu können. Wenn Sie mit dem Zielsystem verbunden sind, können Sie die Variableninhalte beobachten.
268
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.3 Watchtabelle
Status und Steuern von Variablen In der Spalte Statuswert wird der aktuelle Wert der Variablen angezeigt und periodisch aktualisiert. Sie können den Wert einer oder mehrerer Variablen ändern. Gehen Sie bei den zu ändernden Variablen wie folgt vor: 1. Geben Sie in der Spalte Steuerwert einen Wert ein. 2. Aktivieren Sie die Checkbox in dieser Spalte 3. Klicken Sie auf die Schaltfläche Steuern sofort. Die von Ihnen eingegebenen Werte werden in die ausgewählten Variablen geschrieben. ACHTUNG Beachten Sie, wenn Sie die Werte mehrerer Variablen ändern: Die Werte werden sequentiell in die Variablen geschrieben. Es können mehrere Millisekunden vergehen, bis der nächste Wert geschrieben wird. Die Änderung der Variablen erfolgt in der Watchtabelle von oben nach unten. Die Konsistenz ist deshalb nicht gewährleistet.
Anzeige der Watchtabelle fixieren Sie können die Anzeige der aktiven Watchtabelle fixieren: in der rechten oberen Ecke ● Klicken Sie hierzu auf das Symbol für Anzeige beibehalten des Registers Watchtabelle in der Detailanzeige. Das angezeigte Symbol wechselt . zu Es wird weiterhin diese Watchtabelle angezeigt, auch wenn Sie im Projektnavigator eine andere auswählen. ● Um die Anzeige zu lösen, klicken Sie erneut auf das Symbol . wechselt wieder zu
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
. Das angezeigte Symbol
269
Software-Debuggen/Fehlerbehandlung 7.4 Trace
7.4
Trace
Möglichkeiten von Trace Mit Trace können Sie Signalverläufe von Ein-/Ausgängen oder die Werte von Variablen aufzeichnen und speichern. Damit können Sie die Optimierung, beispielsweise von Achsen, dokumentieren. Sie können die Aufzeichnungsdauer einstellen, im Test- oder Debug-Betrieb bis vier Kanäle mit je 8 Werten anzeigen lassen, Triggerbedingungen wählen, zeitliche Verschiebungen parametrieren, zwischen verschiedenen Kurvendarstellungen und Skalierungen wählen usw. Weitere Informationen zum Trace-Tool finden Sie in der SIMOTION Online-Hilfe.
7.5
Programm-Durchlauf
7.5.1
Programm-Durchlauf: Anzeige von Codestelle und Aufrufpfad Sie können sich die Codestelle (z. B. Zeile einer ST-Quelle), die eine MotionTask aktuell durchläuft, sowie deren Aufrufpfad anzeigen lassen. So gehen Sie vor: 1. Klicken Sie in der Funktionsleiste Programm-Durchlauf auf die Schaltfläche "ProgrammDurchlauf anzeigen". Das Fenster "Callstack Programm-Durchlauf (Seite 271)" öffnet. 2. Wählen Sie die gewünschte MotionTask aus. 3. Klicken Sie auf die Schaltfläche "Aktualisieren". Im Fenster wird angezeigt: ● die zu diesem Zeitpunkt durchlaufene Codestelle (z. B. Zeile der ST-Quelle) mit Angabe der Programmquelle und der POE. ● rekursiv die Codestellen anderer POE, welche die durchlaufene Codestelle aufrufen. Für Programmquellen des SIMOTION RT werden nachstehende Namen angezeigt: Tabelle 7- 4
270
Programmquellen des SIMOTION RT
Name
Bedeutung
taskbind.hid
Ablaufsystem
stdfunc.pck
IEC-Bibliothek
device.pck
Gerätespezifische Bibliothek
tp-name.pck
Bibliothek des Technologiepakets tp-name, z. B. cam.pck für die Bibliothek des Technologiepakets CAM.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.5 Programm-Durchlauf
7.5.2
Parameter Callstack Programm-Durchlauf Sie können sich für alle konfigurierten Tasks anzeigen lassen: ● die aktuell durchlaufene Stelle im Programmcode (z. B. Zeile einer ST-Quelle) ● den Aufrufpfad dieser Codestelle Tabelle 7- 5
Parameterbeschreibung Callstack Programm-Durchlauf
Feld
Beschreibung
Selektierte CPU
Das ausgewählte SIMOTION Gerät wird angezeigt.
Aktualisieren
Durch Klicken auf die Schaltfläche werden die aktuellen Codestellen aus dem SIMOTION Gerät gelesen und im geöffneten Fenster angezeigt.
Aufrufende Task
Wählen Sie die Task aus, für die Sie die aktuell durchlaufene Codestelle ermitteln wollen. Zur Auswahl stehen alle konfigurierten Tasks des Ablaufsystems.
Aktuelle Codestelle
Die durchlaufene Stelle des Programmcodes (z. B. Zeile einer STQuelle) wird angezeigt (mit Name der Programmquelle, Zeilennummer, Name der POE).
wird aufgerufen von
Die Codestellen, welche die durchlaufene Codestelle innerhalb der ausgewählten Task aufrufen, werden rekursiv angezeigt (mit Name der Programmquelle, Zeilennummer, Name der POE, ggf. Name der Instanz eines Funktionsbausteins).
Für Namen der Programmquellen des SIMOTION RT siehe Tabelle in "Programm-Durchlauf (Seite 270)".
7.5.3
Funktionsleiste Programm-Durchlauf Mit dieser Funktionsleiste können Sie sich die Codestelle (z. B. Zeile einer ST-Quelle), die eine MotionTask aktuell durchläuft, sowie deren Aufrufpfad anzeigen lassen. Tabelle 7- 6 Symbol
Funktionsleiste Programm-Durchlauf Bedeutung Programm-Durchlauf anzeigen Klicken Sie auf dieses Symbol, um das Fenster "Callstack Programm-Durchlauf" zu öffnen. In diesem Fenster können Sie die gerade aktive Codestelle mit ihren Aufrufpfad anzeigen lassen Siehe: Programm-Durchlauf: Anzeige von Codestelle und Aufrufpfad (Seite 270)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
271
Software-Debuggen/Fehlerbehandlung 7.6 Status Programm (Programmablauf beobachten)
7.6
Status Programm (Programmablauf beobachten)
Programmablaufverfolgung Die Programmablaufverfolgung hat keinen Einfluss auf die Programmbearbeitung selbst, sie bewirkt jedoch eine höhere Kommunikationslast. Dies hat Einfluss auf die Bearbeitung der MotionTasks und der BackgroundTask. Status Programm kann während aller Betriebsarten eines SIMOTION Geräts zu- und abgeschaltet werden. Hinweis Im Prozessbetrieb können Sie Status Programm nur einmal für ein KOP/FUP-Programm, FB oder -FC aufrufen. Im Testbetrieb können Sie Status Programm maximal für vier KOP/FUP-Programme, -FB oder -FC aufrufen. Wenn Sie die Einschränkung nicht beachten, erscheint die Fehlermeldung 25023 "Keine Ressourcen im Run-Time".
7.6.1
Beobachten des Programmablaufs starten und stoppen
Status-Programm starten und stoppen Mit Status-Programm können Sie Informationen zum Status von Netzwerken auf zwei verschiedene Arten abrufen: ● Sie können gezielt die Netzwerke markieren, deren Status angezeigt werden soll. Mehrfachauswahl (Umschalttaste) und die Auswahl aller Netzwerke (Strg+a) ist möglich. Die Boxen werden in der Farbe des entsprechenden Ausgangs dargestellt. Gewählte Netzwerke sind am linken Rand blau markiert. ● Wenn Sie kein Netzwerk markieren, wird der Status für die Netzwerke angezeigt, die im sichtbaren Bereich des Bildschirms liegen. Wenn Sie weiterscrollen wird der Status für die jetzt sichtbaren Netzwerke angezeigt. So starten/stoppen Sie Status-Programm: 1. Stellen Sie sicher, dass beim Compilieren der KOP/FUP-Quelle der zusätzliche Debugcode erzeugt wird: Markieren Sie im Projektnavigator die KOP/FUP-Quelle und wählen Sie das Menü Bearbeiten > Objekteigenschaften. Wählen Sie das Register Compiler, markieren Sie die Checkbox Status Programm ermöglichen und bestätigen Sie mit OK. 2. Öffnen Sie die KOP/FUP-Quelle und übersetzen Sie diese neu mit KOP/FUP-Quelle > Speichern und Übersetzen. 3. Laden und starten Sie das Programm wie gewohnt. Achten Sie darauf, dass sich das Zielsystem im Betriebszustand STOP befindet.
272
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.6 Status Programm (Programmablauf beobachten) 4. Klicken Sie auf die Schaltfläche für Programm Status, um diesen Testmodus zu starten. 5. Um das Beobachten des Programmablaufs zu stoppen klicken Sie auf das Symbol Status Programm. Ist das Beobachten des Programmablaufs eingeschaltet, werden die Strompfade/Signalpfade der gerade ausgewählten bzw. der auf dem Bildschirm sichtbaren Netzwerke anhand der aktuellen Werte gefärbt:
①
Grün: 1, True
②
Grauer Hintergrund: nichtbinärer Wert
③
Rot: 0, False
Bild 7-1
Online-Anzeige im KOP/FUP-Editor
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
273
Software-Debuggen/Fehlerbehandlung 7.6 Status Programm (Programmablauf beobachten)
Hinweis Wenn eine Konstante in einem Netzwerk verwendet wird, wird der aktuelle Wert der Konstante auch im Programmablauf angezeigt. Eine Konstante, die nicht berücksichtigt wird, ist türkis eingefärbt. Die Beobachtung des Programmablaufs wird über das Symbol Status Programm gestartet. Wenn Sie mehrere Programme gleichzeitig mit dem Status Programm beobachten wollen, müssen folgende Bedingungen erfüllt sein: • Markieren Sie im Projektnavigator die gewünschte KOP/FUP-Quelle, wählen Sie im Kontextmenü den Befehl Eigenschaften und markieren Sie im Register Compiler die Checkbox Status Programm ermöglichen. • Markieren Sie im Projektnavigator das gewünschte SIMOTION Gerät, wählen Sie im Kontextmenü den Befehl Testbetrieb und aktivieren Sie die Option Testbetrieb.
274
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
7.7
Haltepunkte (WS)
7.7.1
Allgemeine Vorgehensweise zum Setzen von Haltepunkten Sie können innerhalb einer POE einer Programmquelle (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) Haltepunkte setzen. Bei Erreichen eines aktivierten Haltepunktes wird die Task, in der die POE mit dem Haltepunkt aufgerufen wird, angehalten. Wenn sich der Haltepunkt, der das Anhalten der Tasks ausgelöst hat, in einem Programm oder Funktionsbaustein befindet, werden die Werte der statischen Variablen dieser POE im Register "Status Variablen" der Detailanzeige angezeigt. Temporäre Variablen (auch Durchgangsparameter bei Funktionsbausteinen) werden nicht angezeigt. Statische Variablen anderer POE oder Unit-Variablen können Sie im Symbol-Browser beobachten.
Voraussetzung: ● Die Programmquelle mit der POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) ist geöffnet.
Vorgehensweise So gehen Sie vor: 1. Wählen Sie für das betreffende SIMOTION Gerät die Betriebsart "Debug-Modus", siehe Debug-Modus einstellen (Seite 276). 2. Legen Sie die Debug-Taskgruppe fest, siehe Debug-Taskgruppe festlegen (Seite 277). 3. Setzen Sie Haltepunkte, siehe Haltepunkte setzen (Seite 279). 4. Legen Sie den Aufrufpfad fest, siehe Aufrufpfad für einen einzelnen Haltepunkt festlegen (Seite 282). 5. Aktivieren Sie die Haltepunkte, siehe Haltepunkte aktivieren (Seite 286).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
275
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
7.7.2
Debug-Modus einstellen WARNUNG Beachten Sie unbedingt die einschlägigen Sicherheitsvorschriften. Verwenden Sie den Debug-Modus nur mit aktivierter Lebenszeichenüberwachung (Seite 261) mit einer angemessen kurzen Überwachungszeit! Bei Problemen mit der Kommunikation zwischen PC und dem SIMOTION Gerät kann es sonst zu unkontrollierbaren Achsbewegungen kommen. Die Funktion ist ausschließlich zu Inbetriebnahme-, Diagnose- und Servicezwecken freigegeben. Die Funktion ist generell nur von befugtem Fachpersonal zu benutzen. Die Sicherheitsabschaltungen der übergeordneten Steuerung sind unwirksam! Deshalb ist auf eine hardwaremäßige Ausführung des NOT-AUS-Kreises zu achten. Hierzu sind vom Anwender die erforderlichen Maßnahmen zu treffen. So stellen Sie den Debug-Modus ein: 1. Markieren Sie im Projektnavigator das SIMOTION Gerät. 2. Wählen Sie das Kontextmenü Testbetrieb. 3. Wählen Sie die Betriebsart (Seite 259) Debug-Modus. 4. Akzeptieren Sie die Sicherheitshinweise 5. Parametrieren Sie die Lebenszeichenüberwachung. Beachten Sie den Abschnitt: Wichtige Hinweise zur Lebenszeichenüberwachung (Seite 261). 6. Bestätigen Sie mit OK. Wenn keine Verbindung zum Zielsystem besteht (Offline-Modus), wird der Online-Modus automatisch hergestellt. Der aktivierte Debug-Modus wird in der Statuszeile angezeigt. Die Funktionsleiste Haltepunkte (Seite 281) wird eingeblendet. Hinweis Im Debug-Modus können Sie Programmquellen nicht ändern! ACHTUNG Das Drücken der Leertaste oder der Wechsel in eine andere Windows-Anwendung bewirken im Debug-Modus bei aktivierten Haltepunkten: • Das SIMOTION Gerät geht in den Betriebszustand STOP. • Die Ausgänge werden deaktiviert (ODIS).
276
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
WARNUNG Diese Funktion wird nicht in allen Betriebszuständen garantiert. Deshalb ist auf eine hardwaremäßige Ausführung des NOT-AUS-Kreises zu achten. Hierzu sind vom Anwender die erforderlichen Maßnahmen zu treffen.
7.7.3
Debug-Taskgruppe festlegen Bei Erreichen eines aktivierten Haltepunktes werden alle Tasks angehalten, die der DebugTaskgruppe zugeordnet sind.
Voraussetzung ● Das betreffende SIMOTION Gerät befindet sich im Debug-Modus.
Vorgehensweise So ordnen Sie eine Task der Debug-Taskgruppe zu: 1. Markieren Sie im Projektnavigator das betreffende SIMOTION Gerät. 2. Wählen Sie Kontextmenü Debug-Taskgruppe. Das Fenster Debug-Taskgruppe öffnet. 3. Wählen Sie die Tasks aus, die bei Erreichen eines Haltepunktes angehalten werden sollen: – Wenn Sie nur einzelne Tasks anhalten wollen (im Betriebszustand RUN): Aktivieren Sie die Auswahlmöglichkeit Debug-Taskgruppe. Ordnen Sie alle Tasks, die bei Erreichen eines Haltepunktes angehalten werden sollen, der Liste Anzuhaltende Tasks zu. – Wenn Sie alle Anwender-Tasks anhalten wollen (über Betriebszustand HALT): Aktivieren Sie die Auswahlmöglichkeit Alle Tasks. Wählen Sie in diesem Fall auch, ob nach dem Fortsetzen der Programmbearbeitung die Ausgänge und Technologieobjekte wieder freigegeben werden sollen. ACHTUNG Beachten Sie das unterschiedliche Verhalten bei Erreichen eines aktivierten Haltepunkts, siehe nachfolgende Tabelle
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
277
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS) Tabelle 7- 7
Verhalten am Haltepunkt in Abhängigkeit von den anzuhaltenden Tasks in der Debug-Taskgruppe Eigenschaft
Anzuhaltende Tasks Einzelne ausgewählte Tasks (Debug-Taskgruppe)
Alle Tasks
Verhalten bei Erreichen des Haltepunkts Betriebszustand
RUN
HALT
Angehaltene Tasks
Nur Tasks in der Debug-Taskgruppe
Alle Tasks
Ausgänge
Aktiv
Abgeschaltet (ODIS aktiviert)
Technologie
Regelung aktiv
Keine Regelung (ODIS aktiviert)
Laufzeitmessung der Tasks
Aktiv für alle Tasks
Abgeschaltet für alle Task
Zeitüberwachung der Tasks
Abgeschaltet für Tasks in der DebugTaskgruppe
Abgeschaltet für alle Tasks
Echtzeituhr
Läuft weiter
Läuft weiter
Verhalten beim Fortsetzen der Programmbearbeitung Betriebszustand
RUN
RUN
Gestartete Tasks
Alle Tasks in der Debug-Taskgruppe
Alle Tasks
Ausgänge
Aktiv
Technologie
Regelung aktiv
Das Verhalten der Ausgänge und Technologieobjekte ist abhängig von der Checkbox Mit ’Fortsetzen’ werden die Ausgänge aktiviert (ODIS deaktiviert). • Aktiv: ODIS wird deaktiviert. Alle Ausgänge und Technologieobjekte werden freigegeben. • Inaktiv: ODIS bleibt aktiviert. Alle Ausgänge und Technologieobjekte werden nur durch einen erneuten Download des Projekts freigegeben.
Hinweis Änderungen an der Debug-Taskgruppe können Sie nur vornehmen, wenn keine Haltepunkte aktiviert sind.
Weiteres Vorgehen: 1. Setzen Sie Haltepunkte (siehe Haltepunkte setzen (Seite 279)). 2. Legen Sie den Aufrufpfad fest (siehe Aufrufpfad für einen einzelnen Haltepunkt festlegen (Seite 282)). 3. Aktivieren Sie die Haltepunkte (siehe Haltepunkte aktivieren (Seite 286)).
278
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
7.7.4
Haltepunkte setzen
Voraussetzungen: 1. Die Programmquelle mit der POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) ist geöffnet. 2. Das betreffende SIMOTION Gerät befindet sich in der Betriebsart "Debug-Modus", siehe Debug-Modus einstellen (Seite 276). 3. Die Debug-Taskgruppe ist festgelegt, siehe Debug-Taskgruppe festlegen (Seite 277).
Vorgehensweise So setzen Sie einen Haltepunkt: 1. Wählen Sie eine Codestelle aus, an der kein Haltepunkt gesetzt ist: – SIMOTION ST: Setzen Sie in der ST-Quelle den Cursor in eine Zeile, die eine Anweisung enthält. – SIMOTION MCC: Markieren Sie im MCC-Chart einen MCC-Befehl (außer Modul oder Kommentarblock). – SIMOTION KOP/FUP: Setzen Sie den Cursor in ein Netzwerk des KOP/FUPProgramms 2. Alternativ: – Wählen Sie Menü Debug > Haltepunkt setzen / entfernen (Tastenkürzel F9). – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
.
So entfernen Sie einen Haltepunkt: 1. Wählen Sie die Codestelle mit dem Haltepunkt aus. 2. Alternativ: – Wählen Sie Menü Debug > Haltepunkt setzen / entfernen (Tastenkürzel F9). – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
.
So entfernen Sie alle Haltepunkte (in allen Programmquellen) des SIMOTION Geräts: ● Alternativ: – Wählen Sie Menü Debug > Alle Haltepunkte entfernen (Tastenkürzel STRG+F5). – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
.
279
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
Hinweis Haltepunkte können Sie nicht setzen: • Bei SIMOTION ST: in Zeilen, die ausschließlich Kommentar enthalten. • Bei SIMOTION MCC: auf die Befehle Modul oder Kommentarblock. • Bei SIMOTION KOP/FUP: innerhalb eines Netzwerks. • An Codestellen, in denen bereits weitere Debug-Punkte (z. B. Triggerpunkte) gesetzt sind. Die Debug-Punkte in allen Programmquellen des SIMOTION Geräts können Sie in der Debug-Tabelle auflisten: • Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche Tabelle".
für "Debug-
In der Debug-Tabelle können Sie auch alle Haltepunkte (in allen Programmquellen) des SIMOTION Geräts entfernen: • Klicken Sie in der auf die Schaltfläche für "Alle Haltepunkte löschen". Gesetzte Haltepunkte bleiben auch nach Verlassen der Betriebsart "Debug-Modus" gespeichert, sie werden nur im Debug-Modus angezeigt. Sie können die Diagnosefunktionen Status Programm (Seite 272) und Haltepunkte gemeinsam in einer Programmquelle bzw. POE verwenden. Es gelten jedoch folgende Einschränkungen in Abhängigkeit von den Programmiersprachen: ● SIMOTION ST: Bei Version V3.2 des SIMOTION Kernels dürfen die mit Status Programm zu testenden (markierten) Zeilen der ST-Quelle keinen Haltepunkt enthalten. ● SIMOTION MCC und KOP/FUP: Die mit Status Programm zu testenden Befehle des MCC-Charts (bzw. Netzwerke des KOP/FUP-Programms) dürfen keinen Haltepunkt enthalten.
Weiteres Vorgehen 1. Legen Sie den Aufrufpfad fest, siehe Aufrufpfad für einen einzelnen Haltepunkt festlegen (Seite 282). 2. Aktivieren Sie die Haltepunkte, siehe Haltepunkte aktivieren (Seite 286).
280
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
7.7.5
Funktionsleiste Haltepunkte Diese Funktionsleiste enthält wichtige Bedienhandlungen zum Setzen und Aktivieren von Haltepunkten: Tabelle 7- 8 Symbol
Funktionsleiste Haltepunkte Bedeutung Haltepunkt setzen / entfernen Klicken Sie auf dieses Symbol, um an der ausgewählten Codestelle einen Haltepunkt zu setzen bzw. einen vorhandenen Haltepunkt zu entfernen. Siehe: Haltepunkte setzen (Seite 279). Haltepunkt aktivieren / deaktivieren Klicken Sie auf dieses Symbol, um den Haltepunkt an der ausgewählten Codestelle zu aktivieren bzw. zu deaktivieren. Siehe: Haltepunkte aktivieren (Seite 286). Aufrufpfad bearbeiten Klicken Sie auf dieses Symbol, um den Aufrufpfad für Haltepunkte festzulegen: • Wenn eine Codestelle mit Haltepunkt ausgewählt ist: den Aufrufpfad für diesen Haltepunkt. • Wenn eine Codestelle ohne Haltepunkt ausgewählt wird, den Aufrufpfad für alle Haltepunkte der POE. Siehe: Aufrufpfad für einen einzelnen Haltepunkt festlegen (Seite 282), Aufrufpfad für alle Haltepunkte festlegen (Seite 284). Alle Haltepunkte aktivieren Klicken Sie auf dieses Symbol, um in der aktuellen Programmquelle bzw. POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) alle Haltepunkte zu aktivieren. Siehe: Haltepunkte aktivieren (Seite 286). Alle Haltepunkte deaktivieren Klicken Sie auf dieses Symbol, um in der aktuellen Programmquelle bzw. POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) alle Haltepunkte zu deaktivieren. Siehe: Haltepunkte aktivieren (Seite 286). Alle Haltepunkte entfernen Klicken Sie auf dieses Symbol, um in der aktuellen Programmquelle bzw. POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) alle Haltepunkte zu entfernen. Siehe: Haltepunkte setzen (Seite 279). Debug-Tabelle Klicken Sie auf dieses Symbol, um die Debug-Tabelle anzuzeigen. Siehe: Parameter Debug-Tabelle.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
281
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS) Symbol
Bedeutung Call Stack anzeigen Klicken Sie auf dieses Symbol, um nach Erreichen eines aktivierten Haltepunktes: • den Aufrufpfad am aktuellen Haltepunkt ansehen, • die Codestellen ansehen, an denen die anderen Tasks der Debug-Taskgruppe angehalten wurden, sowie deren Aufrufpfad. Siehe: Call-Stack anzeigen (Seite 289). Fortsetzen Klicken Sie auf dieses Symbol, um nach Erreichen eines aktivierten Haltepunktes den Programmablauf fortzusetzen. Siehe: Haltepunkte aktivieren (Seite 286), Call-Stack anzeigen (Seite 289).
7.7.6
Aufrufpfad für einen einzelnen Haltepunkt festlegen
Voraussetzungen: 1. Die Programmquelle mit der POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) ist geöffnet. 2. Das betreffende SIMOTION Gerät befindet sich in der Betriebsart "Debug-Modus", siehe Debug-Modus einstellen (Seite 276). 3. Die Debug-Taskgruppe ist festgelegt, siehe Debug-Taskgruppe festlegen (Seite 277). 4. Haltepunkt ist gesetzt, siehe Haltepunkte setzen (Seite 279).
Vorgehensweise So legen Sie den Aufrufpfad für einen einzelnen Haltepunkt fest: 1. Wählen Sie eine Codestelle aus, an der bereits ein Haltepunkt gesetzt ist: – SIMOTION ST: Setzen Sie den Cursor in eine entsprechende Zeile der ST-Quelle. – SIMOTION MCC: Markieren Sie einen entsprechenden Befehl im MCC-Chart. – SIMOTION KOP/FUP: Setzen Sie den Cursor in ein entsprechendes Netzwerk des KOP/FUP-Programms. 2. Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche bearbeiten".
für "Aufrufpfad
Im Fenster "Aufrufpfad/Taskauswahl Haltepunkt" wird die markierte Codestelle angezeigt (mit Name der Programmquelle, Zeilennummer, Name der POE).
282
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS) 3. Wählen Sie die Task aus, in der das Anwenderprogramm (d. h. alle Tasks in der DebugTaskgruppe) angehalten wird, wenn der ausgewählte Haltepunkt erreicht wird. Zur Auswahl stehen: – alle Aufrufstellen ab dieser Aufrufebene Das Anwenderprogramm wird immer angehalten, wenn der aktivierte Haltepunkt in einer beliebigen Task der Debug-Taskgruppe erreicht wird. – die einzelnen Tasks, von denen der ausgewählte Haltepunkt erreicht werden kann. Das Anwenderprogramm wird nur dann angehalten, wenn der Haltepunkt in der ausgewählten Task erreicht wird. Die Task muss sich in der Debug-Taskgruppe befinden. Die Angabe eines Aufrufpfads ist möglich. 4. Nur bei Funktionen und Funktionsbausteinen: Wählen Sie den Aufrufpfad aus, d. h. die aufrufende Codestelle (in der aufrufenden POE). Zur Auswahl stehen: – alle Aufrufstellen ab dieser Aufrufebene Es wird kein Aufrufpfad angegeben. Das Anwenderprogramm wird immer am aktivierten Haltepunkt angehalten, wenn die POE in den ausgewählten Tasks aufgerufen wird. – Nur wenn eine einzelne Task ausgewählt ist: die aufrufenden Codestellen innerhalb der ausgewählten Task (mit Name der Programmquelle, Zeilennummer, Name der POE). Der Aufrufpfad wird angegeben. Das Anwenderprogramm wird nur dann am aktivierten Haltepunkt angehalten, wenn die POE von der ausgewählten Codestelle aufgerufen wird. Wenn die POE der ausgewählten aufrufenden Codestelle wiederum von anderen Codestellen aufgerufen wird, werden sukzessive weitere Zeilen eingeblendet, in denen Sie ähnlich vorgehen. 5. Wenn der Haltepunkt erst nach mehrmaligem Erreichen der Codestelle aktiviert werden soll, wählen Sie die entsprechende Anzahl. Hinweis Den Aufrufpfad zu den einzelnen Haltepunkten können Sie auch in der Debug-Tabelle festlegen: für "Debug1. Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche Tabelle". Das Fenster "Debug-Tabelle" öffnet. 2. Klicken Sie auf die entsprechende Schaltfläche in der Spalte "Aufrufpfad". 3. Gehen Sie weiter wie oben beschrieben vor: – Legen Sie die Task fest – Legen Sie den Aufrufpfad fest (nur bei Funktionen und Funktionsbausteinen) – Legen Sie die Anzahl der Durchläufe fest, nach denen der Haltepunkt aktiviert werden soll.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
283
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
Weiteres Vorgehen: ● Aktivieren Sie die Haltepunkte, siehe Haltepunkte aktivieren (Seite 286). Hinweis Den Aufrufpfad an einem aktuellen Haltepunkt sowie die Codestellen, an denen die anderen Tasks der Debug-Taskgruppe angehalten wurden, können Sie mit der Funktion "Call Stack anzeigen (Seite 289)" einsehen.
Siehe auch Aufrufpfad für alle Haltepunkte festlegen (Seite 284)
7.7.7
Aufrufpfad für alle Haltepunkte festlegen Mit diesem Vorgehen können Sie: ● für alle zukünftigen Haltepunkte in einer POE (z. B. MCC-Chart, KOP/FUP-Programm oder POE in einer ST-Quelle) eine Defaulteinstellung wählen. ● für alle bisher gesetzten Haltepunkte in dieser POE den Aufrufpfad übernehmen und angleichen.
Voraussetzungen ● Die Programmquelle mit der POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) ist geöffnet. ● Das betreffende SIMOTION Gerät befindet sich in der Betriebsart "Debug-Modus", siehe Debug-Modus einstellen (Seite 276). ● Die Debug-Taskgruppe ist festgelegt, siehe Debug-Taskgruppe festlegen (Seite 277).
Vorgehensweise So legen Sie den Aufrufpfad für alle zukünftigen Haltepunkte in einer POE fest: 1. Wählen Sie eine Codestelle aus, an der kein Haltepunkt gesetzt ist: – SIMOTION ST: Setzen Sie den Cursor in eine entsprechende Zeile der ST-Quelle. – SIMOTION MCC: Markieren Sie einen entsprechenden Befehl im MCC-Chart. – SIMOTION KOP/FUP: Setzen Sie den Cursor in ein entsprechendes Netzwerk des KOP/FUP-Programms 2. Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche "Aufrufpfad bearbeiten".
für
Im Fenster "Aufrufpfad/Taskauswahl alle Haltepunkte je POE" wird die markierte Codestelle angezeigt (mit Name der Programmquelle, Zeilennummer, Name der POE.
284
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS) 3. Wählen Sie die Task aus, in der das Anwenderprogramm (d. h. alle Tasks in der DebugTaskgruppe) angehalten wird, wenn ein Haltepunkt in dieser POE erreicht wird. Zur Auswahl stehen: – alle Aufrufstellen ab dieser Aufrufebene Das Anwenderprogramm wird immer angehalten, wenn ein aktivierter Haltepunkt der POE in einer beliebigen Task der Debug-Taskgruppe erreicht wird. – die einzelnen Tasks, von denen der ausgewählte Haltepunkt erreicht werden kann. Das Anwenderprogramm wird nur dann angehalten, wenn ein Haltepunkt in der ausgewählten Task erreicht wird. Die Task muss sich in der Debug-Taskgruppe befinden. Die Angabe eines Aufrufpfads ist möglich. 4. Nur bei Funktionen und Funktionsbausteinen: Wählen Sie den Aufrufpfad aus, d. h. die aufrufende Codestelle (in der aufrufenden POE). Zur Auswahl stehen: – alle Aufrufstellen ab dieser Aufrufebene Es wird kein Aufrufpfad angegeben. Das Anwenderprogramm wird immer an einem aktivierten Haltepunkt angehalten, wenn die POE in den ausgewählten Tasks aufgerufen wird. – Nur wenn eine einzelne Task ausgewählt ist: die aufrufenden Codestellen innerhalb der ausgewählten Task (mit Name der Programmquelle, Zeilennummer, Name der POE). Der Aufrufpfad wird angegeben. Das Anwenderprogramm wird nur dann an einem aktivierten Haltepunkt angehalten, wenn die POE von der ausgewählten Codestelle aufgerufen wird. Wenn die ausgewählte aufrufende Codestelle wiederum von anderen Codestellen aufgerufen wird, werden sukzessive weitere Zeilen eingeblendet, in denen Sie ähnlich vorgehen. 5. Wenn ein Haltepunkt erst nach mehrmaligem Erreichen der Codestelle aktiviert werden soll, wählen Sie die entsprechende Anzahl der Durchläufe. 6. Wenn Sie diesen Aufrufpfad für alle bisher gesetzten Haltepunkte in dieser POE übernehmen und angleichen wollen: – Klicken Sie auf Übernehmen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
285
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
Weiteres Vorgehen: ● Aktivieren Sie die Haltepunkte, siehe Haltepunkte aktivieren (Seite 286). Hinweis Den Aufrufpfad an einem aktuellen Haltepunkt sowie die Codestellen, an denen die anderen Tasks der Debug-Taskgruppe angehalten wurden, können Sie mit der Funktion "Call Stack anzeigen (Seite 289)" einsehen.
Siehe auch Aufrufpfad für einen einzelnen Haltepunkt festlegen (Seite 282)
7.7.8
Haltepunkte aktivieren Sie müssen die Haltepunkte aktivieren, damit sie auf den Programmablauf wirken.
Voraussetzungen 1. Die Programmquelle mit der POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) ist geöffnet. 2. Das betreffende SIMOTION Gerät befindet sich in der Betriebsart "Debug-Modus", siehe Debug-Modus einstellen (Seite 276). 3. Die Debug-Taskgruppe ist festgelegt, siehe Debug-Taskgruppe festlegen (Seite 277). 4. Haltepunkte sind gesetzt, siehe Haltepunkte setzen (Seite 279). 5. Aufrufpfade sind festgelegt, siehe Aufrufpfad für einen einzelnen Haltepunkt festlegen (Seite 282).
286
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
Haltepunkte aktivieren So aktivieren Sie einen einzelnen Haltepunkt: 1. Wählen Sie eine Codestelle aus, an der bereits ein Haltepunkt gesetzt ist: – SIMOTION ST: Setzen Sie den Cursor in eine entsprechende Zeile der ST-Quelle. – SIMOTION MCC: Markieren Sie einen entsprechenden Befehl im MCC-Chart. – SIMOTION KOP/FUP: Setzen Sie den Cursor in ein entsprechendes Netzwerk des KOP/FUP-Programms. 2. Alternativ: – Wählen Sie Menü Debug > Haltepunkt aktivieren / deaktivieren (Tastenkürzel F12). – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
.
So aktivieren Sie alle Haltepunkte (in allen Programmquellen) des SIMOTION Geräts: ● Alternativ: – Wählen Sie Menü Debug > Alle Haltepunkte aktivieren. – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
.
Hinweis Haltepunkte aller Programmquellen des SIMOTION Geräts können Sie in der Debug-Tabelle aktivieren und deaktivieren: für "Debug1. Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche Tabelle". Das Fenster "Debug-Tabelle" öffnet. 2. Führen Sie nachstehende Aktion aus, abhängig davon, welche Haltepunkte Sie aktivieren oder deaktivieren wollen: – Einzelne Haltepunkte: Aktivieren oder deaktivieren Sie die entsprechende Checkbox. – Alle Haltepunkte (in allen Programmquellen): Klicken Sie auf die entsprechende Schaltfläche.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
287
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
Verhalten am aktivierten Haltepunkt Bei Erreichen eines aktivierten Haltepunkts (gegebenenfalls über den ausgewählten Aufrufpfad (Seite 282)) werden die Tasks angehalten, die der Debug-Taskgruppe zugeordnet sind. Das Verhalten ist abhängig von den Tasks in der Debug-Taskgruppe und ist in "Debug-Taskgruppe festlegen (Seite 277)" beschrieben. Der Haltepunkt wird besonders markiert. Wenn sich der Haltepunkt, der das Anhalten der Tasks ausgelöst hat, in einem Programm oder Funktionsbaustein befindet, werden die Werte der statischen Variablen dieser POE im Register "Status Variablen" der Detailanzeige angezeigt. Temporäre Variablen (auch Durchgangsparameter bei Funktionsbausteinen) werden nicht angezeigt. Statische Variablen anderer POE oder Unit-Variablen können Sie im Symbol-Browser (Seite 264) beobachten. Mit der Funktion "Call-Stack anzeigen (Seite 289)" können Sie: ● den Aufrufpfad am aktuellen Haltepunkt ansehen, ● die Codestellen mit Aufrufpfad ansehen, an denen die anderen Tasks der DebugTaskgruppe angehalten wurden.
Programmablauf fortsetzen So setzen Sie den Programmablauf wieder fort: ● Alternativ: – Wählen Sie Menü Debug > Fortsetzen (Tastenkürzel STRG+F8). für
– Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche "Fortsetzen".
Haltepunkte deaktivieren So deaktivieren Sie einen einzelnen Haltepunkt: 1. Wählen Sie die Codestelle mit dem aktivierten Haltepunkt aus. 2. Alternativ: – Wählen Sie Menü Debug > Haltepunkt aktivieren / deaktivieren (Tastenkürzel F12). – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
.
So deaktivieren Sie alle Haltepunkte (in allen Programmquellen) des SIMOTION Geräts: ● Alternativ: – Wählen Sie Menü Debug > Alle Haltepunkte deaktivieren. – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche
288
.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Software-Debuggen/Fehlerbehandlung 7.7 Haltepunkte (WS)
7.7.9
Call-Stack anzeigen Mit der Funktion "Call-Stack anzeigen" können Sie: ● den Aufrufpfad am aktuellen Haltepunkt ansehen, ● die Codestellen mit Aufrufpfad ansehen, an denen die anderen Tasks der DebugTaskgruppe angehalten wurden.
Voraussetzung Das Anwenderprogramm steht an einem aktivierten Haltepunkt, d. h. die Tasks der DebugTaskgruppe (Seite 277) sind angehalten.
Vorgehensweise So rufen Sie die Funktion "Call-Stack anzeigen" auf: ● Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche "Call-Stack anzeigen".
für
Es öffnet sich das Dialogfenster "Call-Stack Haltepunkt". Der aktuelle Aufrufpfad (einschließlich der aufrufenden Task und Anzahl der eingestellten Durchläufe) wird angezeigt. Der Aufrufpfad kann nicht verändert werden. So wenden Sie die Funktion "Call-Stack anzeigen" an: 1. Lassen Sie das Dialogfenster "Call-Stack Haltepunkt" weiter geöffnet. 2. So zeigen Sie die Codestelle an, bei der eine andere Task angehalten wurde: – Wählen Sie die entsprechende Task. Zur Auswahl stehen alle Tasks der DebugTaskgruppe. Die Codestelle einschließlich Aufrufpfad wird angezeigt. Falls die Codestelle in einem Anwenderprogramm enthalten ist, wird die betreffende Programmquelle mit der POE (z. B. ST-Quelle, MCC-Chart, KOP/FUP-Programm) geöffnet und die Codestelle markiert. 3. So setzen Sie den Programmablauf wieder fort: – Klicken Sie in der Funktionsleiste Haltepunkte auf die Schaltfläche (Tastenkürzel Strg+F8).
für "Fortsetzen"
Beim Erreichen des nächsten aktivierten Haltepunkts werden die Tasks der DebugTaskgruppe erneut angehalten. Der aktuelle Aufrufpfad einschließlich der aufrufenden Task wird angezeigt. 4. Das Dialogfenster "Call-Stack Haltepunkt" schließen Sie mit "OK". Für Namen der Programmquellen des SIMOTION RT siehe Tabelle in "Programm-Durchlauf (Seite 270)".
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
289
Anwendungsbeispiele 8.1
8
Beispiele Anhand von zwei einfachen Beispielen werden Sie in die Programmiersprachen KOP und FUP eingeführt.
8.2
Beispielprogramme erstellen
Voraussetzungen für die Programmerstellung Das Projekt ist die oberste Hierarchiestufe der Datenverwaltung. Alle Daten, die z. B. zu einer Produktionsmaschine gehören, legt SIMOTION SCOUT in dem zum Projekt gehörenden Verzeichnis ab. Das Projekt bildet somit die Klammer für alle SIMOTION Geräte, Antriebe usw., die zu einer Maschine gehören. Innerhalb des Projekts muss die verwendete Hardware dem System bekannt gemacht werden. u. a.: ● SIMOTION Gerät ● zentrale Peripherie (mit I/O-Adressen) ● dezentrale Peripherie (mit I/O-Adressen) Erst nach Konfiguration eines SIMOTION Geräts können Sie KOP/FUP-Quellen einfügen und bearbeiten.
Beispielprogramme Wir erstellen zwei kurze Programme (Programm Blinker, Programm Achse positionieren), die Ihnen beispielhaft alle Arbeitsschritte von der Erstellung bis zum Starten und Testen eines Programms aufzeigen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
291
Anwendungsbeispiele 8.3 Programm Blinker
8.3
Programm Blinker
Voraussetzungen Ein Projekt muss angelegt und innerhalb des Projekts muss die verwendete Hardware dem System bekannt sein.
Aufgabenstellung Ausgabe eines sich zyklisch ändernden Bitmusters nach Überschreiten eines Grenzwerts. Diese Aufgabenstellung gliedert sich in folgende Teilaufgaben: ● KOP/FUP-Quelle einfügen ● KOP/FUP-Programm einfügen erstes Netzwerk Hochzählen einer Programmvariable und Vergleichen mit einem Referenzwert zweites Netzwerk Nach Überschreiten des Referenzwerts wird die Programmvariable zurückgesetzt und ein Bitmuster ausgegeben ● Übersetzen ● Programm in eine Task einfügen ● Programm ins Zielgerät laden Das Ergebnis des Programms sehen Sie an den Ausgängen Ihres Zielsystems. Es wird hier die KOP-Programmierung betrachtet.
292
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
8.3.1
KOP/FUP-Quelle einfügen So fügen Sie eine KOP/FUP-Quelle über das Kontextmenü ein: 1. Markieren Sie im Projektnavigator den Ordner PROGRAMME des entsprechenden SIMOTION Geräts. 2. Doppelklicken Sie auf den Eintrag KOP/FUP-Quelle einfügen.
Bild 8-1
Projekt-Ordner
Es öffnet sich das Dialogfenster KOP/FUP-Quelle einfügen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
293
Anwendungsbeispiele 8.3 Programm Blinker
Bild 8-2
Dialogfenster KOP/FUP-Quelle einfügen
3. Geben Sie den Namen der KOP/FUP-Quelle ein. Namen für Programmquellen müssen den Regeln für Bezeichner genügen: Sie sind aus Buchstaben (A … Z, a … z), Ziffern (0 … 9) oder einzelnen Unterstrichen (_) in beliebiger Reihenfolge zusammengesetzt, wobei das erste Zeichen ein Buchstabe oder ein Unterstrich sein muss. Zwischen Groß- und Kleinbuchstaben wird nicht unterschieden. Die zulässige Länge der Namen ist abhängig von der Version des SIMOTION Kernels: – Ab Version V4.1 des SIMOTION Kernels: maximal 128 Zeichen. – Bis Version V4.0 des SIMOTION Kernels: maximal 8 Zeichen. Namen müssen innerhalb des SIMOTION Geräts eindeutig sein. Geschützte oder reservierte Bezeichner (Seite 333) sind nicht erlaubt. Bisher vorhandene KOP/FUPProgramme werden angezeigt. 4. Markieren Sie im Register Compiler die Checkbox Status Programm ermöglichen, um später die Online-Statusanzeige benutzen zu können. 5. Zusätzlich können Sie Autor, Version und einen Kommentar eingeben.
294
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker 6. Markieren Sie die Checkbox Editor automatisch öffnen. 7. Bestätigen Sie mit OK. Im Arbeitsbereich erscheinen die Deklarationstabellen für exportierte und quellinterne Variablen. Im Beispielprogramm werden hier keine Variablen definiert.
Bild 8-3
Deklarationstabellen für exportierte und quellinterne Deklarationen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
295
Anwendungsbeispiele 8.3 Programm Blinker
8.3.2
KOP/FUP-Programm einfügen So fügen Sie ein KOP/FUP-Programm ein: 1. Öffnen Sie im Projektnavigator im Ordner PROGRAMME die neu eingefügte KOP/FUPQuelle. 2. Doppelklicken Sie in der KOP/FUP-Quelle auf den Eintrag KOP/FUP-Programm einfügen.
Bild 8-4
Projekt-Ordner öffnen
Es öffnet sich das Dialogfenster KOP/FUP-Programm einfügen.
296
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
Bild 8-5
Dialogfenster KOP/FUP-Programm einfügen
Tragen Sie im Dialogfenster KOP/FUP-Programm einfügen den Namen des Programms ein. Die Namen müssen innerhalb einer Quelle eindeutig sein. Geschütze oder reservierte Bezeichner (Seite 333) sind nicht erlaubt. Es werden angezeigt: – alle POEs der eigenen Programmquelle – die exportierbaren POEs (z. B. KOP/FUP-Programme, MCC-Charts) anderer Programmquellen 3. Wählen Sie als Erstelltyp Programm. 4. Aktivieren Sie gg. Exportierbar, wenn das KOP/FUP-Programm auch in anderen Programmquellen (KOP/FUP-, MCC- oder ST-Quellen) oder im Ablaufsystem verfügbar sein soll.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
297
Anwendungsbeispiele 8.3 Programm Blinker 5. Markieren Sie die Checkbox Editor automatisch öffnen. 6. Bestätigen Sie mit OK. Ein leeres KOP/FUP-Programm wird geöffnet.
Bild 8-6
298
Geöffnetes KOP/FUP-Programm
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
8.3.3
Variablen in die Deklarationstabelle eintragen So tragen Sie Variablen ein: 1. Wählen Sie das Register Parameter / Variablen. 2. Geben Sie Name, Variablentyp, Datentyp bzw. Anfangswert (entsprechend der nachfolgenden Abbildung) in die Deklarationstabelle ein.
Bild 8-7
Variablen in der Deklarationstabelle
3. Wählen Sie das Register I/O-Symbole. 4. Geben Sie Name und Absolutbezeichner (entsprechend der nachfolgenden Abbildung) ein. Der Datentyp wird automatisch eingetragen.
Bild 8-8
8.3.4
I/O-Symbole in der Deklarationstabelle
Programmtitel eingeben So geben Sie den Programmtitel ein: 1. Klicken Sie in die Titelzeile. 2. Geben Sie den Namen des Programms in das aufgeblendete Fenster ein.
Bild 8-9
Programmtitel
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
299
Anwendungsbeispiele 8.3 Programm Blinker
8.3.5
Netzwerk einfügen So fügen Sie ein Netzwerk ein: 1. Wählen Sie den Menüpunkt KOP/FUP-Programm > Netzwerk einfügen.
Bild 8-10
Menüauswahl
2. Klicken Sie in die Titelzeile. 3. Geben Sie den Namen des Netzwerks in das aufgeblendete Fenster ein.
Bild 8-11
Netzwerk mit eingetragenen Namen
4. Klicken Sie die Stromschiene links von der Spule an.
300
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
8.3.6
Leerbox einfügen So fügen Sie eine Leerbox ein: 1. Wählen Sie den Menüpunkt KOP/FUP-Programm > Element einfügen > Leerbox.
Bild 8-12
Leerbox einfügen
Es wird eine Leerbox eingefügt. Pflichtparameter in einem Netzwerk sind mit ??? gekennzeichnet, optionale Parameter mit ... .
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
301
Anwendungsbeispiele 8.3 Programm Blinker
8.3.7
Box-Typ auswählen
Bild 8-13
Leerbox
So wählen Sie einen Box-Typ: 1. Drücken Sie in der markierten Leerbox die Enter-Taste. Ein Pull-Down-Menü erscheint. 2. Wählen Sie den entsprechenden Box-Typ aus dem Pull-Down-Menü und bestätigen Sie Ihre Auswahl durch Drücken der Enter-Taste.
Bild 8-14
302
Box-Typ-Auswahl
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
8.3.8
Parametrierung des ADD-Aufrufs So parametrieren Sie den ADD-Aufruf: 1. Klicken Sie in die anderen Pflicht-Eingabefelder ???.
Bild 8-15
ADD-Box
2. Geben Sie die entsprechenden Werte ein.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
303
Anwendungsbeispiele 8.3 Programm Blinker
8.3.9
Vergleicher einfügen So fügen Sie einen Vergleicher ein: 1. Markieren Sie die ADD-Box.
Bild 8-16
Markierte ADD-Box
2. Wählen Sie KOP/FUP-Programm > Element einfügen > Vergleicher > >=.
Bild 8-17
304
Vergleicher auswählen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
Bild 8-18
8.3.10
Eingefügter Vergleicher
Vergleicher beschriften So beschriften Sie den Vergleicher: 1. Klicken Sie einzeln die Eingabefelder des Vergleichers an. 2. Geben Sie die entsprechenden Werte für den Vergleicher ein.
Bild 8-19
Beschrifteter Vergleicher
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
305
Anwendungsbeispiele 8.3 Programm Blinker
8.3.11
Spule initialisieren So initialisieren Sie die Spule: 1. Klicken Sie in das Eingabefeld ??? der Spule. 2. Tragen Sie die entsprechende Variable ein.
Bild 8-20
8.3.12
Initialisierte Spule
Nächstes Netzwerk einfügen So fügen Sie ein weiteres Netzwerk ein: 1. Gehen Sie beim Einfügen des zweiten Netzwerks vor wie beim ersten Netzwerk.
Bild 8-21
306
Projekt mit zwei Netzwerken
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
8.3.13
Detailanzeige So blenden Sie die Detailanzeige ein: 1. Wählen Sie den Menüpunkt Ansicht > Detailanzeige. Informationen z. B. Compilermeldungen während des Übersetzens eines Programms werden angezeigt.
Bild 8-22
8.3.14
Menüauswahl Detailanzeige
Übersetzen So übersetzen Sie das erstellte Programm: 1. Markieren Sie im Projektnavigator das Programm. 2. Wählen Sie im Menü KOP/FUP Programm den Befehl Übernehmen und Übersetzen. Die Quelle mit ihren POEs wird übernommen und übersetzt. Während des Übersetzungsvorgangs werden in der Detailanzeige Meldungen über die erfolgreiche Übersetzung angezeigt. Sollten beim Übersetzungsvorgang Fehler auftreten, werden diese dort im Klartext angezeigt.
Bild 8-23
Menüauswahl Übernehmen und Übersetzen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
307
Anwendungsbeispiele 8.3 Programm Blinker
Bild 8-24
308
Übersetztes Projekt mit Compiler-Informationen in der Detailanzeige
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
8.3.15
Beispielprogramm einer Ablaufebene zuordnen So ordnen Sie das Programm einer Ablaufebene zu: 1. Doppelklicken Sie im Projektnavigator auf den Ordner ABLAUFSYSTEM. 2. Klicken Sie auf die BackgroundTask. 3. Klicken Sie auf das Register Programmzuordnung. 4. Markieren Sie das Programm Q_blink.p_blink. 5. Klicken Sie auf die Schaltfläche >>.
Bild 8-25
Programm der BackgroundTask zuordnen
6. Klicken Sie auf Schließen und bestätigen Sie die Meldung, dass sich das Ablaufsystem geändert hat, mit Ja. Die Änderungen werden ins Projekt übernommen.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
309
Anwendungsbeispiele 8.3 Programm Blinker
8.3.16
Beispielprogramm starten So starten Sie das Programm: 1. Wählen Sie den Menüpunkt Projekt > Speichern und alles neu übersetzen. Das Projekt wird lokal auf der Festplatte gespeichert und übersetzt. 2. Wählen Sie den Menüpunkt Projekt > Mit Zielsystem verbinden oder betätigen Sie die . Schaltfläche Der Online-Modus wird hergestellt. 3. Wählen Sie den Menüpunkt Zielsystem > Laden ins Zielsystem oder betätigen Sie die . Schaltfläche Die Projektdaten (u. a. das Beispielprogramm) und die Daten der Hardwarekonfiguration werden in den RAM-Speicher des Zielsystems geladen. 4. Markieren Sie beide Netzwerke und betätigen Sie in der Funktionsleiste des KOP-Editors (Seite 24) die Schaltfläche für Status Programm (Tastenkürzel Strg+F7). Das Beobachten des Programmablaufs (Seite 272) ist eingeschaltet. 5. Markieren Sie im Projektnavigator das SIMOTION Gerät und wählen Sie im Kontextmenü Zielgerät > Betriebszustand. Das Fenster Betriebszustand mit dem Softwareschalter für die Betriebsarten wird angezeigt. 6. Klicken Sie im Softwareschalter auf die Schaltfläche RUN. Das SIMOTION Gerät befindet sich im Betriebszustand RUN. Das Beispielprogramm wird durchlaufen und die Strompfade/Signalpfade entsprechend der aktuellen Signalwerte gefärbt dargestellt (Seite 272).
310
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.3 Programm Blinker
Bild 8-26
Beispielprogramm wird gestartet
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
311
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4
Programm Achse positionieren
Voraussetzungen Ein Projekt muss erstellt und eine CPU und eine virtuelle Positionierachse angelegt sein.
Aufgabenstellung Eine Achse soll mit einer Geschwindigkeit 100 mm/s von der aktuellen Position 1000 mm in negative Richtung gefahren werden. Diese Aufgabenstellung gliedert sich in folgende Teilaufgaben: ● KOP/FUP-Quelle einfügen ● KOP/FUP-Programm einfügen – Netzwerk einfügen – Freigabe der Achse setzen – Achse auf Position fahren – Freigabe der Achse wegnehmen ● Programm übersetzen ● Programm in eine Task einfügen ● Programm ins Zielgerät laden Für die Programmierung werden PLCopen-Bausteine verwendet. Die PLCopen-Bausteine sind für eine Verwendung in zyklischen Programmen/Tasks vorgesehen und ermöglichen eine Motion Control Programmierung in einer PLC-geprägten Sicht. Sie können vorzugsweise in der Programmiersprache KOP/FUP angewendet werden. PLCopen-Bausteine sind als Standardfunktionen (direkt über die Befehlsbibliothek) verfügbar. Weitere Informationen zu PLCopen-Bausteine finden Sie im Funktionshandbuch SIMOTION PLCopen-Bausteine. Für die genannten Teilaufgaben Freigabe der Achse setzen und Achse auf Position fahren/Freigabe der Achse wegnehmen ist ein TO-spezifischer Befehl vorhanden. Jeder Befehl wird in KOP/FUP durch eine Box dargestellt. Die Parameter zu den einzelnen Befehlen (Position = 1000, Geschwindigkeit = 100 usw.) werden eingegeben über das Dialogfenster Variablendeklaration - oder über das Dialogfenster Aufrufparameter eingeben - oder Eintragen der Werte in die Eingabefelder an jedem Konnektor. Die Aufgabe wird mit der KOP-Programmierung realisiert.
312
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.1
KOP/FUP-Quelle einfügen So fügen Sie eine KOP/FUP-Quelle ein (zum Ablauf Quelle und Programm einfügen siehe auch Beispiel Programm Blinker (Seite 292)): 1. Öffnen Sie im Projektnavigator den Ordner PROGRAMME des entsprechenden SIMOTION Geräts. 2. Doppelklicken Sie auf den Eintrag KOP/FUP-Quelle einfügen. Es öffnet sich das Dialogfenster KOP/FUP-Quelle einfügen. 3. Geben Sie den Namen der KOP/FUP-Quelle ein. Namen für Programmquellen müssen den Regeln für Bezeichner genügen: Sie sind aus Buchstaben (A … Z, a … z), Ziffern (0 … 9) oder einzelnen Unterstrichen (_) in beliebiger Reihenfolge zusammengesetzt, wobei das erste Zeichen ein Buchstabe oder ein Unterstrich sein muss. Zwischen Groß- und Kleinbuchstaben wird nicht unterschieden. Die zulässige Länge der Namen ist abhängig von der Version des SIMOTION Kernels: – Ab Version V4.1 des SIMOTION Kernels: maximal 128 Zeichen. – Bis Version V4.0 des SIMOTION Kernels: maximal 8 Zeichen. Namen müssen innerhalb des SIMOTION Geräts eindeutig sein. Geschützte oder reservierte Bezeichner (Seite 333) sind nicht erlaubt. Bisher vorhandene Programmquellen (z. B. ST-Quellen, MCC-Quellen) werden angezeigt. 4. Markieren Sie im Register Compiler die Checkbox Status Programm ermöglichen, um später die Online-Statusanzeige benutzen zu können. 5. Zusätzlich können Sie Autor, Version und einen Kommentar eingeben. 6. Markieren Sie die Checkbox Editor automatisch öffnen. 7. Bestätigen Sie mit OK. Im Arbeitsbereich erscheinen die Deklarationstabellen für globale und Unit-lokale Variablen.
Siehe auch Programm Blinker (Seite 292)
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
313
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.2
KOP/FUP-Programm einfügen So fügen Sie ein KOP/FUP-Programm ein: 1. Öffnen Sie im Projektnavigator im Ordner PROGRAMME die neu eingefügte KOP/FUP-Quelle. 2. Doppelklicken Sie in der KOP/FUP-Quelle auf den Eintrag KOP/FUP-Programm einfügen. Es öffnet sich das Dialogfenster KOP/FUP-Programm einfügen. 3. Tragen Sie im Dialogfenster KOP/FUP-Programm einfügen den Namen des Programms ein. Die Namen müssen innerhalb des SIMOTION Geräts eindeutig sein. Geschütze oder reservierte Bezeichner (Seite 333) sind nicht erlaubt. Es werden angezeigt: – alle POEs der eigenen Programmquelle – die exportierbaren POEs (z. B. KOP/FUP-Programme, MCC-Charts) anderer Programmquellen 4. Wählen Sie als Erstelltyp Programm. 5. Markieren Sie die Checkbox Editor automatisch öffnen. 6. Bestätigen Sie mit OK. Ein leeres KOP/FUP-Programm wird geöffnet. 7. Klicken Sie in den Arbeitsbereich und wählen Sie den Menüpunkt KOP/FUP-Programm > Netzwerk einfügen, um ein neues Netzwerk einzufügen.
Bild 8-27
Eingefügtes Netzwerk
Hinweis Pflichtparameter in einem Netzwerk sind mit ??? gekennzeichnet, optionale Parameter mit ... .
314
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren 8. Markieren Sie die eingefügte Box und wählen Sie im Kontextmenü Löschen. Die Box wird aus dem Netzwerk entfernt.
Bild 8-28
Eingefügtes Netzwerk ohne Box
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
315
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.3
TO-spezifischen Befehl einfügen So fügen Sie einen TO-spezifischen Befehl ein: 1. Um die Anzeige im Arbeitsbereich übersichtlich zu gestalten, wählen Sie im Kontextmenü des Netzwerks Anzeige > Pflicht und belegte Boxparameter. 2. Wählen Sie im Projektnavigator die Registerkarte Befehlsbibliothek. Es werden die Befehlsgruppen angezeigt. 3. Öffnen Sie durch Klick auf die jeweiligen Pluszeichen die Befehlsgruppe PLCopen > SingleAxis. 4. Platzieren Sie per Drag&Drop den Befehl _mc_power im Netzwerk (siehe Netzwerk mit Zuweisung RET). Durch diesen Befehl wird die Achse freigegeben.
Bild 8-29
316
TO-spezifischer Befehl (_mc_power) aus der Befehlsbibliothek
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
Bild 8-30
Netzwerk mit eingefügter _mc_power Box
5. Markieren Sie das Netzwerk und wählen Sie den Menüpunkt KOP/FUP-Programm > Netzwerk einfügen, um ein zweites Netzwerk einzufügen. 6. Markieren Sie die eingefügte Box des zweiten Netzwerks und wählen Sie im Kontextmenü Löschen. Die Box wird aus dem Netzwerk entfernt. 7. Platzieren Sie per Drag&Drop aus der Befehlsbibliothek den Befehl _mc_moverelative an die markierte Position im zweiten Netzwerk. Mit diesem Befehl wird die Achse mit vorgegebener Geschwindigkeit positioniert.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
317
Anwendungsbeispiele 8.4 Programm Achse positionieren
318
Bild 8-31
TO-spezifischer Befehl (_mc_moverelative) aus der Befehlsbibliothek
Bild 8-32
Netzwerk mit eingefügter _mc_moverelative Box
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.4
Beschaltung der Freigabeeingänge Der Freigabeeingang enable des Befehls _mc_power und der Freigabeingang execute des Befehls _mc_moverelative benötigen noch eine Beschaltung mit Schließern. So fügen Sie die Schließer ein: 1. Klicken Sie in den Arbeitsbereich und wählen Sie im Kontextmenü Anzeige > Alle Boxparameter. Es werden alle Ein- und Ausgänge der Boxen angezeigt. 2. Wählen Sie im Projektnavigator die Registerkarte Befehlsbibliothek. Es werden die Befehlsgruppen angezeigt. 3. Öffnen Sie durch Klick auf das Pluszeichen die Befehlsgruppe KOP-Elemente. 4. Platzieren Sie per Drag&Drop das KOP-Element Schließer am Freigabeeingang enable des Funktionsbausteins _mc_power.
Bild 8-33
Per Drag&Drop das KOP-Element Schließer am Konnektor des Freigabeeingangs enable einfügen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
319
Anwendungsbeispiele 8.4 Programm Achse positionieren
Bild 8-34
320
Netzwerk mit eingefügtem KOP-Element Schließer
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren 5. Platzieren Sie per Drag&Drop zwei KOP-Elemente Schließer am Freigabeeingang execute des Funktionsbausteins _mc_moverelative.
Bild 8-35
Netzwerke mit den eingefügten Schließern
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
321
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.5
Variablen in die Deklarationstabelle eintragen So tragen Sie Variablen ein: 1. Wählen Sie das Register Parameter / Variablen. 2. Geben Sie Name, Variablentyp, Datentyp bzw. Anfangswert (entsprechend der nachfolgenden Abbildung) in die Deklarationstabelle ein. Um die PLCopen-Bausteine nutzen zu können, müssen Sie zu den verwendeten Bausteinen (_mc_power und _mc_moverelative) jeweils eine Instanz anlegen. Der Datentyp der Instanz entspricht dem Bausteinnamen. Bei den Variablen i_mc_power und i_mc_moverelative handelt es sich um Instanzvariablen für die beiden Funktionsbausteine _mc_power und _mc_moverelative. Weitere Informationen bezüglich Deklaration und Verwendung von Instanzvariablen finden Sie unter Beispiel: Funktionsbaustein (FB) (Seite 151) .
Bild 8-36
322
Variablen in der Deklarationstabelle
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.6
Parametrierung der Schließer So parametrieren Sie den jeweiligen Schließer: 1. Klicken Sie in das Eingabefeld ??? des Schließers. 2. Tragen Sie die entsprechende Variable ein. 3. Drücken Sie die Enter-Taste.
Bild 8-37
Parametrieren der Schließer
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
323
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.7
Aufrufparameter für den Befehl _mc_power einstellen Hinweis Das nachfolgend angezeigte Dialogfenster Aufrufparameter eingeben gibt es für jeden Simotion-Befehl. So stellen Sie die Aufrufparameter ein: 1. Doppelklicken Sie auf die Box. 2. Wählen Sie die Instanz, die zu referenzierende Achse, zu setzende Achsfreigaben, Stoppmodus und Freigabestatus der Achse aus. Wenn Sie das Projekt drucken, erscheinen Ihre Angaben im Ausdruck entsprechend Ihrer Einstellung, z. B. Nur belegte Boxparameter. 3. Bestätigen Sie mit OK.
Bild 8-38
324
Aufrufparameter einstellen für PLCopen Baustein _mc_power
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
Bild 8-39
Beschriftete _mc_power Box
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
325
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.8
Aufrufparameter für den Befehl _mc_moverelative einstellen So stellen Sie die Aufrufparameter ein: 1. Doppelklicken Sie auf die _mc_moverelative Box. 2. Wählen Sie Instanz und die zu referenzierende Achse aus. Geben Sie die Werte für zu verfahrende Wegdifferenz und maximale Geschwindigkeit der Achse an. Wenn Sie das Projekt drucken, erscheinen Ihre Angaben im Ausdruck entsprechend Ihrer Einstellung, z. B. Nur belegte Boxparameter. 3. Bestätigen Sie mit OK.
Bild 8-40
326
Aufrufparameter einstellen für PLCopen Baustein _mc_moverelative
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
Bild 8-41
Netzwerk mit eingetragenen Variablen
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
327
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.9
Detailanzeige So blenden Sie die Detailanzeige ein: 1. Wählen Sie den Menüpunkt Ansicht > Detailanzeige. Informationen z. B. Compilermeldungen während des Übersetzens eines Programms werden angezeigt.
8.4.10
Übersetzen So übersetzen Sie das Programm: 1. Markieren Sie in der Projektnavigation das Programm. 2. Wählen Sie im Menü KOP/FUP Programm den Menüpunkt Übernehmen und Übersetzen. Während des Übersetzungsvorgangs werden in der Detailanzeige Meldungen über die erfolgreiche Übersetzung angezeigt. Sollten beim Übersetzungsvorgang Fehler auftreten, werden diese dort im Klartext angezeigt.
8.4.11
Beispielprogramm einer Ablaufebene zuordnen Bevor Sie das Beispielprogramm ausführen können, muss es einer Ablaufebene bzw. einer Task zugeordnet sein. Wenn diese Voraussetzung erfüllt ist, können Sie die Verbindung zum Zielsystem herstellen, das Programm in das Zielsystem laden und es anschließend starten. So ordnen Sie das Programm einer Ablaufebene zu (siehe auch Beispiel Programm Blinker (Seite 309)): 1. Doppelklicken Sie auf im Projektnavigator auf den Ordner ABLAUFSYSTEM. 2. Markieren Sie die BackgroundTask. 3. Klicken Sie auf das Register Programmzuordnung. 4. Markieren Sie das Programm. 5. Klicken Sie auf die Schaltfläche >>. 6. Klicken Sie auf Schließen.
Siehe auch Beispielprogramm einer Ablaufebene zuordnen (Seite 309)
328
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anwendungsbeispiele 8.4 Programm Achse positionieren
8.4.12
Beispielprogramm starten So starten Sie das Programm: 1. Wählen Sie den Menüpunkt Projekt > Speichern und alles neu übersetzen. Das Projekt wird lokal auf der Festplatte gespeichert und übersetzt. 2. Wählen Sie den Menüpunkt Projekt > Mit Zielsystem verbinden oder betätigen Sie die . Schaltfläche Der Online-Modus wird hergestellt. 3. Wählen Sie den Menüpunkt Zielsystem > Laden ins Zielsystem oder betätigen Sie die . Schaltfläche Die Projektdaten (u. a. das Beispielprogramm) und die Daten der Hardwarekonfiguration werden in den RAM-Speicher des Zielsystems geladen. 4. Markieren Sie beide Netzwerke und betätigen Sie in der Funktionsleiste des KOP-Editors für Status Programm (Tastenkürzel Strg+F7). (Seite 24) die Schaltfläche Das Beobachten des Programmablaufs (Seite 272) ist eingeschaltet. 5. Markieren Sie im Projektnavigator das SIMOTION Gerät und wählen Sie im Kontextmenü Zielgerät > Betriebszustand. Das Fenster Betriebszustand mit dem Softwareschalter für die Betriebsarten wird angezeigt. 6. Klicken Sie im Softwareschalter auf die Schaltfläche RUN. Das SIMOTION Gerät befindet sich im Betriebszustand RUN. Das Beispielprogramm wird durchlaufen und die Strompfade/Signalpfade entsprechend der aktuellen Signalwerte gefärbt dargestellt (Seite 272).
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
329
Anwendungsbeispiele 8.4 Programm Achse positionieren
Bild 8-42
330
Beispielprogramm wird gestartet
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
A
Anhang A.1
Tastenkombinationen Folgende Tastenkombinationen stehen zur Verfügung:
Bei geöffneten KOP/FUP-Editor Cursor-Tasten
Bei selektiertem Operator: Navigation zwischen den einzelnen Operatoren
Strg+Cursor oben
Vorheriges Netzwerk auswählen
Strg+Cursor unten
Nächstes Netzwerk auswählen
Bild Auf
Netzwerk am Anfang des sichtbaren Editorbereichs auswählen
Bild Ab
Netzwerk am Ende des sichtbaren Editorbereichs auswählen
Entf
Löschen eines Operators
Tab/Shift+Tab
Weiterschalten zum nächsten Button/Eingabefeld/Zurückspringen zum vorhergehenden Button/Eingabefeld
Return
Öffnen des Editfelds des aktuellen Operanden bzw. Bestätigung der Eingabe im Editfeld
Esc
Abbrechen der Eingabe bei geöffnetem Editfeld
Menü Fenster Strg+Shift+F5
Ordnet alle in dieser Applikation geöffneten Fenster untereinander gleichmäßig von oben nach unten an.
Strg+Shift+F3
Ordnet alle in dieser Applikation geöffneten Fenster nebeneinander gleichmäßig von links nach rechts an.
Alt+F4
Schließt alle Fenster und beendet die Applikation.
Menü Ansicht Strg+F11
Maximiert Arbeitsbereich
Strg+F12
Maximiert Detailanzeige
Strg+Num+
Vergrößert den Inhalt des Arbeitsbereiches.
Strg+Num-
Verkleinert den Inhalt des Arbeitsbereiches.
F5
Aktualisiert die Ansicht
Menü Bearbeiten Strg+Z
Macht die letzte Aktion rückgängig (Ausnahme: speichern)
Strg+Y
Stellt die zuletzt rückgängig gemachte Aktion wieder her.
Strg+X
Ausschneiden eines Befehls
Strg+C
Kopieren eines Befehls
Strg+V
Einfügen eines Befehls
Entf
Löscht markierte Befehle im KOP-Editor.
Alt+Enter
Zeigt die Eigenschaften des aktiven/markierten Objekts zum Bearbeiten an.
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
331
Anhang A.1 Tastenkombinationen Menü Bearbeiten Enter
Öffnet markiertes Objekt.
Strg+B
Speichert und übersetzt das aktive/markierte Objekt.
Strg+A
Markiert alle Objekte im aktuellen Fenster
Alt+F8
Vergleicher einfügen
Alt+F9
Leerbox einfügen
Strg+R
Neues Netzwerk einfügen
Strg+L
Sprungmarke ein/aus
Strg+Shift+K
Kommentarzeile ein-/ausschalten
Strg+Z
Rückgängig
Strg+Y
Wiederholen
Strg+1
Umschalten nach KOP
Strg+3
Umschalten nach FUP
Strg+T
Symbolprüfung und Typaktualisierung
Strg+Shift+B
Darstellungsoptionen für Boxen
Shift+F6
Wechsel zwischen Deklarationstabelle und Editorbereich
KOP-Elemente F2
Schließer einfügen
F3
Öffner einfügen
F7
Spule einfügen
F8
Verzweigung auf
F9
Verzweigung zu
FUP-Elemente F2
Und-Box einfügen
F3
Oder-Box einfügen
F4
XOR-Box einfügen
F7
Zuweisung
F8
Binärer Eingang einfügen
F9
Binärer Eingang negieren
Symboleingabehilfe Strg+H
332
Öffnet das Dialogfenster Symboleingabehilfe
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Anhang A.2 Geschützte und reservierte Bezeichner
A.2
Geschützte und reservierte Bezeichner Reservierte Bezeichner dürfen Sie nur wie vorbestimmt verwenden. Sie dürfen keine Variable und keinen Datentyp mit dem Namen eines reservierten Bezeichners deklarieren. Eine Unterscheidung zwischen Groß- und Kleinschreibung findet nicht statt. Die Programmiersprache ST besitzt geschützte und reservierte Bezeichner (siehe Programmier- und Bedienhandbuch SIMOTION ST). Diese gelten auch für die Programmiersprache KOP/FUP. Zusätzlich besitzt die Programmiersprache KOP/FUP noch die in der Tabelle aufgelisteten geschützten und reservierten Bezeichner. Eine Auflistung aller Bezeichner die in SIMOTION eine vordefinierte Bedeutung haben, finden Sie im Funktionshandbuch SIMOTION Basisfunktionen.
Tabelle A- 1 Geschützte Bezeichner gültig nur für die Sprache KOP/FUP A ANDN C CAL
CALCN
CALC J JMP
JMPCN
JMPC L LD
LDN
O ORN R RET
RETCN
RETC S ST
STN
X XORN
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
333
Index _ _additionObjectType, 100 _camTrackType, 100 _controllerObjectType, 100 _device, 134 _direct, 119, 122, 134 _fixedGearType, 100 _formulaObjectType, 100 _getcommandid Signalvorverschaltung, 158 _getSafeValue Anwendung, 134 _sensorType, 100 _setSafeValue Anwendung, 134
A Abgeleiteter Datentyp Aufzählungen definieren, 99 Reichweite, 98 Strukturen definieren, 98 UDT, 98 Ablaufsystem Ablaufebenen und Tasks, 255 Programm einer Task zuordnen, 253, 309, 328 Startreihenfolge Tasks, 257 Abwärtszähler CTD, 218 CTD_DINT, 219 CTD_UDINT, 220 Aktivieren Automatische Symbolprüfung, 30 on-the-fly Variablendeklaration, 36 Symbol-Browser, 264 Typaktualisierung, 30 Allgemeine numerische Standardfunktionen, 232 Ändern Erstelltyp KOP/FUP-Programm, 58 Farben, 36 Kommentare KOP/FUP-Netzwerk, 66 Kommentare KOP/FUP-Programm, 66 Operand- und Kommentarfelder, 35 Schriftarten, 35 Variablenwerte im Symbol-Browser, 266
SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
ANY, 96 ANY_BIT, 96 ANY_DATE, 96 ANY_ELEMENTARY, 96 ANY_INT, 96 ANY_NUM, 96 ANY_REAL, 96 ANYOBJECT, 100 Arbeitsbereich Ansicht vergrößern/verkleinern, 22 maximieren, 22 Workbench, 21 Arithmetische Operatoren, 230 Auf-/Abwärtszähler CTUD, 221 CTUD_DINT, 223 CTUD_UDINT, 224 Aufrufparameter einstellen für KOP/FUP-Elemente, 79, 324, 326 einzeln einstellen für KOP/FUP-Elemente, 78 Aufrufpfad Callstack, 289 Haltepunkt, 282, 284 Programm-Durchlauf, 270 Aufwärtszähler CTU, 215 CTU_DINT, 216 CTU_UDINT, 217 Aufzählungen Beispiel, 99 definieren, 99 Ausgang rücksetzen, 177 setzen, 178 Ausschneiden KOP/FUP-Elemente, 76 KOP/FUP-Netzwerk, 68 KOP/FUP-Quelle, 43 Automatische Symbolprüfung aktivieren, 30 deaktivieren, 34 KOP/FUP-Editor, 29 Automatische Syntaxprüfung KOP/FUP-Elemente, 75
B Befehlsaufruf
335
Index
Drag&Drop, 27 Befehlsbibliothek, 83 Besonderheiten, 85 Funktionen einfügen, 84 KOP/FUP-Elemente einfügen, 84 Nichtverwendbare Funktionen, 84 Befehlsname Drag&Drop, 28 Beispielprogramme KOP/FUP FUP-Programm "Achse positionieren", 312 KOP-Programm "Blinker", 292 Voraussetzungen, 291 Betriebsart Debug-Modus, 260, 276 Prozessbetrieb, 260 Testbetrieb, 260 Bezeichner Regeln für Namensgebung, 89 reserviert KOP/FUP, 333 Binäreingang einfügen, 191 negieren, 192 Bitdatentypen, 93, 208 BOOL, 93 Boolsche Signalvorverschaltung, 158 Box-Typ auswählen, 302 Schnittstellenabgleich, 159 BYTE, 93
C camType, 100 Codeattribute, 168 Compiler globale Einstellungen, 48 lokale Einstellungen, 49 CONCAT, 212 CONSTANT, 102
D DATE, 94 DATE_AND_TIME, 94 Datentypen Bitdatentyp, 93 elementar, 93 numerisch, 93 Schnittstellenabgleich, 159 STRING, 94 Technologieobjekt, 100 Vererbung, 101
336
Zeit, 94 Datentyp-Liste einstellen in Deklarationstabellen, 34 Datum und Zeit, 212 Deaktivieren Automatische Symbolprüfung, 34 Typaktualisierung, 34 Debug-Modus, 260, 276 Deklaration Reichweite, 89 Deklarationstabelle Abschnitt Implementation, 98 Abschnitt Interface, 98 Anfangswert, 91 Aufzählungen definieren, 99 Datentyp-Liste einstellen, 34 Drag&Drop, 26, 27 drucken, 60 ein-/ausblenden, 23 Feldlänge und Feldelement, 90 Initialisierungswert, 91 Kommentar, 91 Reichweite der abgeleiteten Datentypen, 98 Strukturen definieren, 98 Variablen deklarieren, 299, 322 vergrößern/verkleinern, 23 Workbench, 21 Detailanzeige einblenden, 307, 328 maximieren, 22 übersetzen, 42, 55 Workbench, 21 DINT, 93 DINT#MAX, 95 DINT#MIN, 95 Direktzugriff, 119, 122 Eigenschaften, 120 Download Einfluss auf Variableninitialisierung, 109 Drag&Drop aus den Deklarationstabellen, 26 Befehlsaufruf, 27 Befehlsname, 28 Elemente in einem Netzwerk, 28 Funktionen anderer Quellen, 28 Funktionsbausteine anderer Quellen, 28 in der Deklarationstabelle, 27 KOP/FUP-Elemente, 27 Variablen, 26 driveAxis, 100 Drucken Deklarationstabellen, 60 Druckvariante definieren, 61 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Index
Kommentare, 60 KOP/FUP-Programm, 59 KOP/FUP-Quelle, 59 Leere Seiten, 62 Netzwerkbereich, 60 Netzwerke platzieren, 62 DT, 94 DT_TO_DATE, 212 DT_TO_TOD, 212 DWORD, 93
E Editorbereich, 63 Eigenschaften KOP/FUP-Programm, 57 KOP/FUP-Quelle, 47 Einblenden Detailanzeige, 307, 328 Einfügen KOP/FUP-Elemente, 74, 304, 316, 319 KOP/FUP-Netzwerk, 64, 68, 300, 306 KOP/FUP-Programm, 52, 296, 314 KOP/FUP-Quelle, 40, 43, 293, 313 Leerbox, 301 TO-spezifischer Befehl, 316, 319 Einstellungen KOP/FUP-Editor, 29 Elementare Datentypen Übersicht, 93 Ersetzen KOP/FUP-Elemente im Projekt, 81 Erstelltyp, 58 Exklusiv-ODER Exklusiv-ODER-Box, 190 verknüpfen, 173 EXP-Format, 45, 46 Exportieren KOP/FUP-Quelle im EXP-Format, 45 KOP/FUP-Quelle im XML-Format, 44 POE als XML-Format, 45 externalEncoderType, 100
F Farben ändern, 36 Fehlerstelle, 55 Feldelement Anfangswert, 91 Initialisierungswert, 91 Variablen, 90 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Feldlänge Variablen, 90 Flankenerkennung F_TRIG, 214 fallend, 183, 201 Flanke 0 -> 1 abfragen, 182, 200 Flanke 1 -> 0 abfragen, 181, 199 R_TRIG, 213 steigend, 184, 202 Übersicht, 213 Flipflop vorrangig rücksetzen, 179, 197 vorrangig setzen, 180, 198 followingAxis, 100 followingObjectType, 100 Funktion (FC), 58 Beispiel, 146 Drag&Drop von Funktionen anderer Quellen, 28 einfügen, 142 Funktionsbaustein (FB), 58 Drag&Drop von Funktionsbausteinen anderer Quellen, 28 einfügen, 142 Funktionsleiste FUP-Editor, 24 KOP/FUP-Editor, 24 KOP/FUP-Quelle, 24 KOP-Editor, 24 Workbench, 21 Funktionsplan, 18 FUP, 18 FUP-Bitverknüpfungsoperationen Binäreingang einfügen, 191 Binäreingang negieren, 192 Exklusiv-ODER-Box, 190 Flanke 0 -> 1 abfragen, 200 Flanke 1 -> 0 abfragen, 199 Flankenerkennung (fallend), 201 Flankenerkennung (steigend), 202 Flipflop vorrangig rücksetzen, 197 Flipflop vorrangig setzen, 198 Konnektor, 194 ODER-Box, 189 Übersicht, 187 UND-Box, 188 Zuweisung, 193 Zuweisung rücksetzen, 195 Zuweisung setzen, 196
G Ganzzahl
337
Index
Datentypen, 93 Geräteglobale Anwendervariablen definieren, 103 Gleitpunktzahl Datentypen, 93
H Haltepunkt, 275 aktivieren, 286 Aufrufpfad, 282, 284 Call-Stack, 289 deaktivieren, 288 entfernen, 279 Funktionsleiste, 281 setzen, 279
I I/O-Variable anlegen, 125, 133 Direktzugriff, 119, 122 erstellen, 125, 133 Prozessabbild, 119, 122 Prozessabbild der BackgroundTask, 129 Importieren KOP/FUP-Quelle aus XML-Daten, 44 KOP/FUP-Quelle im EXP-Format, 46 POE als XML-Format, 45 Inbetriebnahme Ablaufebenen und Tasks, 255 Inbetriebnehmen (Software) Programm einer Task zuordnen, 253 Projekt ins Zielsystem laden, 258 Startreihenfolge Tasks, 257 Initialisierung Relaisspule, Ausgang, 306 Zeitpunkt der Variableninitialisierung, 109 Instanzvariable Schnittstellenabgleich, 159 INT, 93 INT#MAX, 95 INT#MIN, 95
K Know-how-Schutz, 43 Kommentar drucken, 60 Konnektor, 176, 194 Konstanten
338
Zeitangaben, 94 Kontaktplan, 17 Kontextmenü KOP/FUP-Editor, 24 KOP, 17 KOP/FUP-Editor Ansicht vergrößern/verkleinern, 22 Automatische Symbolprüfung, 29 Darstellung Netzwerke, 63 Einstellungen, 29 Farben ändern, 36 Funktionsleisten, 24 in den Vordergrund holen, 23 Kontextmenü, 24 Menüleiste, 24 Online-Hilfe aufrufen, 37 on-the-fly Variablendeklaration aktivieren, 36 Operand- und Kommentarfelder ändern, 35 Schriftarten ändern, 35 Standardsprache einstellen, 37 Tastenkombination, 26 Typaktualisierung, 29 Workbench, 21 KOP/FUP-Elemente, 63 Anzeige der Boxparameter, 77 Aufrufparameter einstellen, 79, 324, 326 ausschneiden, 76 automatische Syntaxprüfung, 75 Definition KOP-Grafik, 69 Defnintion FUP-Grafik, 71 Drag&Drop, 27 einfügen, 74, 304, 316, 319 einzelnen Aufrufparameter einstellen, 78 ersetzen im Projekt, 81 Freigabeausgang (ENO) der KOP-Box, 70 Freigabeeingang (EN) der KOP-Box, 70 kopieren, 76 löschen, 76 markieren, 75 Parametereingabe, 76, 303, 305, 323 Parametereingabe mit Symboleingabehilfe, 77 Regeln für FUP-Anweisungen, 71 Regeln für KOP-Anweisungen, 69 Strompfad, 69 Stromschiene, 69 suchen im Projekt, 80 Umschaltung KOP- in FUP-Darstellung, 72 Umschaltung:FUP- in KOP-Darstellung, 73 KOP/FUP-Netzwerk, 63 Aktion rückgänig, 68 Aktion wiederholen, 68 ausschneiden, 68 einfügen, 64, 68, 300, 306 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Index
Kommentarbereich, 66 Kommentare eingeben/ändern, 66 Kommentarzeile ein-/ausblenden, 67 kopieren, 68 löschen, 68 markieren, 64 Nummerierung, 65 sprachabhängige Texte, 66 Sprungmarke ein-/ausblenden, 67 Titel eingeben, 66, 300 Titelbereich, 66 KOP/FUP-Programm, 19, 52, 58 drucken, 59 Eigenschaften, 57 einfügen, 52, 296, 314 Erstelltyp ändern, 58 Kommentare eingeben/ändern, 66 Kommentarzeile ein-/ausblenden, 67 kopieren, 54 löschen, 56 öffnen, 54 Reihenfolge festlegen, 54 RUN, 310, 329 schließen, 56 starten, 310, 329 Titel eingeben, 66, 299 übernehmen, 55, 307, 328 übersetzen, 55, 307, 328 umbenennen, 57 zuordnen Ablaufebene, 309, 328 KOP/FUP-Quelle ausschneiden, 43 drucken, 59 Eigenschaften, 47 einfügen, 40, 43, 293, 313 exportieren, 44 exportieren im EXP-Format, 45 exportieren im XML-Format, 44 Funktionsleisten, 24 importieren, 44 importieren aus XML-Daten, 44 importieren im EXP-Format, 46 Know-how-Schutz, 43 kopieren, 43 lokale Compilereinstellungen, 49 löschen, 43 öffnen, 42 Programmorganisationseinheit (POE), 39 Reihenfolge festlegen, 54 schließen, 43 SIMOTION Gerät, 39 übernehmen, 42 übersetzen, 42 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
umbenennen, 47 KOP-Bitverknüpfungsoperationen Ausgang rücksetzen, 177 Ausgang setzen, 178 Exklusiv-ODER verknüpfen, 173 Flanke 0 -> 1 abfragen, 182 Flanke 1 -> 0 abfragen, 181 Flankenerkennung (fallend), 183 Flankenerkennung (steigend), 184 Flipflop vorrangig rücksetzen, 179 Flipflop vorrangig setzen, 180 Konnektor, 176 Öffnerkontakt, 172 Parallelzweig auf, 185 Parallelzweig zu, 186 Relaisspule, Ausgang, 175 Schließerkontakt, 171 Signalzustand invertieren, 174 Übersicht, 170 Kopieren KOP/FUP-Elemente, 76 KOP/FUP-Netzwerk, 68 KOP/FUP-Programm, 54 KOP/FUP-Quelle, 43
L Leerbox aufrufen, 243 Box-Typ auswählen, 302 einfügen, 301 LIMIT Begrenzungsfunktion, 251 Literaturhinweis, 13 Logarithmische Standardfunktionen, 233 Logische Operationen Nichtbinäre Logik, 229 Löschen KOP/FUP-Elemente, 76 KOP/FUP-Netzwerk, 68 KOP/FUP-Programm, 56 KOP/FUP-Quelle, 43 LREAL, 93
M Markieren KOP/FUP-Elemente, 75 KOP/FUP-Netzwerk, 64 MAX Maximum-Funktion, 249 measuringInputType, 100 Menüleiste KOP/FUP-Editor, 24
339
Index
Workbench, 21, 24 MIN Minimum-Funktion, 250 MOVE Wert übertragen, 235
N Namensraum, 138 Netzwerk, 63 Netzwerkbereich drucken, 60 Neu I/O-Variable, 125, 133 KOP/FUP-Programm, 52 KOP/FUP-Quelle, 40 Numerische Datentypen, 93, 208 Numerische Standardfunktionen allgemeine numerische Standardfunktionen, 232 logarithmische Standardfunktionen, 233 trigonometrische Standardfunktionen, 234
O ODER-Box, 189 Offline-Modus Watchtabelle, 268 Öffnen KOP/FUP-Programm, 54 KOP/FUP-Quelle, 42 Öffnerkontakt, 172 Online-Hilfe KOP/FUP-Editor, 37 Online-Modul Watchtabelle, 268 on-the-fly Variablendeklaration aktivieren, 36 Operand- und Kommentarfelder ändern, 35 outputCamType, 100
P Parallelzweig auf, 185 Parallelzweig zu, 186 Parametereingabe KOP/FUP-Elemente, 76, 303, 305, 323 TO-spezifischer Befehl, 323 posAxis, 100 Preprozessor aktivieren, 50 verwenden, 50 Programmablauf, 272
340
Programm-Durchlauf, 270 Funktionsleiste, 271 Programmorganisationseinheit (POE), 19 exportieren als XML-Format, 45 Funktion (FC), 19 Funktionsbaustein (FB), 19 importieren als XML-Format, 45 KOP/FUP-Quelle, 39 Programm, 19 Programmquelle, 19 KOP/FUP-Quelle, 19 MCC-Quelle, 19 ST-Quelle, 19 Programmsteuerung Leerbox aufrufen, 243 RET Springe zurück, 244 Programmstruktur, 166 Projekt laden ins Zielsystem, 258 Projektnavigator SIMOTION Gerät, 39 Workbench, 21 Prozessabbild BackgroundTask, 119 Eigenschaften, 120 Prinzip und Verwendung, 119, 128 zyklische Tasks, 119, 122 Prozessbetrieb, 260
Q Querverweisliste, 162 angezeigte Daten, 163 Einzelschrittverfolgung (MCC), 163 erzeugen, 162 filtern, 165 sortieren, 165 TSI#dwuser_1, 163 TSI#dwuser_2, 163
R REAL, 93 Referenz, 100 Referenzdaten, 162 Reichweite der Deklarationen, 89 Relaisspule, Ausgang, 175 Initialisierung, 306 Reservierte Bezeichner, 333 RET Springe zurück, 244 RETAIN, 102 ROL Bit links rotieren, 239 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Index
ROR Bit rechts rotieren, 241 Rotieroperationen ROL Bit links rotieren, 239 ROR Bit rechts rotieren, 241 Übersicht, 239 Rückwärtskompatibilität, 55 RUN Einfluss auf Variableninitialisierung, 109 KOP/FUP-Programm, 310, 329
S Schiebeoperationen SHL Bit links schieben, 237 SHR Bit rechts schieben, 238 Übersicht, 236 Schließen KOP/FUP-Programm, 56 KOP/FUP-Quelle, 43 Schließerkontakt, 171 Schnittstellenabgleich Detailanzeige, 159 Einschränkungen, 159 manuelle Aktualisierung FB/FC-Aufruf, 159 Schriftarten ändern, 35 SEL Binäre Auswahl, 248, 252 Selektierfunktionen LIMIT Begrenzungsfunktion, 251 MAX Maximum-Funktion, 249 MIN Minimum-Funktion, 250 MUX Multiplexfunktion, 252 SEL Binäre Auswahl, 248 Sequentielle Programmabarbeitung Einfluss auf I/O-Zugriffe, 119, 122 Einfluss auf Variableninitialisierung, 109 SHL Bit links schieben, 237 SHR Bit rechts schieben, 238 Signalvorverschaltung _getcommandid, 158 boolsche, 158 nicht-boolsche, 158 Signalzustand invertieren, 174 SIMOTION Gerät KOP/FUP-Quelle, 39 Projektnavigator, 39 SINT, 93 SINT#MAX, 95 SINT#MIN, 95 Sprachabhängige Texte KOP/FUP-Netzwerk, 66 Sprungmarke, 228 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Ein-/ausblenden im KOP/FUP-Netzwerk, 67 Sprungoperationen Springe im Baustein wenn 0, 227 Springe im Baustein wenn 1, 226 Sprungmarke, 228 Übersicht, 225 ST _alarm, 138 _device, 138 _direct, 138 _project, 138 _task, 138 _to, 138 Standardsprache KOP/FUP-Editor, 37 Starten KOP/FUP-Programm, 310, 329 Status Programm Programmablauf verfolgen, 272 starten und stoppen, 272 Übersicht, 272 STOP auf RUN Einfluss auf Variableninitialisierung, 109 STRING, 94 Strompfad KOP/FUP-Elemente, 69 Stromschiene KOP/FUP-Elemente, 69 StructAlarmId, 97 STRUCTALARMID#NIL, 97 StructTaskId, 97 STRUCTTASKID#NIL, 97 Strukturen definieren, 98 Suchen KOP/FUP-Elemente im Projekt, 80 Symbol-Browser, 264 aktivieren, 264 Anzeige fixieren, 267 Variablenwerte ändern, 266 Symboleingabehilfe beschriften KOP/FUP-Elemente, 77 Systemdatentypen, 101 Systemfunktionen Vererbung, 101 Systemvariablen Vererbung, 101
T T#MAX, 95 T#MIN, 95
341
Index
Task Ablaufebenen, 255 Einfluss auf Variableninitialisierung, 109 Programm einer Task zuordnen, 253 sequentielle Tasks, 255 Startreihenfolge, 257 zyklische Tasks, 255 Tastenkombination KOP/FUP-Editor, 26, 331 Technologieobjekt Datentyp, 100 Vererbung, 101 Testbetrieb, 260 TIME, 94 TIME#MAX, 95 TIME#MIN, 95 TIME_OF_DAY, 94 TIME_OF_DAY#MAX, 95 TIME_OF_DAY#MIN, 95 TO#NIL, 100 TOD, 94 TOD#MAX, 95 TOD#MIN, 95 TOF Ausschaltverzögerung, 247 TON Einschaltverzögerung, 246 TO-spezifischer Befehl einfügen, 316, 319 Parametereingabe, 323 TP Puls, 245 Trace, 270 Trigonometrische Standardfunktionen, 234 TRUNC, 207 TSI#dwuser_1 Querverweisliste, 163 TSI#dwuser_2 Querverweisliste, 163 Typaktualisierung aktivieren, 30 deaktivieren, 34 KOP/FUP-Editor, 29
U Übersetzen Detailanzeige, 42, 55 KOP/FUP-Programm, 55, 307, 328 KOP/FUP-Quelle, 42 Reihenfolge der POE festlegen, 54 UDINT, 93 UDINT#MAX, 95 UDINT#MIN, 95 UINT, 93
342
UINT#MAX, 95 UINT#MIN, 95 Umbenennen KOP/FUP-Programm, 57 KOP/FUP-Quelle, 47 Umschaltung KOP- in FUP-Darstellung, 72 Umschaltung FUP- in KOP-Darstellung, 73 Umwandlerfunktionen Bitdatentypen, 208 Datum und Zeit, 212 Numerische Datentypen, 208 TRUNC, 207 UND-Box, 188 Unit, 19 Unterprogramm, 139 Informationsaustausch, 141 USINT, 93 USINT#MAX, 95 USINT#MIN, 95
V VAR, 102 VAR CONSTANT, 102 VAR_GLOBAL, 102 VAR_GLOBAL CONSTANT, 102 VAR_GLOBAL RETAIN, 102 VAR_IN_OUT, 102 VAR_INPUT, 102 VAR_OUTPUT, 102 VAR_TEMP, 102 Variablen, 102 Anfangswert, 91 definieren, 103, 299, 322 Drag&Drop, 26 Feldlänge und Feldelement, 90 Initialisierungswert, 91 lokale, 106 Prozessabbild, 119, 128 Unit-Variable, 104 Zeitpunkt der Initialisierung, 109 Variablentypen, 86 Schlüsselwörter, 102 Verbindungen definieren, 135 zu Bibliotheken, 135 zu KOP/FUP-Programmen, 135 zu MCC-Charts, 135 zu ST-Quellen, 135 Vererbung bei Technologieobjekten, 101 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
Index
Vergleicher, 203 Vergleichsoperationen Übersicht, 203 Vergleicher, 203 Verschiebeoperationen MOVE Wert übertragen, 235 Vorverschaltung, 158
W Watchtabelle anlegen, 268 Anzeige fixieren, 269 Offline-Modus, 268 Online-Modus, 268 Status und Steuern von Variablen, 269 Übersicht, 268 WORD, 93 Workbench Arbeitsbereich, 21 Deklarationstabellen, 21 Detailanzeige, 21 Funktionsleisten, 21, 24 KOP/FUP-Editor, 21 Menüleiste, 21, 24 Projektnavigator, 21
Z Zähleroperationen Abwärtszähler CTD, 218 Abwärtszähler CTD_DINT, 219 Abwärtszähler CTD_UDINT, 220 Auf-/Abwärtszähler CTUD, 221 Auf-/Abwärtszähler CTUD_DINT, 223 Auf-/Abwärtszähler CTUD_UDINT, 224 Aufwärtszähler CTU, 215 Aufwärtszähler CTU_DINT, 216 Aufwärtszähler CTU_UDINT, 217 Übersicht, 215 Zeitoperationen TOF Ausschaltverzögerung, 247 TON Einschaltverzögerung, 246 TP Puls, 245 Zeittypen Übersicht, 94 Zuweisung, 193 rücksetzen, 195 setzen, 196 Zyklische Programmabarbeitung Einfluss auf I/O-Zugriffe, 119, 122, 128 Einfluss auf Variableninitialisierung, 109 SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
343
SIMOTION SIMOTION SCOUT SIMOTION KOP/FUP Programmier- und Bedienhandbuch, 05/2009
344
