How it Works
WAGO
Loading...
759-333
Datasheet
1 pgs278.24 Kb0
User guide
10 pgs75 Kb0
User guide
487 pgs3.3 Mb0
User guide
118 pgs970.29 Kb0
Table of contents
Loading...

WAGO 759-333 User guide

Download
Handbuch für
SPS Programmierung
mit
CoDeSys 2.3
Copyright 1994, 1997, 1999, 2001, 2002, 2003, 2005, 2006, 2007 by 3S - Smart Software Solutions GmbH Alle Rechte vorbehalten.
Es wurden alle erdenklichen Maßnahmen getroffen, um die Richtigkeit und Vollständigkeit der vorliegenden Dokumentation zu gewährleisten. Da sich Fehler, trotz aller Sorgfalt, nie vollständig vermeiden lassen, sind wir für Hinweise und Anregungen jederzeit dankbar.
Warenzeichen
Intel ist ein eingetragenes Warenzeichen und 80286, 80386, 80486, Pentium sind Warenzeichen der Intel Corporation.
Microsoft, MS und MS-DOS sind eingetragene Warenzeichen, Windows und Intellisense sind Warenzeichen der Microsoft Corporation.
Herausgeber:
3S - Smart Software Solutions GmbH Memminger Straße 151 D-87439 Kempten Tel. +49/ 831/ 5 40 31 - 0 Fax +49/ 831/ 5 40 31 – 50
Stand: 17.12.2007
Dokument Version 5.0, ab CoDeSys V.2.3.9.0
Inhalt
Inhalt
1 Kurzer Einblick in CoDeSys 1-1
1.1 Was ist CoDeSys ................................................................................................... 1-1
1.2 Überblick über die Funktionalität von CoDeSys... .................................................. 1-1
1.3 Übersicht der Anwender-Dokumentation zu CoDeSys .......................................... 1-3
2 Was ist was in CoDeSys 2-1
2.1 Bestandteile eines Projekts.................................................................................... 2-1
2.2 Die Sprachen.......................................................................................................... 2-8
2.2.1 Anweisungsliste (AWL)..................................................................................... 2-8
2.2.2 Strukturierter Text (ST)... .................................................................................. 2-10
2.2.3 Ablaufsprache (AS)........................................................................................... 2-16
2.2.4 Funktionsplan (FUP)......................................................................................... 2-22
2.2.5 Der freigraphische Funktionsplaneditor (CFC)... .............................................. 2-22
2.2.6 Kontaktplan (KOP)... ......................................................................................... 2-22
2.3 Debugging, Onlinefunktionalitäten... ...................................................................... 2-24
2.4 Die Norm... ............................................................................................................. 2-26
3 Wir schreiben ein kleines Programm 3-1
3.1 Die Steuerung einer Ampelanlage... ...................................................................... 3-1
3.2 Die Visualisierung einer Ampelanlage.................................................................... 3-11
4 Die Komponenten im Einzelnen 4-1
4.1 Hauptfenster........................................................................................................... 4-1
4.2 Projekt Optionen..................................................................................................... 4-3
4.3 Projekte verwalten.................................................................................................. 4-22
4.4 Objekte verwalten................................................................................................... 4-56
4.5 Allgemeine Editierfunktionen.................................................................................. 4-64
4.6 Allgemeine Online Funktionen... ............................................................................ 4-71
4.7 Fenster ... ............................................................................................................... 4-88
4.8 Die rettende Hilfe.................................................................................................... 4-89
5 Die Editoren 5-1
5.1 Das gilt für alle Editoren... ...................................................................................... 5-1
5.2 Der Deklarationseditor............................................................................................ 5-3
5.2.1 Arbeiten im Deklarationseditor.......................................................................... 5-3
5.2.2 Deklarationseditoren im Online Modus ............................................................. 5-11
5.2.3 Pragma-Anweisungen im Deklarationseditor.................................................... 5-12
5.3 Editoren der textuellen Programmiersprachen....................................................... 5-20
5.3.1 Arbeiten in den Texteditoren............................................................................. 5-20
5.3.2 Der Anweisungslisteneditor... ........................................................................... 5-23
5.3.3 Der Editor für Strukturierten Text... ................................................................... 5-24
5.4 Editoren der grafischen Programmiersprachen...................................................... 5-25
5.4.1 Arbeiten in den grafischen Editoren.................................................................. 5-25
5.4.2 Der Funktionsplaneditor.................................................................................... 5-29
5.4.3 Der Kontaktplaneditor... .................................................................................... 5-34
5.4.4 Der Ablaufspracheneditor... .............................................................................. 5-41
5.4.5 Der freigraphische Funktionsplaneditor (CFC)... .............................................. 5-50
CoDeSys V2.3 i
Inhalt
6 Die Ressourcen 6-1
6.1 Übersicht Ressourcen ............................................................................................ 6-1
6.2 Globale Variablen, Variablenkonfiguration, Dokumentvorlage ...............................6-2
6.2.1 Globale Variablen.............................................................................................. 6-2
6.2.2 Variablenkonfiguration... ...................................................................................6-7
6.2.3 Dokumentvorlage ..............................................................................................6-8
6.3 Alarmkonfiguration.................................................................................................. 6-9
6.3.1 Überblick ........................................................................................................... 6-9
6.3.2 Alarmsystem, Begriffe .......................................................................................6-10
6.3.3 Alarmklassen..................................................................................................... 6-11
6.3.4 Alarmgruppen.................................................................................................... 6-14
6.3.5 Alarmspeicherung ............................................................................................. 6-15
6.3.6 Menü Extras: Einstellungen .............................................................................. 6-16
6.4 Bibliotheksverwaltung............................................................................................. 6-17
6.5 Logbuch.................................................................................................................. 6-20
6.6 Steuerungskonfiguration......................................................................................... 6-22
6.6.1 Überblick ........................................................................................................... 6-22
6.6.2 Arbeiten im CoDeSys Steuerungskonfigurator..................................................6-23
6.6.3 Allgemeine Einstellungen in der Steuerungskonfiguration................................ 6-25
6.6.4 Anwendungsspezifischer Parameterdialog .......................................................6-26
6.6.5 Konfiguration eines I/O Moduls... ......................................................................6-27
6.6.6 Konfiguration eines Kanals ...............................................................................6-30
6.6.7 Konfiguration von Profibus Modulen... .............................................................. 6-31
6.6.8 Konfiguration von CANopen Modulen............................................................... 6-39
6.6.9 Konfiguration eines CanDevice (CANopen Slave)............................................ 6-45
6.6.10 Konfiguration von DeviceNet Modulen.............................................................. 6-48
6.6.11 Steuerungskonfiguration im Online Modus ....................................................... 6-53
6.6.12 Hardware Scan/Status/Diagnose aus dem Zielsystem .....................................6-53
6.7 Taskkonfiguration... ................................................................................................ 6-54
6.7.1 Arbeiten im Taskkonfigurator ............................................................................ 6-55
6.7.2 System-Ereignisse ............................................................................................ 6-58
6.7.3 Taskkonfiguration im Online Modus.................................................................. 6-59
6.8 Watch- und Rezepturverwalter... ............................................................................6-61
6.8.1 Überblick ........................................................................................................... 6-61
6.8.2 Watch- und Rezepturverwalter im Offline Modus.............................................. 6-61
6.8.3 Watch- und Rezepturverwalter im Online Modus.............................................. 6-63
6.9 Traceaufzeichnung... ..............................................................................................6-64
6.9.1 Überblick und Konfiguration ..............................................................................6-64
6.9.2 Traceaufzeichnung durchführen .......................................................................6-66
6.9.3 Betrachten der Traceaufzeichnung ................................................................... 6-67
6.9.4 'Extras' 'Tracewerte speichern'.......................................................................... 6-69
6.9.5 'Extras' 'Externe Tracekonfigurationen' ............................................................. 6-70
6.10 Arbeitsbereich..................................................................................................... 6-71
6.11 Parameter Manager ........................................................................................... 6-71
6.11.1 Aktivieren des Parameter Managers................................................................. 6-72
6.11.2 Der Parameter Manager Editor, Overview ........................................................ 6-72
6.11.3 Parameterlisten: Typen und Attribute................................................................ 6-73
6.11.4 Parameterlisten verwalten................................................................................. 6-76
6.11.5 Parameterlisten editieren .................................................................................. 6-77
6.11.6 Parameter Manager im Online Modus .............................................................. 6-78
6.11.7 Export / Import von Parameterlisten.................................................................. 6-79
6.12 Zielsystemeinstellungen .....................................................................................6-80
6.13 PLC Browser....................................................................................................... 6-81
6.13.1 Allgemeines zur PLC-Browser- Bedienung....................................................... 6-81
ii CoDeSys V2.3
Inhalt
6.13.2 Kommandoeingabe im PLC-Browser................................................................ 6-82
6.13.3 Verwendung von Makros bei der Kommandoeingabe im PLC-Browser........... 6-83
6.13.4 Weitere PLC-Browser-Optionen ....................................................................... 6-84
6.14 Tools................................................................................................................... 6-84
6.14.1 Eigenschaften der bestehenden Verknüpfungen (Objekt Eigenschaften) ........ 6-85
6.14.2 Verwalten von Verknüpfungen.......................................................................... 6-88
6.14.3 Die wichtigsten Fragen zu Tools....................................................................... 6-89
7 ENI Versionsverwaltung 7-1
7.1.1 Was ist ENI ....................................................................................................... 7-1
7.1.2 Voraussetzungen für das Arbeiten mit einer ENI Projektdatenbank................. 7-1
7.1.3 Arbeiten in CoDeSys mit der Projektdatenbank................................................ 7-2
7.1.4 Kategorien innerhalb der Projektdatenbank...................................................... 7-2
8 DDE Kommunikation 8-1
8.1 DDE Schnittstelle des CoDeSys Programmiersystems... ...................................... 8-1
8.2 DDE Kommunikation über den GatewayDDE-Server... ......................................... 8-2
9 Lizenzmanagement in CoDeSys 9-1
9.1 Der 3S Licensing Manager..................................................................................... 9-1
9.1.1 Erstellen einer lizenzpflichtigen Bibliothek........................................................ 9-1
10 ANHANG 10-1
Anhang A IEC Operatoren und zusätzliche normerweiternde Funktionen 10-1
10.1 Arithmetische Operatoren... ............................................................................... 10-1
10.2 Bitstring Operatoren... ........................................................................................ 10-4
10.3 Bit-Shift Operatoren............................................................................................ 10-6
10.4 Auswahloperatoren... ......................................................................................... 10-9
10.5 Vergleichsoperatoren... ...................................................................................... 10-11
10.6 Adressoperatoren............................................................................................... 10-13
10.7 Aufrufoperator... ................................................................................................. 10-14
10.8 Typkonvertierungen............................................................................................ 10-15
10.9 Numerische Operatoren... .................................................................................. 10-20
10.10 Initialisierungs-Operator ..................................................................................... 10-24
Anhang B Operanden in CoDeSys 10-27
10.11 Konstanten... ...................................................................................................... 10-27
10.12 Variablen... ......................................................................................................... 10-29
10.13 Adressen... ......................................................................................................... 10-32
10.14 Funktionen.......................................................................................................... 10-33
Anhang C Datentypen in CoDeSys 10-35
10.15 Standard Datentypen ......................................................................................... 10-35
10.16 Definierte Datentypen......................................................................................... 10-37
Anhang D CoDeSys Bibliotheken 10-45
10.17 Die Bibliothek Standard.lib ................................................................................. 10-45
10.17.1 String Funktionen.............................................................................................. 10-45
10.17.2 Bistabile Funktionsblöcke... .............................................................................. 10-48
10.17.3 Flankenerkennung... ......................................................................................... 10-50
10.17.4 Zähler................................................................................................................ 10-51
CoDeSys V2.3 iii
Inhalt
10.17.5 Timer................................................................................................................. 10-53
10.18 Die Bibliothek Util.lib........................................................................................... 10-57
10.18.1 BCD-Konvertierung... ........................................................................................ 10-57
10.18.2 Bit-/Byte-Funktionen.......................................................................................... 10-57
10.18.3 Mathematische Hilfsfunktionen... ...................................................................... 10-58
10.18.4 Regler................................................................................................................ 10-61
10.18.5 Signalgeneratoren............................................................................................. 10-64
10.18.6 Funktionsmanipulatoren.................................................................................... 10-66
10.18.7 Analogwertverarbeitung... ................................................................................. 10-67
10.19 Die Bibliothek AnalyzationNew.lib ...................................................................... 10-68
10.20 Die CoDeSys Systembibliotheken...................................................................... 10-69
Anhang E Übersicht: Operatoren und Bibliotheksbausteine 10-71
10.21 Operatoren in CoDeSys......................................................................................10-71
10.22 Bibliotheksbausteine der Standard.lib ................................................................ 10-74
10.23 Bibliotheksbausteine der Util.lib.......................................................................... 10-75
Anhang F Kommandozeilen-/Kommandodatei-Befehle 10-77
10.24 Kommandozeilen-Befehle...................................................................................10-77
10.25 Kommandodatei (Cmdfile)-Befehle..................................................................... 10-78
Anhang G Siemens Import 10-87
10.26 SEQ-Symbolikdatei importieren.......................................................................... 10-87
10.27 S5-Datei importieren........................................................................................... 10-88
10.28 Konvertierung S5 nach IEC 1131-3.................................................................... 10-88
Anhang H Dialoge der Zielsystemeinstellungen 10-93
10.29 Einstellungen in Kategorie Zielplattform ............................................................. 10-94
10.29.1 Zielsystem 'Intel 386 compatible', Zielplattform................................................. 10-94
10.29.2 Zielsystem Motorola 68K, Kategorie Zielplattform ............................................10-95
10.29.3 Zielsystem Infineon C16x, Kategorie Zielplattform............................................ 10-96
10.29.4 Zielsysteme Intel StrongARM und Power PC, Kategorie Zielplattform ............. 10-97
10.29.5 Zielsystem MIPS III ISA, Kategorie Zielplattform .............................................. 10-98
10.29.6 Zielsystem Hitachi SH, Kategorie Zielplattform................................................. 10-99
10.29.7 Zielsystem 8051 compatible, Kategorie Zielplattform .......................................10-100
10.29.8 Zielsystem TriCore, Kategorie Zielplattform...................................................... 10-100
10.30 Einstellungen in Kategorie Speicheraufteilung ................................................... 10-101
10.31 Einstellungen in Kategorie Allgemein ................................................................. 10-103
10.32 Einstellungen in Kategorie Netzfunktionen......................................................... 10-105
10.33 Einstellungen in Kategorie Visualisierung...........................................................10-106
Anhang I Tastaturbedienung 10-109
10.34 Tastaturbedienung.............................................................................................. 10-109
10.35 Tastenkombinationen ......................................................................................... 10-109
Anhang J Empfehlungen zur Bezeichnervergabe 10-113
10.36 Bezeichnervergabe bei der Deklaration..............................................................10-113
10.37 Bezeichner für Variablen (Variablennamen)....................................................... 10-113
10.38 Bezeichner für benutzerdefinierte Datentypen (DUT)......................................... 10-115
10.39 Bezeichner für Funktionen, Funktionsblöcke, Programme (POUs).................... 10-115
10.40 Bezeichner für Visualisierungen ......................................................................... 10-116
iv CoDeSys V2.3
Inhalt
Anhang K Übersetzungsfehler und -warnungen 10-117
10.41 Warnungen......................................................................................................... 10-117
10.42 Übersetzungsfehler... ......................................................................................... 10-123
11 Index I
CoDeSys V2.3 v
Inhalt
vi CoDeSys V2.3
1 - Kurzer Einblick in CoDeSys

1 Kurzer Einblick in CoDeSys

1.1 Was ist CoDeSys

CoDeSys steht für Controller Development System. Es ist eine Entwicklungsumgebung für
Steuerungen.
CoDeSys ermöglicht dem SPS-Programmierer einen einfachen Einstieg in die mächtigen Sprachmittel der IEC. Die Benutzung der Editoren und der Debugging-Funktionen hat die ausgereiften Entwicklungsumgebungen höherer Programmiersprachen zum Vorbild (wie etwa Visual C++).

1.2 Überblick über die Funktionalität von CoDeSys...

Wie ist ein Projekt strukturiert?
Ein Projekt, das das Steuerungsprogramm umfasst, wird in einer Datei abgelegt, die den Namen des Projekts trägt. Ein Projekt enthält verschiedene Arten von Objekten: Bausteine, Datentypen­Definitionen, Darstellungselemente (Visualisierung) und Ressourcen.
Der erste Baustein, der in einem neuen Projekt angelegt wird, trägt automatisch den Namen PLC_PRG. Dort startet die Ausführung (entsprechend der main-Funktion in einem C-Programm), und von hier aus können andere Bausteine aufgerufen werden (Programme, Funktionsblöcke und Funktionen).
Wenn Sie eine Taskkonfiguration (Ressourcen) definiert haben, muss kein Programm mit Namen PLC_PRG angelegt werden. Näheres hierzu finden Sie im Kapitel 6.7,Taskkonfiguration.
Im Object Organizer finden Sie alle Objekte Ihres Projekts aufgelistet.
Wie erstelle ich mein Projekt?
Zunächst müssen die Zielsystemeinstellungen für Ihre Steuerung eingestellt und gegebenenfalls angepasst werden.
Dann sollten Sie Ihre Steuerung konfigurieren, um die im Projekt ver wendeten Ein- und Ausgangsadressen auf Korrektheit überprüfen zu können.
Anschließend können Sie die notwendigen Bausteine an legen und in den gewünschten Sprachen programmieren.
Nach Abschluss der Programmierung können Sie das Projekt übersetzen, und eventuell angezeigte Fehler beseitigen.
Wie kann ich mein Projekt testen?
Sind alle Fehler beseitigt, aktivieren Sie die Simulation, loggen sich in der simulierten Steuerung ein und 'laden' Ihr Projekt in die Steuerung. Sie befinden sich nun im Onlinebetrieb.
Sie können nun das Fenster mit Ihrer Steuerungskonfiguration öffnen und Ihr Projekt auf korrekten Ablauf testen. Belegen Sie hierzu manuell die Eingänge, und beobachten Sie, ob die Ausgänge wie gewünscht gesetzt werden. Des Weiteren können Sie in den Bausteinen den Werteverlauf der lokalen Variablen beobachten. Im Watch- und Rezepturverwalter können Sie die Datensätze konfigurieren, deren Werte Sie betrachten wollen.
Debugging
Im Falle eines Programmierfehlers können Sie Breakpoints (Haltepunkte) setzen. Stoppt die Ausführung in einem solchen Breakpoint, so können Sie die Werte sämtlicher Projektvariablen zu diesem Zeitpunkt einsehen. Durch schritt weises Abarbeiten (Einzelschritt), können Sie die logische Korrektheit Ihres Programms überprüfen.
CoDeSys V2.3 1-1
Überblick über die Funktionalität von CoDeSys...
Weitere Online-Funktionalitäten
Weitere Debugging-Funktionen: Sie können Programmvariablen und Ein/Ausgänge auf bestimmte Werte setzen. Mit der Ablaufkontrolle können Sie überprüfen, welche Programmzeilen durchlaufen wurden. Ein Logbuch zeichnet Vorgänge bzw. Benutzeraktionen und interne Vorgänge während der Online-
Sessions chronologisch auf. Die Traceaufzeichnung bietet Ihnen die Möglichkeit, den Verlauf von Variablen zyklusecht über
einen längeren Zeitraum aufzuzeichnen und darzustellen. Diese Funktion muss in den Zielsystemeinstellungen aktiviert sein.
Ebenso abhängig von den Zielsystemeinstellungen steht optional ein PLC-Browser zur Abfrage bestimmter Informationen aus der Steuerung zur Verfügung.
Ist das Projekt erstellt und getestet, so kann es in die Hardware geladen und auch hier getestet werden. Es stehen Ihnen die gleichen Onlinefunktionen wie bei der Simulation zur Verfügung.
Weitere Möglichkeiten von CoDeSys
Das gesamte Projekt kann jederzeit dokumentiert, in eine Textdatei exportiert und in eine andere Sprache übersetzt werden.
Zur Kommunikation verfügt CoDeSys über eine Symbol- eine DDE- sowie eine COM-Schnittstelle. Ein Gateway-Server plus OPC-Server und DDE-Server sind Bestandteil der CoDeSys­Standardinstallation.
Das Verwenden des entsprechenden Satzes von Zielsystemeinstellungen, die über eine Target Datei (Target Support Package) geladen werden, ermöglicht es, dasselbe CoDeSys Projekt auf verschiedenen Zielsystemen anzuwenden.
Netzwerkglobale Variablen und ein Parameter Manager (Objektverzeichnis) können optional (abhängig von den Zielsystemeinstellungen) für den Datenaustausch in einem Netzwerk mit anderen Steuerungen genützt werden.
ENI: Die Schnittstelle 'En
gineering Interface' kann benützt werden, um über den eigenständigen ENI Server auf eine externe Datenbank zuzugreifen, in der CoDeSys Bausteine bzw. Übersetzungsdateien verwaltet werden. Diese stehen damit auch anderen Clients des ENI Servers zur Verfügung, was z.B. einen Multi-User-Betrieb bei der Erstellung von CoDeSys Projekten, einen gemeinsamen Datenpool für verschiedene Tools neben CoDeSys, sowie eine Versionsverwaltung erlaubt.
Tools: Der Tool-Mechanismus dient dazu, zielsystemspezifische Exe-Dateien in CoDeSys einzubinden. Außerdem können Dateien festgelegt werden, die auf die Steuerung geladen werden sollen. Man kann Tool-Verknüpfungen für ein Zielsystem in der Target-Datei vordefinieren oder auch im Projekt individuell im Ressourcen-Baum einfügen. Die Verfügbarkeit der Tools-Funktion ist zielsystemabhängig.
Eine CoDeSys Visualisierung kann mit CoDeSys HMI als pure Bedienoberfläche eingesetzt werden oder zielsystemabhängig als Web-Visualisierung und/oder Target-Visualisierung aufbereitet werden. Letztere ermöglichen ein Aufrufen der die Daten der laufenden Steuerung anzeigenden Visualisierung über das Internet bzw. direkt auf einem Monitor am Steuerungsrechner. Sehen Sie zur CoDeSys Visualisierung das separate Benutzerhandbuch.
Bibliotheken, die in CoDeSys erstellt werden, können mit Lizenzinformation versehen werden, die ihre Verwendung lizenzabhängig macht.
1-2 CoDeSys V2.3
1 - Kurzer Einblick in CoDeSys

1.3 Übersicht der Anwender-Dokumentation zu CoDeSys

Modul Inhalt der Doku Name der Datei
CoDeSys Programmiersystem
vorliegendes Handbuch sowie Online Hilfe über Hilfe-Menü des Programmiersystems
Erste Schritte mit dem CoDeSys Programmiersystem
CoDeSys_V23_D.pdf
Erste Schritte mit CoDeSys V23.pdf
Gateway Server Konzept, Installation und User Interface;
sowie Online Hilfe zum User Interface über Gateway Menü, das durch Mausklick auf Gateway-Symbol in der Systemleiste geöffnet wird
(nur in Englisch verfügbar)
OPC Server OPC-Server V2.0, Installation und
Benutzung
CoDeSys Visualisierung
SoftMotion Handbuch zur Bedienung, partielle
Bibliotheken Standard.lib und Util.lib sind im
ENI Server Installation und Konfiguration des ENI
Handbuch zur CoDeSys Visualisierung incl. CoDeSys HMI, Target- und Web­Visualisierung
Beschreibung der SoftMotion-Bibliotheken
vorliegenden Handbuch beschrieben. Für die CoDeSys Systembibliotheken gibt
es je ein separates Dokument das den Namen der Bibliothek trägt.
(SoftMotion-Bibliotheken: siehe SoftMotion-Dokumenation.)
Servers im Hinblick auf die Verwaltung eines CoDeSys-Projekts in einer externen Datenbank.
Zur Konfiguration in CoDeSys siehe vorliegendes Handbuch.
Zu ENI Admin, ENI Control und ENI Explorer siehe jeweilige Online Hilfe.
Gateway Manual.pdf
OPC_20_How_to_use_D.pdf
CoDeSys_Visu_V23_D.pdf
CoDeSys_SoftMotion_V23_D.pdf
<SysLib-Name>.pdf CoDeSys_V23_D.pdf
EniServerQuickstart_D.pdf CoDeSys_V23_D.pdf
CoDeSys V2.3 1-3
Übersicht der Anwender-Dokumentation zu CoDeSys
1-4 CoDeSys V2.3
2 - Was ist was in CoDeSys

2 Was ist was in CoDeSys

2.1 Bestandteile eines Projekts...

Projekt

Ein Projekt beinhaltet alle Objekte eines Steuerungsprogramms. Ein Projekt wird in einer Datei mit dem Namen des Projekts gespeichert. Zu einem Projekt gehören folgende Objekte:
Bausteine, Datentypen, Visualisierungen, Ressourcen und Bibliotheken.

Baustein

Funktionen, Funktionsblöcke und Programme sind Bausteine, die durch Aktionen ergänzt werden können.
Jeder Baustein besteht aus einem Deklarationsteil und einem Code-Teil. Der Code-Teil ist in einer der IEC-Programmiersprachen AWL, ST, AS, FUP, KOP oder CFC geschrieben.
CoDeSys unterstützt alle IEC-Standardbausteine. Wenn Sie diese Bausteine in Ihrem Projekt benutzen wollen, müssen Sie die Bibliothek standard.lib in Ihr Projekt einbinden.

Funktion

Bausteine können andere Bausteine aufrufen. Rekursionen sind jedoch nicht erlaubt.
Eine Funktion ist ein Baustein, der als Ergebnis der Ausführung genau ein Datum (das auch mehrelementig sein kann, wie z.B. Felder oder Strukturen) zurückliefert. Der Aufruf einer Funktion kann in textuellen Sprachen als ein Operator in Ausdrücken vorkommen.
Bei der Deklaration einer Funktion ist darauf zu achten, dass die Funktion einen Typ erhalten muss. D.h. nach dem Funktionsnamen muss ein Doppelpunkt gefolgt von einem Typ eingegeben werden. Beachten Sie außerdem die Empfehlungen zur Namensvergabe, Anhang J.
Eine korrekte Funktionsdeklaration sieht z.B. so aus:
FUNCTION Fct: INT
Außerdem muss der Funktion ein Ergebnis zugewiesen werden. D.h. der Funktionsname wird benutzt wie eine Ausgabevariable.
Eine Funktionsdeklaration beginnt mit dem Schlüsselwort FUNCTION.
In AS kann ein Funktionsaufruf nur innerhalb von Aktionen eines Schrittes oder in einer Transition erfolgen.
In ST kann ein Funktionsaufruf als Operand in Ausdrücken verwendet werden.
Hinweis: CoDeSys erlaubt die Verwendung von globalen Variablen innerhalb einer Funktion. Dies weicht
bewusst von der IEC61131-3 Norm ab, nach der der Rückgabewert einer Funktion ausschließlich durch die Eingabeparameter verändert wird. Der Unterschied zwischen Funktionen und Programmen besteht somit nur darin, dass Funktionen nur genau einen Rückgabewert liefern und dass ihre Parameter und Rückgabewerte über den Stack übergeben werden.
Beispiele für den Aufruf der oben beschriebenen Funktion:
in AWL:
LD 7
Fct 2,4 ST Ergebnis
in ST:
Ergebnis := Fct(7, 2, 4);
CoDeSys V2.3 2-1
in FUP:
Achtung: Wird eine lokale Variable in einer Funktion als RETAIN deklariert, hat dies keine Auswirkung. Die
Variable wird nicht im Retain-Bereich gespeichert!
Hinweis: Wenn Sie in Ihrem Projekt eine Funktion mit Namen CheckBounds definieren, können Sie damit
Bereichsüberschreitungen in Arrays automatisch überprüfen (siehe Anhang C, Die Datentypen).
Wenn Sie die Funktionen CheckDivByte, CheckDivWord, CheckDivDWord und CheckDivReal definieren, können Sie damit bei Verwendung des Operators DIV den Wert des Divisors überprüfen, beispielsweise um eine Division durch 0 zu verhindern (siehe Anhang A, Die IEC Operatoren).
Wenn Sie die Funktionen CheckRangeSigned und CheckRangeUnsigned definieren, können Sie damit im Online-Betrieb automatisch Bereichsüberschreitungen bei Variablen, die mit Unterbereichstypen (siehe Anhang C, Die Datentypen) deklariert sind, abfangen. Die genannten Funktionsnamen sind aufgrund der hier beschriebenen Einsatzmöglichkeit reserviert.
Funktionsbaustein (Funktionsblock)
Bestandteile eines Projekts...
Ein Funktionsbaustein - auch Funktionsblock genannt - ist ein Baustein der bei der Ausführung einen oder mehrere Werte liefert. Ein Funktionsblock liefert keinen Rückgabewert im Gegensatz zu einer Funktion.
Eine Funktionsblockdeklaration beginnt mit dem Schlüsselwort FUNCTION_BLOCK.
Beachten Sie die Empfehlungen zur Namensvergabe, Anhang J.
Es können Vervielfältigungen, genannt Instanzen (Kopien) eines Funktionsblocks geschaffen werden.
Beispiel in AWL für einen Funktionsblock mit zwei Eingabevariablen und zwei Ausgabevariablen. Eine Ausgabe ist das Produkt der beiden Eingaben, die andere ein Vergleich auf Gleichheit:

Instanzen von Funktionsblöcken

Es können Vervielfältigungen, genannt Instanzen (Kopien) eines Funktionsblocks geschaffen werden.
Jede Instanz besitzt einen zugehörigen Bezeichner (den Instanznamen), und eine Datenstruktur, die ihre Eingaben, Ausgaben und internen Variablen beinhaltet. Instanzen werden wie Variablen lokal
2-2 CoDeSys V2.3
2 - Was ist was in CoDeSys
oder global deklariert, indem als Typ eines Bezeichners der Name des Funktionsblocks angegeben wird.
Beachten Sie die Empfehlungen zur Namensvergabe, Anhang J.
Beispiel für eine Instanz mit Namen INSTANZ des Funktionsblocks FUB:
INSTANZ: FUB;
Aufrufe von Funktionsblöcken geschehen stets über die oben beschriebenen Instanzen.
Nur auf die Ein- und Ausgabeparameter kann von außerhalb einer Instanz eines Funktionsblocks zugegriffen werden, nicht auf dessen interne Variablen.
Die Deklarationsteile von Funktionsblöcken und Programmen können Instanzdeklarationen beinhalten. Instanzdeklarationen in Funktionen sind nicht zulässig.
Der Zugriff auf die Instanz eines Funktionsblocks ist auf den Baustein beschränkt, in dem sie instanziert wurde, es sei denn, sie wurde global deklariert.
Der Instanzname einer Instanz eines Funktionsblocks kann als Eingabe einer Funktion oder eines Funktionsblocks benutzt werden.
Hinweis: Alle Werte bleiben von einer Ausführung des Funktionsblocks bis zur nächsten erhalten. Daher
liefern Aufrufe eines Funktionsblocks mit denselben Argumenten nicht immer dieselben Ausgabewerte!
Hinweis: Enthält der Funktionsblock mindestens eine Retain-Variable, wird die gesamte Instanz im Retain-
Bereich gespeichert.

Aufruf eines Funktionsblocks

Man kann die Eingabe- und Ausgabevariablen eines Funktionsblocks von einem anderen Baustein aus ansprechen, indem man eine Instanz des Funktionsblocks anlegt und über folgende Syntax die gewünschte Variable angibt:
<Instanzname>.<Variablenname>
Zuweisung der Parameter beim Aufruf:
Wenn man die Eingabe- und/oder Ausgabeparameter beim Aufruf setzen will, dann geschieht das bei den Textsprachen AWL und ST, indem man nach dem Instanznamen des Funktionsblocks in Klammer den Parametern Werte zuweist. Die Zuweisung geschieht bei Eingabeparametern durch ":=" wie bei der Initialisierung von Variablen an der Deklarationsstelle, bei Ausgabeparametern mit "=>").
Wird die Instanz unter Verwendung der Eingabehilfe (<F2>) mit Option Mit Argumenten im Implementationsfenster eines ST oder AWL-Bausteins eingefügt, wird sie automatisch in dieser Syntax mit ihren Parametern dargestellt. Die Parameter müssen jedoch dann nicht zwingend belegt werden.
Beispiel:
FBINST ist eine lokale Variable vom Typ eines Funktionsblocks, der die Eingabevariable xx und die Ausgabevariable yy enthält. Beim Aufruf von FBINST über die Eingabehilfe wird sie so in ein ST­Programm eingefügt: FBINST1(xx:= , yy=> );
EinAusgabevariablen beim Aufruf: Beachten Sie, dass EinAusgabevariablen (VAR_IN_OUT) eines Funktionsblocks als Pointer
übergeben werden. Ihnen können deshalb beim Aufruf keine Konstanten zugewiesen werden und es kann nicht lesend oder schreibend von außen auf sie zugegriffen werden.
Beispiel
Aufruf einer VAR_IN_OUT Variable inout1 des Funktionsblocks fubo in einem ST-Baustein:
VAR inst:fubo; var1:int; END_VAR var1:=2; inst(inout1:=var1);
Nicht zulässig wäre: inst(inout1:=2); bzw. inst.inout1:=2;
CoDeSys V2.3 2-3
Bestandteile eines Projekts...
Beispiele für den Aufruf des Funktionsblocks FUB:
siehe oben, Absatz 'Funktionsblock'
Das Multiplikationsergebnis wird in der Variablen ERG abgelegt, das Ergebnis des Vergleichs wird in QUAD gespeichert. Es sei eine Instanz von FUB mit dem Namen INSTANZ deklariert.
So wird die Instanz eines Funktionsblocks in AWL aufgerufen:
So wird die Instanz eines Funktionsblocks in ST aufgerufen (Deklarationsteil wie bei AWL):
So wird die Instanz eines Funktionsblocks in FUP aufgerufen (Deklarationsteil wie bei AWL):
In AS können Aufrufe von Funktionsblöcken nur in Schritten vorkommen.
2-4 CoDeSys V2.3

Programm

Ein Programm ist ein Baustein, der bei der Ausführung einen oder mehrere Werte liefert. Programme sind global im gesamten Projekt bekannt. Alle Werte bleiben von einer Ausführung des Programms bis zur nächsten erhalten.
Eine Programmdeklaration beginnt mit dem Schlüsselwort PROGRAM und endet mit END_PROGRAM. Beachten Sie die Empfehlungen zur Namensvergabe, Anhang J.
Beispiel für ein Programm:
Programme können von Programmen und Funktionsblöcken aufgerufen werden. Ein Programmaufruf in einer Funktion ist nicht erlaubt. Es gibt auch keine Instanzen von Programmen.
2 - Was ist was in CoDeSys
Wenn ein Baustein ein Programm aufruft, und es werden dabei Werte des Programms verändert, dann bleiben diese Veränderungen beim nächsten Aufruf des Programms erhalten, auch wenn das Programm von einem anderen Baustein aus aufgerufen wird.
Dies ist anders als beim Aufruf eines Funktionsblocks. Dort werden nur die Werte in der jeweiligen Instanz eines Funktionsblocks geändert. Diese Veränderungen spielen also auch nur eine Rolle, wenn dieselbe Instanz aufgerufen wird.
Wenn man beim Aufruf eines Programms die Eingabe- und/oder Ausgabeparameter, also Werte der Ein-/Ausgabevariablen beim Aufruf setzen will, dann geschieht das bei den Textsprachen AWL und ST, indem man nach dem Programmnamen in Klammer den Parametern Werte zuweist. Die Zuweisung erfolgt durch ":=" wie bei der Initialisierung von Variablen an der Deklarationsstelle.
Wird ein Programm unter Verwendung der Eingabehilfe (<F2>) mit Option MIt Argumenten im Implementationsfenster eines ST oder AWL-Bausteins eingefügt, wird sie automatisch in dieser Syntax mit ihren Parametern dargestellt. Die Parameter müssen jedoch dann nicht zwingend belegt werden.
Beispiele für Aufrufe eines Programms:
In einem Programm PRGexample2 sind die Eingabevariable in_var und die Ausgabevariable out_var jeweils vom Typ INT deklariert. Lokal deklariert ist die Variable erg, ebenfalls vom Typ INT:
In AWL:
CAL PRGexample2
LD PRGexample2.out_var ST ERG oder mit unmittelbarer Angabe der Parameter (Eingabehilfe "Mit Argumenten", s.o.):
CAL PRGexample2(in_var:=33, out_var=>erg )
In ST:
PRGexample; Erg := PRGexample2.out_var; oder mit unmittelbarer Angabe der Parameter (Eingabehilfe "Mit Argumenten", s.o.):
PRGexample2(in_var:=33, out_var=>erg );
CoDeSys V2.3 2-5

PLC_PRG

Bestandteile eines Projekts...
In FUP:
Beispiel für eine mögliche Aufrufsequenz von PLC_PRG:
Sehen Sie hierzu das Programm PRGbeispiel in der Abbildung zu Beginn dieses Kapitels:
LD 0
ST PRGbeispiel.PAR (*PAR wird mit 0 vorbesetzt*) CAL AWLaufruf (*ERG in AWLaufruf ergibt sich zu 1*) CAL STaufruf (*ERG in STaufruf ergibt sich zu 2*)
CAL FUPaufruf (*ERG in FUPaufruf ergibt sich zu 3*)
Wenn von einem Hauptprogramm aus zunächst die Variable PAR des Programms PRGbeispiel mit 0 initialisiert wird, und dann nacheinander Programme mit den obigen Programmaufrufen aufgerufen werden, dann wird das Ergebnis Erg in den Programmen die Werte 1,2 und 3 haben. Wenn man die Reihenfolge der Aufrufe vertauscht, ändern sich dem entsprechend auch die Werte der jeweiligen Ergebnisparameter.

Aktion

Es ist möglich, aber nicht zwingend, die Projektabarbeitung über so genannte Tasks (Taskkonfiguration) zu steuern. Liegt jedoch keine Taskkonfiguration vor, muss
das Projekt den
Baustein PLC_PRG enthalten. Der PLC_PRG wird als Baustein vom Typ Programm automatisch erzeugt, wenn in einem neu angelegten Projekt erstmalig mit 'Projekt' 'Objekt einfügen' ein Baustein eingefügt wird. PLC_PRG wird pro Steuerungszyklus genau einmal aufgerufen.
Liegt eine Taskkonfiguration vor, darf das Projekt kein PLC_PRG enthalten, da dann die Ausführungsreihenfolge von der Taskzuordnung abhängt.
Vorsicht: Löschen Sie den Baustein PLC_PRG nicht und benennen Sie ihn auch nicht um (vorausgesetzt Sie
verwenden keine Taskkonfiguration. PLC_PRG ist generell das Hauptprogramm in einem Single­Task Programm.
Zu Funktionsblöcken und Programmen können Aktionen definiert und hinzugefügt werden ('Projekt' 'Aktion hinzufügen'). Die Aktion stellt eine weitere Implementation dar, die durchaus in einer anderen Sprache als die 'normale' Implementation erstellt werden kann. Jede Aktion erhält einen Namen.
Eine Aktion arbeitet mit den Daten des Funktionsblocks bzw. Programms, zu dem sie gehört. Die Aktion verwendet die gleichen Ein-/ Ausgabevariablen und lokalen Variablen, wie die 'normale' Implementation.
Beispiel für eine Aktion eines Funktionsblocks:
2-6 CoDeSys V2.3
2 - Was ist was in CoDeSys
In diesem Beispiel wird bei Aufruf des Funktionsblocks Counter die Ausgabevariable out erhöht bzw. erniedrigt in Abhängigkeit der Eingabevariablen in. Bei Aufruf der Aktion 'Reset' des Funktionsblocks wird die Ausgabevariable out auf Null gesetzt. Es wird in beiden Fällen die gleiche Variable out beschrieben.
Aufruf einer Aktion:
Eine Aktion wird mit <Programmname>.<Aktionsname> bzw. <Instanzname>.<Aktionsname> aufgerufen. Beachten Sie die Schreibweise im FUP (siehe Beispiel unten). Soll die Aktion innerhalb des eigenen Bausteins aufgerufen werden, so verwendet man in den Texteditoren nur den Aktionsnamen und in den grafischen den Funktionsblockaufruf ohne Instanzangabe.
Beispiele für Aufrufe der obigen Aktion aus einem anderen Baustein:
Deklaration für alle Beispiele:
PROGRAM PLC_PRG VAR inst : counter;
END_VAR
Aufruf von Aktion 'Reset' in einem anderen Baustein, der in AWL programmiert ist:
CAL inst.Reset(in := FALSE) LD inst.out ST ERG
Aufruf in einem anderen Baustein, der in ST programmiert ist:
inst.Reset(in := FALSE);
Erg := inst.out;
Aufruf in einem anderen Baustein, der in FUP programmiert ist:
Hinweis: Bei Bausteinen in Ablaufsprache spielen Aktionen eine besondere Rolle.

Ressourcen

Die Ressourcen benötigen Sie zum Konfigurieren und Organisieren Ihres Projektes und zur Verfolgung von Variablenwerten:
• Globale Variablen, die im gesamten Projekt bzw. Netzwerk verwendet werden können
• Bibliotheken, die über den Bibliotheksverwalter ins Projekt eingebunden werden können
• Logbuch zum Aufzeichnen der Online-Aktivitäten
• Alarmkonfiguration zum Konfigurieren von Alarmbehandlung im Projekt
• Steuerungskonfiguration zum Konfigurieren Ihrer Hardware
• Taskkonfiguration zur Steuerung Ihres Programms über Tasks
• Watch- und Rezepturverwalter in zum Anzeigen und Vorbelegen von Variablenwerten
• Zielsystemeinstellungen zur Anwahl und gegebenenfalls Endkonfiguration des Zielsystems
• Arbeitsbereich mit einem Abbild der Projektoptionen
Abhängig vom gewählten Zielsystem bzw. den in CoDeSys vorgenommenen Zielsystemeinstellungen können folgende Ressourcen ebenfalls verfügbar sein:
• Parameter Manager für den Datenaustausch mit anderen Steuerungen in einem Netzwerk
• PLC-Browser als Monitor der Steuerung
• Traceaufzeichnung zur grafischen Aufzeichnung von Variablenwerten
• Tools zum Aufruf externer Anwendungen
CoDeSys V2.3 2-7
• SoftMotion Funktionalität (lizenzpflichtig) mit CNC-Editor (CNC-Programmliste) und CAM-Editor
(Kurvenscheiben)
Siehe hierzu Kapitel 6, Ressourcen.

Bibliotheken

Sie können in Ihr Projekt eine Reihe von Bibliotheken einbinden, deren Bausteine, Datentypen und globale Variablen Sie genauso benutzen können wie selbst definierte. Die Bibliotheken standard.lib und util.lib stehen Ihnen standardmäßig zur Verfügung.
Siehe hierzu Kapitel 6.3, Bibliotheksverwaltung, 'Bibliotheksverwaltung'.

Datentypen

Neben den Standarddatentypen können vom Benutzer eigene Datentypen definiert werden. Strukturen, Aufzählungstypen und Referenzen können angelegt werden.
Siehe hierzu Anhang C, Die Datentypen.

Visualisierung

CoDeSys stellt Ihnen zur Veranschaulichung Ihrer Projektvariablen die Möglichkeit einer Visualisierung zur Verfügung. Mit Hilfe der Visualisierung kann man im Offline Modus geometrische Elemente zeichnen. Diese können dann im Online Modus in Abhängigkeit von bestimmten Variablenwerten ihre Form/Farbe/Textausgabe verändern.
Die Sprachen...
Eine Visualisierung kann auch als ausschließliche Bedienoberfläche eines Projekts mit CoDeSys HMI oder zielsystemabhängig auch als Web- oder Target-Visualisierung über Internet bzw. auf dem Zielsystem genutzt werden.
Siehe hierzu das Dokument 'CoDeSys Visualisierung'.

2.2 Die Sprachen...

Unterstützte Programmiersprachen

CoDeSys unterstützt alle in der Norm IEC-61131 beschriebenen Programmiersprachen:
Textuelle Sprachen:
• Anweisungsliste (AWL)
• Strukturierter Text (ST)
Grafische Sprachen:
• Ablaufsprache (AS)
• Kontaktplan (KOP)
• Funktionsplan (FUP)
• Zusätzlich gibt es auf Basis des Funktionsplans den Freigraphischen Funktionsplan (CFC).

2.2.1 Anweisungsliste (AWL)...

Eine Anweisungsliste (AWL) besteht aus einer Folge von Anweisungen. Jede Anweisung beginnt in einer neuen Zeile, und beinhaltet einen Operator und, je nach Art der Operation, einen oder mehrere durch Kommata abgetrennte Operanden.
Vor einer Anweisung kann sich ein Identifikator Marke befinden, gefolgt von einem Doppelpunkt (:). Er dient der Kennzeichnung der Anweisung und kann beispielsweise als Sprungziel verwendet werden.
2-8 CoDeSys V2.3
Ein Kommentar muss das letzte Element in einer Zeile sein. Leere Zeilen können zwischen Anweisungen eingefügt werden.
Beispiel:
LD 17 ST lint (* Kommentar *)
GE 5 JMPC next LD idword
EQ istruct.sdword STN test next:
Modifikatoren und Operatoren in AWL
In der Sprache AWL können folgende Operatoren und Modifikatoren verwendet werden.
Modifikatoren:
bei JMP, CAL, RET: Die Anweisung wird nur ausgeführt, wenn das Ergebnis des
• C
vorhergehenden Ausdrucks TRUE ist.
2 - Was ist was in CoDeSys
bei JMPC, CALC,
• N
RETC:
sonst: Negation des Operanden (nicht des Akku).
• N
Die Anweisung wird nur ausgeführt, wenn das Ergebnis des vorhergehenden Ausdrucks FALSE ist.
Im Folgenden finden Sie eine Tabelle aller Operatoren in AWL mit deren möglichen Modifikatoren und der jeweiligen Bedeutung:
Operator Modifikatoren Bedeutung
LD N Setze aktuelles Ergebnis gleich dem Operanden
ST N Speichere aktuelles Ergebnis an die Operandenstelle
S
R
AND N,( Bitweise AND
OR N,( Bitweise OR
XOR N,( Bitweise exklusives OR
ADD ( Addition
SUB ( Subtraktion
MUL ( Multiplikation
Setze den Bool-Operand genau dann auf TRUE, wenn das aktuelle Ergebnis TRUE ist
Setze den Bool-Operand genau dann auf FALSE, wenn das aktuelle Ergebnis TRUE ist
DIV ( Division
GT ( >
GE ( >=
EQ ( =
NE ( <>
LE ( <=
LT ( <
JMP CN Springe zur Marke
CoDeSys V2.3 2-9
Die Sprachen...
CAL CN Rufe Programm oder Funktionsblock auf
RET CN Verlasse den Baustein und kehre ggf. zurück zum Aufrufer.
)
Werte zurückgestellte Operation aus
Eine Auflistung sämtlicher IEC-Operatoren finden Sie im Anhang.
Beispiel für ein AWL-Programm unter Verwendung einiger Modifikatoren:
LD TRUE (*Lade TRUE in den Akkumulator*)
ANDN BOOL1 (*führe AND mit dem negierten Wert der Variable BOOL1 aus*)
JMPC marke (*wenn das Ergebnis TRUE war, springe zur Marke "marke"*)
LDN BOOL2 (*Speichere den negierten Wert von *)
ST ERG (*BOOL2 in ERG*)
Marke:
LD BOOL2 (*Speichere den Wert von *)
ST ERG *BOOL2 in ERG*)
Es ist in AWL auch möglich, Klammern nach einer Operation zu setzen. Als Operand wird dann der Wert der Klammer betrachtet.
Zum Beispiel:
LD 2
MUL 2 ADD 3
Erg
Hier ist der Wert von Erg 7. Wenn man aber Klammern setzt
LD 2 MUL (2 ADD 3
) ST Erg
ergibt sich als Wert für Erg 10, denn die Operation MUL wird erst ausgewertet, wenn man auf ")" trifft; als Operand für MUL errechnet sich dann 5.

2.2.2 Strukturierter Text (ST)...

Der Strukturierte Text besteht aus einer Reihe von Anweisungen, die wie in Hochsprachen bedingt ("IF..THEN..ELSE) oder in Schleifen (WHILE..DO) ausgeführt werden können.
Beispiel:
IF value < 7 THEN WHILE value < 8 DO
value := value + 1; END_WHILE; END_IF;
2-10 CoDeSys V2.3
Ausdrücke
Ein Ausdruck ist ein Konstrukt, das nach seiner Auswertung einen Wert zurückliefert.
Ausdrücke sind zusammengesetzt aus Operatoren und Operanden. Ein Operand kann eine Konstante, eine Variable, ein Funktionsaufruf oder ein weiterer Ausdruck sein.
Auswertung von Ausdrücken
Die Auswertung eines Ausdrucks erfolgt durch Abarbeitung der Operatoren nach bestimmten Bindungsregeln. Der Operator mit der stärksten Bindung wird zuerst abgearbeitet, dann der Operator mit der nächst stärkeren Bindung, usw., bis alle Operatoren abgearbeitet sind.
Operatoren mit gleicher Bindungsstärke werden von links nach rechts abgearbeitet.
Nachfolgend finden Sie eine Tabelle der ST-Operatoren in der Ordnung ihrer Bindungsstärke:
Operation Symbol Bindungsstärke
Einklammern (Ausdruck) Stärkste Bindung
2 - Was ist was in CoDeSys
Funktionsaufruf Funktionsname
(Parameterliste)
Potenzieren EXPT
Negieren Komplementbildung
Multiplizieren Dividieren Modulo
Addieren Subtrahieren
Vergleiche <,>,<=,>=
Gleichheit Ungleichheit
Bool AND AND
Bool XOR XOR
Bool OR OR Schwächste Bindung
­NOT
* / MOD
+
-
= <>
Die folgende Tabelle zeigt tabellarisch geordnet die möglichen Anweisungen in ST und je ein Beispiel:
Anweisungsart Beispiel
Zuweisung A:=B; CV := CV + 1; C:=SIN(X);
Aufruf eines Funktionsblocks und Benutzung der FB-Ausgabe
RETURN RETURN;
IF D:=B*B;
CoDeSys V2.3 2-11
CMD_TMR(IN := %IX5, PT := 300); A:=CMD_TMR.Q
IF D<0.0 THEN C:=A; ELSIF D=0.0 THEN C:=B; ELSE C:=D; END_IF;
Die Sprachen...
CASE CASE INT1 OF
1: BOOL1 := TRUE; 2: BOOL2 := TRUE; ELSE BOOL1 := FALSE; BOOL2 := FALSE; END_CASE;
FOR J:=101;
FOR I:=1 TO 100 BY 2 DO IF ARR[I] = 70 THEN
J:=I; EXIT;
END_IF; END_FOR;
WHILE J:=1;
WHILE J<= 100 AND ARR[J] <> 70 DO J:=J+2;
END_WHILE;
REPEAT J:=-1;
REPEAT J:=J+2;
UNTIL J= 101 OR ARR[J] = 70 END_REPEAT;
EXIT EXIT;
Leere Anweisung ;
Zuweisungsoperator
Auf der linken Seite einer Zuweisung steht ein Operand (Variable, Adresse), dem der Wert des Ausdrucks auf der rechten Seite zugewiesen wird mit dem Zuweisungsoperator :=
Beispiel:
Var1 := Var2 * 10;
Nach Ausführung dieser Zeile hat Var1 den zehnfachen Wert von Var2.
Aufruf von Funktionsblöcken in ST
Ein Funktionsblock in ST wird aufgerufen, indem man den Namen der Instanz des Funktionsblocks schreibt und anschließend in Klammer die gewünschten Werte den Parametern zuweist. Im folgenden Beispiel wird ein Timer aufgerufen mit Zuweisungen für dessen Parameter IN und PT. Anschließend wird die Ergebnisvariable Q an die Variable A zugewiesen.
Die Ergebnisvariable wird wie in AWL mit dem Namen des Funktionsblocks, einem anschließenden Punkt und dem Namen der Variablen angesprochen:
CMD_TMR(IN := %IX5, PT := 300); A:=CMD_TMR.Q
RETURN-Anweisung
Die RETURN-Anweisung kann man verwenden, um einen Baustein zu verlassen, beispielsweise abhängig von einer Bedingung.
2-12 CoDeSys V2.3
CASE-Anweisung
Mit der CASE-Anweisung kann man mehrere bedingte Anweisungen mit derselben Bedingungsvariablen in ein Konstrukt zusammenfassen.
Syntax:
CASE <Var1> OF
<Wert 1>: <Anweisung 1> <Wert 2>: <Anweisung 2>
<Wert3, Wert4, Wert5: <Anweisung 3> <Wert6 .. Wert10 : <Anweisung 4> ... <Wert n>: <Anweisung n>
ELSE <ELSE-Anweisung>
END_CASE;
Eine CASE-Anweisung wird nach folgendem Schema abgearbeitet:
• Wenn die Variable in <Var1> den Wert <Wert i> hat, dann wird die Anweisung <Anweisung i>
ausgeführt.
2 - Was ist was in CoDeSys
• Hat <Var 1> keinen der angegebenen Werte, dann wird die <ELSE-Anweisung> ausgeführt.
• Wenn für mehrere Werte der Variablen, dieselbe Anweisung auszuführen ist, dann kann man
diese Werte mit Kommata getrennt hintereinander schreiben, und damit die gemeinsame Anweisung bedingen.
• Wenn für einen Wertebereich der Variablen, dieselbe Anweisung auszuführen ist, dann kann man
den Anfangs- und Endwert getrennt durch zwei Punkte hintereinander schreiben, und damit die gemeinsame Anweisung bedingen.
Beispiel.:
CASE INT1 OF
1, 5: BOOL1 := TRUE; BOOL3 := FALSE; 2: BOOL2 := FALSE;
BOOL3 := TRUE;
10..20: BOOL1 := TRUE; BOOL3:= TRUE;
ELSE BOOL1 := NOT BOOL1; BOOL2 := BOOL1 OR BOOL2;
END_CASE;
IF-Anweisung
Mit der IF-Anweisung kann man eine Bedingung abprüfen und abhängig von dieser Bedingung Anweisungen ausführen.
Syntax:
IF <Boolscher_Ausdruck1> THEN
<IF_Anweisungen>
{ELSIF <Boolscher_Ausdruck2>
THEN
CoDeSys V2.3 2-13
Die Sprachen...
<ELSIF_Anweisungen1> .
.
ELSIF <Boolscher_Ausdruck n>
THEN
<ELSIF_Anweisungen n-1>
ELSE
<ELSE_Anweisungen>
} END_IF;
Der Teil in geschweiften Klammern {} ist optional.
Wenn <Boolscher_Ausdruck1> TRUE ergibt, dann werden nur die <IF_Anweisungen> ausgeführt und keine der weiteren Anweisungen.
Andernfalls werden die Boolschen Ausdrücke, beginnend mit <Boolscher_Ausdruck2> der Reihe nach ausgewertet, bis einer der Ausdrücke TRUE ergibt. Dann werden nur die Anweisungen nach diesem Boolschen Ausdruck und vor dem nächsten ELSE oder ELSIF ausgewertet.
Wenn keine der Boolschen Ausdrücke TRUE ergibt, dann werden ausschließlich die <ELSE_Anweisungen> ausgewertet.
Beispiel:
IF temp<17 THEN heizung_an := TRUE;
ELSE heizung_an := FALSE; END_IF;
Hier wird die Heizung angemacht, wenn die Temperatur unter 17 Grad sinkt, ansonsten bleibt sie aus.
FOR-Schleife
Mit der FOR-Schleife kann man wiederholte Vorgänge programmieren.
Syntax:
DO
INT_Var :INT;
FOR <INT_Var> := <INIT_WERT>
TO <END_WERT> {BY <Schrittgröße>}
<Anweisungen>
END_FOR;
Der Teil in geschweiften Klammern {} ist optional.
Die <Anweisungen> werden solange ausgeführt, solange der Zähler <INT_Var> nicht größer als der <END_WERT> ist. Dies wird vor der Ausführung der <Anweisungen> überprüft, so dass die <Anweisungen> niemals ausgeführt werden, wenn <INIT_WERT> größer als <END_WERT> ist.
Immer, wenn <Anweisungen> ausgeführt worden ist, wird <INT_Var> um <Schrittgröße> erhöht. Die Schrittgröße kann jeden Integerwert haben. Fehlt sie wird diese auf 1 gesetzt. Die Schleife muss also terminieren, da <INT_Var> nur größer wird.
2-14 CoDeSys V2.3
Beispiel:
FOR Zaehler:=1 TO 5 BY 1 DO
Var1:=Var1*2; END_FOR; Erg:=Var1;
Nehmen wir an, dass die Variable Var1 mit dem Wert 1 vorbelegt wurde, dann wird sie nach der FOR­Schleife den Wert 32 haben.
Hinweis: Der <END_WERT> darf nicht der Grenzwert des Zählers <INT_VAR> sein. Z.B. wenn die Variable
WHILE-Schleife
Die WHILE-Schleife kann benutzt werden wie die FOR-Schleife, mit dem Unterschied, dass die Abbruchbedingung ein beliebiger boolscher Ausdruck sein kann. Das heißt, man gibt eine Bedingung an, die, wenn sie zutrifft, die Ausführung der Schleife zur Folge hat.
Syntax:
WHILE <Boolscher Ausdruck> DO
2 - Was ist was in CoDeSys
Zaehler vom Typ SINT ist, darf der <END_WERT> nicht 127 sein, sonst erfolgt eine Endlosschleife.
<Anweisungen> END_WHILE;
Die <Anweisungen> werden solange wiederholt ausgeführt, wie <Boolscher_Ausdruck> TRUE ergibt. Wenn <Boolscher_Ausdruck> bereits bei der ersten Auswertung FALSE ist, dann werden die <Anweisungen> niemals ausgeführt. Wenn <Boolscher_Ausdruck> niemals den Wert FALSE annimmt, dann werden die <Anweisungen> endlos wiederholt, wodurch ein Laufzeitfehler entsteht.
Hinweis: Der Programmierer muss selbst dafür sorgen, dass keine Endlosschleife entsteht, indem er im
Beispiel:
WHILE Zaehler<>0 DO
Var1 := Var1*2; Zaehler := Zaehler-1; END_WHILE
Die WHILE- und die REPEAT-Schleife sind in gewissem Sinne mächtiger als die FOR-Schleife, da man nicht bereits vor der Ausführung der Schleife die Anzahl der Schleifendurchläufe wissen muss. In manchen Fällen wird man also nur mit diesen beiden Schleifenarten arbeiten können. Wenn jedoch die Anzahl der Schleifendurchläufe klar ist, dann ist eine FOR- Schleife zu bevorzugen, da sie keine endlosen Schleifen ermöglicht.
REPEAT-Schleife
Anweisungsteil der Schleife die Bedingung verändert, also zum Beispiel einen Zähler hoch- oder runterzählt.
Die REPEAT-Schleife unterscheidet sich von den WHILE-Schleifen dadurch, dass die Abbruchbedingung erst nach dem Ausführen der Schleife überprüft wird. Das hat zur Folge, dass die Schleife mindestens einmal durchlaufen wird, egal wie die Abbruchbedingung lautet.
Syntax:
REPEAT
<Anweisungen>
UNTIL <Boolscher Ausdruck>
END_REPEAT;
Die <Anweisungen> werden solange ausgeführt, bis <Boolscher Ausdruck> TRUE ergibt.
CoDeSys V2.3 2-15
Wenn <Boolscher Ausdruck> bereits bei der ersten Auswertung TRUE ergibt, dann werden <Anweisungen> genau einmal ausgeführt. Wenn <Boolscher_Ausdruck> niemals den Wert TRUE annimmt, dann werden die <Anweisungen> endlos wiederholt, wodurch ein Laufzeitfehler entsteht.
Hinweis: Der Programmierer muss selbst dafür sorgen, dass keine Endlosschleife entsteht, indem er im
Beispiel:
REPEAT
Var1 := Var1*2; Zaehler := Zaehler-1;
UNTIL Zaehler=0 END_REPEAT
EXIT-Anweisung
Wenn die EXIT-Anweisung in einer FOR-, WHILE- oder REPEAT-Schleife vorkommt, dann wird die innerste Schleife beendet, ungeachtet der Abbruchbedingung.
Die Sprachen...
Anweisungsteil der Schleife die Bedingung verändert, also zum Beispiel einen Zähler hoch- oder runterzählt.

2.2.3 Ablaufsprache (AS)...

Die Ablaufsprache ist eine grafisch orientierte Sprache, die es ermöglicht, die zeitliche Abfolge verschiedener Aktionen innerhalb eines Programms zu beschreiben. Dazu werden Schrittelemente verwendet, denen bestimmte Aktionen zugeordnet werden und deren Abfolge über Transitionselemente gesteuert wird.
Beispiel für ein Netzwerk in der Ablaufsprache:
Schritt
Ein in Ablaufsprache geschriebener Baustein besteht aus einer Folge von Schritten, die über gerichtete Verbindungen (Transitionen) miteinander verbunden sind.
Es gibt zwei Arten von Schritten.
2-16 CoDeSys V2.3
• Die vereinfachte Form besteht aus einer Aktion und einem Flag, das anzeigt, ob der Schritt aktiv
ist. Ist zu einem Schritt die Aktion implementiert, so erscheint ein kleines Dreieck in der rechten oberen Ecke des Schrittkästchens.
• Ein IEC-Schritt besteht aus einem Flag und einer oder mehreren zugewiesenen Aktionen oder
boolschen Variablen. Die assoziierten Aktionen erscheinen rechts vom Schritt.
Aktion
Eine Aktion kann eine Folge von Instruktionen in AWL oder in ST, eine Menge von Netzwerken in FUP oder in KOP oder wieder eine Ablaufstruktur (AS) enthalten.
Bei den vereinfachten Schritten ist eine Aktion immer mit ihrem Schritt verbunden. Um eine Aktion zu editieren, führen Sie auf dem Schritt, zu dem die Aktion gehört, einen doppelten Mausklick aus, oder markieren Sie den Schritt und führen den Menübefehl 'Extras' 'Zoom Aktion/Transition' aus. Zusätzlich ist eine Ein- und/oder Ausgangsaktion pro Schritt möglich.
Aktionen von IEC-Schritten hängen im Object Organizer direkt unter ihrem AS-Baustein und werden mit Doppelklick oder Drücken der <Eingabetaste> in ihren Editor geladen. Neue Aktionen können mit 'Projekt' 'Aktion hinzufügen' erzeugt werden. Einem IEC-Schritt können maximal neun Aktionen hinzugefügt werden.
Eingangs- bzw. Ausgangsaktion
2 - Was ist was in CoDeSys
Einem Schritt kann zusätzlich zur Schritt-Aktion eine Eingangsaktion und eine Ausgangsaktion hinzugefügt werden. Eine Eingangsaktion wird nur einmal ausgeführt, gleich nachdem der Schritt aktiv geworden ist. Eine Ausgangsaktion wird nur einmal ausgeführt, bevor der Schritt deaktiviert wird.
Ein Schritt mit Eingangsaktion wird durch ein 'E' in der linken unteren Ecke gekennzeichnet, die Ausgangsaktion durch ein 'X' in der rechten unteren Ecke.
Die Ein- und Ausgangsaktion kann in einer beliebigen Sprache implementiert werden. Um eine Ein­bzw. Ausgangsaktion zu editieren, führen Sie auf die entsprechende Ecke im Schritt, einen doppelten Mausklick aus.
Beispiel eines Schrittes mit Ein- und Ausgangsaktion:
Transition / Transitionsbedingung
Zwischen den Schritten liegen so genannte Transitionen.
Eine Transitionsbedingung muss den Wert TRUE oder FALSE haben. Somit kann sie aus einer Boolschen Variablen, Boolschen Adresse oder einer Boolschen Konstante bestehen. Sie kann auch eine Folge von Instruktionen mit einem Boolschen Ergebnis in ST-Syntax (z.B. (i <= 100) AND b) oder einer beliebigen Sprache enthalten (siehe 'Extras' 'Zoom Aktion/Transition'). Aber eine Transition darf keine Programme, Funktionsblöcke oder Zuweisungen enthalten!
Zur Analyse von Transitionsausdrücken kann das Flag SFCErrorAnalyzationTable definiert werden.
Im AS-Editor kann eine Transitionsbedingung direkt an die Transitionsmarke geschrieben werden oder es kann ein eigenes Editorfenster dafür geöffnet werden. Die im Editor (siehe Kapitel 5.4.4, 'Extras' 'Zoom Aktion/Transition') vorliegende Bedingung hat Vorrang!
Hinweis: Neben Transitionen kann auch der Tip-Modus benützt werden, um zum nächsten Schritt
weiterzuschalten, siehe SFCtip und SFCtipmode.
Aktiver Schritt
Nach dem Aufruf des AS-Bausteins wird zunächst die zum Initialschritt (doppelt umrandet) gehörende Aktion ausgeführt. Ein Schritt, dessen Aktion ausgeführt wird, gilt als 'aktiv'. Im Online Modus werden aktive Schritte blau dargestellt.
CoDeSys V2.3 2-17
Pro Zyklus werden zunächst alle Aktionen ausgeführt, die zu aktiven Schritten gehören. Danach werden die diesen Schritten nachfolgenden Schritte auf 'aktiv' gesetzt, wenn die Transitionsbedingungen für diese nachfolgenden Schritte TRUE sind. Die nun aktiven Schritte werden dann im nächsten Zyklus ausgeführt.
Hinweis: Enthält der aktive Schritt eine Ausgangsaktion, wird auch diese erst im nächsten Zyklus ausgeführt,
IEC-Schritt
Neben den vereinfachten Schritten stehen die normkonformen IEC-Schritte in AS zur Verfügung.
Um IEC-Schritte verwenden zu können, müssen Sie in Ihr Projekt die spezielle SFC-Bibliothek lecsfc.lib einbinden.
Einem IEC-Schritt können maximal neun Aktionen zugewiesen werden. IEC-Aktionen sind nicht wie bei den vereinfachten Schritten als Eingangs- Schritt- oder Ausgangsaktion fest einem Schritt zugeordnet, sondern liegen getrennt von den Schritten vor und können innerhalb ihres Bausteins mehrfach verwendet werden. Dazu müssen sie mit dem Befehl 'Extras' 'Aktion assoziieren' zu den gewünschten Schritten assoziiert werden.
Neben Aktionen können auch boolesche Variablen Schritten zugewiesen werden.
Über so genannte Bestimmungszeichen (Qualifier) wird die Aktivierung und Deaktivierung der Aktionen und boolschen Variablen gesteuert. Zeitliche Verzögerungen sind dabei möglich. Da eine Aktion immer noch aktiv sein kann, wenn bereits der nächste Schritt abgearbeitet wird, z.B. durch Bestimmungszeichen S (Set), kann man Nebenläufigkeiten erreichen.
Die Sprachen...
vorausgesetzt, die darauf folgende Transition ist TRUE.
Eine assoziierte boolesche Variable wird bei jedem Aufruf des AS-Bausteines gesetzt oder zurückgesetzt. Das heißt, ihr wird jedes Mal entweder der Wert TRUE oder FALSE neu zugewiesen.
Die assoziierten Aktionen zu einem IEC-Schritt werden rechts vom Schritt in einem zweigeteilten Kästchen dargestellt. Das linke Feld enthält den Qualifier, evtl. mit Zeitkonstanten und das rechte den Aktionsnamen bzw. boolschen Variablennamen.
Beispiel für einen IEC-Schritt mit zwei Aktionen:
Zur leichteren Verfolgung der Vorgänge werden alle aktiven Aktionen im Onlinebetrieb wie die aktiven Schritte blau dargestellt. Nach jedem Zyklus wird überprüft, welche Aktionen aktiv sind.
Beachten Sie hierzu auch die Einschränkung bei der Verwendung von Zeit-Qualifiern bei mehrmals verwendeten Aktionen im gleichen Zyklus (siehe 'Qualifier') !
Hinweis: Wird eine Aktion deaktiviert, so wird sie noch einmal ausgeführt. Das heißt, dass jede Aktion
mindestens zweimal ausgeführt wird (auch eine Aktion mit Qualifier P).
Bei einem Aufruf werden zuerst die deaktivierten Aktionen in alphabetischer Reihenfolge abgearbeitet und dann alle aktiven Aktionen wiederum in alphabetischer Reihenfolge.
Ob es sich bei einem neu eingefügten Schritt um einen IEC-Schritt handelt, ist abhängig davon, ob der Menübefehl 'Extras' 'IEC-Schritte benutzen' angewählt ist.
Im Object Organizer hängen die Aktionen direkt unter ihrem jeweiligen AS-Baustein. Neue Aktionen können mit 'Projekt' 'Aktion hinzufügen' erzeugt werden.
2-18 CoDeSys V2.3
Qualifier
2 - Was ist was in CoDeSys
AS-Baustein mit Aktionen im Object Organizer:
Zum Assoziieren der Aktionen zu IEC-Schritten stehen folgende Qualifier (Bestimmungszeichen) zur Verfügung:
N Non-stored die Aktion ist solange aktiv wie der Schritt
R overriding Reset die Aktion wird deaktiviert
S Set (Stored) die Aktion wird aktiviert und bleibt bis zu einem Reset aktiv
L time Limited die Aktion wird für eine bestimmte Zeit aktiviert, maximal solange der
Schritt aktiv ist
D time Delayed die Aktion wird nach einer bestimmten Zeit aktiv, sofern der Schritt noch
P Pulse die Aktion wird genau einmal ausgeführt, wenn der Schritt aktiv wird
SD Stored and time Delayed die Aktion wird nach einer bestimmten Zeit aktiviert und bleibt bis zu einem
DS Delayed and Stored die Aktion wird nach einer bestimmten Zeit aktiviert, sofern der Schritt noch
SL Stored and time Limited die Aktion ist für eine bestimmte Zeit aktiviert
Die Bestimmungszeichen L, D, SD, DS und SL benötigen eine Zeitangabe im TIME­Konstantenformat. Diese ist direkt (z.B. „T#5s“) oder über eine Variable vom Datentyp TIME (z.B. „plc_prg.t_var“) möglich.
Hinweis: Wird eine Aktion deaktiviert, so wird sie noch einmal ausgeführt. Das heißt, dass jede Aktion
mindestens zweimal ausgeführt wird (auch eine Aktion mit Qualifier P).
Hinweis: Bei einem Aufruf werden zuerst die deaktivierten Aktionen in alphabetischer Reihenfolge
abgearbeitet und dann alle aktiven Aktionen wiederum in alphabetischer Reihenfolge.
Achtung: Wird dieselbe Aktion in zwei unmittelbar aufeinander folgenden Schritten mit Qualifiern benutzt, die
den zeitlichen Ablauf beeinflussen, kann bei der zweiten Verwendung der Zeit-Qualifier nicht mehr wirksam werden. Um dies zu umgehen, muss ein Zwischenschritt eingefügt werden, so dass in dem dann zusätzlich zu durchlaufenden Zyklus der Aktionszustand erneut initialisiert werden kann.
Implizite Variablen in AS
aktiv ist und dann solange der Schritt aktiv ist
Reset aktiv
aktiv ist und bleibt bis zu einem Reset aktiv
In der AS können implizit deklarierte Variablen ("Flags") zur Abfage des Status von Schritten und Aktionen sowie der Zeitdauer von Schritten verwendet werden. Diese Flags werden jeweils zu Beginn eines Zyklus gesetzt. Für IEC-Schritte und –Aktionen stehen sie über die standardmäßig eingebundene Bibliothek iecsfc.lib zur Verfügung (Strukturen SFCStepType und SFCActionType), für die vereinfachten Schritte sind sie in CoDeSys direkt implementiert:
Abfrage des Zustands eines Schrittes oder einer Aktion über boolesche Variablen:
• Für IEC-Schritte: <StepName>.x bzw. <StepName>._x: <StepName>.x zeigt den aktuellen
Aktivierungszustand. <StepName>._x zeigt den Aktivierungszustand für den nächsten Zyklus an. Wenn <StepName>.x=TRUE, wird der Schritt im aktuellen Zyklus ausgeführt.
CoDeSys V2.3 2-19
Die Sprachen...
• Wenn <StepName>._x=TRUE und <StepName>.x=FALSE, wird der Schritt im nächsten Zyklus
ausgeführt, d.h. <StepName>._x wird zu Beginn eines Zyklus auf <StepName>.x kopiert.
• Für vereinfachte Schritte: <StepName> bzw. _<StepName>: Wenn <StepName> TRUE ist, wird
der Schritt im aktuellen Zyklus ausgeführt. Wenn _<StepName> TRUE ist, wird der Schritt im nächsten Zyklus ausgeführt, d.h. <StepName> wird zu Beginn eines Zyklus auf _<StepName> kopiert.
• Für IEC-Aktionen: <Aktionsname>.x wird TRUE sobald die Aktion aktiv wird. (<Aktionsname>._x
dient ausschließlich internen Zwecken, nicht zur Zustandsabfrage).
Abfrage der Zeitdauer eines Schritts über TIME-Variablen:
Folgende implizite Variablen liefern die aktuelle Zeitdauer seit Aktivwerden eines Schrittes, für den in den Schrittattributen mindestens die minimale Zeitdauer konfiguriert ist:
• Für IEC-Schritte: <StepName>.t (<StepName>._t von extern nicht verwendbar)
• Für vereinfachte Schritte: _time<StepName>. Diese implizite Variable muss allerdings zu diesem
Zweck auch explizit als TIME-Variable deklariert werden; z.B. "_timeStep1 : TIME;"
• Für IEC-Aktionen: die impliziten Zeitvariablen werden nicht verwendet
Diese Zustands-"Flags" können in jeder Aktion und Transition des AS-Bausteins benutzt werden. Es kann aber auch von anderen Programmen aus darauf zugegriffen werden:
AS-Flags
Beispiel: boolvar1:=sfc.step1.x;
step1.x ist hier eine implizite boolesche Variable, die den Zustand von IEC-Schritt step1 im Baustein sfc1 darstellt.
Zur Steuerung des Ablaufs in der Ablaufsprache können Flags genutzt werden, die während der Projektabarbeitung automatisch erzeugt werden. Dazu müssen entsprechende Variablen global oder lokal, als Aus- oder Eingabevariable deklariert werden. Beispiel: Wenn im AS ein Schritt länger aktiv ist, als in seinen Attributen angegeben, wird ein Flag gesetzt, das über eine Variable namens SFCError zugänglich wird (SFCError wird TRUE). Folgende Flag-Variablen sind möglich:
SFCEnableLimit: Diese spezielle Variable ist vom Typ BOOL. Wenn sie TRUE ist, werden Zeitüberschreitungen bei den Schritten in SFCError registriert. Ansonsten werden Zeitüberschreitungen ignoriert. Die Verwendung kann beispielsweise bei Inbetriebnahme oder Handbetrieb nützlich sein.
SFCInit: Wenn diese boolesche Variable TRUE ist, dann wird die Ablaufsprache auf den Init-Schritt zurückgesetzt. Die anderen AS-Flags werden ebenfalls zurückgesetzt (Initialisierung). Solange die Variable TRUE ist, bleibt der Init-Schritt gesetzt (aktiv), wird aber nicht ausgeführt. Erst wenn SFCInit wieder auf FALSE gesetzt wird, wird der Baustein normal weiterbearbeitet.
SFCReset: Diese Variable vom Typ BOOL verhält sich ähnlich wie SFCInit. Im Unterschied zu dieser wird allerdings nach der Initialisierung der Init-Schritt weiter abgearbeitet. So könnte beispielsweise im Init-Schritt das SFCReset-Flag gleich wieder auf FALSE gesetzt werden.
Bitte beachten: Ab Compiler-Version 2.3.7.0 können mit SFCReset auch boolesche Aktionen, die IEC-Schritten
zugeordnet sind, zurückgesetzt werden, was vorher nicht möglich war.
SFCQuitError: Solange diese boolesche Variable TRUE ist, wird die Abarbeitung des AS-Diagramms angehalten, eine eventuelle Zeitüberschreitung in der Variablen SFCError wird dabei zurückgesetzt. Wenn die Variable wieder auf FALSE gesetzt wird, werden alle bisherigen Zeiten in den aktiven Schritten zurückgesetzt. Voraussetzung dafür ist die Deklaration des Flags SFCError, das die Zeitüberschreitung registriert.
SFCPause: Solange diese boolesche Variable TRUE ist, wird die Abarbeitung des AS-Diagramms angehalten.
2-20 CoDeSys V2.3
2 - Was ist was in CoDeSys
SFCError: Diese boolesche Variable wird TRUE, wenn in einem AS-Diagramm eine Zeitüberschreitung aufgetreten ist. Wenn im Programm nach der ersten Zeitüberschreitung eine weitere auftritt, wird diese nicht mehr registriert, wenn die Variable SFCError vorher nicht wieder zurückgesetzt wurde. Die Deklaration von SFCError ist Voraussetzung für das Funktionieren der anderen Flag-Variablen zur Kontrolle des zeitlichen Ablaufs (SFCErrorStep, SFCErrorPOU, SFCQuitError, SFCErrorAnalyzationTable).
SFCTrans: Diese boolesche Variable wird TRUE, wenn eine Transition schaltet. SFCErrorStep: Diese Variable ist vom Typ STRING. Wird durch SFCError eine Zeitüberschreitung im
AS-Diagramm registriert, wird in dieser Variable der Name des Schritts gespeichert, der die Zeitüberschreitung verursacht hat. Voraussetzung dafür ist die Deklaration der Variablen SFCError, die die Zeitüberschreitung registriert.
SFCErrorPOU: Diese Variable vom Typ STRING erhält im Falle einer Zeitüberschreitung den Namen des Bausteins, in dem die Zeitüberschreitung aufgetreten ist. Voraussetzung dafür ist die Deklaration der Variablen SFCError, die die Zeitüberschreitung registriert.
SFCCurrentStep: Diese Variable ist vom Typ STRING. In dieser Variablen wird der Name des Schritts gespeichert, der aktiv ist, unabhängig von der Zeitüberwachung. Bei einer Paralellverzweigung wird der Schritt im äußersten rechten Zweig gespeichert.
SFCErrorAnalyzationTable: Diese Variable vom Typ ARRAY [0..n] OF ExpressionResult gibt für jede Variable eines zusammengesetzten Transitionsausdrucks, die zu einem FALSE der Transition und damit zu einer Zeitüberschreitung im vorangehenden Schritt führt, folgende Informationen aus: Name, Adresse, Kommentar, aktueller Wert.
Dies ist für maximal 16 Variablen möglich, d.h. der Array-Bereich ist max. 0..15.
Die Struktur ExpressionResult sowie die implizit verwendeten Analyse-Bausteine sind in der Bibliothek AnalyzationNew.lib enthalten. Die Analyse-Bausteine können auch explizit in Bausteinen, die nicht in SFC programmiert sind, verwendet werden.
Voraussetzung für die Analyse des Transitionsausdrucks ist die Registrierung einer Zeitüberschreitung im vorangehenden Schritt. Daher muss dort eine Zeitüberwachung implementiert sein und die Variable SFCError (siehe oben) im Baustein deklariert sein.
SFCTip, SFCTipMode: Diese Variablen vom Typ BOOL erlauben den Tip-Betrieb des SFC. Wenn dieser durch SFCTipMode=TRUE eingeschaltet ist, kann nur zum nächsten Schritt weitergeschaltet werden, indem SFCTip auf TRUE gesetzt wird. Solange SFCTipMode auf FALSE gesetzt ist, kann zusätzlich auch über die Transitionen weitergeschaltet werden.
Hinweis: Beachten Sie auch die im vorhergehenden Kapitel beschriebenen impliziten Variablen, die zur
Alternativzweig
Zwei oder mehr Zweige in AS können als Alternativverzweigungen definiert werden. Jeder Alternativzweig muss mit einer Transition beginnen und enden. Alternativverzweigungen können Parallelverzweigungen und weitere Alternativverzweigungen beinhalten. Eine Alternativverzweigung beginnt an einer horizontalen Linie (Alternativanfang) und endet an einer horizontalen Linie (Alternativende) oder mit einem Sprung.
Wenn der Schritt, der der Alternativanfangslinie vorangeht, aktiv ist, dann wird die erste Transition jeder Alternativverzweigung von links nach rechts ausgewertet. Die erste Transition von links, deren Transitionsbedingung den Wert TRUE hat, wird geöffnet und die nachfolgenden Schritte werden aktiviert (siehe aktiver Schritt).
Abfrage von Status und Zeitdauer von Schritten und Aktionen verwendet werden können.
Parallelzweig
Zwei oder mehr Verzweigungen in AS können als Parallelverzweigungen definiert werden. Jeder Parallelzweig muss mit einem Schritt beginnen und enden. Parallelverzweigungen können Alternativverzweigungen oder weitere Parallelverzweigungen beinhalten. Eine Parallelverzweigung beginnt bei einer doppelten Linie (Parallelanfang) und endet bei einer doppelten Linie (Parallelende) oder bei einem Sprung. Sie kann mit einer Sprungmarke versehen werden
CoDeSys V2.3 2-21
Wenn der der Parallelanfangs-Linie vorangehende Schritt aktiv ist, und die Transitionsbedingung nach diesem Schritt den Wert TRUE hat, dann werden die ersten Schritte aller Parallelverzweigungen aktiv (siehe aktiver Schritt). Diese Zweige werden nun alle parallel zueinander abgearbeitet. Der Schritt nach der Parallelende-Linie wird aktiv, wenn alle vorangehenden Schritte aktiv sind, und die Transitionsbedingung vor diesem Schritt den Wert TRUE liefert.
Sprung
Ein Sprung ist eine Verbindung zu dem Schritt, dessen Name unter dem Sprungsymbol angegeben ist. Sprünge werden benötigt, weil es nicht erlaubt ist, nach oben führende oder sich überkreuzende Verbindungen zu schaffen.

2.2.4 Funktionsplan (FUP)...

Der Funktionsplan ist eine graphisch orientierte Programmiersprache. Er arbeitet mit einer Liste von Netzwerken, wobei jedes Netzwerk eine Struktur enthält, die jeweils einen logischen bzw. arithmetischen Ausdruck, den Aufruf eines Funktionsblocks, einen Sprung oder eine Return­Anweisung darstellt.
Der freigraphische Funktionsplaneditor werden keine Netzwerke verwendet
Beispiel für ein Netzwerk im Funktionsplan:
Die Sprachen...

2.2.5 Der freigraphische Funktionsplaneditor (CFC)...

Der freigraphische Funktionsplaneditor arbeitet nicht wie der Funktionsplan FUP mit Netzwerken, sondern mit frei platzierbaren Elementen. Dies erlaubt beispielsweise Rückkoppelungen.
Beispiel für eine Implementation im Freigraphischen Funktionsplaneditor:

2.2.6 Kontaktplan (KOP)...

Der Kontaktplan ist eine grafisch orientierte Programmiersprache, die dem Prinzip einer elektrischen Schaltung angenähert ist.
Einerseits eignet sich der Kontaktplan dazu, logische Schaltwerke zu konstruieren, andererseits kann man aber auch Netzwerke wie im FUP erstellen. Daher kann der KOP sehr gut dazu benutzt werden, um den Aufruf von anderen Bausteinen zu steuern. Der Kontaktplan besteht aus einer Folge von Netzwerken. Ein Netzwerk wird auf der linken und rechten Seite von einer linken und einer rechten vertikalen Stromleitung begrenzt. Dazwischen befindet sich ein Schaltplan aus Kontakten, Spulen und Verbindungslinien.
Jedes Netzwerk besteht auf der linken Seite aus einer Folge von Kontakten, die von links nach rechts den Zustand "AN" oder "AUS" weitergeben, diese Zustände entsprechen den booleschen Werten TRUE und FALSE. Zu jedem Kontakt gehört eine boolesche Variable. Wenn diese Variable TRUE ist,
2-22 CoDeSys V2.3
Kontakt
2 - Was ist was in CoDeSys
dann wird der Zustand über die Verbindungslinie von links nach rechts weitergegeben, sonst erhält die rechte Verbindung den Wert AUS.
Beispiel eines Netzwerks im Kontaktplan aus Kontakten und Spulen:
Jedes Netzwerk im KOP besteht auf der linken Seite aus einem Netzwerk von Kontakten (Kontakte werden dargestellt durch zwei parallele Linien: | |), die von links nach rechts den Zustand "An" oder "Aus" weitergeben.
Diese Zustände entsprechen den booleschen Werten TRUE und FALSE. Zu jedem Kontakt gehört eine boolesche Variable. Wenn diese Variable TRUE ist, dann wird der Zustand über die Verbindungslinie von links nach rechts weitergegeben, sonst erhält die rechte Verbindung den Wert "Aus".
Kontakte können parallel geschaltet sein, dann muss einer der Parallelzweige den Wert "An" übergeben, damit die Parallelverzweigung den Wert "An" übergibt, oder die Kontakte sind in Reihe geschaltet, dann müssen alle Kontakte den Zustand "An" übergeben, damit der letzte Kontakt den Zustand "An" weitergibt. Dies entspricht also einer elektrischen Parallel- bzw. Reihenschaltung.
Ein Kontakt kann auch negiert sein, erkennbar am Schrägstrich im Kontaktsymbol: |/|. Dann wird der Wert der Linie weitergegeben, wenn die Variable FALSE ist.
Spule
Auf der rechten Seite eines Netzwerks im KOP befindet sich eine beliebige Anzahl so genannter Spulen, dargestellt durch Klammern:( ). Diese können nur parallel geschaltet werden. Eine Spule gibt den Wert der Verbindungen von links nach rechts weiter, und kopiert ihn in eine zugehörige boolesche Variable. An der Eingangslinie kann der Wert AN (entspricht der booleschen Variablen TRUE) oder der Wert AUS anliegen (entsprechend FALSE).
Kontakte und Spulen können auch negiert werden .Wenn eine Spule negiert ist (erkennbar am Schrägstrich im Spulensymbol: (/)), dann kopiert sie den negierten Wert in die zugehörige boolesche Variable. Wenn ein Kontakt negiert ist, dann schaltet er nur dann durch, wenn die zugehörige boolesche Variable FALSE ist.
Funktionsblöcke im Kontaktplan
Neben Kontakten und Spulen können Sie auch Funktionsblöcke und Programme eingeben, diese müssen im Netzwerk einen Eingang und einen Ausgang mit booleschen Werten haben und können an denselben Stellen verwendet werden wie Kontakte, d.h. auf der linken Seite des KOP-Netzwerks.
Set/Reset-Spulen
Spulen können auch als Set- oder Reset-Spulen definiert sein. Eine Set-Spule (erkennbar am ‚S' im Spulensymbol: (S)) überschreibt in der zugehörigen booleschen Variablen niemals den Wert TRUE. D.h., wenn die Variable einmal auf TRUE gesetzt wurde, dann bleibt sie es auch.
Eine Reset-Spule (erkennbar am ‚R' im Spulensymbol: (R)), überschreibt in der zugehörigen booleschen Variablen niemals den Wert FALSE: Wenn die Variable einmal auf FALSE gesetzt wurde, dann bleibt sie es auch.
CoDeSys V2.3 2-23
KOP als FUP
Beim Arbeiten mit dem KOP kann leicht der Fall auftreten, dass Sie das Ergebnis der Kontaktschaltung zur Steuerung anderer Bausteine nutzen wollen. Dann können Sie einerseits das Ergebnis mit Hilfe der Spulen in einer globalen Variable ablegen, die an anderer Stelle weiter benutzt wird. Sie können aber auch den eventuellen Aufruf direkt in Ihr KOP-Netzwerk einbauen. Dazu führen Sie einen Baustein mit EN-Eingang ein.
Solche Bausteine sind ganz normale Operanden, Funktionen, Programme oder Funktionsblöcke, die einen zusätzlichen Eingang haben, der mit EN beschriftet ist. Der EN-Eingang ist immer vom Typ BOOL und seine Bedeutung ist: der Baustein mit EN-Eingang wird dann ausgewertet, wenn EN den Wert TRUE hat.
Ein EN-Baustein wird parallel zu den Spulen geschaltet, wobei der EN-Eingang mit der Verbindungslinie zwischen den Kontakten und den Spulen verbunden wird. Wenn über diese Linie die Information AN transportiert wird, dann wird dieser Baustein ganz normal ausgewertet.
Ausgehend von einem solchen EN-Baustein können Netzwerke wie in FUP erstellt werden.
Beispiel eines KOP-Netzwerks mit einem EN-Baustein:
Debugging, Onlinefunktionalitäten...

2.3 Debugging, Onlinefunktionalitäten...

Debugging

Mit den Debugging-Funktionen von CoDeSys wird Ihnen das Auffinden von Fehlern erleichtert. Um „debuggen“ zu können, muss der Befehl 'Projekt' Optionen' ausgeführt und im erscheinenden
Dialog unter Übersetzungsoptionen der Punkt Debugging ausgewählt werden.

Breakpoint

Ein Breakpoint ist eine Stelle im Programm, an der die Abarbeitung angehalten wird. Somit ist es möglich, die Werte von Variablen an einer bestimmten Programmstelle zu betrachten.
Breakpoints können in allen Editoren gesetzt werden. In den Texteditoren werden Breakpoints auf Zeilennummern gesetzt, in FUP und KOP auf Netzwerknummern, im CFC auf Bausteine und in AS auf Schritte. In Funktionsblockinstanzen können keine Breakpoints gesetzt werden.
Achtung: Laufzeitsystem CoDeSys SP 32 Bit Full deaktiviert die Watchdog-Funktion für die betroffene Task
sobald die Programmabarbeitung an einem Breakpoint stoppt.

Einzelschritt

Einzelschritt bedeutet:
• in AWL: Das Programm bis zum nächsten CAL, LD oder JMP-Befehl ausführen.
• in ST: Die nächste Anweisung ausführen.
• in FUP, KOP: Das nächste Netzwerk ausführen
• in AS: Die Aktion zum nächsten Schritt ausführen
• in CFC: Den nächsten Baustein (Box) im CFC-Programm ausführen
Durch schrittweise Abarbeitung können Sie die logische Korrektheit Ihres Programms überprüfen.
2-24 CoDeSys V2.3

Einzelzyklus

Wenn Einzelzyklus gewählt wurde, dann wird nach jedem Zyklus die Abarbeitung angehalten.

Werte Online verändern

Variablen können im laufenden Betrieb einmalig auf einen bestimmten Wert gesetzt werden (Wert schreiben) oder auch nach jedem Zyklus wieder neu mit einem bestimmten Wert beschrieben werden (Forcen). Sie können den Variablenwert im Online-Betrieb auch verändern, indem Sie einen Doppelklick darauf durchführen. Boolesche Variablen wechseln dadurch von TRUE auf FALSE bzw. umgekehrt, für alle anderen erhalten Sie einen Dialog Variable xy schreiben, in dem Sie den aktuellen Variablenwert editieren können.

Monitoring

Im Online Modus werden für alle am Bildschirm sichtbaren Variablen laufend die aktuellen Werte aus der Steuerung gelesen und dargestellt. Diese Darstellung finden Sie im Deklarations- und Programmeditor, außerdem können Sie im Watch- und Rezepturmanager und in einer Visualisierung aktuelle Variablenwerte ausgeben. Sollen Variablen aus Funktionsblock-Instanzen "gemonitored" werden, muss erst die entsprechende Instanz geöffnet werden Beim Monitoring von VAR_IN_OUT Variablen wird der dereferenzierte Wert ausgegeben.
Beim Monitoring von Pointern wird im Deklarationsteil sowohl der Pointer als auch der dereferenzierte Wert ausgegeben. Im Programmteil wird nur der Pointer ausgegeben:
+ --pointervar = '<'pointervalue'>'
Beispiel für Monitoring von Pointern:
2 - Was ist was in CoDeSys
POINTER im dereferenzierten Wert werden ebenfalls entsprechend angezeigt. Mit einfachem Klick auf das Kreuz oder mit Doppelklick auf die Zeile wird die Anzeige expandiert bzw. kollabiert.
CoDeSys V2.3 2-25
In den Implementierungen wird der Wert des Pointers angezeigt. Für Dereferenzierungen wird jedoch der dereferenzierte Wert angezeigt.
Monitoring von ARRAY-Komponenten: Zusätzlich zu Array-Komponenten, die über eine Konstante indiziert sind, werden auch Komponenten angezeigt, die über eine Variable indiziert sind:
Besteht der index aus einem Ausdruck (z.B. [i+j] oder [i+1]), kann die Komponente nicht angezeigt werden.
Bitte beachten: Wenn die Anzahl der Variablen, die maximal "gemonitored" werden können, erreicht ist, wird für

Simulation

Bei der Simulation wird das erzeugte Steuerungsprogramm nicht in der Steuerung, sondern auf dem Rechner, auf dem auch CoDeSys läuft, abgearbeitet. Es stehen alle Onlinefunktionen zur Verfügung. Sie haben somit die Möglichkeit, die logische Korrektheit Ihres Programms ohne Steuerungshardware zu testen.
Hinweis: Bausteine aus externen Bibliotheken laufen nicht in der Simulation.
anarray[1] = 5 anarray[i] = 1
jede weitere Variable anstelle des aktuellen Wertes der Text "Zu viele Monitoring Variablen" angezeigt.
Die Norm...

Logbuch

Das Logbuch zeichnet Benutzeraktionen, interne Vorgänge, Statusänderungen und Ausnahmezustände während des Online-Modus chronologisch auf. Es dient der Überwachung und der Fehlerrückverfolgung.

2.4 Die Norm...

Die Norm IEC 61131-3 ist ein internationaler Standard für Programmiersprachen von speicherprogrammierbaren Steuerungen.
Die in CoDeSys realisierten Programmiersprachen sind konform zu den Anforderungen der Norm.
Nach diesem Standard besteht ein Programm aus folgenden Elementen:
• Strukturen
• Bausteine
• Globale Variablen
Die allgemeinen Sprachelemente werden in den Abschnitten Bezeichner, Adressen, Typen, Kommentare und Konstanten beschrieben.
Die Abarbeitung eines CoDeSys-Programms beginnt mit dem speziellen Baustein PLC_PRG. Der Baustein PLC_PRG kann andere Bausteine aufrufen.
2-26 CoDeSys V2.3
3 - Wir schreiben ein kleines Programm

3 Wir schreiben ein kleines Programm

3.1 Die Steuerung einer Ampelanlage...

Einführung
Gehen wir nun daran, ein kleines Beispielprogramm zu schreiben. Es soll eine Mini-Ampelanlage werden, die zwei Autoampeln an einer Kreuzung steuern soll. Beide Ampeln werden sich in ihren rot/grün-Phasen abwechseln, und um Unfälle zu vermeiden, werden wir zwischen den Phasen auch noch gelb bzw. gelb/rot-Umschaltphasen vorsehen. Letztere werden länger dauern als erstere.
In diesem Beispiel werden Sie sehen, wie sich zeitabhängige Programme mit den Sprachmitteln der IEC61131-3 darstellen lassen, wie man mit Hilfe von CoDeSys die verschiedenen Sprachen der Norm editiert, und wie man sie problemlos verbinden kann, und nicht zuletzt lernen Sie die Simulation von CoDeSys kennen.
Bausteine erzeugen
Aller Anfang ist leicht: starten Sie zunächst CoDeSys, und wählen Sie 'Datei' 'Neu'.
In der erscheinenden Dialogbox 'Zielsystemeinstellungen' können Sie ein Zielsystem oder die Einstellung 'None' auswählen. Letztere entspricht der Einstellung Simulationsmodus, was für unser Beispiel ausreicht. Bestätigen Sie mit OK und Sie erhalten den Dialog 'Neuer Baustein', bereits vorbelegt mit dem Eintrag PLC_PRG. Behalten Sie diesen Namen bei, und die Art des Bausteins sollte auf jeden Fall ein Programm sein, jedes Projekt benötigt ein Programm diesen Namens. Für unseren Fall wählen wir als Sprache dieses Bausteins den freigraphischen Funktionsplaneditor (CFC).
Die Bedeutung der Bausteine werden wir im Anschluss erklären, erzeugen Sie zunächst noch drei weitere mit dem Befehl 'Projekt' 'Objekt' 'einfügen' über die Menüleiste oder über das Kontextmenü (rechte Maustaste drücken im Object Organizer): Ein Programm in der Sprache Ablaufsprache (AS) namens ABLAUF, einen Funktionsblock in der Sprache Funktionsplan (FUP) namens AMPEL, sowie einen Baustein WARTEN, ebenfalls von dem Typ Funktionsblock, den wir als Anweisungsliste (AWL) programmieren wollen.
Was macht AMPEL?
Im Baustein AMPEL werden wir die einzelnen Ampelphasen den Ampellichtern zuordnen, d.h. wir werden dafür sorgen, dass die rote Lampe bei der Phase rot und bei der Phase gelb/rot leuchtet, die gelbe Lampe bei der Phase gelb und gelb/rot, usw.
Was macht WARTEN?
In WARTEN werden wir einen einfachen Timer programmieren, der als Eingabe die Dauer der Phase in Millisekunden bekommen wird, und der als Ausgabe TRUE liefert, sobald die Zeit abgelaufen ist.
Was macht ABLAUF?
In ABLAUF wird alles miteinander verbunden, so dass das richtige Ampellicht zur richtigen Zeit und mit der gewünschten Dauer leuchten wird.
Was macht PLC_PRG ?
In PLC_PRG wird das eingehende Startsignal mit dem Ampelphasenablauf gekoppelt und die ‚Farbanweisungen' für die einzelnen Lampen beider Ampeln als Ausgänge zur Verfügung gestellt.
"AMPEL"-Deklaration
Widmen wir uns zunächst dem Baustein AMPEL. Im Deklarationseditor deklarieren Sie als Eingabevariable (zwischen den Schlüsselwörtern VAR_INPUT und END_VAR) eine Variable namens
CoDeSys V2.3 3-1
Die Steuerung einer Ampelanlage...
STATUS vom Typ INT. STATUS wird vier mögliche Zustände haben, nämlich jeweils einen für die Ampelphasen grün, gelb, gelb-rot, und rot.
Ausgaben hat unsere Ampel dem entsprechend drei, nämlich ROT, GELB, GRUEN (Umlaute werden für Variablen nicht akzeptiert. Deklarieren Sie diese drei Variablen; dann sieht der Deklarationsteil unseres Funktionsblocks AMPEL folgendermaßen aus:
"AMPEL"-Rumpf
Nun gilt es, aus der Eingabe STATUS des Bausteins die Werte der Ausgabevariablen zu ermitteln. Gehen Sie dazu in den Rumpf des Bausteins. Klicken Sie in das Feld links neben dem ersten Netzwerk (das graue Feld mit der Nummer 0001). Sie haben jetzt das erste Netzwerk selektiert. Wählen Sie nun den Menüpunkt
'Einfügen' 'Baustein'.
Es wird im ersten Netzwerk eine Box mit dem Operator AND und zwei Eingängen eingefügt:
Klicken Sie mit dem Mauszeiger auf den Text AND, so dass er markiert erscheint, und ändern Sie den Text in EQ. Selektieren Sie ebenso jeweils die drei Fragezeichen der beiden Eingänge und überschreiben Sie sie mit "STATUS" bzw. "1". Sie erhalten folgendes Netzwerk:
Klicken Sie nun an eine Stelle hinter der EQ Box. Es wird nun der Ausgang der EQ-Operation selektiert. Wählen Sie
'Einfügen' 'Zuweisung'. Die drei Fragezeichen ??? ändern Sie in GRUEN. Sie haben nun ein Netzwerk der folgenden Gestalt erstellt:
STATUS wird mit 1 verglichen, das Ergebnis wird GRUEN zugewiesen. Dieses Netzwerk schaltet also auf GRUEN, wenn der vorgegebene Statuswert 1 ist.
Für die anderen Ampelfarben benötigen wir zwei weitere Netzwerke. Erzeugen Sie das erste mit dem Befehl 'Einfügen' 'Netzwerk (danach)' und erstellen Sie wie oben beschrieben einen EQ-Baustein. Wenn Sie den Ausgang selektiert haben wählen Sie den Befehl 'Einfügen' 'Baustein' und ersetzen in diesem das "AND" durch ein "OR". Selektieren Sie dann wiederum den Ausgang des OR-Bausteins
3-2 CoDeSys V2.3
3 - Wir schreiben ein kleines Programm
und weisen Sie ihn über den Befehl 'Einfügen' 'Zuweisung' GELB zu. Selektieren Sie nun den zweiten Eingang des OR, indem Sie mit der Maus auf den waagrechten Strich neben den drei Fragezeichen klicken, so dass dieser mit einem punktierten Rechteck markiert wird und fügen Sie mit 'Einfügen' 'Baustein' und wie bereits beschrieben einen weiteren EQ-Baustein an. Letztendlich sollte das Netzwerk wie im Folgenden gezeigt aussehen:
Das dritte Netzwerk erstellen Sie am besten, indem Sie das zweite kopieren und bearbeiten. Klicken Sie dazu auf das Netzwerkfeld 002 und wählen Sie die Befehle 'Bearbeiten' 'Kopieren' und 'Bearbeiten' 'Einfügen'. Das kopierte Netzwerk wird nun unter 002 eingefügt und erhält Nummer "003". Editieren Sie nun entsprechend der oben gezeigten Abbildung die Ein- und Ausgänge, indem Sie jeweils auf die vorhandenen Einträge klicken und die gewünschten Werte eingeben.
Nun ist unser erster Baustein bereits fertig. AMPEL steuert uns, je nach Eingabe des Wertes STATUS, die jeweils gewünschte Ampelfarbe.
Anbinden der standard.lib
Für den Timer im Baustein WARTEN benötigen wir einen Baustein aus der Standardbibliothek. Öffnen Sie also den Bibliotheksverwalter mit 'Fenster' 'Bibliotheksverwaltung'. Wählen Sie 'Einfügen' 'Weitere Bibliothek'. Der Dialog zum Öffnen von Dateien erscheint. Aus der Liste der Bibliotheken wählen Sie standard.lib.
"WARTEN" Deklaration
Gehen wir nun zum Baustein WARTEN. Dieser soll ein Timer werden, mit dem wir die Länge jeder Ampelphase angeben können. Unser Baustein erhält als Eingabevariable eine Variable ZEIT vom Typ TIME, und als Ausgabe liefert er einen booleschen Wert, den wir OK nennen wollen, und der TRUE
CoDeSys V2.3 3-3
Die Steuerung einer Ampelanlage...
sein soll, wenn die gewünschte Zeit abgelaufen ist. Diesen Wert besetzen wir mit FALSE vor, indem wir an das Ende der Deklaration (aber vor dem Strichpunkt)" := FALSE " einfügen.
Für unsere Zwecke benötigen wir den Baustein TP, einen Pulsgeber. Dieser hat zwei Eingänge (IN, PT) und zwei Ausgänge (Q, ET). TP macht nun folgendes:
Solange IN FALSE ist, ist ET 0 und Q FALSE. Sobald IN den Wert TRUE liefert, wird im Ausgang ET die Zeit in Millisekunden hochgezählt. Wenn ET den Wert PT erreicht, wird ET nicht mehr weiter gezählt. Q liefert unterdessen so lange TRUE wie ET kleiner als PT ist. Sobald der Wert PT erreicht ist, liefert Q wieder FALSE.
Um den Baustein TP im Baustein WARTEN verwenden zu können, müssen wir von TP eine lokale Instanz anlegen. Dazu deklarieren wir uns eine lokale Variable ZAB (für Zeit abgelaufen) vom Typ TP (zwischen den Schlüsselwörtern VAR, END_VAR).
Der Deklarationsteil von WARTEN sieht somit wie folgt aus:
"WARTEN"-Rumpf
Um den gewünschten Timer zu realisieren, muss der Rumpf des Bausteins wie folgt ausprogrammiert werden:
Zunächst wird abgefragt, ob Q bereits auf TRUE gesetzt ist (ob also bereits gezählt wird), in diesem Fall ändern wir nichts an der Belegung von ZAB, sondern rufen den Funktionsblock ZAB ohne Eingabe auf (um zu prüfen, ob die Zeit bereits abgelaufen ist).
3-4 CoDeSys V2.3
Andernfalls setzen wir die Variable IN in ZAB auf FALSE, und damit gleichzeitig ET auf 0 und Q auf FALSE. So sind alle Variablen auf den gewünschten Anfangszustand gesetzt. Nun speichern wir die benötigte Zeit aus der Variablen ZEIT in der Variablen PT, und rufen ZAB mit IN:=TRUE auf. Im Funktionsblock ZAB wird nun die Variable ET hoch gezählt bis sie den Wert ZEIT erreicht, dann wird Q auf FALSE gesetzt.
Der negierte Wert von Q wird nach jedem Durchlauf von WARTEN in OK gespeichert. sobald Q FALSE ist, liefert also OK TRUE.
Der Timer ist hiermit fertig. Nun gilt es, unsere beiden Funktionsblöcke WARTEN und AMPEL im Programm ABLAUF zusammen zu bringen, so dass die Abfolge der Ampelphasen wie gewünscht gesteuert wird.
"ABLAUF" erste Ausbaustufe
Zunächst deklarieren wir uns die Variablen, die wir brauchen. Das sind eine Eingangsvariable START vom Typ BOOL, zwei Ausgangsvariablen AMPEL1_STATUS und AMPEL2_STATUS vom Typ INT und eine vom Typ WARTEN (VERZ wie Verzögerung). Das Programm ABLAUF sieht nun folgendermaßen aus:
3 - Wir schreiben ein kleines Programm
Ein AS-Diagramm erstellen
Das Anfangsdiagramm eines Bausteins in AS besteht stets aus einer Aktion "Init" einer nachfolgenden Transition "Trans0" und einem Sprung zurück zu Init. Wir müssen dies etwas erweitern.
Legen wir zunächst die Struktur des Diagramms fest, bevor wir die einzelnen Aktionen und Transitionen programmieren. Erstmal benötigen wir für jede Ampelphase einen Schritt. Fügen Sie diesen ein, indem Sie Trans0 markieren, und 'Einfügen' 'Schritt-Transition (danach)' wählen. Wiederholen Sie diesen Vorgang noch dreimal.
Wenn Sie direkt auf den Namen einer Transition oder eines Schrittes klicken, dann wird dieser markiert, und Sie können ihn verändern. Nennen Sie die erste Transition nach Init "START", alle anderen Transitionen "VERZ.OK".
Die erste Transition schaltet durch, wenn START auf TRUE gesetzt wird, alle anderen dann, wenn VERZ in OK TRUE ausgibt, also wenn die eingegebene Zeit abgelaufen ist.
CoDeSys V2.3 3-5
Die Steuerung einer Ampelanlage...
Die Schritte erhalten (von oben nach unten) die Namen Schalt1, Gruen2, Schalt2, Gruen1, wobei Init seinen Namen natürlich behält. "Schalt" soll jedes Mal eine Gelbphase bedeuten, bei Gruen1 wird AMPEL1 bei Gruen2 AMPEL2 grün sein. Ändern Sie zuletzt noch die Rücksprungadresse von Init nach Schalt1. Wenn Sie alles richtig gemacht haben, dann müsste das Diagramm nun folgendermaßen aussehen:
Nun müssen wir die einzelnen Schritte ausprogrammieren. Wenn Sie auf dem Feld eines Schrittes einen Doppelklick ausführen, öffnen Sie einen Dialog zum Öffnen einer neuen Aktion. In unserem Fall werden wir als Sprache jeweils AWL (Anweisungsliste) verwenden.
Aktionen und Transitionsbedingungen
In der Aktion zum Schritt Init werden die Variablen initialisiert, der STATUS von AMPEL1 soll 1 (grün) sein. Der Status von AMPEL2 soll 3 (rot) sein. Die Aktion Init sieht dann so aus:
3-6 CoDeSys V2.3
3 - Wir schreiben ein kleines Programm
Bei Schalt1 wechselt der STATUS von AMPEL1 auf 2 (gelb), der von AMPEL2 auf 4 (gelb-rot). Außerdem wird nun eine Verzögerungszeit von 2000 Millisekunden festgelegt. Die Aktion sieht nun wie folgt aus:
Bei Gruen2 ist AMPEL1 rot (STATUS:=3), AMPEL2 grün (STATUS:=1), und die Verzögerungszeit ist auf 5000 Millisekunden gesetzt:
Bei Schalt2 wechselt der STATUS von AMPEL1 auf 4 (gelb-rot), der von AMPEL2 auf 2 (gelb). Es wird nun eine Verzögerungszeit von 2000 Millisekunden festgelegt:
Bei Gruen1 ist AMPEL1 grün (STATUS:=1), AMPEL2 rot (STATUS:=3), und die Verzögerungszeit wird auf 5000 Millisekunden eingestellt:
CoDeSys V2.3 3-7
Die Steuerung einer Ampelanlage...
Damit ist die erste Ausbauphase unseres Programms beendet.
Wenn Sie einen ersten Test des Bausteins ABLAUF im Simulationsmodus durchführen wollen, führen Sie folgende Schritte durch:
1. Öffnen Sie Baustein PLC_PRG. Von hier erfolgt der Start jeden Projektes. Um den bereits programmierten Baustein ABLAUF provisorisch starten zu können, fügen Sie einen Baustein ein, markieren Sie das "AND" im Baustein und ersetzen es durch "ABLAUF". Belassen Sie die Ein- und Ausgänge vorerst unbelegt.
2. Übersetzen Sie das Projekt mit 'Projekt' 'Übersetzen'. Im Meldungsfenster unterhalb des Arbeitsfensters sollte die Meldung "0 Fehler, 0 Warnungen" erscheinen. Führen Sie nun den Befehl 'Online' 'Einloggen' aus, um in den Simulationsmodus einzuloggen (die Option 'Online' 'Simulation' sollte bereits aktiviert sein). Starten Sie das Programm mit 'Online' 'Start'. Öffnen Sie den Baustein ABLAUF, indem Sie eine Doppelklick auf "ABLAUF" im Object Organizer ausführen. Das Programm ist jetzt zwar gestartet, für den Start des Ampelablaufs jedoch ist noch erforderlich, dass die Variable START den Wert TRUE erhält. Später wird sie diesen aus PLC_PRG bekommen, im Moment müssen wir ihn noch direkt im Baustein setzen. Führen Sie dazu im Deklarationsteil von ABLAUF einen Doppelklick auf die Zeile aus, in der START definiert ist (START=FALSE). Daraufhin erscheint hinter der Variablen in türkis die Option "<:=TRUE>". Wählen Sie nun den Befehl 'Online' 'Werte schreiben', um die Variable auf diesen Wert zu setzen. Daraufhin wird START im Ablaufdiagramm blau angezeigt und Sie erkennen das Abarbeiten der einzelnen Schritte durch die blaue Markierung des jeweilig aktiven Schrittes.
Soweit zum kleinen Zwischentest. Führen Sie danach den Befehl 'Online' 'Ausloggen' durch, um den Simulationsmodus zu verlassen und weiter programmieren zu können.
ABLAUF zweite Ausbaustufe
Damit sich in unserem Diagramm wenigstens eine Alternativverzweigung befindet, und damit wir unsere Ampelanlage nachts abstellen können, bauen wir in unser Programm nun einen Zähler ein, der nach einer bestimmten Zahl von Ampelzyklen die Anlage abstellt.
Zunächst brauchen wir also eine neue Variable ZAEHLER vom Typ INT. Deklarieren Sie diese wie gehabt im Deklarationsteil von ABLAUF und initialisieren Sie sie in Init mit 0.
Aktion Init, zweite Fassung
Markieren Sie nun die Transition nach Schalt1 und fügen Sie einen Schritt und eine Transition danach ein. Markieren Sie die neu entstandene Transition und fügen Sie eine Alternativverzweigung links davon ein. Fügen Sie nach der linken Transition einen Schritt und eine Transition ein. Fügen Sie nach der nun neu entstandenen Transition einen Sprung nach Schalt1 ein.
Benennen Sie die neu entstandenen Teile wie folgt: Der obere der beiden neuen Schritte soll "Zaehlen" heißen, der untere "Aus". Die Transitionen heißen (von oben nach unten und von links nach rechts) BEENDEN, TRUE und VERZ.OK. Das Sprungziel wird von "Step" in "Schalt1" umbenannt. Der neu entstandene Teil sollte also so aussehen wie der hier schwarz umrandete Teil:
3-8 CoDeSys V2.3
3 - Wir schreiben ein kleines Programm
Einbau Zähler
Es gibt also zwei neue Aktionen und eine neue Transitionsbedingung zu implementieren. Beim Schritt Zaehlen geschieht nichts anderes, als dass ZAEHLER um eins erhöht wird:
Aktion Zaehlen
Die Transition BEENDEN überprüft, ob der Zähler größer als eine bestimmte Zahl ist, z.B. 7:
Transition BEENDEN
Bei Aus wird der Status beider Ampeln auf 5 (AUS) gesetzt, (wobei jede andere beliebige Zahl ungleich 1,2,3 oder 4 für diesen Status gewählt werden könnte), der ZAEHLER wird auf 0 zurückgesetzt und eine Verzögerungszeit von 10 Sekunden festgelegt:
CoDeSys V2.3 3-9
Aktion Aus
Das Ergebnis
In unserer Ampelstadt wird es also nach sieben Ampelzyklen Nacht, für zehn Sekunden schaltet die Ampel sich aus, dann wird es wieder Tag, die Ampelanlage schaltet sich wieder ein, und das ganze geht wieder von vorn los. Wenn Sie wollen, können Sie dies nun wie oben beschrieben, im Simulationsmodus testen, bevor es zum Erstellen des Bausteins PLC_PRG geht.
PLC_PRG
Im Baustein ABLAUF haben wir den zeitlichen Ablauf der Phasen der beiden Ampeln definiert und korreliert. Da wir jedoch die Ampelanlage als Modul eines Bussystems, z.B. CAN, ansehen wollen, müssen wir nun im Baustein PLC_PRG entsprechende Ein- und Ausgangsvariablen für die Kommunikation über einen Bus zur Verfügung stellen. Wir wollen die Ampelanlage über einen EIN­Schalter in Betrieb nehmen und wir wollen bei jedem Schritt in ABLAUF jeder der sechs Lampen (jede Ampel Rot, Grün, Gelb) die jeweilige „Signalanweisung" zusenden. Für diese sechs Ausgänge und einen Eingang deklarieren wir nun, bevor wir das Programm im Editor erstellen, entsprechende boolesche Variablen und weisen sie dabei gleichzeitig den zugehörigen IEC-Adressen zu.
Die Steuerung einer Ampelanlage...
Im Deklarationseditor von PLC_PRG deklarieren wir zunächst die Variablen Ampel1 und Ampel2 vom Typ Ampel:
Diese übergeben bei jedem Schritt im Baustein ABLAUF die booleschen Werte für jede der sechs Lampen an die oben geforderten sechs Ausgänge. Die sechs dafür vorgesehenen Ausgangsvariablen deklarieren wir jedoch nicht innerhalb des PLC_PRG-Bausteins, sondern als global im ganzen Projekt verfügbare Variablen unter Ressourcen bei 'Globale Variablen'. Ebenso die boolesche Eingangsvariable EIN, über die die Variable START im Baustein ABLAUF auf TRUE gesetzt werden kann. Auch EIN wird eine IEC-Adresse zugeordnet.
Wählen Sie also das Registerblatt Ressourcen und öffnen die Liste Globale Variablen.
Deklarieren Sie folgendermaßen:
3-10 CoDeSys V2.3
3 - Wir schreiben ein kleines Programm
Dem Namen der Variable (z.B. EIN) folgt nach AT mit einem Prozentzeichen beginnend die IEC­Adresse. I steht dabei für Eingang, Q für Ausgang, X (in diesem Beispiel verwendet) steht für Byte und mit 0.0 (0.1, 0.2 usw.) werden die einzelnen Bits des Moduls angesprochen. Die erforderliche Steuerungskonfiguration werden wir in diesem Beispiel nicht vornehmen, da sie davon abhängt, welche Ausstattung an Konfigurationsdateien Ihnen zur Verfügung steht. Siehe gegebenenfalls hierzu Kapitel 6.6, Ressourcen, Steuerungskonfiguration.
Wir wollen nun den Baustein PLC_PRG fertig stellen.
Dazu gehen wir ins Editorfenster. Wir haben den freigraphischen Funktionsplaneditor CFC gewählt, dementsprechend erhalten wir unter der Menüleiste die CFC-Symbolleiste mit den verfügbaren Bauelementen.
Klicken Sie mit der rechten Maustaste ins Editorfenster und wählen Sie das Element Baustein. Klicken Sie auf den Text AND und schreiben Sie stattdessen "ABLAUF". Daraufhin erhalten Sie den Baustein ABLAUF mit den bereits definierten Ein- und Ausgangsvariablen dargestellt. Fügen Sie zwei weitere Baustein-Elemente hinzu, die Sie AMPEL benennen. Ampel ist ein Funktionsblock, deshalb erhalten Sie über dem Baustein drei rote Fragezeichen, die Sie durch die Namen der oben lokal deklarierten Variablen AMPEL1 und AMPEL2 ersetzen. Nun setzen Sie ein Element des Typs Eingang, den Sie mit EIN betiteln und sechs Elemente des Typs Ausgang, die Sie wie dargestellt mit den Variablennamen A1_gruen, A1_gelb, A1_rot, A2_gruen, A2_gelb A2_rot versehen.
Nun sind alle Elemente des Programms platziert und Sie können ihre Ein- und Ausgänge verbinden, indem Sie mit der Maus auf die kurze Linie an Ein- oder Ausgang eines Elements klicken und diese bei gedrückter Maustaste zum Ein- oder Ausgang des gewünschten Elements ziehen.
Ihr Programm sollte letztendlich wie hier dargestellt aussehen:
Ampelsimulation
Testen Sie nun Ihr Programm. Dazu müssen Sie es wieder übersetzen ('Projekt' 'Alles übersetzen'), laden ('Online' 'Einloggen') und starten. Führen Sie dazu 'Online' 'Start' aus und setzen Sie die Variable EIN auf TRUE, letzteres beispielsweise dadurch, dass Sie in PLC_PRG einen Doppelklick auf den Eintrag "EIN" in der Eingangsbox im CFC-Editor ausführen. Daraufhin erscheint die Variable als mit <TRUE> vormarkiert. Führen Sie dann <Strg><F7> oder den Befehl 'Online' 'Schreiben' aus, um diesen Wert zu setzen. Die Variable START in ABLAUF, die wir in der ersten Ausbaustufe des Programms noch per Hand auf TRUE gesetzt hatten, erhält diesen Wert nun also von Variable EIN aus PLC_PRG. Daraufhin laufen die Ampelzyklen los. Das Fenster des Bausteins PLC_PRG hat sich bereits zum Monitor Fenster gewandelt. Mit Doppelklick auf das Pluszeichen im Deklarationseditor klappt die Variablendarstellung auf und Sie können die Werte der einzelnen Variablen beobachten.

3.2 Die Visualisierung einer Ampelanlage...

Mit der Visualisierung von CoDeSys kann man schnell und einfach Projekt variablen mit Leben erfüllen. Wir werden im Folgenden zu unserer Ampelanlage zwei Ampeln und einen EIN-Schalter zeichnen, die den Schaltvorgang veranschaulichen sollen.
CoDeSys V2.3 3-11
Erstellen einer neuen Visualisierung
Um eine Visualisierung zu erstellen, müssen Sie zuerst im Object Organizer den Bereich Visualisierung auswählen. Klicken Sie hierzu am unteren Rand des Fensters auf der linken Seite, in
dem Bausteine steht, auf die Registerkarte mit diesem Symbol Wenn Sie nun den Befehl 'Projekt' 'Objekt einfügen' ausführen, öffnet sich ein Dialog.
Geben Sie hier einen beliebigen Namen ein. Wenn Sie den Dialog mit OK bestätigen, öffnet sich ein Fenster, in dem Sie Ihre neue Visualisierung erstellen können.
Element in Visualisierung einfügen
Für unsere Ampel-Visualisierung gehen Sie am besten folgendermaßen vor:
• Geben Sie den Befehl 'Einfügen' 'Ellipse' und versuchen Sie einen nicht allzu großen Kreis (2cm)
zu zeichnen. Dazu klicken Sie in das Editierfeld und ziehen mit gedrückter linker Maustaste den Kreis in die Länge.
• Führen Sie nun einen Doppelklick auf den Kreis aus. Es öffnet der Dialog zum Editieren von
Visualisierungselementen.
• Wählen Sie die Kategorie Variablen und tragen im Feld Farbwechsel den Text "A1_rot" oder
".A1_rot" ein. Das bedeutet, dass die globale Variable A1_rot den Farbwechsel bewirkt, wenn sie den Wert TRUE erhält. Der Punkt vor dem Variablennamen zeigt an, dass es sich um eine globale Variable handelt, ist jedoch nicht zwingend erforderlich:
Die Visualisierung einer Ampelanlage...
und dem Namen Visualisierung.
• Anschließend wählen Sie die Kategorie Farben und klicken auf die Schaltfläche Innen im Bereich
Farbe. Wählen Sie eine möglichst neutrale Farbe, beispielsweise schwarz.
• Klicken Sie nun auf die Schaltfläche Innen im Bereich Alarmfarbe, und wählen Sie ein Rot aus, das
am ehesten einem Ampelrot entspricht.
3-12 CoDeSys V2.3
Der so entstandene Kreis wird im Normalzustand schwarz sein, und wenn die Variable ROT von AMPEL1 TRUE ist, wird seine Farbe auf Rot wechseln. Wir haben also bereits das erste Licht der ersten Ampel erstellt!
Die weiteren Ampellichter
Geben Sie nun die Befehle 'Bearbeiten' 'Kopieren' (<Strg>+<C>) und dann zweimal 'Bearbeiten' 'Einfügen' (<Strg>+<V>). So erhalten Sie zwei weitere, exakt gleich große Kreise, die über dem
ersten liegen. Sie können die Kreise verschieben, indem sie auf den Kreis klicken, und mit gedrückter linker Maustaste in die gewünschte Position verschieben. Die gewünschte Position sollte in unserem Fall in einer Reihe übereinander in der linken Hälfte des Editorfensters sein. Mit einem Doppelklick auf einen der beiden unteren Kreise öffnen Sie wieder den Konfigurationsdialog. Geben Sie im Feld Farbwechsel des entsprechenden Kreises die folgenden Variablen ein:
für den mittleren Kreis: A1_gelb
für den unteren Kreis: A1_gruen Wählen Sie nun für die Kreise in der Kategorie Farben und im Bereich Alarmfarbe die entsprechende
Farbe aus (gelb bzw. grün).
Das Ampelgehäuse
Geben Sie nun den Befehl 'Einfügen' 'Rechteck', und fügen Sie in derselben Weise wie eben den Kreis, ein Rechteck ein, das die drei Kreise umfasst. Wählen Sie für das Rechteck wiederum eine möglichst neutrale Farbe und geben Sie den Befehl 'Extras' 'Nach hinten legen', damit die Kreise wieder sichtbar werden.
3 - Wir schreiben ein kleines Programm
Falls der Simulationsmodus noch nicht eingeschaltet ist, können Sie ihn mit dem Befehl 'Online' 'Simulation' aktivieren.
Wenn Sie nun die Simulation mit den Befehlen 'Online' 'Einloggen' und 'Online' 'Start' starten, können Sie den Farbwechsel der ersten Ampel mit verfolgen.
Die zweite Ampel
Die zweite Ampel können Sie am einfachsten erstellen, indem Sie sämtliche Komponenten der ersten Ampel kopieren. Dazu markieren Sie alle Elemente der ersten Ampel und kopieren sie (wie vorhin die Lichter der ersten Ampel) mit den Befehlen 'Bearbeiten' 'Kopieren' und 'Bearbeiten' 'Einfügen'. In den jeweiligen Visualisierungsdialogen müssen Sie dann nur noch den Text "A1" in "A2" ändern, und schon ist die Visualisierung der zweiten Ampel fertig.
Der EIN-Schalter
Fügen Sie ein Rechteck ein und vergeben Sie wie oben für die Ampeln beschrieben beliebige Farben und tragen bei Variablen für den Farbwechsel ".EIN " ein. In der Kategorie Text tragen Sie bei Inhalt "EIN" ins Eingabefeld ein:
CoDeSys V2.3 3-13
Die Visualisierung einer Ampelanlage...
Um mit Mausklick auf den Schalter die Variable EIN auf TRUE setzen zu können, müssen Sie in der Kategorie Eingabe die Option Variable tasten aktivieren und dahinter die Variable .EIN eingeben. Variable tasten bedeutet, dass bei Mausklick auf das Visualisierungselement die Variable .EIN auf TRUE, bei Loslassen der Maustaste aber wieder auf FALSE zurückgesetzt wird (Wir schaffen uns somit einen einfachen Einschalter für unser Ampelprogramm).
Visualisierungskonfiguration, 'Eingabe'
Schrift in der Visualisierung
Um die Visualisierung zu vervollständigen, sollten Sie noch zwei weitere flache Rechtecke einfügen, die Sie unterhalb der Ampeln platzieren.
Im Visualisierungsdialog stellen Sie jeweils in der Kategorie Farben für Rahmen 'Keine Rahmenfarbe' ein und schreiben in der Kategorie Text ins Feld Inhalt "Ampel 1" beziehungsweise "Ampel 2". Nun sieht Ihre Visualisierung folgendermaßen aus:
3-14 CoDeSys V2.3
4 - Die Komponenten im Einzelnen

4 Die Komponenten im Einzelnen

4.1 Hauptfenster...

Komponenten des Hauptfensters

Beispiel Hauptfenster
Folgende Elemente befinden sich im Hauptfenster von CoDeSys (von oben nach unten):
• Die Menüleiste (Viele der Menübefehle finden sich auch im Kontextmenü, das über die rechte
• Die Funktionsleiste (optional); mit Schaltflächen zur schnelleren Ausführung von Menübefehlen.
• Der Object Organizer mit Registerkarten für Bausteine, Datentypen, Visualisierungen und
• Ein vertikaler Bildschirmteiler zwischen dem Object Organizer und dem Arbeitsbereich von
• Der Arbeitsbereich, in dem sich die Editorfenster (Anzahl unbegrenzt) befinden.
• Das Meldungsfenster (optional)
• Die Statusleiste (optional); mit Informationen über den derzeitigen Zustand des Projekts

Menüleiste

Die Menüleiste befindet sich am oberen Rand des Hauptfensters. Sie enthält alle Menübefehle.
Maustaste geöffnet wird.)
Ressourcen
CoDeSys
CoDeSys V2.3 4-1

Funktionsleiste

Durch Klicken mit der Maus auf ein Symbol ermöglicht die Funktionsleiste eine schnellere Auswahl eines Menübefehls. Die Auswahl der zur Verfügung gestellten Symbole passt sich automatisch an das aktive Fenster an.
Wenn Sie den Mauszeiger eine kurze Zeit über einem Symbol in der Funktionsleiste halten, wird der Name des Symbols in einem Tooltip angezeigt.
Um die Beschreibung jedes Symbols der Funktionsleiste zu erhalten, wählen Sie in der Hilfe den Editor, über den Sie Information wünschen, und klicken Sie das Funktionsleistensymbol, an dem Sie interessiert sind.
Hauptfenster...
Die Anzeige der Funktionsleiste ist optional (siehe 'Projekt' 'Optionen' Kategorie Arbeitsbereich

Object Organizer

Der Object Organizer befindet sich immer an der linken Seite von CoDeSys. Unten sehen Sie die Symbole der vier Registerkarten für die Objektkategorien Visualisierungen und Ressourcen. Zum Wechseln zwischen den jeweiligen Objektkategorien
klicken sie mit der Maus auf die entsprechende Registerkarte oder benutzen Sie die linke bzw. rechte Pfeiltaste.
Zusätzliche Symbole vor oder hinter den Objekteinträgen kennzeichnen bestimmte Stati hinsichtlich Online Change und ENI-Anbindung an eine Datenbank.
Wie Sie mit den Objekten im Object Organizer arbeiten, erfahren Sie unter Objekte verwalten.

Bildschirmteiler

Der Bildschirmteiler ist die Grenze zwischen zwei nicht überlappenden Fenstern. In CoDeSys gibt es Bildschirmteiler zwischen dem Object Organizer und dem Arbeitsbereich des Hauptfensters, zwischen der Schnittstelle (Deklarationsteil) und der Implementierung (Anweisungsteil) von Bausteinen und zwischen dem Arbeitsbereich und dem Meldungsfenster.
Wenn Sie den Mauszeiger auf den Bildschirmteiler führen, können Sie damit den Bildschirmteiler verschieben. Dies geschieht durch Bewegen der Maus bei gedrückter linker Maustaste.
).
Bausteine, Datentypen,
Beachten Sie, dass der Bildschirmteiler stets an seiner absoluten Position bleibt, auch wenn die Fenstergröße verändert wird. Wenn der Bildschirmteiler nicht mehr vorhanden zu sein scheint, dann vergrößern Sie einfach Ihr Fenster.

Arbeitsbereich

Der Arbeitsbereich befindet sich an der rechten Seite im CoDeSys-Hauptfenster. Alle Editoren für Objekte und der Bibliotheksverwaltung werden in diesem Bereich geöffnet. In der Titelleiste der Fenster erscheint der jeweilige Objektname, bei Bausteinen werden in einer Klammer dahinter zusätzlich je ein Kürzel für den Bausteintyp und die verwendete Programmiersprache angegeben.
Unter dem Menüpunkt 'Fenster' befinden sich alle Befehle zur Fensterverwaltung.

Meldungsfenster

Das Meldungsfenster befindet sich getrennt durch einen Bildschirmteiler unterhalb des Arbeitsbereiches im Hauptfenster.
Es enthält alle Meldungen aus dem letzten Übersetzungs-, Überprüfungs- oder Vergleichvorgang. Auch Suchergebnisse und die Querverweisliste können hier ausgegeben werden.
4-2 CoDeSys V2.3
Wenn Sie im Meldungsfenster mit der Maus einen Doppelklick auf eine Meldung ausführen oder die <Eingabetaste> drücken, öffnet der Editor mit dem betroffenen Objekt und die entsprechende Zeile des Objekts wird markiert. Mit den Befehlen
'Bearbeiten' 'Nächster Fehler' und 'Bearbeiten' 'Vorheriger Fehler' kann schnell zwischen den Fehlermeldungen gesprungen werden.
Die Anzeige des Meldungsfensters ist optional (siehe 'Fenster' 'Meldungen').

Statusleiste

Die Statusleiste, die sich unten im Fensterrahmen des CoDeSys-Hauptfensters befindet, zeigt Ihnen Informationen über das aktuelle Projekt und über Menübefehle an.
Trifft eine Aussage zu, so erscheint der Begriff rechts in der Statusleiste in schwarzer Schrift, ansonsten in grauer Schrift.
Wenn Sie im Online Modus arbeiten, so erscheint der Begriff Online in schwarzer Schrift, arbeiten Sie dagegen im Offline Modus, erscheint er in grauer Schrift.
Im Online Modus erkennen Sie in der Statusleiste, ob Sie sich in der Simulation befinden (SIM), das Programm abgearbeitet wird (LÄUFT), ein Breakpoint gesetzt ist (BP) und Variablen geforced werden (FORCE).
Bei Texteditoren wird die Zeilen- und Spaltennummer der aktuellen Cursorposition angegeben (z.B. Z.:5, Sp.:11). Wenn Sie im Überschreibmodus arbeiten, wird in der Statusleiste 'ÜB' schwarz angezeigt. Sie können durch Betätigen der Taste <Einfg> zwischen dem Überschreib- und dem Einfügemodus wechseln.. Befindet sich der Mauszeiger in einer Visualisierung, wird die aktuelle X- und Y-Position des Cursors in Pixel relativ zur oberen linken Ecke des Bilds angegeben. Befindet sich der Mauszeiger auf einem Element oder wird ein Element bearbeitet, wird die Nummer desselben angegeben. Haben Sie ein Element zum Einfügen ausgewählt, so erscheint dies ebenfalls (z.B. Rechteck).
4 - Die Komponenten im Einzelnen
Wenn Sie einen Menübefehl angewählt, aber noch nicht betätigt haben, dann erscheint eine kurze Beschreibung in der Statusleiste.
Die Anzeige der Statusleiste ist optional (siehe 'Projekt' 'Optionen' Kategorie Arbeitsbereich).

Kontextmenü

Kurzform: <Umschalt>+<F10>
Anstatt die Menüleiste zu verwenden, um einen Befehl auszuführen, können Sie die rechte Maustaste verwenden. Das dann angezeigte Menü enthält die am häufigsten verwendeten Befehle für ein markiertes Objekt oder für den aktiven Editor. Die Auswahl der zur Verfügung gestellten Befehle passt sich automatisch an das aktive Fenster an.

4.2 Projekt Optionen...

Die Einstellungen unter ‘Projekt’ 'Optionen’ dienen unter anderem der Konfiguration der Ansicht des CoDeSys Hauptfensters. Soweit nicht anders vermerkt, werden sie in der Datei "CoDeSys.ini" gespeichert, also beim nächsten Start von CoDeSys wiederhergestellt.
Ein Abbild der für das Projekt eingestellten Projektoptionen wird in den Ressourcen im Knoten 'Arbeitsbereich' angelegt.
Mit dem Befehl wird der Dialog Optionen geöffnet. Die Einstellungsmöglichkeiten sind in verschiedene Kategorien aufgeteilt. Wählen Sie auf der linken Seite des Dialogs die gewünschte Kategorie durch einen Mausklick oder mit Hilfe der Pfeiltasten aus und verändern Sie auf der rechten Seite die Optionen.
CoDeSys V2.3 4-3
Projekt Optionen...
Kategorien: in CoDeSys

Laden & Speichern X

Benutzerinformation X
Editor X
Arbeitsbereich X
Farben X
Verzeichnisse Kat. Allgemein Kat. Projekt
Logbuch X
Übersetzungsoptionen
Kennworte
Sourcedownload X
Symbolkonfiguration X
Projektdatenbank
Makros
Optionen für Laden & Speichern
gespeichert
im Projekt
gespeichert
X
X
X
X
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, erhalten Sie den
Optionen-Dialog der Kategorie Laden & Speichern
Bei Aktivierung einer Option, erscheint ein Haken vor der Option. Sicherheitskopie erstellen: CoDeSys speichert die alte Datei bei jedem 'Datei' 'Speichern' in eine
Sicherungsdatei mit dem Zusatz ".bak". Diese Datei bleibt im Gegensatz zu der *.asd-Sicherungsdatei (siehe unten, 'Automatisch sichern') auch nach Beenden des Projekts erhalten. Sie können daraus also stets die Version vor der letzten Speicherung wieder herstellen.
Automatisch sichern: Das geöffnete Projekt wird wiederholt in dem von Ihnen eingestellten Zeitintervall (Sicherungsintervall (Min.)) in eine temporäre Datei mit dem Zusatz ".asd" im Projektverzeichnis gespeichert. Diese Datei wird beim normalen Beenden des Programms gelöscht. Sollte CoDeSys aus irgendeinem Grund nicht "normal" beendet werden (z.B. bei einem Stromausfall), wird die Datei nicht gelöscht. Wenn Sie das Projekt in diesem Fall wieder öffnen, erscheint folgende Meldung:
4-4 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Sie können nun entscheiden, ob Sie die Originaldatei oder die Sicherungsdatei öffnen wollen. Wenn eine Bibliothek *.lib als Projekt geöffnet ist, wird eine entsprechende Sicherungsdatei "*.asl"
angelegt. Automatisch sichern vor Übersetzen: Das Projekt wird vor jedem Übersetzungslauf gespeichert.
Dabei wird eine Datei mit dem Zusatz ".asd" bzw. ".asl" angelegt, die sich verhält wie bei der Option 'Automatisch sichern' beschrieben.
Projektinformation verlangen: Beim Abspeichern eines neuen Projekts oder beim Abspeichern eines Projekts unter einem neuen Namen wird automatisch der Dialog 'Projektinformation' aufgerufen. Die Projektinformationen können Sie jederzeit mit dem Befehl 'Projekt' 'Projektinformation' einsehen und bearbeiten.
Automatisch laden: Beim nächsten Start von CoDeSys wird das zuletzt geöffnete Projekt automatisch geladen. Das Laden eines Projekts kann beim Start von CoDeSys auch durch Angabe eines Projektes in der Befehlszeile erfolgen.
An Bootprojekt erinnern vor Beenden: Wenn seit dem Erzeugen eines Bootprojekts das Projekt in modifizierter Form auf die Steuerung geladen wurde, ohne ein neues Bootprojekt zu erzeugen, wird der Anwender beim Verlassen des Projekts darauf aufmerksam gemacht: "Seit dem letzten Download ist kein Bootprojekt erzeugt worden. Trotzdem beenden?“
Zugangsdaten für Projektdatenbank speichern: Benutzername und Passwort, wie sie gegebenenfalls für den Zugang zur ENI-Datenbank eingegeben wurden, werden gespeichert. Für die bei 'Projekt aus Projektdatenbank öffnen' ('Datei' 'Öffnen') eingegebenen Zugangsdaten werden dann auch Benutzername und Passwort in der codesys.ini gespeichert.
Optionen für Benutzerinformation
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, erhalten Sie folgenden Dialog:
Optionen-Dialog der Kategorie Benutzerinformation
CoDeSys V2.3 4-5
Zur Benutzerinformation gehören der Name des Benutzers, seine Initialen und die Firma, bei der er arbeitet. Jeder der Einträge kann verändert werden. Die Angaben werden für weitere Projekte, die mit
CoDeSys auf dem Rechner erstellt werden, automatisch übernommen.
Optionen für Editor
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, erhalten Sie den unten gezeigten Dialog.
Bei Aktivierung einer Option, erscheint ein Haken vor der Option.
Sie können folgende Einstellungen zu den Editoren vornehmen: Automatisch deklarieren: In allen Editoren erscheint nach Eingabe einer noch nicht deklarierten
Variablen der Dialog 'Variablendeklaration', mit dessen Hilfe diese Variable deklariert werden kann. Automatisch formatieren: CoDeSys führt eine automatische Formatierung im
Anweisungslisteneditor und im Deklarationseditor durch. Wenn eine Zeile verlassen wird, werden folgende Formatierungen durchgeführt: 1. Operatoren und Schlüsselwörter, die in Kleinbuchstaben geschrieben sind, werden in Grossbuchstaben dargestellt, 2. Tabulatoren werden eingefügt, so dass sich eine einheitliche Spaltenaufteilung ergibt.
Optionen-Dialog der Kategorie Editor
Projekt Optionen...
Komponenten auflisten: Wenn diese Option aktiviert ist, steht die "Intellisense-Funktion" in CoDeSys zur Verfügung. Wenn Sie dann an den Stellen, an denen ein Bezeichner eingegeben werden soll, nur einen Punkt eingeben, erhalten Sie eine Auswahlliste aller im Projekt verfügbaren globalen Variablen. Wenn Sie den Namen einer Funktionsblock-Instanz, gefolgt von einem Punkt, eingeben, erhalten Sie eine Auswahlliste der Ein- und Ausgänge des instanzierten Funktionsblockes. Die "Intellisense-Funktion" gibt es in den Editoren, im Watch- und Rezepturverwalter, in der Visualisierung und in der Trace-Konfiguration.
Deklarationen als Tabelle: Sie können Variablen statt mit dem üblichen Deklarationseditor in einem Editor in Tabellenform editieren. Diese Tabelle ist wie ein Karteikasten geordnet, in dem es Registerkarten für Eingabe-, Ausgabe-, lokale und EinAusgabevariablen gibt. Für jede Variable stehen Ihnen die Felder Name, Adresse, Typ, Initial und Kommentar zur Verfügung.
Tab-Breite: Sie können hier angeben, wie breit ein Tabulator in den Editoren dargestellt wird. Voreingestellt ist eine Breite von vier Zeichen, wobei die Zeichenbreite wiederum von der eingestellten Schriftart abhängt.
Schrift: Nach Drücken dieser Schaltfläche wird der Dialog 'Schriftart' geöffnet. Wählen Sie hier die Schriftmerkmale, die in allen CoDeSys-Editoren verwendet werden soll. Die Größe der Schrift ist die Grundeinheit für alle Zeichnungsoperationen. Die Wahl einer größeren Schriftgröße vergrößert somit die Ausgabe und auch den Ausdruck bei jedem Editor von CoDeSys.
4-6 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Dialog zur Einstellung der Schrift
Markierung: Wählen Sie hier, ob die aktuelle Markierung in den graphischen Editoren durch ein gepunktetes Rechteck (Gepunktet), durch ein Rechteck mit durchgezogener Linie oder durch ein ausgefülltes Rechteck (Ausgefüllt) angezeigt werden soll. Aktiviert ist die Auswahl, vor der ein Punkt erscheint.
Bitwerte: Wählen Sie, ob binäre Datentypen (BYTE, WORD, DWORD) beim Monitoring Dezimal, Hexadezimal oder Binär dargestellt werden sollen. Aktiviert ist die Auswahl, vor der ein Punkt
erscheint. Monitoring von komplexen Typen (Array, Pointer, VAR_IN_OUT) unterbinden: Wenn diese
Option aktiviert ist, werden komplexe Datentypen wie Arrays, Pointer, VAR_IN_OUTs im Monitorfenster des Online Modus nicht dargestellt.
Baustein-Symbole anzeigen: Wenn diese Option aktiviert ist, werden in den Bausteinboxen Symbole dargestellt, sofern diese als Bitmaps im Bibliotheksverzeichnis vorliegen. Der Name der Bitmap-Datei muss sich aus dem Bausteinnamen und der Erweiterung .bmp zusammensetzen. Beispiel: Für den Baustein TON ist das Symbol in der Datei TON.bmp enthalten:
Optionen für Arbeitsbereich
Wenn Sie diese Kategorie im Optionsdialog wählen, erhalten Sie folgenden Dialog:
Optionen-Dialog der Kategorie Arbeitsbereich
Aktivieren Sie aus den folgenden Optionen die gewünschten durch Mausklick, so dass ein Haken bzw. ein erscheint:
CoDeSys V2.3 4-7
Projekt Optionen...
Funktionsleiste: Die Funktionsleiste mit den Schaltflächen zur schnelleren Auswahl von Menübefehlen wird unterhalb der Menüleiste sichtbar.
Statusleiste: Die Statusleiste wird am unteren Rand des CoDeSys-Hauptfensters sichtbar. Onlinebetrieb im Sicherheitsmodus: Im Online Modus erscheint bei den Befehlen 'Start', 'Stop',
'Reset', 'Breakpoint an', 'Einzelzyklus', 'Werte schreiben', 'Werte forcen' und 'Forcen aufheben' ein Dialog mit der Sicherheitsabfrage, ob der Befehl wirklich ausgeführt werden soll. Wenn das Laufzeitsystem es unterstützt, erscheint beim Laden eines Projekts auf die Steuerung ein erweiterter Dialog: Er zeigt zusätzlich die Projektinformationen eines ggfs. bereits auf der Steuerung vorhandenen sowie des neu zu ladenden Projekts an. Diese Projektinformationen erscheinen dann ebenfalls beim Erzeugen eines Bootprojekts, wenn bereits ein solches auf der Steuerung vorliegt. Die Option wird mit dem Projekt gespeichert.
Kommunikationseinstellungen vor Login abfragen: Nach dem Befehl 'Online' 'Login' erscheint zunächst der Kommunikationsparameter-Dialog. Erst nachdem dieser mit OK geschlossen wurde, wird in den Online Modus gewechselt.
Kommunikationseinstellungen nicht im Projekt speichern: Die Einstellungen des Kommunikationsparameter-Dialogs ('Online' 'Kommunikationsparameter') werden nicht mit dem Projekt gespeichert.
Druckbereiche anzeigen: In jedem Editorfenster werden durch rot gestrichelte Linien die Begrenzungen des aktuell eingestellten Druckbereiches markiert. Dessen Größe hängt von den Druckereigenschaften (Papiergröße, Ausrichtung) und der Größe des "Content"-Bereichs der eingestellten Druckvorlage ab.
F4 ignoriert Warnungen: Nach einem Übersetzungslauf springt der Fokus beim Drücken von F4 im Meldungsfenster nur in Zeilen mit Fehlermeldungen, Warnungsausgaben werden ignoriert.
MDI-Darstellung: Per Default ist diese Option (Multiple-Document-Interface) aktiviert, also das gleichzeitige Öffnen mehrerer Objekte (Fenster) möglich. Wird die Option deaktiviert (SDI-Modus, Single-Document-Interface), kann jeweils nur 1 Fenster im Arbeitsbereich geöffnet werden, das dann im Vollbildmodus dargestellt wird. Ausnahme: Die Aktion eines Programms kann auch im MDI-Modus gleichzeitig mit dem Programm dargestellt werden.
Kommunikations-Timeout [ms]: für Standard-Kommunikationsdienste: Zeitspanne in Millisekunden, nach der die Kommunikation zum Zielsystem (Standard-Kommunikationsdienste) abgebrochen wird, wenn keine Aktivität mehr festgestellt wird. Mögliche Werte: 1-10000000. ms.
Kommunikations-Timeout für Download [ms]: für lange Kommunikationsdienste (Programm­Download, Datei Up- und Download, Bootprojekterzeugung und -überprüfung): Zeitspanne in Millisekunden, nach der die Kommunikation zum Zielsystem abgebrochen wird, wenn keine Aktivität mehr festgestellt wird (Download Wait Time). Mögliche Werte: 1-10000000.
XML-Encoding: Das Format für XML-Exporte aus CoDeSys kann ausgewählt werden. Die Standard­Einstellung ist ISO 8859-1. Betroffen ist die Kommunikation über über ENI, Message Interface und COM Automation Interface, wie auch jede benutzer-gesteuerte Export aus CoDeSys. Eine Ausnahme ist der XML-Export des Lizenz-Managers.
Sprache: Wählen Sie, in welcher Landessprache die Menü- und Dialogtexte sowie die Online Hilfe erscheinen sollen.
Hinweise: Beachten Sie, dass die Sprachauswahl unter Windows 98 nicht möglich ist !
Die hier vorgenommenen Einstellungen für den Arbeitsbereich werden in CoDeSys
gespeichert.
4-8 CoDeSys V2.3
Optionen für Farben
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, erhalten Sie folgenden Dialog:
Optionen-Dialog der Kategorie Farbe
Sie können hier die voreingestellten Farbeinstellungen von CoDeSys für Zeilennummern (Voreinstellung: hellgrau), für Breakpoint-Positionen (dunkelgrau), für einen gesetzten Breakpoint (hellblau), für die aktuelle Position (rot), für die durchlaufenen Positionen (grün) oder für das Monitoring boolescher Werte (blau) ändern.
4 - Die Komponenten im Einzelnen
Wenn Sie eine der angegebenen Schaltflächen gewählt haben, wird der Dialog zum Eingeben von Farben geöffnet.
Dialog zur Einstellung der Farbe
CoDeSys V2.3 4-9
Optionen für Verzeichnisse
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, erhalten Sie folgenden Dialog:
Optionen-Dialog der Kategorie Verzeichnisse
Projekt Optionen...
In den Bereichen Projekt und Allgemein können Verzeichnisse eingetragen werden, die CoDeSys nach Bibliotheken, SteuerungsKonfigurations- und Visualisierungsdateien (bitmaps, XML-Dateien für dynamische Texte etc.) durchsuchen bzw. für die Ablage von Übersetzungs- und Source-Upload- Dateien verwenden soll. (Hinweis: Übersetzungsdateien sind beispielsweise map- und list-Dateien, nicht jedoch z.B. Symboldateien! Letztere werden im Projektverzeichnis gespeichert.)
Wenn Sie die Schaltfläche (...) hinter einem Feld betätigen, dann öffnet der Dialog zum Auswählen eines Verzeichnisses. Für Bibliotheks- und Konfigurationsdateien können jeweils mehrere Pfade getrennt durch ein Semikolon ";" eingegeben werden.
Hinweis: Bibliothekspfade können relativ zum aktuellen Projektverzeichnis eingegeben werden, indem ein "."
vorangestellt wird. Wird z.B. ".\libs" angegeben, werden die Bibliotheken auch im Verzeichnis 'C:\Programme\projects\libs' gesucht, wenn das aktuelle Projekt im Verzeichnis 'C:\Programme\projects' liegt. Für Informationen zu Bibliothekspfaden siehe auch Kapitel 6.4, 'Einfügen' 'weitere Bibliothek'.
Hinweis: Verwenden Sie in den Verzeichnispfaden keine Leerzeichen und Sonderzeichen außer "_".
Die Angaben im Bereich Projekt werden mit dem Projekt gespeichert, die im Bereich Allgemein werden in die ini-Datei des Programmiersystems geschrieben und gelten somit für alle Projekte.
Im Bereich Zielsystem werden die Verzeichnisse für Bibliotheken und Konfigurationsdateien dargestellt, die im Zielsystem eingestellt sind, z.B. durch die Angaben in der Target-Datei. Diese Felder sind nicht editierbar, aber ein Eintrag kann selektiert und kopiert werden (Kontextmenü Rechte Maustaste).
CoDeSys sucht generell zuerst in den bei 'Projekt' eingetragenen Verzeichnissen, dann in den unter 'Zielsystem' (in der Target-Datei definierten) und zuletzt in den unter 'Allgemein' angegebenen. Liegen gleichnamige Dateien vor, wird die verwendet, die im zuerst durchsuchten Verzeichnis steht.
4-10 CoDeSys V2.3
Optionen für Logbuch
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, wird der unten gezeigte Dialog geöffnet. Hier können Sie eine Datei konfigurieren, die als Projekt-Logbuch alle Benutzeraktionen und internen Vorgänge während des Online-Modus chronologisch aufzeichnet
Wird ein bestehendes Projekt geöffnet, für das noch kein Logbuch generiert wurde, öffnet ein Dialog, der darauf aufmerksam macht, dass nun ein Logbuch angelegt wird, das erstmals mit dem nächsten Login-Vorgang Einträge erhält.
Optionen-Dialog der Kategorie Logbuch
4 - Die Komponenten im Einzelnen
Das Logbuch wird beim Speichern des Projekts automatisch als Binärdatei im Projektverzeichnis gespeichert. Wenn Sie ein anderes Zielverzeichnis wünschen, können Sie die Option Verzeichnis für Projekt-Logbücher: aktivieren und im Editierfeld den entsprechenden Pfad eingeben. Über die Schaltfläche erhalten Sie dazu den Dialog 'Verzeichnis auswählen'.
Die Logbuch-Datei erhält automatisch den Namen des Projekts mit der Erweiterung .log. Unter
Maximale Größe eines Projekt-Logbuchs wird die Höchstanzahl der aufzuzeichnenden Online- Sessions festgelegt. Wird während der Aufzeichnung diese Anzahl überschritten, wird der jeweils
älteste Eintrag zugunsten des neuesten gelöscht. Die Funktion Logbuch kann im Optionsfeld Logbuch aktivieren ein- oder ausgeschaltet werden. Im Bereich Filter können Sie wählen, welche Aktionen aufgezeichnet werden sollen. Nur Aktionen der
hier mit einem Haken versehenen Kategorien werden im Logbuch-Fenster erscheinen bzw. in die Logbuch-Datei geschrieben.
Das Logbuch-Fenster können Sie mit dem Befehl 'Fenster' 'Logbuch' öffnen.

Übersetzungsoptionen

Die Einstellungen in dieser Kategorie des Dialogs 'Optionen’ beziehen sich auf das Übersetzen, also Kompilieren des Projekts.
Debugging: Diese Option ist zielsystemabhängig anwählbar bzw. voreingestellt. Wenn sie aktiviert ist, wird zusätzlich Debugging-Code erzeugt, d.h. der Code kann deutlich umfangreicher werden. Der Debugging-Code ist notwendig, um die von CoDeSys angebotenen Debugging-Funktionen zu benutzen (z.B. Breakpoints). Wenn Sie die Option ausschalten, wird die Abarbeitung des Projekts schneller und der Code-Umfang geringer. Die Option wird mit dem Projekt gespeichert.
Konstanten ersetzen: Für jede Konstante skalaren Typs (also nicht für Strings, Arrays und Strukturen) wird direkt deren Wert geladen und im Online Modus werden die Konstanten in grün angezeigt. Forcen, Schreiben und Monitoring einer Konstante ist dann nicht mehr möglich. Ist die Option deaktiviert, wird der Wert über Variablenzugriff auf einen Speicherplatz geladen (dies ermöglicht zwar das Schreiben des Variablenwerts, bedeutet aber längere Bearbeitungszeit).
CoDeSys V2.3 4-11
Projekt Optionen...
Optionen-Dialog der Kategorie Übersetzungsoptionen
Verschachtelte Kommentare: Kommentare können ineinander verschachtelt eingegeben werden. Beispiel:
(* a:=inst.out; (* to be checked *) b:=b+1; *)
Der Kommentar, der mit der ersten Klammer beginnt, wird hier nicht bereits durch die Klammer nach 'checked' abgeschlossen, sondern erst durch die letzte Klammer.
Achtung: Diese Option muss derzeit mit Vorsicht verwendet werden: Wenn die Optionen-Einstellung im Projekt
nicht mit der in einer dort verwendeten, in CoDeSys erstellten Bibliothek übereinstimmt, kommt es zu Übersetzungsfehlern, die vom Anwender schwer interpretiert und auch oft nicht beseitigt werden können!
Binärfile erzeugen: Beim Übersetzen wird ein binäres Abbild des erzeugten Codes (Bootprojekt) im Projektverzeichnis angelegt. Der Dateiname: <projektname>.bin. Beachten Sie hierzu auch die Möglichkeit, mit dem Befehl 'Online' 'Bootprojekt erzeugen' das Bootprojekt und die Datei mit der zugehörigen Check-Summe online auf der Steuerung bzw. offline im Projektverzeichnis abzulegen.
Aktionen verschatten Programme: Diese Option ist per Default aktiviert, wenn ein neues Projekt angelegt wird. Sie bedeutet: Wenn eine lokale Aktion den gleichen Namen trägt wie eine Variable oder ein Programm, gilt folgende Rangfolge bei der Abarbeitung: lokale Variable vor lokaler Aktion vor globaler Variable vor Programm.
Achtung: Wird ein Projekt geöffnet, das mit einer früheren CoDeSys-Version erstellt wurde, ist die Option per
Default deaktiviert. Somit wird die beim Erstellen gültige bisherige Rangfolge (lokale Variable vor globaler Variable vor Programm vor lokaler Aktion) beibehalten.
LREAL als REAL übersetzen: Wenn diese Option aktiviert wird (Verfügbarkeit laufzeitsystemabhängig, Default: nicht aktiviert), werden beim Kompilieren des Projekts LREAL­Werte wie REAL-Werte behandelt. Dies kann verwendet werden, um Projekte plattformunabhängig zu entwickeln.
Anzahl der Datensegmente: Hier wird festgelegt, wie viel Speichersegmente in der Steuerung für die Daten des Projekts reserviert werden sollen. Dieser Platz ist nötig, damit ein Online Change auch durchgeführt werden kann, wenn neue Variablen hinzugefügt wurden. Wenn beim Übersetzen die Meldung kommt "Speicher für globale Variablen aufgebraucht.", erhöhen Sie die hier eingetragene
4-12 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Anzahl. Lokale Programmvariablen werden in dieser Beziehung ebenfalls als globale Variablen gehandhabt.
Objekte ausschließen: Diese Schaltfläche führt zum Dialog Objekte vom Übersetzen ausschließen: Wählen Sie hier im dargestellten Baum die Projektbausteine aus, die bei einem
Kompilierungslauf nicht übersetzt werden sollen, und aktivieren Sie die Option Nicht übersetzen. Daraufhin werden die ausgeschlossenen Bausteine im Baum grün angezeigt. Um automatisch alle Bausteine auszuschließen, die im Programm nicht verwendet werden, drücken Sie die Schaltfläche Unbenutzte ausschließen. Ein im Object Organizer markiertes Objekt kann übrigens auch über den Befehl 'Vom Übersetzen ausschließen' im Kontextmenü vom Übersetzen ausgenommen werden.
Compiler-Version: Die für den Übersetzungsvorgang zu verwendende Compiler-Version kann hier definiert werden. In CoDeSys Versionen nach V2.3.3 stehen jeweils sowohl die aktuelle als auch die bisherigen Compiler-Versionen (für jede Version / jedes Service Pack / jedes Patch) zurückgehend bis V2.3.3 zur Verfügung. Wenn Sie wollen, dass ein Projekt stets mit der neuesten Compiler-Version übersetzt werden soll, aktivieren Sie die Option Immer Aktuell. In diesem Fall wird allerdings berücksichtigt, ob das Projekt augenblicklich auch in der entsprechenden Version des Programmiersystems geöffnet ist. Ist dies nicht der Fall, wird die Compiler-Version genommen, die
der des gerade verwendeten Programmiersystems entspricht, Wenn das Projekt automatisch mit einer bestimmten Version übersetzt werden soll, stellen Sie diese über das Auswahlfeld bei Festlegen ein.
Um auf den Übersetzungsvorgang Einfluss zu nehmen, können zwei Makros angegeben werden: Das Makro im Feld Makro vor dem Übersetzen wird vor dem Übersetzungslauf ausgeführt, das
Makro im Feld Makro nach dem Übersetzen danach. Folgende Makro-Befehle können hier allerdings nicht ausgeführt werden: file new, file open, file close, file saveas, file quit, online, project compile, project check, project build, project clean, project rebuild, debug, watchlist
Automatisch prüfen:
Zur Überprüfung der semantischen Korrektheit bei jedem Übersetzungslauf des Projekts können die folgenden Optionen aktiviert werden:
•
•
•
•
Die Ergebnisse werden im Meldungsfenster ausgegeben. Diese Prüfungen können über das Befehlsmenü 'Überprüfen' im Menü 'Projekt' auch gezielt angestoßen werden.
Wenn das Zielsystem es unterstützt, werden negative Prüfergebnisse als Übersetzungsfehler ausgegeben.
Hinweis: Alle im Dialog Übersetzungsoptionen festgelegten Einstellungen werden mit dem Projekt gespeichert.

Kennworte

Unbenutzte Variablen
Überlappende Speicherbereiche
Konkurrierender Zugriff
Mehrfaches Speichern auf Output
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, erhalten Sie den unten gezeigten Dialog.
Zugriffschutz:
Sie können eine Projektdatei vor unerwünschten Zugriffen schützen, indem Sie das Öffnen und Verändern der Datei durch Kennworte absichern.
Geben Sie das gewünschte Kennwort im Feld Kennwort ein. Für jeden getippten Buchstaben erscheint im Feld ein Stern (*). Dasselbe Wort müssen Sie im Feld Kennwort bestätigen wiederholen. Schließen Sie den Dialog mit OK. Wenn die Meldung kommt:
"Das Kennwort und seine Bestätigung stimmen nicht überein.",
haben Sie sich bei einem der beiden Einträge vertippt. Wiederholen Sie deswegen am besten beide Einträge solange, bis der Dialog ohne Meldung schließt.
CoDeSys V2.3 4-13
Projekt Optionen...
Optionen-Dialog der Kategorie Kennworte
Wenn Sie nun die Datei abspeichern und erneut öffnen, erscheint ein Dialog, in dem Sie aufgefordert werden, das Kennwort einzugeben. Das Projekt wird nur dann geöffnet, wenn Sie das richtige Kennwort eingetippt haben, ansonsten meldet Ihnen CoDeSys:
"Das Kennwort ist nicht korrekt."
Schreibschutz:
Neben dem Öffnen der Datei können Sie auch das Verändern der Datei mit einem Kennwort schützen. Dazu müssen Sie einen Eintrag in das Feld Schreibschutz-Kennwort vornehmen, und diesen Eintrag wieder im Feld darunter bestätigen.
Ein schreibgeschütztes Projekt kann auch ohne Passwort geöffnet werden. Drücken Sie hierzu einfach die Schaltfläche Abbrechen, wenn CoDeSys Sie beim Öffnen einer Datei auffordert, das Schreibschutz-Kennwort einzugeben. Nun können Sie das Projekt übersetzen, in die Steuerung laden, simulieren etc., aber Sie können es nicht verändern.
Wenn Sie ein Kennwort vergessen haben sollten, dann wenden Sie sich bitte an Ihren Steuerungshersteller.
Die Kennworte werden mit dem Projekt gespeichert.
Um differenziertere Zugriffsrechte zu schaffen, können Sie Arbeitsgruppen festlegen ('Projekt' 'Objekt Zugriffsrechte' und 'Passwörter für Arbeitsgruppen').
Beachten Sie außerdem die erweiterte Schutzmöglichkeit für ein Projekt durch Verschlüsselung beim Speichern (siehe Kap. 4.3, ‚Datei’ ‚Speichern unter’), die beispielsweise dazu dienen kann, eine Bibliothek vor der Verwendung ohne Schlüsseleingabe zu schützen.
4-14 CoDeSys V2.3
Optionen für Sourcedownload
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, wird folgender Dialog geöffnet:
Optionen-Dialog der Kategorie Sourcedownload
Sie können wählen, zu welchem Zeitpunkt und in welchem Umfang der Quellcode des Projekts in die Steuerung gespeichert wird. Die Daten werden hierzu gepackt.
4 - Die Komponenten im Einzelnen
Die Option Nur Quellcode betrifft ausschließlich die CoDeSys-Datei (Zusatz .pro). Die Option Alle Dateien umfasst zusätzlich Dateien wie z.B. die zugehörigen Bibliotheken,
Visualisierungs-Bitmaps, Konfigurationsdateien usw. Mit der Option Implizit beim Laden wird beim Befehl 'Online' 'Laden' der gewählte Dateiumfang
automatisch in die Steuerung geladen. Mit der Option Hinweis beim Laden erhalten Sie beim Befehl 'Online' 'Laden' einen Dialog mit der
Frage „Quellcode in die Steuerung schreiben?" Drücken Sie Ja, wird der gewählte Dateiumfang automatisch in die Steuerung geladen, andernfalls schließen sie mit Nein.
Mit der Option Implizit beim Bootprojekt erzeugen wird beim Befehl 'Online' 'Bootprojekt erzeugen' der gewählte Datenumfang automatisch in die Steuerung geladen.
Mit der Option Nur auf Anforderung muss der gewählte Dateiumfang ausdrücklich über den Befehl 'Online' 'Quellcode laden' in die Steuerung geladen werden.
Das in der Steuerung gespeicherte Projekt können Sie unter 'Datei' 'Öffnen' mit 'Projekt aus der Steuerung öffnen' wieder Hochladen. Die Daten werden dabei wieder entpackt!
Optionen für Symbolkonfiguration
Der hier gebotene Dialog dient der Konfiguration der Symboldatei, die bei jedem Kompilieren des Projekts erzeugt wird. Die Symboldatei wird als Textdatei <Projektname>.sym bzw. Binärdatei <Projektname>.sdb (das Format ist abhängig von der verwendeten Gateway-Version) im Projektverzeichnis angelegt. Die Symboldatei ist für den Datenaustausch mit der Steuerung über die Symbolschnittstelle nötig und wird dazu beispielsweise von OPC- oder GatewayDDE-Server verwendet.
Der hier gebotene Dialog (nicht verfügbar im Simulationsmodus) dient der Konfiguration der Symboldatei. Diese wird als Textdatei <Projektname>.sym bzw. Binärdatei <Projektname>.sdb (abhängig von der verwendeten Gateway-Version) im Projektverzeichnis angelegt. Die Symboldatei ist für den Datenaustausch mit der Steuerung über die Symbolschnittstelle nötig und wird dazu beispielsweise von OPC- oder GatewayDDE-Server verwendet.
Wenn die Option Symboleinträge erzeugen angewählt ist, werden automatisch bei jedem Übersetzen des Projekts Symboleinträge für die Projektvariablen in der Symbol-Datei angelegt. Ansonsten erhält sie nur Versionsinformationen zur Datei und zum Projekt sowie eine Checksumme.
CoDeSys V2.3 4-15
Projekt Optionen...
Wenn zusätzlich die Option XML-Datei erzeugen aktiviert ist, wird außerdem eine XML-Version der Symboldatei erzeugt. Diese wird ebenfalls im Projektverzeichnis angelegt und erhält den Namen <Projektname>.SYM_XML.
Für das Konfigurieren der Symboldatei-Einträge gilt folgendes:
• Wenn die Option 'Symbolkonfiguration aus INI-Datei' in den Zielsystemeinstellungen (Target-Datei)
aktiviert ist, wird die Konfiguration der Symboleinträge aus der codesys.ini oder aus einer dort genannten anderen ini-Datei gelesen. (Der CoDeSys-Dialog Objektattribute ist in diesem Fall nicht editierbar.)
• Wenn die Option 'Symbolkonfiguration aus INI-Datei' nicht aktiviert ist, werden die Symboleinträge
gemäß den Einstellungen erzeugt, die Sie im Dialog 'Objektattribute setzen' vornehmen. Dorthin gelangen Sie über die Schaltfläche Symbolfile konfigurieren:
Dialog 'Objektattribute setzen' (in Optionen-Dialog, Kategorie Symbolkonfiguration)
Wählen Sie im als Baumstruktur dargestellten Auswahleditor die Variablen aus, für die Symboleinträge erzeugt werden sollen. Dazu können Sie entweder Projektbausteine markieren, wodurch automatisch die zugehörigen Variablen ausgewählt werden, oder Sie können gezielt einzelne Variableneinträge markieren. Für die getroffene Auswahl setzen Sie dann im unteren Dialogteil die gewünschten Optionen durch Mausklick auf das zugehörige Kästchen. Aktivierte Optionen sind mit einem Haken versehen. Folgende Optionen können eingestellt werden:
Variablen des Objekts ausgeben: Die Variablen des gewählten Objektes werden ins Symbolfile ausgegeben.
Nur wenn die Option Variablen des Objekts ausgeben aktiviert ist, können folgende weitere Optionen wirksam werden:
Sammeleinträge ausgeben: Für Strukturen und Arrays des Objektes werden Einträge zum Zugriff auf die Gesamtvariablen erzeugt.
Strukturkomponenten ausgeben: Für Strukturen des Objektes wird für jede Variablenkomponente ein eigener Eintrag erzeugt.
Feldkomponenten ausgeben: Für Arrays des Objektes wird für jede Variablenkomponente ein eigener Eintrag erzeugt.
Schreibzugriff: Die Variablen des Objektes dürfen vom OPC-Server verändert werden.
Nachdem die Optioneneinstellungen für die aktuelle Variablenauswahl vorgenommen wurde, können – ohne den Dialog vorher mit OK schließen zu müssen - andere Bausteine ausgewählt werden und
4-16 CoDeSys V2.3
ebenfalls mit einer Optionenkonfiguration versehen werden. Dies kann für beliebig viele Bausteinselektionen hintereinander ausgeführt werden.
Wird der Dialog mit OK geschlossen, werden alle seit Öffnen des Dialogs vorgenommenen Konfigurationen übernommen.
Hinweis: Beachten Sie die Möglichkeit, mit Hilfe von Pragmas gezielt einzelne Variablen ohne Schreib-
/Leserecht bzw. gar nicht in die Symboldatei zu übernehmen.
Optionen für Projektdatenbank
In diesem Dialog wird festgelegt, ob das Projekt in einer Projektdatenbank verwaltet werden soll und es werden die für diesen Fall nötigen Konfigurationen der ENI-Schnittstelle vorgenommen.
Projektdatenbank (ENI) verwenden: Aktivieren Sie diese Option, wenn Sie über einen ENI-Server auf eine Projektdatenbank zugreifen wollen, um alle oder bestimmte zum Projekt gehörigen Bausteine über diese Datenbank zu handhaben. Voraussetzung hierfür ist, dass ENI-Server und Projektdatenbank installiert sind und Sie als gültiger Datenbank-Benutzer definiert sind. Sehen Sie hierzu auch die Dokumentation zum ENI-Server bzw. Kapitel 7, 'Die CoDeSys ENI-Schnittstelle'.
Optionen-Dialog der Kategorie Projektdatenbank
4 - Die Komponenten im Einzelnen
Wenn die Option aktiviert ist, stehen für jedes Objekt des Projekts die Funktionen (Einchecken, Abrufen etc.) der Projektdatenbank zur Verfügung. Zum einen werden dann gewisse Datenbankfunktionen automatisch ablaufen, wenn dies in den Optionen-Dialogen so konfiguriert ist, zum anderen können aber auch die Befehle des Menüs ‘Projekt’ Projektdatenbank’ zum gezielten Aufruf der Funktionen verwendet werden. Außerdem ist dann im Dialog für die Objekteigenschaften ein Registerblatt 'Projektdatenbank' verfügbar, über den der Baustein einer bestimmten Datenbankkategorie zugeordnet werden kann.
Neue Objekte automatisch in folgende Projektdatenbank ablegen: Hier nehmen Sie eine Standardeinstellung vor: Wenn ein Objekt im Projekt neu eingefügt wird ('Objekt einfügen'), wird es automatisch der hier eingestellten Objektkategorie zugeordnet. Diese Zuordnung wird in den Objekteigenschaften ('Projekt' 'Objekt' 'Eigenschaften') wiedergegeben und kann dort auch für das Objekt verändert werden. Die möglichen Zuordnungen sind:
Projekt: Der Baustein wird in dem Datenbankverzeichnis abgelegt, das im Dialog ENI­Einstellungen/Projektobjekte unter 'Projektname' definiert ist.
Gemeinsame Objekte: Der Baustein wird in dem Datenbankverzeichnis verwaltet, das im Dialog ENI-Einstellungen/Gemeinsame Objekte unter 'Projektname' definiert ist.
Lokal: Der Baustein wird nicht über das ENI in der Projektdatenbank verwaltet, sondern ausschließlich lokal im Projekt gespeichert.
Neben 'Projektobjekte' und 'Gemeinsame Objekte' gibt es eine dritte Datenbankkategorie 'Übersetzungsdateien' für solche Objekte, die erst beim Kompilieren eines Projekts entstehen, weswegen die Kategorie hier nicht relevant ist.
CoDeSys V2.3 4-17
Projekt Optionen...
Nach Art von neuen Objekten fragen: Wenn diese Option aktiviert ist, wird bei jedem Einfügen eines neuen Objekts im Projekt der Dialog 'Objekt' 'Eigenschaften' geöffnet, in dem ausgewählt werden kann, welcher der oben genannten drei Objektkategorien der Baustein angehören soll. Damit kann also die Standardeinstellung überschrieben werden.
ENI konfigurieren: Diese Schaltfläche führt zu den ENI-Einstellungen, die in drei Dialogen vorgenommen werden.
Die zum Projekt gehörenden Objekte, die in der Datenbank verwaltet werden sollen, können den Datenbankkategorien 'Projektobjekte', 'Gemeinsame Objekte' oder 'Übersetzungsdateien' zugeordnet sein. Für jede dieser Kategorien wird in den folgenden Dialogen der Projektdatenbankoptionen festgelegt, in welchem Verzeichnis sie in der Datenbank liegen und welche Voreinstellungen für gewisse Datenbankfunktionen gelten:
•
Dialog ENI-Konfiguration / Projektobjekte
•
Dialog ENI-Konfiguration / Gemeinsame Objekte
•
Dialog ENI-Konfiguration / Übersetzungsdateien
Bitte beachten: Die Objekte werden in jedem Fall auch zusätzlich lokal, also mit dem Projekt gespeichert.
Die Dialoge erscheinen bei einer Erstkonfiguration nacheinander, wobei ein Wizard (über die Schaltfläche Weiter) den Benutzer führt. Dabei werden die im ersten Dialog vorgenommenen Einstellungen in die beiden anderen übernommen und es müssen nur gewünschte Abweichungen eingegeben werden.
Liegt bereits eine Konfiguration vor, sind die Dialoge in Form von drei Registerblättern in einem Fenster zusammengefasst.
Wurde vor der Konfiguration nicht bereits erfolgreich in die Datenbank eingeloggt (Login-Dialog über Menü ‘Projekt’ Projektdatenbank’ 'Login') wird der Login-Dialog zu diesem Zweck automatisch geöffnet werden.
Optionen für Projektobjekte und Gemeinsame Objekte bezüglich Projektdatenbank
Diese Dialoge sind Bestandteil der Optionseinstellungen für die Projektdatenbank ('Projekt' 'Optionen' 'Projektdatenbank'). Hier wird definiert, mit welchen Zugangsparametern die Objekte der Kategorien 'Projekt' und 'Gemeinsame Objekte' in der Datenbank verwaltet werden. Beide Dialoge enthalten die gleichen Punkte. (Ein dritter Dialog steht für die Einstellungen bezüglich der Kategorie Übersetzungsdateien zur Verfügung).
ENI-Verbindung
TCP/IP-Adresse: Adresse des Rechners, auf dem der ENI-Server läuft
Port: Default: 80; muss mit der Einstellung in der ENI-Server Konfiguration
übereinstimmen
Projektname: Name des Verzeichnisses in der Datenbank, in dem die Objekte der
betreffenden Kategorie abgelegt werden sollen. Falls das Verzeichnis in der Datenbank bereits existiert, können Sie es im Verzeichnisbaum der ENI Projekte auswählen, den Sie über die Schaltfläche ... erhalten. Wenn Sie sich allerdings vorher noch nicht über den Login-Dialog als ENI-Benutzer identifiziert haben, erscheint beim Drücken dieser Schaltfläche allerdings zunächst eben dieser Login-Dialog, wo Sie Benutzernamen und Passwort für den ENI­Zugang zu den drei Datenbank-Kategorien eingeben müssen.
Nur lesender Zugriff Wenn diese Option aktiviert ist, kann auf die Daten des hier definierten
Datenbankverzeichnisses nur lesend zugegriffen werden
4-18 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Dialog 'Projektobjekte' in Optionen-Kategorie Projekdatenbank
Abrufen
Die Datenbankfunktion Abrufen (Menü ‘Projekt’ Projektdatenbank’ bedeutet, dass die aktuelle Version eines Bausteins aus der Datenbank ins lokal geöffnete Projekt kopiert wird, wobei die lokale Version überschrieben wird. Automatisch erfolgt dies für alle gegenüber der lokalen Projektversion veränderten Bausteine zu jedem der folgenden Zeitpunkte, der aktiviert (mit einem Haken markiert) ist:
Beim Projekt Öffnen Wenn das Projekt in CoDeSys geöffnet wird
Sofort bei Änderungen im ENI Wenn in der Datenbank eine neuere Version eines Bausteins
eingecheckt wird; der Baustein wird dann unmittelbar im geöffneten Projekt aktualisiert und es wird eine entsprechende Meldung ausgegeben
Vor jedem Compile Vor jedem Übersetzungsvorgang in CoDeSys
Auschecken
Die Datenbankfunktion Auschecken bedeutet, dass der Baustein als 'in Bearbeitung' markiert wird und für andere Benutzer gesperrt ist, bis er durch Einchecken oder Rückgängigmachen des Auscheckens wieder freigegeben wird.
Wenn die Option Unmittelbar bei Beginn einer Änderung aktiviert ist, dann erfolgt das Auschecken eines Bausteins automatisch, sobald mit dessen Bearbeitung im Projekt begonnen wird. Falls das Objekt bereits durch einen anderen Benutzer ausgecheckt ist (erkenntlich an einem roten Kreuz vor dem Objektnamen im Object Organizer), wird eine Meldung ausgegeben.
CoDeSys V2.3 4-19
Projekt Optionen...
Einchecken
Die Datenbankfunktion Einchecken bedeutet, dass eine neue Version eines Objekts in der Datenbank angelegt wird. Die alten Versionen bleiben erhalten. Die möglichen Zeitpunkte:
Bei Projekt Speichern Wenn diese Option aktiviert ist, wird jeder veränderte Baustein
automatisch bei jedem Speichern des Projekts eingecheckt.
Nach erfolgreichem Compile Wenn diese Option aktiviert ist, wird nach jedem fehlerfreiem
Übersetzungslauf des Projekts jedes veränderte Objekt eingecheckt.
Für die Punkte Abrufen, Aus- und Einchecken kann jeweils die Option mit Nachfrage aktiviert werden. In diesem Fall erscheint, bevor die betreffende Aktion ausgeführt wird, ein Dialog, in dem der Anwender nochmals bestätigen muss bzw. abbrechen kann.
Die Punkte des Dialogs 'Gemeinsame Objekte' entsprechen denen des oben beschriebenen Dialogs 'Projektobjekte'. Die Einstellungen gelten für alle Objekte, die der Datenbankkategorie 'Gemeinsame Objekte' zugeordnet sind.
Die Dialoge erscheinen bei einer Erstkonfiguration nacheinander, wobei ein Wizard (über die Schaltfläche Weiter) den Benutzer führt. Dabei werden die im ersten Dialog vorgenommenen Einstellungen in die beiden anderen übernommen und es müssen nur gewünschte Abweichungen eingegeben werden.
Abbrechen schließt den Dialog, ohne die vorgenommenen Änderungen zu speichern. Wird eine bereits vorhandene Optionenkonfiguration verändert, wird die neue Einstellung (alle drei Dialoge) mit
OK gespeichert und zum Hauptdialog 'Optionen' 'Projektdatenbank' zurückgekehrt.
Optionen für Übersetzungsdateien bezüglich der Projektdatenbank
Dieser Dialog ist Bestandteil der Optionseinstellungen für die Projektdatenbank ('Projekt' 'Optionen' 'Projektdatenbank'). Hier wird festgelegt, wie die Objekte der Kategorie Übersetzungsdateien in der Datenbank verwaltet werden. (Außerdem stehen zwei weitere Dialoge zum Setzen der Optionen für Objekte der Kategorie Projekt und der Kategorie Gemeinsam zur Verfügung.)
Dialog Übersetzungsdateien in Kategorie Projekdatenbank
Für die Eingabefelder TCP/IP-Adresse, Port, Projektname siehe bei Dialog Projektobjekte/Gemeinsame Objekte.
ASCII-Symbolinformation erzeugen (.sym)
4-20 CoDeSys V2.3
Wenn diese Option aktiviert ist, wird, sobald eine Symboldatei *.sym (Textformat) bzw. *.sdb (Binärformat) erzeugt wird, diese auch in die Datenbank geschrieben. Beim Erzeugen der
4 - Die Komponenten im Einzelnen
Binär-Symbolinformation erzeugen (.sdb)
Bootprojekt erzeugen
Die Dialoge erscheinen bei einer Erstkonfiguration nacheinander, wobei ein Wizard (über die Schaltfläche Weiter) den Benutzer führt. Dabei werden die im ersten Dialog vorgenommenen Einstellungen in die beiden anderen übernommen und es müssen nur gewünschte Abweichungen eingegeben werden.
Wird Abbrechen gedrückt, kehrt man ebenfalls zum Hauptdialog zurück, wobei die Einstellungen auf Registerblatt 'Übersetzungsdateien' nicht gespeichert werden. (Diejenigen, die bereits für Projektobjekte und Allgemeine Objekte vorgenommen worden waren, bleiben jedoch erhalten.)
Optionen für Makros
Wenn Sie diese Kategorie im Dialog 'Optionen' wählen, wird folgender Dialog geöffnet:
Optionen-Dialog der Kategorie Makros
Symbole gelten die in den Projektoptionen in der Kategorie 'Symbolkonfiguration' gesetzten Objektattribute.
Wenn diese Option aktiviert ist, wird, sobald ein Bootprojekt erzeugt wird, dieses auch in der Datenbank abgelegt.
In diesem Dialog können aus den Kommandodatei-Befehlen des CoDeSys Batch-Mechanismus Makros definiert werden, die dann im Menü 'Bearbeiten' 'Makros' aufgerufen werden können.
Gehen Sie folgendermaßen vor, um neue Makros zu definieren:
• Tragen Sie im Eingabefeld Name einen Namen für das zu erstellende Makro ein. Nach Drücken
der Schaltfläche Neu wird dieser Name in die Makroliste übernommen und dort als selektiert markiert. Die Makroliste ist in Baumstruktur angelegt. Die lokal angelegten Makros stehen untereinander, eventuell eingebundene Makrobibliotheken (siehe unten) erscheinen mit dem Namen der Bibliotheksdatei. Über das Plus- bzw. Minuszeichen vor dem Bibliotheksnamen kann die Liste der Bibliothekselemente auf- oder zugeklappt werden.
• Definieren Sie im Feld Menü, wie der Menüeintrag heißen soll, mit dem das Makro ins Menü
'Bearbeiten' 'Makros' eingehängt wird. Um einen Buchstaben als Short-Cut zu erhalten, muss diesem das Zeichen '&' vorangestellt werden. Beispiel: der Name "Ma&kro 1" erzeugt den Menüeintrag "Mak
ro 1".
• Im Editorfeld Anweisungen geben Sie nun die Kommandos für das in der Makroliste markierte
Makro neu ein. Alle Kommandos des CoDeSys Batch-Mechanismus und die im Zusammenhang mit diesen beschriebenen Schlüsselwörtern sind zulässig, Sie erhalten eine Auflistung über die Schaltfläche Hilfe. Eine neue Anweisungszeile wird mit <Strg><Eingabetaste> eingefügt. Über die rechte Maustaste erhalten Sie das Kontextmenü mit den üblichen Texteditorfunktionen. Zusammengehörige Kommando-Bestandteile können mit Anführungszeichen zusammengefasst werden.
CoDeSys V2.3 4-21
Projekte verwalten...
• Falls Sie weitere Makros anlegen wollen, führen Sie die Schritte 1-3 erneut aus, bevor Sie den
Dialog mit OK bestätigen und schließen.
Falls Sie ein Makro wieder löschen wollen, selektieren Sie es in der Makroliste und drücken Sie die Taste <Entf>.
Falls Sie ein Makro umbenennen wollen, selektieren Sie es in der Makroliste, geben unter Name einen anderen Namen ein und drücken dann die Schaltfläche Umbenennen.
Um ein bestehendes Makro zu bearbeiten, selektieren Sie es in der Makroliste und editieren Sie in den Eingabefeldern Menü und/oder Anweisungen. Die Änderungen werden mit OK übernommen.
Beim Verlassen des Dialogs mit OK wird die aktuelle Beschreibung der Makros im Projekt gespeichert.
Die Makro-Menüeinträge erscheinen dann in der Reihenfolge ihrer Definition im Menü 'Bearbeiten' 'Makros'. Eine Prüfung des Makros erfolgt erst beim Ausführen des Menübefehls.
Makrobibliotheken:
Die Makros können in externen Makrobibliotheken gespeichert werden, die dann beispielsweise in anderen Projekten eingebunden werden können.
• Erstellen einer Makrobibliothek aus Makros des aktuellen Projekts:
Drücken Sie die Schaltfläche Erstellen. Sie erhalten den Dialog 'Objekte kopieren', der alle verfügbaren Makros auflistet. Markieren Sie die gewünschten und bestätigen Sie mit OK. Daraufhin schließt der Auswahldialog und es öffnet der Dialog 'Makrobibliothek speichern'. Geben Sie hier einen Namen und Pfad für die zu erstellende Bibliothek ein und drücken Sie die Schaltfläche Speichern. Nun wird die Bibliothek mit <bibliotheksname>.mac angelegt und der Dialog geschlossen.
• Einbinden einer Makrobibliothek <bibliotheksname>.mac ins aktuelle Projekt:
Drücken Sie die Schaltfläche Einbinden. Es erscheint der Dialog Makrobibliothek öffnen', der automatisch nur Dateien mit der Erweiterung *.mac anzeigt. Wählen Sie die gewünschte Bibliothek und drücken Sie die Schaltfläche Öffnen. Der Dialog schließt und die Bibliothek erscheint in der Baumstruktur der Makroliste.
Hinweis: Die Makros eines Projekts können auch exportiert werden ('Projekt' 'Exportieren').

4.3 Projekte verwalten...

Die Befehle, die sich auf ein ganzes Projekt beziehen, stehen unter den Menüpunkten 'Datei' und 'Projekt'. Sehen Sie hierzu die folgenden Kapitel.

'Datei' 'Neu'

Symbol:
Mit diesem Befehl legen Sie ein leeres Projekt mit dem Namen 'Unbenannt' an. Dieser Name muss beim Speichern geändert werden.

'Datei' 'Neu aus Vorlage'

Mit diesem Befehl kann ein beliebiges Projekt geöffnet werden, das als "Vorlage" verwendet werden soll, d.h. das Projekt muss nicht mit speziellen Einstellungen für diesen Zweck abgespeichert worden sein. Es erscheint der Dialog zur Auswahl einer Projektdatei, die dann mit Dateiname "Unbenannt" geöffnet wird.
4-22 CoDeSys V2.3

'Datei' 'Öffnen'

4 - Die Komponenten im Einzelnen
Symbol:
Mit diesem Befehl öffnen Sie ein bereits bestehendes Projekt. Wenn bereits ein Projekt geöffnet ist und verändert wurde, dann fragt CoDeSys, ob dieses Projekt gespeichert werden soll oder nicht.
Der Dialog zum Öffnen einer Datei erscheint, und es muss eine Projektdatei mit dem Zusatz "*.pro" oder eine Bibliotheksdatei mit dem Zusatz "*.lib" ausgewählt werden. Diese Datei muss existieren; es ist nicht möglich, mit dem Befehl 'Öffnen' ein Projekt zu erzeugen.
Um eine Projektdatei aus einer Steuerung hochzuladen, drücken Sie auf die Schaltfläche SPS ....
Besteht noch keine Verbindung mit der Steuerung, erhalten Sie zunächst den Dialog Kommunikationsparameter (siehe Menüpunkt 'Online' 'Kommunikationsparameter') zum Einstellen der Übertragungsparameter. Ist eine Online-Verbindung hergestellt, wird geprüft, ob gleichnamige Projektdateien bereits im Verzeichnis auf Ihrem Rechner vorliegen. Ist dies der Fall, erhalten Sie den Dialog Projekt aus der Steuerung laden, in dem Sie entscheiden können, ob die lokalen Dateien durch die in der Steuerung verwendeten ersetzt werden sollen. (Dieser Vorgang entspricht in umgekehrter Richtung dem Vorgang 'Online' 'Quellcode laden'
, mit dem die Quelldatei des Projekts in
der Steuerung gespeichert wird. Nicht zu verwechseln mit 'Bootprojekt erzeugen' !)
Dialog zum Öffnen einer Datei
Projekt aus der Steuerung öffnen
Hinweis: Beachten Sie, dass nach dem Hochladen eines Projekts dieses noch ohne Namen ist. Sie müssen
es unter neuem Namen abspeichern! Wenn das Zielsystem es unterstützt, wird eine in der Projektinformation eingetragene 'Bezeichnung' automatisch als neuer Dateiname vorgegeben. In diesem Fall öffnet beim Laden des Projekts aus der SPS automatisch der Dialog zum Speichern einer Datei, in dem dieser Dateiname bereits eingetragen ist und bestätigt oder modifiziert werden kann.
Falls noch kein Projekt auf die Steuerung geladen war, erhalten Sie eine entsprechende Fehlermeldung. Sehen sie auch Kap. 4.2, Projekt Optionen, Kategorie Sourcedownload.
Projekt aus Projektdatenbank öffnen
Diese Option dient dazu, ein Projekt zu öffnen, das in einer ENI-Projektdatenbank verwaltet wird. Voraussetzung ist, dass Sie Zugang zu einem ENI-Server haben, der die Datenbank bedient. Bedienen Sie die Schaltfläche ENI... , um zuerst den Dialog 'Projektobjekte' zum Aufbau der Verbindung zum Server zu erhalten.
CoDeSys V2.3 4-23
Geben Sie hier die entsprechenden Zugangsdaten (TCP/IP-Adresse, Port, Benutzername, Passwort, Nur lesender Zugriff) und das Verzeichnis der Datenbank (Projektname), aus dem die Objekte aus der Datenbank abgerufen werden sollen, ein und bestätigen Sie mit Weiter. Daraufhin schließt der Dialog und es öffnet sich der entsprechende für die Kategorie 'Gemeinsame Objekte'. Geben Sie auch hier Ihre Zugangsdaten ein. Mit Fertigstellen wird dieser Dialog geschlossen und die Objekte der eingestellten Verzeichnisse automatisch abgerufen. Nun können Sie in den Projektoptionen die gewünschten Einstellungen vornehmen, die für die weitere Bearbeitung des Projekts gelten sollen. Wenn Sie das Projekt weiterhin in der Datenbank verwalten wollen, parametrieren Sie dementsprechend in den Dialogen der Kategorie Projektdatenbank.
Die Zugangsdaten werden in der codesys.ini Datei gespeichert, Benutzername und Passwort allerdings nur, wenn die Projektoption 'Zugangsdaten für Projektdatenbank speichern' (siehe Kap. 4.2, Kategorie Laden & Speichern) aktiviert ist.
Zuletzt geöffnete Projekte
Im Menü Datei sind im Bereich unterhalb des Menüpunktes 'Beenden' die zuletzt geöffneten Projekte aufgelistet. Wenn Sie eines davon auswählen, wird dieses Projekt geöffnet.
Sind für das Projekt Kennworte oder Arbeitsgruppen definiert worden, so erscheint ein Dialog zur Eingabe des Passworts.

'Datei' 'Schließen'

Projekte verwalten...
Mit diesem Befehl schließen Sie das aktuell geöffnete Projekt. Wenn das Projekt verändert wurde, fragt CoDeSys, ob diese Veränderungen gespeichert werden sollen oder nicht.
Wenn das zu speichernde Projekt den Namen "Unbenannt" trägt muss ein Name dafür festgelegt werden (siehe 'Datei' 'Speichern unter').

'Datei' 'Speichern'

Symbol:
Kurzform: <Strg>+<S>
Mit diesem Befehl speichern Sie das Projekt, sofern es verändert wurde.
Wenn das zu speichernde Projekt den Namen "Unbenannt" trägt, muss ein Name dafür festgelegt werden (siehe 'Datei' 'Speichern unter').

'Datei' 'Speichern unter'

Mit diesem Befehl kann das aktuelle Projekt in einer anderen Datei oder als Bibliothek gespeichert werden. Die ursprüngliche Projektdatei bleibt dabei unverändert. Es besteht die Möglichkeit, die Bibliothek mit einem Lizenzschutz zu versehen. Dann muss bei der Verwendung eine Lizenz-ID eingegeben werden, die vom Hersteller angefordert werden kann (siehe unten).
Nachdem der Befehl gewählt wurde, erscheint der Dialog zum Speichern. Wählen Sie entweder einen existierenden Dateinamen, oder geben Sie einen neuen Dateinamen ein und wählen Sie den gewünschten Dateityp.
Dialog zum 'Speichern unter'
4-24 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Soll das Projekt nur unter einem neuen Namen abgespeichert werden, wählen Sie den Dateityp CoDeSys Projekt (*.pro).
Wenn Sie den Dateityp Projekt Version 1.5 (*.pro) bzw. 2.0 (*.pro), 2.1 (*.pro) oder 2.2 (*.pro) wählen, wird das aktuelle Projekt so abgespeichert, als wäre es mit der Version 1.5 bzw. 2.0, 2.1 oder
2.2 erstellt worden. Spezifische Daten der Version 2.3 können dabei verloren gehen! Das Projekt kann dann aber mit der Version 1.5 bzw. 2.0, 2.1 oder 2.2 weiter bearbeitet werden.
Sie können das aktuelle Projekt auch als Bibliothek abspeichern, um die erstellten Bausteine in anderen Projekten benutzen zu können. Wählen Sie dazu den Dateityp Interne Bibliothek Version (*.lib)
Wählen Sie den Dateityp Externe Bibliothek (*.lib), wenn Sie Bausteine in anderen Programmiersprachen (z.B. C) implementiert haben und einbinden wollen. Dies hat zur Folge, dass eine weitere Datei mit abgespeichert wird, die den Dateinamen der Bibliothek erhält, allerdings mit dem Zusatz "*.h". Diese Datei ist als C-Header-Datei aufgebaut und enthält die Deklarationen aller Bausteine, Datentypen und globalen Variablen. Bei externen Bibliotheken wird in der Simulation die Implementation ausgeführt, die in CoDeSys zu den Bausteinen geschrieben wurde. Mit der echten Hardware wird die in C geschriebene Implementation abgearbeitet.
Datei verschlüsselt speichern:
Um das Projekt verschlüsselt als Projekt oder ibliothek zu speichern, wählen Sie die Option
Verschlüsseltes CoDeSys Projekt (*.pro) bzw. Verschlüsselte interne Bibliothek (*.lib) oder Verschlüsselte externe Bibliothek (*.lib). In diesem Fall erhalten Sie den Dialog 'Verschlüsselung',
wo sie einen Schlüssel definieren und bestätigen können, ohne Eingabe dessen das Projekt nicht mehr geöffnet werden kann bzw. ein Bibliothek nicht mehr eingebunden werden kann:
Dialog zur Verschlüsselung eines Projekts
Diese Verschlüsselung erweitert den Schutz eines Projektes, der bisher allein über die Vergabe von Zugriffs- und Schreibschutz-Passwörtern (siehe Kap. 4.2, Optionen für Kennworte) erreichbar war. Diese Möglichkeiten sind auch weiterhin verfügbar, können aber beispielsweise nicht verhindern, dass eine Bibliothek ohne Passwort in ein Projekt eingebunden wird.
Ein einmal vergebener Schlüssel wird beim weiteren Speichern des Projekts mit gespeichert. Eine Änderung des Schlüssels kann wie seine Erstvergabe über den 'Speichern unter'-Dialog durchgeführt werden.
Wenn ein verschlüsseltes Projekt wieder geöffnet werden soll bzw. wenn eine verschlüsselte Bibliothek in ein Projekt eingebunden werden soll, erscheint der Dialog zum Eingeben des Schlüssels, in den der entsprechende, beim Speichern definierte Schlüssel eingegeben werden muss.
Dialog zum Eingeben des Schlüssels
Bibliothek mit Lizenzschutz versehen:
Soll die Bibliothek einer Lizenzierung unterworfen werden, können ihr die erforderlichen Lizenzinformationen mitgegeben werden. Dazu dient der Dialog 'Informationen zur Lizenzierung bearbeiten', der über die Schaltfläche Lizenzinfo bearbeiten geöffnet wird. Sehen Sie hierzu die Beschreibung des Lizenzmanagements.
CoDeSys V2.3 4-25
Sind alle Eingaben gemacht, drücken Sie OK. Das aktuelle Projekt wird in der angegebenen Datei gespeichert. Wenn der neue Dateiname bereits existiert, wird gefragt, ob diese Datei überschrieben werden soll.
Bei 'Speichern als Bibliothek' wird das gesamte Projekt kompiliert. Wenn dabei ein Übersetzungsfehler auftritt, wird das Projekt nicht als Bibliothek gespeichert und es erscheint ein entsprechender Hinweis.

'Datei' 'Archiv speichern/versenden...'

Mit diesem Befehl kann ein eine komprimierte zip-Archiv-Datei erstellt werden, die alle für ein CoDeSys-Projekt relevanten Dateien enthält. Die zip-Datei kann im Dateisystem abgespeichert oder direkt in einer E-Mail versendet werden.
Beachten Sie hierzu: Die Archiv-Funktion ist nicht geeignet, um Projektumgebungen wiederherzustellen. Sie ist
nur zur einfachen Zusammenfassung aller projektzugehörigen Dateien gedacht. Beim Entpacken eines Archivs müssen die Pfade der einzelnen Dateien der jeweiligen CoDeSys-Umgebung angepasst werden !
Nach Ausführen des Befehls wird der Dialog Archiv speichern geöffnet. Hier wird definiert, welche Datei-Kategorien dem Projekt-Archiv hinzugefügt werden sollen. Eine Kategorie gilt als ausgewählt,
wenn die Kontrollbox davor mit einem Haken Mausklick in das Kästchen oder über einen Doppelklick auf die Kategoriebezeichnung.
Projekte verwalten...
versehen ist. Dies wird erreicht über einen einfachen
Dialog 'Archiv speichern'
Für jede Kategorie, die ausgewählt ist, werden grundsätzlich alle relevanten Dateien in die zip-Datei kopiert. Für einige Kategorien kann jedoch eine Teilauswahl festgelegt werden. Dazu steht der Dialog 'Details' zur Verfügung, der über die Schaltfläche Details geöffnet wird:
4-26 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Dialog 'Details' zur gezielten Dateiauswahl für das zip-Archiv
Der Dialog zeigt eine Liste aller in dieser Kategorie verfügbaren Dateien. Automatisch sind alle Dateien ausgewählt, eine Ausnahme bildet Kategorie 'Target-Dateien' in der nur die für das eingestellte Zielsystem relevanten Dateien ausgewählt sind.
Zum Verändern der Auswahl aktivieren bzw. deaktivieren Sie gewünschten Dateien. Mit der Schaltfläche 'Alles auswählen' bzw. 'Nichts auswählen' können Sie alle Dateien der Liste erfassen, ein Mausklick in die Kontrollbox aktiviert bzw. deaktiviert eine einzelne Datei, ebenso ein Doppelklick auf den Eintrag. Außerdem kann durch Drücken der <Eingabe> Taste ein Eintrag (de)aktiviert werden, wenn er markiert ist.
Wenn der Details-Dialog mit Save geschlossen wird, wird die getroffene Auswahl übernommen. Die Einstellung wird bis zur endgültigen Erstellung des zip-Archivs gespeichert.
Im Hauptdialog 'Archiv speichern' erkennt man die Kategorien, für die eine Teilauswahl vorgenommen wurde, am grauen Hintergrund der Kontrollbox:
.
Die folgende Tabelle zeigt, welche Dateikategorien vordefiniert sind und welche Dateien sie jeweils automatisch anziehen:
Kategorie Zugehörige Dateien
Projektdatei
Referenzierte Bibliotheken
Compile-Informationen
INI-Datei
Logbuch
Bitmap-Dateien
Registrierungseinträge
<Projektname>.pro (die CoDeSys Projektdatei)
*.lib, *.obj, *.hex (Bibliotheken und ggfs. die zugehörigen obj- und hex-Dateien)
*.ci (Information des letzten Übersetzungslaufs), *.ri (Download-Information)
<temp>.* (temporäre Übersetzungs- und Download-Dateien) auch für Simulation
Codesys.ini
*.log (Projekt-Logbuch)
*.bmp (Bitmaps, die in Projektbausteinen und Visualisierungen verwendet werden)
Registry.reg (Einträge für Automation Alliance, Gateway und SPS; folgende Zweige aus der Registry:
HKEY_LOCAL_MACHINE\SOFTWARE\3S-Smart Software Solutions HKEY_LOCAL_MACHINE\SOFTWARE\AutomationAlliance"
Symbol-Dateien
Konfigurationsdateien
Target-Dateien
CoDeSys V2.3 4-27
*.sdb, *.sym (Aus dem Projekt erzeugte Symbolinformation)
Dateien für die Steuerungskonfiguration (Konfigurationsdateien,
Gerätestammdateien, Icons etc.): z.B. *.cfg, *.con, *.eds, *.dib, *.ico ....
*.trg (Target-Dateien im Binärformat für alle installierten Targets) *.txt (Target-Dateien im Textformat für alle installierten Targets, wenn verfügbar)
Projekte verwalten...
Lokaler Gateway
Sprach-Dateien
Bootprojekt
Gateway-Dateien: Gateway.exe, GatewayDDE.exe, GClient.dll, GDrvBase.dll, GDrvStd.dll, Ghandle.dll, GSymbol.dll, GUtil.dll, ggfs. weitere im Gateway­Verzeichnis vorhandene DLLs
Sprachdateien (*.vis, *.xml) für Visualisierungen
Bootprojekt-Dateien <projektname>.prg, <projektname>.chk bzw. die targetspezifischen Bootprojekt-Dateien.
Um beliebige andere Dateien zum zip-Archiv hinzuzufügen, öffnen Sie über die Schaltfläche Andere Dateien... den gleichnamigen Dialog.
Hier kann eine benutzerdefinierte Liste von Dateien erstellt werden. Dazu wird über die Schaltfläche Hinzufügen der Standarddialog zum Öffnen einer Datei geöffnet. Wählen Sie eine Datei aus und bestätigen Sie mit Öffnen. Die Datei wird daraufhin in der Liste im Dialog 'Andere Dateien ...' eingefügt. Über die Schaltfläche Entfernen kann ein Eintrag in der Liste gelöscht werden . Wenn die Liste fertig erstellt ist, wird der Dialog mit OK geschlossen, um die Einträge bis zum Erstellen der zip­Datei zu speichern.
Dialog 'Andere Dateien' für Projekt-Archiv
Um dem zip-Archiv eine Readme-Datei hinzuzufügen, drücken Sie die Schaltfläche Kommentar. Ein gleichnamiger Dialog öffnet, der ein Editierfeld enthält. Hier kann beliebiger Test eingegeben werden. Wird der Dialog mit OK geschlossen, wird bei der Erstellung des zip-Archivs eine Datei namens Readme.txt erstellt. Sie enthält den vom Benutzer eingegebenen Text, dem automatisch das Erstellungs(Build)datum und die Versionsnummer der aktuell verwendeten CoDeSys-Version hinzugefügt wird.
Erstellen des zip-Archivs:
Wenn alle gewünschten Einstellungen vorgenommen wurden, kann im Hauptdialog das zip-Archiv erstellt werden. Folgende Schaltflächen stehen zur Verfügung:
• Speichern... erstellt und speichert die zip-Datei. Der Standarddialog zum Speichern einer Datei
öffnet und es kann angegeben werden, wo die Datei abgelegt werden soll. Der Name der zip-Datei ist per Default <projektname>.zip. Wenn mit Speichern bestätigt wird, startet die Generierung des Archivs. Der Ablauf wird von einem Fortschrittsdialog begleitet und im Meldungsfenster mitprotokolliert. Dort wird auch angezeigt, wenn Dateien nicht gefunden werden.
• S
enden… erstellt eine temporäre zip-Datei und generiert automatisch eine leere E-Mail, die das zip
(<projektname>.zip) als Anhang enthält. Diese Funktion setzt eine korrekte Installation des MAPI (Messaging Application Programming Interface) voraus. Während die E-Mail erzeugt wird, erscheint ein Fortschrittsdialog und der Ablauf wird im Meldungsfenster mitprotokolliert. Die temporäre zip-Datei wird gelöscht, sobald sie der E-Mail als Anhang beigefügt ist.
• Abbrechen: Der Dialog wird ohne Erstellen eines zip-Archivs geschlossen, die vorgenommenen
Einstellungen werden nicht gespeichert.
Bitte beachten: Nach dem Entpacken eines Archivs auf einem anderen System müssen die Pfade der Dateien
eventuell angepasst werden !
4-28 CoDeSys V2.3

'Datei' 'Drucken'

Kurzform: <Strg>+<P>
Mit diesem Befehl wird der Inhalt des aktiven Fensters gedruckt.
Nachdem der Befehl gewählt wurde, erscheint der Dialog zum Drucken. Wählen Sie die gewünschte Option, oder konfigurieren Sie den Drucker und klicken anschließend OK. Das aktive Fenster wird ausgedruckt. Farbausdrucke aus allen Editoren sind möglich.
Sie können die Anzahl der Exemplare angeben oder die Ausgabe in eine Datei umleiten. Mit der Schaltfläche Eigenschaften öffnen Sie den Dialog zur Druckereinrichtung. Das Layout Ihres Ausdruckes können Sie mit dem Befehl 'Datei' 'Einstellungen Dokumentation'
festlegen.
Um die Seitenaufteilung bereits während des Arbeitens in den Editorfenstern berücksichtigen zu können, kann die Anzeige der aktuell eingestellten Druckbereichsgrenzen über die Option 'Druckbereiche anzeigen' im Dialog 'Projekt' 'Optionen' 'Arbeitsbereich' aktiviert werden.
Dialog zum Drucken
4 - Die Komponenten im Einzelnen
Während des Druckens wird Ihnen in einer Dialogbox die Anzahl der bereits gedruckten Seiten mitgeteilt. Wenn Sie diese Dialogbox schließen, stoppt der Druckvorgang nach der nächsten Seite.
Um Ihr gesamtes Projekt zu dokumentieren, benutzen Sie den Befehl 'Projekt' 'Dokumentieren'.
Wenn Sie eine Dokumentvorlage zu Ihrem Projekt erstellen wollen, in der Sie die Kommentare zu allen im Projekt verwendeten Variablen vorgeben können, dann öffnen Sie eine globale Variablenliste und benutzen den Befehl 'Extras' 'Doku-Vorlage erstellen'.
Ist der Fokus im Meldungsfenster, so wird der gesamte Inhalt ausgedruckt, und zwar zeilenweise, wie im Fenster dargestellt. Möglicher Inhalt: Übersetzungsausgabe, Querverweisliste, Suchergebnis, Vergleichsergebnis, Batch-Protokollierung.
CoDeSys V2.3 4-29

'Datei' 'Einstellungen Dokumentation'

Mit diesem Befehl können Sie das Layout der ausgedruckten Seiten festlegen. Es wird nun folgender Dialog geöffnet:
Dialog zur Einstellung des Seitenlayouts der Dokumentation
Im Feld Datei können Sie den Namen und den Pfad der Datei mit Zusatz ".dfr" eintragen, in die das Seitenlayout gespeichert werden soll. Standardmäßig wird die Vorlage in der Datei DEFAULT.DFR abgelegt.
Projekte verwalten...
Wenn Sie ein vorhandenes Layout verändern möchten, öffnen Sie mit der Schaltfläche Durchsuchen den Dialog Öffnen und wählen Sie die gewünschte Datei aus.
Sie können ebenfalls auswählen, ob eine neue Seite für jedes Objekt und für jedes Unterobjekt begonnen wird. Mit der Schaltfläche Einrichtung öffnen Sie die Druckereinrichtung.
Wenn Sie auf die Schaltfläche Bearbeiten klicken, erscheint die Vorlage zur Einstellung des Seitenlayouts. Hier können Sie Seitenzahlen, Datum, Datei- und Bausteinname, sowie Grafiken auf der Seite platzieren und den Textbereich, in den die Dokumentation gedruckt werden soll, festlegen. Die Blattfläche, die durch die Druckereinrichtung vorgegeben wird, wird rot schraffiert markiert.
Dialog zum Einfügen der Platzhalter auf dem Seitenlayout
Mit dem Menüpunkt 'Einfügen' 'Platzhalter' und durch anschließende Auswahl einer der fünf Platzhalter (Seite, Bausteinname, Dateiname, Datum, Inhalt), können Sie durch Aufziehen eines Rechteckes (durch diagonales Ziehen der Maus bei gedrückt gehaltener linker Maustaste) auf dem Layout einen so genannten Platzhalter einfügen. Diese werden im Ausdruck wie folgt ersetzt:
4-30 CoDeSys V2.3
Befehl Platzhalter Wirkung
Seite {Page} Hier erscheint die aktuelle Seitenzahl im Ausdruck.
Bausteinname {POUName} Hier erscheint der Name des aktuellen Bausteins.
Dateiname {FileName} Hier erscheint der Name des Projekts.
Datum {Date} Hier erscheint das aktuelle Datum.
Inhalt {Content} Hier erscheint der Inhalt des Bausteins.
Ferner können Sie mit 'Einfügen' 'Bitmap' eine Bitmap-Grafik (z.B. Firmenlogo) in die Seite einfügen. Dabei müssen Sie nach Auswahl der Grafik ebenfalls ein Rechteck mit der Maus auf dem Layout aufziehen. Es können weitere Visualisierungselemente eingefügt werden.
Wenn die Vorlage verändert wurde, fragt CoDeSys beim Schließen des Fensters, ob diese Veränderungen gespeichert werden sollen oder nicht.
Hinweis: Um die später für das Ausdrucken des Projekts vorgesehene Blattgröße bereits während des

'Datei' 'Beenden'

4 - Die Komponenten im Einzelnen
Programmierens berücksichtigen zu können, stellen Sie das gewünschte Format wie hier beschrieben ein und aktivieren Sie die Option 'Druckbereiche anzeigen' in den Projektoptionen, Kategorie Arbeitsbereich.
Kurzform: <Alt>+<F4>
Mit diesem Befehl beenden Sie CoDeSys.
Wenn ein Projekt geöffnet ist, wird es geschlossen wie in 'Datei' 'Speichern' beschrieben.

'Projekt' 'Übersetzen'

Kurzform: <F11>
Mit 'Projekt' 'Übersetzen' wird das Projekt kompiliert. Der Übersetzungsvorgang ist grundsätzlich inkrementell, d.h. es werden nur die veränderten Bausteine neu übersetzt. Die dazu nötige Information aus dem jeweils letzten Übersetzungsvorgang wird beim Speichern des Projekts in einer *.ci-Datei abgelegt. Ein nicht inkrementeller Übersetzungsvorgang wird auch mit diesem Befehl erreicht, wenn vorher der Befehl 'Projekt' 'Alles bereinigen' ausgeführt wurde.
Für Zielsysteme, die Online Change unterstützen, sind nach dem Übersetzungslauf alle Bausteine im Objekt Manager mit einem blauen Pfeil gekennzeichnet, die beim nächsten Download auf die Steuerung geladen werden.
Der Übersetzungslauf, der mit 'Projekt' 'Übersetzen' durchgeführt wird, erfolgt automatisch, wenn über 'Online' 'Einloggen' in die Steuerung eingeloggt wird.
Zu den Zusammenhängen zwischen Projekt-Übersetzen, Projekt-Download, Online Change und Einloggen auf das Zielsystem sehen Sie bitte eine Übersicht in Kapitel 4.6, ‚Online’ ‚Einloggen’.
Beim Übersetzen wird das Meldungsfenster geöffnet, in dem das Fortschreiten des Übersetzungsvorgangs, die während des Übersetzens eventuell auftretenden Fehler und Warnungen sowie Angaben zu Indizes bzw. Speicherverbrauch (jeweils Anzahl und Prozentsatz) ausgegeben werden. Fehler und Warnungen sind mit Nummern gekennzeichnet. Über F1 erhalten Sie weitere Informationen zum aktuell markierten Fehler.
Ist die Option Sichern vor Übersetzen im Optionsdialog in der Kategorie Laden & Speichern gewählt, so wird das Projekt vor dem Übersetzen gespeichert.
Einzelne bzw. mehrere Objekte können über den Kontextmenü-Befehl 'Vom Übersetzen ausschließen' bzw. über eine entsprechende Konfiguration ('Objekte ausschließen') in den Übersetzungsoptionen vom Übersetzen ausgeschlossen werden (siehe Kapitel 4.2, Übersetzungsoptionen).
CoDeSys V2.3 4-31
Projekte verwalten...
Hinweis: Die Querverweise entstehen während der Kompilierung und werden in der Übersetzungsinformation
mit gespeichert. Um die Befehle 'Aufrufbaum ausgeben', 'Querverweisliste ausgeben' und die Befehle 'Unbenutzte Variablen', 'Konkurrierender Zugriff und 'Mehrfaches Schreiben auf Output' des Menüs 'Projekt' 'Überprüfen' anwenden zu können bzw. aktuelle Resultate zu erhalten, muss das Projekt nach einer Veränderung neu übersetzt werden.
Beispiel für Fehlermeldungen und Übersetungsinformationen im Meldungsfenster eines Projekts

'Projekt' 'Alles übersetzen'

Mit 'Projekt' 'Alles übersetzen' wird im Gegensatz zum inkrementellen Übersetzen ('Projekt' 'Übersetzen') das Projekt komplett neu kompiliert. Dabei wird allerdings die Download-Information nicht verworfen, wie es beim Befehl 'Alles bereinigen' der Fall ist. Beachten Sie die Möglichkeit, Objekte vom Übersetzen auszuschließen (siehe Kapitel 4.2, Übersetzungsoptionen).
Zu den Zusammenhängen zwischen Projekt-Übersetzen, Projekt-Download, Online Change und Einloggen auf das Zielsystem sehen Sie bitte eine Übersicht in Kapitel 4.6, ‚Online’ ‚Einloggen’.

'Projekt' 'Alles bereinigen'

Mit diesem Befehl werden die Informationen des letzten Downloads und des letzten Übersetzungsvorgangs gelöscht.
Nach Anwählen des Befehls erscheint eine Dialogbox, die darauf hinweist, dass Online Change nicht mehr möglich ist. Hier kann der Befehl abgebrochen oder bestätigt werden.
Hinweis: Ein Online Change ist nach 'Alles bereinigen' nur dann möglich, wenn vorher die Datei *.ri mit den
Projektinformationen des letzten Downloads umbenannt oder außerhalb des Projektverzeichnisses gesichert worden war (siehe 'Download-Information laden') und nun vor dem Einloggen gezielt wieder geladen werden kann.
Zu den Zusammenhängen zwischen Projekt-Übersetzen, Projekt-Download, Online Change und Einloggen auf das Zielsystem sehen Sie bitte eine Übersicht in Kapitel 4.6, ‚Online’ ‚Einloggen’.

'Projekt' 'Download-Information laden'

Mit diesem Befehl kann die projektzugehörige Download-Information gezielt wieder geladen werden. Nach Drücken des Befehls öffnet dazu der Standarddialog 'Datei Öffnen'.
Die Download-Information wird automatisch bei jedem Download und zielsystemabhängig eventuell auch bei jeder Bootprojekt-Erzeugung im Offline-Modus, in eine Datei gespeichert, die den Namen <Projektname><Targetidentifier>.ri erhält und ins Projektverzeichnis gelegt wird. Sie wird bei jedem
4-32 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Öffnen des Projekts wieder mit geladen und dient beim erneuten Einloggen auf die Steuerung dazu, festzustellen, ob das Projekt auf der Steuerung dem gerade geöffneten entspricht (ID-Check). Außerdem wird geprüft, bei welchen Bausteinen sich der generierte Code verändert hat. Nur diese Bausteine werden bei Systemen, die Online Change unterstützen, beim Download erneut geladen. Die *.ri-Datei ist somit Voraussetzung für einen Online Change.
Beachten Sie deshalb: Mit dem Befehl 'Projekt' 'Alles bereinigen' wird die projektzugehörige *.ri-Datei
automatisch aus dem Projektverzeichnis gelöscht, so dass zunächst kein Online Change mehr möglich ist, es sei denn, die *.ri-Datei wurde noch an einem anderen Ort oder unter anderem Namen gespeichert und kann gezielt wieder geladen werden.
Zu den Zusammenhängen zwischen Projekt-Übersetzen, Projekt-Download, Online Change und Einloggen auf das Zielsystem sehen Sie bitte eine Übersicht in Kapitel 4.6, ‚Online’ ‚Einloggen’.

'Projekt' 'In andere Sprache übersetzen'

Dieser Menüpunkt dient dazu, die aktuelle Projektdatei in eine andere Sprache zu übersetzen bzw. in einer anderen Sprache darzustellen. Dies geschieht durch das Einlesen einer Übersetzungsdatei, die aus dem Projekt heraus erzeugt wurde und extern mithilfe eines Texteditors mit Übersetzungstexten in der gewünschten Landessprache ergänzt wurde.
Dazu gibt es folgende Untermenüpunkte:
• Übersetzungsdatei erstellen
• Projekt übersetzen
• Projekt übersetzt darstellen
• Übersetzung umschalten
Übersetzungsdatei erstellen
Dieser Befehl des Menüs 'Projekt' 'In andere Sprache übersetzen' führt zum Dialog 'Übersetzungsdatei erstellen'.
Dialog zum Erstellen einer Übersetzungsdatei
Geben Sie im Feld Übersetzungsdatei einen Pfad ein, der anzeigt wo die Datei gespeichert werden soll. Die Default-Dateierweiterung ist *.tlt, es handelt sich um eine Textdatei. Ebenso möglich ist die Verwendung der Erweiterung *.txt, was empfehlenswert ist, falls die Datei beispielsweise in EXCEL oder WORD bearbeitet werden soll, da in diesem Fall die Daten in Tabellenform angeordnet werden.
CoDeSys V2.3 4-33
Projekte verwalten...
Existiert bereits eine Übersetzungsdatei, die Sie bearbeiten wollen, geben Sie den Pfad dieser Datei ein bzw. verwenden Sie den über die Schaltfläche Durchsuchen erreichbaren Standard-Windows­Dialog zum Auswählen einer Datei.
Folgende Informationen aus dem Projekt können der zu erstellenden bzw. zu modifizierenden Übersetzungsdatei optional mitgegeben werden, so dass sie in dieser zur Übersetzung zur Verfügung stehen: Names (Namen, z.B. der Titel 'Bausteine' im Objekt Organizer), Identifiers (Bezeichner), Strings, Kommentare, Visualisierung, Alarmtexte. Zusätzlich können die Positionsinformationen zu diesen Projektelementen übernommen werden.
Sind die entsprechenden Optionen mit einem Haken versehen, werden die Informationen als Sprachsymbole aus dem aktuellen Projekt in eine neu zu erstellende Übersetzungsdatei aufgenommen bzw. in einer bereits existierenden ergänzt. Falls die jeweilige Option nicht angewählt ist, werden sämtliche Informationen der betreffenden Kategorie, gleichgültig aus welchem Projekt sie stammen, aus der Übersetzungsdatei entfernt.
Texte in Visualisierungen:
Als Visualisierungstexte gelten hier die Elemente 'Text' und 'Tooltip-Text' der Visualisierungselemente. Allerdings sind für die Verwendung einer Übersetzungsdatei für Visualisierungstexte folgende Punkte zu beachten:
• Eine *.tlt- oder *.txt-Übersetzungsdatei kann nur mit CoDeSys und CoDeSys HMI, nicht aber mit
der Target-Visualisierung und Web-Visualisierung verwendet werden. Verwenden Sie ggfs. besser eine spezielle Visualisierungs-Sprachdatei *.vis.
• Die Umschaltung in eine andere Sprache ist grundsätzlich nur im Online Modus möglich, d.h. die
Visualisierungstexte werden mit dem Befehl Projekt' 'In andere Sprache übersetzen' nicht mit übersetzt, sondern nur wenn online im Dialog 'Extras' 'Einstellungen' die entsprechende Sprache eingestellt wird.
• Soll eine tlt- oder txt-Datei für Visualisierungstexte ('Text' und 'Text für Tooltip' der
Visualisierungselemente) verwendet werden, müssen die Texte im Konfigurationsdialog des Visualisierungselements zwischen zwei Zeichen "#" eingegeben sein (z.B. #text#).
• Sehen Sie zur Sprachumschaltung in der Visualisierung das Handbuch
CoDeSys_Visualisierung_V23_D.pdf.
Positionsinformationen: Diese beschreibt mit den Angaben Dateipfad, Baustein, Zeile die Position des Sprachsymbols, das zur Übersetzung bereitgestellt wird. Zur Auswahl stehen hier drei Optionen:
• 'Keine': Es werden keine Positionsinformationen generiert.
• 'Erstmaliges Auftreten': Es wird die Position in die Übersetzungsdatei aufgenommen, an der das zu
übersetzende Element erstmalig auftritt.
• 'Alle': Es werden alle Positionen angegeben, an denen das betreffende Element im Projekt auftritt.
Falls eine früher erstellte Übersetzungsdatei editiert wird, die bereits mehr Positionsinformationen enthält als hier ausgewählt, so werden diese entsprechend gekürzt oder ganz gelöscht, gleichgültig aus welchem Projekt sie generiert wurden.
Hinweis: Pro Element (Sprachsymbol) werden maximal 64 Positionsinformationen generiert, selbst wenn der
Anwender im Dialog Übersetzungsdatei erstellen unter Positionsinformationen „Alle" ausgewählt hat.
Bestehende überschreiben: Sämtliche bereits existierende Positionsinformationen in der Übersetzungsdatei, die aktuell bearbeitet wird, werden überschrieben, gleichgültig von welchem Projekt sie generiert wurden.
Zielsprachen: Diese Liste enthält Bezeichner für alle Sprachen, die in der Übersetzungsdatei enthalten sind bzw. nach Beenden des Dialogs 'Übersetzungsdatei erstellen' aufgenommen werden sollen.
Die Schaltfläche Ausschließen öffnet den Dialog 'Bibliotheken ausschließen'.
4-34 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Dialog zum Ausschließen von Bibliotheksinformationen für die Übersetzungsdatei
Hier können aus den ins Projekt eingebundenen Bibliotheken diejenigen ausgewählt werden, deren Bezeichnerinformationen nicht in die Übersetzungsdatei übernommen werden sollen. Dazu wird der betreffende Eintrag aus der linken Tabelle Eingebundene Bibliotheken mit der Maus ausgewählt und über die Schaltfläche Hinzufügen in die rechte Tabelle Ausgeschlossene Bibliotheken gebracht. Ebenso kann mit der Schaltfläche Entfernen ein dort gewählter Eintrag wieder gelöscht werden. Mit OK wird die Einstellung bestätigt und der Dialog geschlossen.
Die Schaltfläche Hinzufügen öffnet den Dialog 'Zielsprache hinzufügen':
Dialog zum Hinzufügen einer Zielsprache (Projekt, In andere Sprache übersetzen)
Im Editierfeld muss ein Sprachbezeichner eingegeben werden, der weder am Anfang noch am Ende ein Leerzeichen oder einen Umlaut (ä, ö, ü) enthalten darf.
Mit OK wird der Dialog 'Zielsprache hinzufügen' geschlossen und die neue Zielsprache erscheint in der Zielsprachen-Liste.
Die Schaltfläche Entfernen löscht einen in der Liste selektierten Eintrag. Ebenfalls über OK können Sie dann den Dialog 'Übersetzungsdatei erstellen' bestätigen, um eine
Übersetzungsdatei zu generieren. Existiert bereits eine gleichnamige Übersetzungsdatei, erhalten Sie zunächst die folgende, mit Ja oder Nein zu beantwortende Sicherheitsabfrage:
"Die angegebene Übersetzungsdatei existiert bereits. Sie wird nun entsprechend geändert, wobei eine Sicherungskopie der bereits bestehenden Datei angelegt wird. Möchten Sie fortfahren ?"
Nein kehrt ohne Aktion zum Dialog 'Übersetzungsdatei erstellen' zurück. Wird Ja gewählt, so wird eine Kopie der bereits bestehenden Übersetzungsdatei mit dem Dateinamen "Backup_of_<Übersetzungsdatei>.xlt" im gleichen Verzeichnis angelegt und die betreffende Übersetzungsdatei gemäß der eingestellten Optionen modifiziert.
Beim Erzeugen einer Übersetzungsdatei geschieht folgendes:
• Für jede neue Zielsprache wird für jedes auszugebende Sprachsymbol ein Platzhalter („##TODO")
generiert. (Siehe hierzu 'Bearbeiten der Übersetzungsdatei).
• Wird eine bereits existierende Übersetzungsdatei verändert, werden Dateieinträge von Sprachen,
die in der Übersetzungsdatei, aber nicht in der Zielsprachen-Liste stehen, entfernt, gleichgültig aus welchem Projekt sie generiert wurden.
CoDeSys V2.3 4-35
Bearbeiten der Übersetzungsdatei
Die Übersetzungsdatei ist als Textdatei zu öffnen und zu speichern. Die Zeichen ## kennzeichnen Schlüsselwörter. Die ##TODO-Platzhalter in der Datei können mit den gültigen Übersetzungstexten ersetzt werden. Pro Sprachsymbol wird ein durch Typenkennzeichner begrenzter Abschnitt angelegt. Zum Beispiel kennzeichnen ##NAME_ITEM und ##END_NAME_ITEM Start und Ende des Abschnitts für einen Objektnamen im Object Organizer. COMMENT_ITEM kennzeichnet Abschnitte für Kommentare, IDENTIFIER_ITEM solche für Bezeichner, STRING_ITEM solche für Strings und VISUALTEXT_ITEM solche für Visualisierungstexte).
Sehen Sie nachfolgend einen Beispiel-Abschnitt in einer Übersetzungsdatei des Formats *.tlt für den Namen (NAME_ITEM) eines im Projekt verwendeten Bausteins: ST_Visu. Die Zielsprachen Englisch(USA) und Französisch sind vorgesehen. In diesem Beispiel wurde auch die Positionsinformation für das zu übersetzende Projektelement mitgegeben:
- vor der Übersetzung:
##NAME_ITEM [D:\CoDeSys\projects\Bspdt_22.pro::ST_Visualisierung::0] ST_Visualisierung ##English :: ##TODO ##French :: ##TODO ##END_NAME_ITEM
- nach der Übersetzung:
Projekte verwalten...
Anstelle der "##TODO"s wurde nun der englische bzw. französische Ausdruck für 'Visualisierung' eingesetzt:
##NAME_ITEM [D:\CoDeSys\projects\Bspdt_22.pro::ST_Visualisierung::0] ST_Visualisierung ##English :: ST_Visualization ##French :: ST_Visu ##END_NAME_ITEM
Es ist darauf zu achten, dass übersetzte Bezeichner und Namen gemäß der Norm gültig bleiben und dass Strings und Kommentare in die entsprechenden Klammerzeichen eingeschlossen werden. Im Falle eines Kommentars, (##COMMENT_ITEM), der mit "(* Kommentar 1 )" in der Übersetzungsdatei steht, muss also das "##TODO' durch ein "(* comment 1 *)" ersetzt werden, im Falle eines Strings (##STRING_ITEM) "'zeichenfolge1'" durch "'string1'".
Hinweis: Folgende Teile der Übersetzungsdatei sollten ohne genaue Kenntnis nicht modifiziert werden:
Sprachblock, Flagblock, Positionsinformationen, Originaltexte.
Projekt übersetzen (in andere Sprache)
Dieser Befehl des Menüs 'Projekt' 'In andere Sprache übersetzen' öffnet den Dialog 'Projekt in andere Sprache übersetzen'.
Das aktuelle Projekt kann unter Verwendung einer gültigen Übersetzungsdatei in eine andere Sprache übersetzt werden.
Hinweis: Wenn Sie die Sprachversion des Projekts, in der es erstellt wurde, erhalten wollen, speichern Sie
eine Projektkopie vor dem Übersetzen unter einem anderen Namen. Ein Übersetzungslauf kann nicht rückgängig gemacht werden. Beachten Sie in diesem Zusammenhang die Möglichkeit, das Projekt in einer anderen Sprache nur darzustellen, wobei es in dieser Darstellung dann allerdings nicht editierbar ist.
Dialog zum Übersetzen des Projekts in eine andere Sprache
4-36 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Das aktuelle Projekt kann unter Verwendung einer gültigen Übersetzungsdatei in eine andere Sprache übersetzt werden.
Hinweis: Wenn Sie die Sprachversion des Projekts, in der es erstellt wurde, erhalten wollen, speichern Sie
eine Projektkopie vor dem Übersetzen unter einem anderen Namen. Ein Übersetzungslauf kann nicht rückgängig gemacht werden. Beachten Sie in diesem Zusammenhang die Möglichkeit, das Projekt in einer anderen Sprache nur darzustellen, wobei es in dieser Darstellung dann allerdings nicht editierbar ist.
Geben Sie im Feld Übersetzungsdatei den Pfad der zu verwendenden Übersetzungsdatei an. Über Durchsuchen erhalten Sie den Standard-Windows-Dialog zum Auswählen einer Datei.
Im Feld Zielsprache erhalten Sie eine Liste der in der Übersetzungsdatei enthaltenen Sprachen­Bezeichner zur Auswahl der gewünschten Zielsprache.
OK startet die Übersetzung des aktuellen Projekts mit Hilfe der angegebenen Übersetzungsdatei in die ausgewählte Zielsprache. Während der Übersetzung werden ein Fortschrittsdialog und gegebenenfalls Fehlermeldungen angezeigt. Nach der Übersetzung werden die Dialogbox sowie alle geöffneten Editierfenster des Projekts geschlossen.
Abbrechen schließt die Dialogbox ohne Modifizierung des aktuellen Projekts.
Falls die Übersetzungsdatei fehlerhafte Eingaben enthält, wird nach Drücken von OK eine Fehlermeldung ausgegeben, die Dateipfad und fehlerhafte Zeile ausgibt, z.B.: "[C:\Programme\CoDeSys\projects\visu.tlt (78)]; Übersetzungstext erwartet".
Hinweis: Beachten Sie die Besonderheiten für Texte in Visualisierungen, s.o. ‚Übersetzungsdatei erstellen’.
Projekt übersetzt darstellen
Wenn für das Projekt eine Übersetzungsdatei existiert, kann eine der übersetzten Versionen dargestellt werden, ohne dass das Projekt in der Original-Sprachversion überschrieben wird.
(Beachten Sie diese Möglichkeit im Vergleich zum "wirklichen" Übersetzen des Projekts, wofür der Befehl 'Projekt in andere Sprache übersetzen' 'Projekt übersetzen' zur Verfügung steht.)
Der Befehl 'Projekt übersetzt darstellen' des Menüs 'Projekt' 'In andere Sprache übersetzen' öffnet den Dialog 'Projekt übersetzt anzeigen'.
Geben Sie im Feld Übersetzungsdatei den Pfad der zu verwendenden Übersetzungsdatei an. Über Durchsuchen erhalten Sie den Standard-Windows-Dialog zum Auswählen einer Datei.
Im Feld Zielsprache erhalten Sie eine Auswahlliste, die neben dem Eintrag "<Originalsprache> auch die in der Übersetzungsdatei enthaltenen Sprachen-Bezeichner anbietet. Die Originalsprache ist die, die momentan mit dem Projekt gespeichert ist. Sie kann sich nur ändern, wenn Sie 'Projekt' 'Übersetzen' durchführen. Wählen Sie nun eine der möglichen anderen Sprachen und schließen den Dialog mit OK. Daraufhin wird das Projekt in der gewählten Sprache dargestellt, kann in dieser Darstellung jedoch nicht editiert werden!
Dialog zum Darstellen des Projekts in einer andere Sprache
Um nun in die Originalsprache zurückzuschalten, können Sie den Befehl 'Übersetzung umschalten' verwenden.
Hinweis: Beachten Sie die Besonderheiten für Texte in Visualisierungen, s.o. ‚Übersetzungsdatei erstellen’.
CoDeSys V2.3 4-37
Übersetzung umschalten
Wenn Sie mit dem Befehl 'Projekt übersetzt darstellen' die (schreibgeschützte) Darstellung des Projekts in einer anderen, über die Übersetzungsdatei bereitgestellten Landessprache herbeigeführt haben, können Sie mit dem Befehl 'Übersetzung umschalten' des Menüs 'Projekt' 'In andere Sprache übersetzen' zwischen dieser Sprachversion und der (editierbaren) Originalversion hin- und her schalten.
Hinweis: Beachten Sie die Besonderheiten für Texte in Visualisierungen, s.o. ‚Übersetzungsdatei erstellen’.

'Projekt' 'Dokumentieren'

Dieser Befehl ermöglicht es Ihnen, eine Dokumentation ihres gesamten Projekts zu drucken.
Dialog zur Projektdokumentation
Projekte verwalten...
Zu einer vollständigen Dokumentation gehören:
• die Bausteine
• eine Inhaltsübersicht der Dokumentation
• die Datentypen
• die Visualisierungen
• die Ressourcen (globale Variablen, Variablenkonfiguration, Traceaufzeichnung,
Steuerungskonfiguration, Taskkonfiguration, Watch- und Rezepturverwalter)
• die Aufrufbäume von Bausteinen und Datentypen
• die Querverweisliste
Für die letzten beiden Punkte muss das Projekt fehlerfrei übersetzt worden sein.
Ausgedruckt werden die im Dialog ‚Projekt dokumentieren’ selektierten Bereiche (blau unterlegt).
Wenn Sie das gesamte Projekt selektieren wollen, selektieren Sie den Namen Ihres Projektes in der ersten Zeile.
Wollen Sie dagegen nur ein einzelnes Objekt selektieren, klicken Sie auf das entsprechende Objekt bzw. bewegen das gepunktete Rechteck mit den Pfeiltasten auf das gewünschte Objekt. Objekte, die
4-38 CoDeSys V2.3
vor ihrem Symbol ein Pluszeichen haben, sind Organisationsobjekte, die weitere Objekte beinhalten. Mit einem Klick auf ein Pluszeichen wird das Organisationsobjekt aufgeklappt und mit einem Klick auf das nun erscheinende Minuszeichen kann es wieder zugeklappt werden. Wenn Sie ein Organisationsobjekt selektieren, sind alle zugehörigen Objekte ebenfalls selektiert. Bei gedrückter <Umschalt>-Taste können Sie einen Bereich von Objekten auswählen, bei gedrückter <Strg>-Taste, mehrere einzelne Objekte.
Wenn Sie Ihre Auswahl getroffen haben, klicken Sie auf OK. Es erscheint der Dialog zum Drucken. Das Layout der zu druckenden Seiten können Sie mit 'Datei' 'Einstellungen Dokumentation' festlegen.

'Projekt' 'Exportieren'

CoDeSys bietet die Möglichkeit, Bausteine zu exportieren bzw. importieren. Damit haben Sie die Möglichkeit, Programme zwischen verschiedenen IEC-Programmiersystemen auszutauschen.
Bisher gibt es ein standardisiertes Austauschformat für Bausteine in AWL, ST und AS (das Common Elements-Format der IEC 61131-3). Für die Bausteine in KOP und FUP und die anderen Objekte hat CoDeSys ein eigenes Ablageformat, da es hierfür kein textuelles Format in der IEC 61131-3 gibt.
Die ausgewählten Objekte werden in eine ASCII-Datei geschrieben.
Es können Bausteine, Datentypen, Visualisierungen und die Ressourcen exportiert werden. Zusätzlich können die Einträge im Bibliotheksverwalter, d.h. die Verknüpfungsinformation zu den Bibliotheken mit exportiert werden (nicht die Bibliotheken selbst!)
4 - Die Komponenten im Einzelnen
Achtung: Der Wieder-Import eines exportierten FUP- oder KOP-Bausteins schlägt fehl, wenn im graphischen
Editor ein Kommentar ein einfaches Hochkomma (') enthält, da dieses als String-Beginn interpretiert wird!
Wenn Sie Ihre Auswahl im Dialogfenster getroffen haben (die Auswahl erfolgt wie bei 'Projekt' 'Dokumentieren' beschrieben), können Sie noch entscheiden, ob Sie die Auswahl in eine Datei exportieren wollen, oder für jedes Objekt eine eigene Exportdatei generieren lassen. Schalten Sie hierzu entsprechend die Option Eine Datei je Objekt aus oder ein und klicken Sie dann auf <OK.>. Es erscheint der Dialog zum Speichern von Dateien. Geben Sie einen Dateinamen mit Zusatz ".exp" bzw. ein Verzeichnis für die einzelnen Objekt-Exportdateien an, die dann unter "Objektname.exp" dort angelegt werden.

'Projekt' 'Importieren'

Wählen Sie in dem erscheinenden Dialog zum Öffnen von Dateien die gewünschte Export-Datei aus.
Die Daten werden in das aktuelle Projekt importiert. Wenn ein gleichnamiges Objekt im Projekt bereits besteht, dann erscheint eine Dialogbox mit der Frage "Wollen Sie es ersetzen?": Antworten Sie mit Ja, wird das Objekt im Projekt ersetzt durch das Objekt aus der Importdatei, antworten Sie mit Nein erhält der Name des neuen Objekts als Ergänzung einen Unterstrich und eine Zählnummer ("_0", "_1", ..). Mit <Ja, alle> bzw. <Nein, alle> wird dies für alle Objekte durchgeführt.
Wird die Information zur Verknüpfung mit einer Bibliothek importiert, so wird die Bibliothek geladen und im Bibliotheksverwalter am Ende der Liste hinzugefügt. Wurde die Bibliothek bereits im Projekt geladen, so wird sie nicht erneut geladen. Ist allerdings in der Exportdatei, die importiert wird, ein anderer Speicherzeitpunkt für die Bibliothek angegeben, so wird der Bibliotheksnamen im Bibliotheksverwalter mit einem "*" gekennzeichnet (z.B. standard.lib*30.3.99 11:30:14), analog zum Laden eines Projektes. Kann die Bibliothek nicht gefunden werden, so erscheint der Informationsdialog: "Kann Bibliothek {<Pfad>\}<name> <date> <time>" nicht finden", analog zum Laden eines Projektes.
Im Meldungsfenster wird der Import protokolliert.

'Projekt' 'Siemens Import'

Im Untermenü 'Siemens Import' finden Sie Befehle zum Import von Bausteinen und Variablen aus Siemens-STEP5-Dateien.
Es stehen folgende Befehle zur Verfügung:
• 'SEQ-Symbolikdatei importieren'
CoDeSys V2.3 4-39
• 'S5-Datei importieren'
Nähere Angaben finden Sie in Kapitel Anhang G 'Siemens-Import'.

'Projekt' 'Vergleichen'

Dieser Befehl wird verwendet um zwei Projekte zu vergleichen oder die aktuelle Version des geöffneten Projekts mit der, die zuletzt gespeichert worden war.
Projekte verwalten...
Übersicht:
Definitionen: aktuelles Projekt: Projekt, das momentan in Bearbeitung ist
Vergleichsprojekt: Projekt, das zum Vergleich aufgerufen wird
Vergleichsmodus: In diesem Modus wird das Projekt nach Anwahl des Befehls dargestellt.
Einheit: Kleinste Vergleichseinheit, die aus einer Zeile (Deklarationseditor, ST, AWL),
einem Netzwerk (FUP, KOP) oder einem Element/Baustein (CFC, SFC) bestehen kann.
Im Vergleichsmodus werden das aktuelle und das Vergleichsprojekt in einem zweigeteilten Fenster gegenübergestellt und die als unterschiedlich befundenen Bausteine farblich gekennzeichnet.
Bei Editorbausteinen gibt es auch für die Inhalte eine direkte Gegenüberstellung.
Vor dem Vergleichslauf können Filter bezüglich der Berücksichtigung von Leerzeichen und Kommentaren aktiviert werden.
Außerdem kann gewählt werden, ob im Vergleichsmodus Veränderungen innerhalb bestehen bleibender Einheiten als solche dargestellt werden oder ob alle unterschiedlichen Einheiten als 'neu eingefügt' bzw. 'nicht mehr vorhanden' markiert werden.
Die Version des Vergleichsprojekts kann für einzelne unterschiedliche Einheiten oder für einen ganzen Block gleich markierter ins aktuelle Projekt übernommen werden.
Beachten Sie: Solange der Vergleichsmodus aktiviert ist (siehe Statuszeile: COMPARE), kann das Projekt nicht editiert werden!
Durchführung Projektvergleich
Nach Anwahl des Befehls öffnet der Dialog 'Projektvergleich':
Dialog für Projektvergleich
Geben Sie den Pfad des Vergleichsprojekts ein. Über die Schaltfläche gelangen Sie zum Standarddialog für das Öffnen einer Datei, den Sie zur Projektauswahl zu Hilfe nehmen können. Wenn der Name des aktuellen Projekts eingetragen ist, wird die momentane Fassung des Projekts mit der bei der letzten Speicherung verglichen.
Falls das Projekt in einer ENI-Datenbank verwaltet wird, können Sie die lokal geöffnete mit der aktuellen Datenbankversion vergleichen. Aktivieren Sie hierzu die Option Vergleichen mit Projektdatenbank.
4-40 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Folgende Optionen bezüglich des Vergleichs können aktiviert/deaktiviert werden: Leerzeichen ignorieren: Es werden keine Unterschiede gemeldet, die in unterschiedlicher Anzahl
von Leerzeichen bestehen.
Kommentare ignorieren: Es werden keine Unterschiede gemeldet, die Kommentare betreffen. Eigenschaften ignorieren: Es werden keine Unterschiede gemeldet, die die Objekt-Eigenschaften
betreffen. Änderungen gegenüberstellen: Wenn die Option aktiviert ist: Für eine Einheit innerhalb eines
Bausteins, die nicht gelöscht oder neu hinzugefügt, sondern nur verändert wurde, wird im zweigeteilten Fenster des Vergleichsmodus die Version des Vergleichsprojekts direkt der des aktuellen Projekts gegenübergestellt (rot markiert, siehe unten). Wenn die Option deaktiviert ist: Die betreffende Einheit wird im Vergleichsprojekt als 'nicht mehr vorhanden' und im aktuellen Projekt als 'neu eingefügt' dargestellt (siehe unten), also nicht direkt gegenübergestellt.
Beispiel für "Änderungen gegenüberstellen"
Zeile 0005 wurde im aktuellen Projekt verändert (linke Fensterhälfte).
Wenn der Dialog 'Projektvergleich' mit OK geschlossen wird, wird der Vergleich gemäß den Einstellungen durchgeführt.
Darstellung des Vergleichsergebnisses
Die Ergebnisse werden zunächst im Strukturbaum des Projektes (Projektübersicht) dargestellt, von dem aus dann einzelne Bausteine geöffnet werden können, um deren inhaltliche Veränderungen zu sehen.
1. Projektübersicht im Vergleichsmodus:
Nach dem durchgeführten Projektvergleich öffnet ein zweigeteiltes Fenster, das den Strukturbaum des Projekts im Vergleichsmodus darstellt. In der Titelleiste steht: "Projektvergleich <Pfad aktuelles Projekt> - <Pfad Vergleichsprojekt>".
Die linke Fensterhälfte zeigt das aktuelle Projekt, die rechte das Vergleichsprojekt. Die Projektübersicht zeigt an oberster Stelle den Projektnamen und entspricht ansonsten der Struktur des Object Organizers.
Bausteine, die Unterschiede aufweisen, werden mit einer Schattierung hinterlegt und durch die Textfarbe bzw. einen Textzusatz gekennzeichnet:
Rot: Einheit wurde inhaltlich modifiziert; wird in beiden Fensterhälften rot dargestellt. Blau: Einheit ist nur im Vergleichsprojekt vorhanden; an gegenüberliegender Stelle in Strukturbaum
des aktuellen Projekts wird eine Lücke eingefügt. Grün: Einheit ist nur im aktuellen Projekt vorhanden; an gegenüberliegender Stelle in Strukturbaum
des Vergleichsprojekts wird eine Lücke eingefügt.
CoDeSys V2.3 4-41
Projekte verwalten...
Schwarz: Einheit, für die keine Unterschiede festgestellt wurde. "(Eigenschaften geändert)": Dieser Text erscheint hinter dem Bausteinnamen im Strukturbaum des
aktuellen Projekts, wenn Unterschiede in den Bausteineigenschaften gefunden wurden. "(Zugriffsrechte geändert)": Dieser Text erscheint hinter dem Bausteinnamen im Strukturbaum des
aktuellen Projekts, wenn Unterschiede in den Zugriffsrechten gefunden wurden.
Beispiel, Projekt im Vergleichsmodus
2. Bausteininhalt im Vergleichsmodus:
Durch einen Doppelklick auf eine Zeile in der Projektübersicht (siehe oben), wird der betroffene Baustein geöffnet.
Beispiel, Baustein im Vergleichsmodus
4-42 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Arbeiten im Vergleichsmodus (Menü 'Extras', Kontextmenü)
Steht der Cursor im zweigeteilten Vergleichsfenster auf einer Zeile, die eine Verschiedenheit anzeigt, bietet das Menü 'Extras' bzw. das Kontextmenü (rechte Maustaste) je nachdem ob man sich in der Projektübersicht oder innerhalb eines Bausteins befindet, eine Auswahl der folgenden Befehle:
• 'Nächster Unterschied'
• 'Vorheriger Unterschied'
• 'Änderung übernehmen'
• 'Einzelne Änderung übernehmen'
• 'Eigenschaften übernehmen'
• 'Zugriffsrechte übernehmen'
Hinweis: Die Übernahme von unterschiedlichen Programmpassagen (Änderungen) oder Zugriffsrechten ist nur vom Vergleichsprojekt ins aktuelle Projekt möglich, nicht umgekehrt.
'Extras' 'Nächster Unterschied'
Kurzform: <F7>
Dieser Befehl steht im Vergleichsmodus zur Verfügung (siehe oben 'Projekt' 'Vergleichen').
Der Cursor springt zur nächsten Stelle (Zeile in der Projektübersicht/Zeile bzw. Netzwerk im Baustein), die eine Verschiedenheit anzeigt.
'Extras' 'Vorheriger Unterschied'
Kurzform: <Umschalt><F7>:
Dieser Befehl steht im Vergleichsmodus zur Verfügung (siehe oben 'Projekt' 'Vergleichen').
Der Cursor springt zur vorhergehenden Stelle (Zeile in der Projektübersicht/Zeile bzw. Netzwerk im Baustein), die eine Verschiedenheit anzeigt.
'Extras' 'Änderung übernehmen'
Kurzform: <Leertaste>
Dieser Befehl steht im Vergleichsmodus zur Verfügung (siehe oben 'Projekt' 'Vergleichen').
Für alle Einheiten, die mit derjenigen zusammen hängen, in der aktuell der Cursor steht und die die gleiche Änderungsmarkierung erhalten haben (z.B. aufeinander folgende Zeilen), wird die Version des Vergleichsprojekts ins aktuelle Projekt übernommen (nur in dieser Richtung möglich!). Die betreffenden Einheiten erscheinen daraufhin in der entsprechenden Farbe in der linken Fensterhälfte.
Zum Übernehmen von Änderungen einzelner Einheiten siehe ’Einzelne Änderung übernehmen’.
'Extras' 'Einzelne Änderung übernehmen'
Kurzform: <Strg> <Leertaste>
Dieser Befehl steht im Vergleichsmodus zur Verfügung (siehe oben 'Projekt' 'Vergleichen').
Nur für die Vergleichseinheit, auf der aktuell der Cursor steht (z.B. Zeile in der Projektübersicht oder Zeile bzw. Netzwerk im Baustein), wird die Version des Vergleichsprojekts ins aktuelle Projekt übernommen (nur in dieser Richtung möglich!). Die betreffende Einheit erscheint daraufhin in der entsprechenden Farbe in der linken Fensterhälfte.
Wenn für einen Baustein im Stukturbaum, der rot markiert war weil eine inhaltliche Änderung festgestellt wurde, diese Änderung übernommen wird, dann wird der Baustein im aktuellen Projekt durch gelbe Schrift kenntlich gemacht.
Bausteine, die nur aufgrund von ‚Änderung übernehmen’ im aktuellen Projekt vorhanden sind, werden ebenfalls mit gelber Schrift dargestellt. Bausteine, die nur aufgrund von ‚Änderung übernehmen’ aus dem aktuellen Projekt entfernt wurden, werden im Vergleichsprojekt mit gelber Schrift dargestellt.
CoDeSys V2.3 4-43
'Extras' 'Eigenschaften übernehmen'
Dieser Befehl steht im Vergleichsmodus und dort nur in der Projektübersicht zur Verfügung (siehe oben 'Projekt' 'Vergleichen').
Für den Baustein, auf dem aktuell der Cursor steht, werden die Bausteineigenschaften aus dem Vergleichsprojekts ins aktuelle Projekt (nur in dieser Richtung möglich!).
'Extras' 'Zugriffsrechte übernehmen'
Dieser Befehl steht im Vergleichsmodus und dort nur in der Projektübersicht zur Verfügung (siehe oben 'Projekt' 'Vergleichen').
Für den Baustein, auf dem aktuell der Cursor steht, werden die Zugriffsrechte aus dem Vergleichsprojekts ins aktuelle Projekt (nur in dieser Richtung möglich!).

'Projekt' 'Kopieren'

Mit diesem Befehl können Sie Objekte (Bausteine, Datentypen, Visualisierungen und Ressourcen) sowie Verknüpfungen zu Bibliotheken aus anderen Projekten in Ihr Projekt kopieren.
Der Befehl öffnet zunächst den Standarddialog zum Öffnen von Dateien.. Wenn sie dort eine Datei ausgewählt haben, wird ein Dialog geöffnet, in dem Sie die gewünschten Objekte markieren können. Die Auswahl erfolgt wie unter 'Projekt' 'Dokumentieren' beschrieben.
Projekte verwalten...
Wenn ein gleichnamiges Objekt im Projekt bereits besteht, dann erhält der Name des neuen Objekts als letztes Zeichen einen Unterstrich und eine Zählnummer ("_1", "_2" ...).

'Projekt' 'Projektinformation'

Unter diesem Menüpunkt können Sie Informationen zu Ihrem Projekt abspeichern. Wenn der Befehl gegeben wurde, öffnet der Dialog ‚Projektinformation’.
Als Projektinformation werden folgende Angaben angezeigt:
• Dateiname
• Verzeichnispfad
• Der Zeitpunkt der letzten Änderung (Geändert am)
Diese Angaben können nicht geändert werden.
Dialog zum Eingeben der Projektinformation
4-44 CoDeSys V2.3
4 - Die Komponenten im Einzelnen
Darüber hinaus können Sie noch folgende eigene Angaben hinzufügen:
• eine Bezeichnung des Projekts:
Bitte beachten: Sofern vom Zielsystem unterstützt, wird die hier eingetragene Bezeichnung automatisch als
Dateiname vorgeschlagen, sobald das Projekt über die Funktion 'Datei' 'Öffnen' 'Projekt aus der Steuerung öffnen' wieder in CoDeSys geladen wird (In diesem Fall öffnet der Dialog zum Speichern einer Datei).
• der Name des Autors,
• die Version und
• eine Beschreibung des Projekts.
Diese Angaben sind optional. Bei Drücken der Schaltfläche Statistik erhalten Sie eine statistische Auskunft über das Projekt (siehe
nächste Abbildung). Diese enthält die Angaben aus der Projektinformation, sowie die Anzahl der Bausteine, Datentypen, der lokalen und globalen Variablen, wie sie bei der letzten Übersetzung aufgezeichnet wurden.
Die Schaltfläche Lizenzinfo... kann betätigt werden, wenn es sich um ein CoDeSys Projekt handelt, das bereits mit dem Befehl 'Datei' 'Speichern unter...'. als lizenzpflichtiges Modul gespeichert wurde. In diesem Fall öffnet sie den Dialog 'Informationen zur Lizenzierung bearbeiten', wo die Lizenzinformationen modifiziert bzw. gelöscht werden können. Siehe hierzu Kapitel 9, 'Lizenzmanagement in CoDeSys'.
Wenn Sie die Option Projektinformation verlangen in der Kategorie Laden & Speichern im Optionsdialog wählen, dann wird beim Abspeichern eines neuen Projekts oder beim Abspeichern eines Projekts unter einem neuen Namen automatisch der Projektinformationen-Dialog aufgerufen.
Beispiel einer Projektstatistik

'Projekt' 'Global Suchen'

Mit diesem Befehl können Sie nach dem Vorkommen eines Textes in Bausteinen, in Datentypen in den Objekten der globalen Variablen, in der Steuerungskonfiguration, in der Taskkonfiguration und in den Deklarationsteilen der Bibliotheken suchen. Wenn der Befehl eingegeben wurde, öffnet sich ein Dialog, in dem Sie die Bausteine und Objekte auswählen können, die durchsucht werden sollen. Die Auswahl erfolgt wie bei 'Projekt' 'Dokumentieren' beschrieben.
CoDeSys V2.3 4-45
Projekte verwalten...
Wird die Auswahl mit OK bestätigt, erscheint der Standarddialog zum Suchen. Dieser erscheint direkt,
wenn der Befehl 'Global Suchen' über das Symbol
in der Menüleiste aufgerufen wurde, die Suche bezieht sich dann automatisch auf alle durchsuchbaren Teile des Projekts. Die zuletzt eingegebenen Suchstrings können über die Combobox des Feldes
Suche nach ausgewählt werden. Wird ein Text in einem Objekt gefunden, so wird das Objekt in den zugehörigen Editor bzw. in den Bibliotheksverwalter geladen und die Fundstelle angezeigt. Das Anzeigen des gefundenen Textes sowie das Suchen und Weitersuchen verhalten sich analog zum Befehl 'Bearbeiten' 'Suchen'.
Wenn Sie die Schaltfläche Ins Meldungsfenster anwählen, werden alle Verwendungsstellen der gesuchten Zeichenfolge in den ausgewählten Objekten zeilenweise in tabellarischer Form im Meldungsfenster aufgelistet. Abschließend wird die Anzahl der gefundenen Stellen angegeben.
Falls das Meldungsfenster nicht geöffnet war, wird es eingeblendet. Pro gefundener Stelle wird folgendes ausgegeben:
• Objektname
• Fundstelle im Deklarationsteil (Decl) oder im Implementationsteil (Impl) eines Bausteins
• Zeilen- bzw. Netzwerknummern
• komplette Zeile bei den textuellen Editoren
• komplette Texteinheit bei den grafischen Editoren
Meldungsfenster mit Ausgabe des Suchergebnisses
Wenn Sie im Meldungsfenster mit der Maus einen Doppelklick auf eine Zeile ausführen oder die <Eingabetaste> drücken, öffnet der Editor mit dem Objekt. Die betroffene Zeile des Objekts wird markiert. Mit den Funktionstasten <F4> und <Umschalt>+<F4> kann schnell zwischen den Ausgabezeilen gesprungen werden.

'Projekt' 'Global Ersetzen'

Mit diesem Befehl können Sie nach dem Vorkommen eines Textes in Bausteinen, Datentypen oder den Objekten der globalen Variablen in der Steuerungskonfiguration, Taskkonfiguration suchen und diesen Text durch einen anderen ersetzen. Bedienung und Ablauf verhalten sich ansonsten wie 'Projekt' 'Global Suchen' bzw. 'Bearbeiten' 'Ersetzen'. Allerdings werden die Bibliotheken nicht zur Auswahl angeboten und es ist keine Ausgabe ins Meldungsfenster möglich.

'Projekt' 'Überprüfen'

Mit diesem Befehl öffnen Sie ein Untermenü mit den folgenden Befehlen zur Überprüfung der semantischen Korrektheit des Projekts:
• Unbenutzte Variablen
• Überlappende Speicherbereiche
• Konkurrierender Zugriff
• Mehrfaches Speichern auf Output
Die Ergebnisse werden im Meldungsfenster ausgegeben.
4-46 CoDeSys V2.3
Jede dieser Funktionen prüft den Stand des letzten Übersetzungslaufs. Wurde das Projekt seither geändert, erscheint eine Warnung im Meldungsfenster. Um ein aktuelles Prüfergebnis zu erhalten, sollten Sie also das Projekt neu übersetzen.
Hinweis: Diese Prüfungen können auch in den Projektoptionen, Kategorie Übersetzungsoptionen so definiert
werden, dass sie bei jedem Übersetzungslauf automatisch durchgeführt werden.
Unbenutzte Variablen
Diese Funktion des Menüs 'Projekt' 'Überprüfen' (siehe oben) sucht nach Variablen, die deklariert sind, aber im Programm nicht verwendet werden. Sie werden mit Bausteinname und –zeile ausgegeben, z.B.: PLC_PRG (4) – var1. Variablen in Bibliotheken werden nicht berücksichtigt.
Die Ergebnisse werden im Meldungsfenster ausgegeben.
Überlappende Speicherbereiche
Diese Funktion Menüs 'Projekt' 'Überprüfen' (siehe oben) prüft, ob bei der Zuweisung von Variablen mittels „AT"-Deklaration auf bestimmte Speicherbereiche Überschneidungen entstehen. Beispielsweise entsteht durch die Zuweisung der Variablen "var1 AT %QB21: INT" und "var2 AT %QD5: DWORD" eine Überschneidung, da sie das Byte 21 gemeinsam belegen. Die Ausgabe sieht dann folgendermaßen aus:
%QB21 wird durch folgende Variablen referenziert: PLC_PRG (3): var1 AT %QB21 PLC_PRG (7): var2 AT %QD5
4 - Die Komponenten im Einzelnen
Die Ergebnisse werden im Meldungsfenster ausgegeben.
Konkurrierender Zugriff
Diese Funktion Menüs 'Projekt' 'Überprüfen' (siehe oben) sucht nach Speicherbereichen von IEC­Adressen, die in mehr als einer Task referenziert werden. Zwischen lesendem oder schreibendem Zugriff wird dabei nicht unterschieden. Die Ausgabe lautet beispielsweise:
%MB28 wird in folgenden Tasks referenziert: Task1 – PLC_PRG (6): %MB28 [Nur-Lese-Zugriff] Task2 – POU1.ACTION (1) %MB28 [Schreibzugriff]
Die Ergebnisse werden im Meldungsfenster ausgegeben.
Mehrfaches Speichern auf Output
Diese Funktion Menüs 'Projekt' 'Überprüfen' (siehe oben) sucht nach Speicherbereichen, auf die in einem Projekt an mehr als einer Stelle schreibend zugegriffen wird. Die Ausgabe sieht beispielsweise so aus:
%QB24 wird an folgenden Stellen beschrieben: PLC_PRG (3): %QB24 PLC_PRG.POU1 (8): %QB24
Die Ergebnisse werden im Meldungsfenster ausgegeben.

Arbeitsgruppen

Es können in CoDeSys bis zu acht Gruppen mit unterschiedlichen Zugriffsrechten auf Bausteine, Datentypen, Visualisierungen und Ressourcen eingerichtet werden. Es können Zugriffsrechte für einzelne oder alle Objekte festgelegt werden. Jedes Öffnen eines Projekts geschieht als Mitglied einer bestimmten Arbeitsgruppe. Als solches Mitglied muss man sich mit einem Passwort autorisieren.
Die Arbeitsgruppen sind von 0 bis 7 durchnumeriert, wobei die Gruppe 0 die Administratorrechte besitzt, d.h. nur Mitglieder der Gruppe 0 dürfen Passwörter und Zugriffsrechte für alle Gruppen bzw. Objekte festlegen.
Wenn ein neues Projekt angelegt wird, dann sind zunächst alle Passwörter leer. Solange kein Passwort für die Gruppe 0 festgelegt wurde, betritt man das Projekt automatisch als Mitglied der Gruppe 0.
CoDeSys V2.3 4-47
Projekte verwalten...
Wenn beim Laden des Projekts ein Passwort für die Arbeitsgruppe 0 festgestellt wird, dann wird beim Öffnen des Projekts für alle Gruppen die Eingabe eines Passworts verlangt. Dazu öffnet folgender Dialog:
Dialog zur Passworteingabe
Stellen Sie in der Combobox Arbeitsgruppe auf der linken Seite des Dialogs, die Gruppe ein, zu der Sie gehören, und geben Sie auf der rechten Seite das dazugehörige
Passwort ein. Drücken Sie OK. Wenn das Passwort nicht mit dem gespeicherten Passwort übereinstimmt, kommt die Meldung:
„Das Kennwort ist nicht korrekt."
Erst wenn Sie das korrekte Kennwort eingegeben haben, wird das Projekt geöffnet.
Achtung: Werden nicht für alle Arbeitsgruppen Passwörter vergeben, so kann man ein Projekt über eine
Arbeitsgruppe, für die keines vergeben wurde, öffnen !
Mit dem Befehl 'Passwörter für Arbeitsgruppe' können Sie Passwörter vergeben und mit 'Objekt' 'Zugriffsrechte' die Rechte für einzelne oder alle Objekte vergeben.

'Projekt' 'Passwörter für Arbeitsgruppen'

Mit diesem Befehl öffnet man den Dialog zur Passwortvergabe für Arbeitsgruppen. Dieser Befehl kann nur von Mitgliedern der Gruppe 0 ausgeführt werden. Wenn der Befehl gegeben wurde, öffnet folgender Dialog:
Dialog zur Passwortvergabe für Arbeitsgruppen
In der linken Combobox Arbeitsgruppe können Sie die Gruppe auswählen. Für diese geben Sie das gewünschte Passwort im Feld Passwort ein. Für jeden getippten Buchstaben erscheint im Feld ein Stern (*). Dasselbe Wort müssen Sie im Feld
Passwort bestätigen wiederholen. Schließen Sie den Dialog nach jeder Passworteingabe mit OK. Bei falscher Bestätigung erscheint die Meldung:
„Das Kennwort und seine Bestätigung stimmen nicht überein.",
und der Dialog bleibt geöffnet, bis er durch korrekte Eingabe bzw. durch Abbrechen geschlossen wird.
Rufen Sie den Befehl für die Passwortvergabe für die nächste Gruppe erneut auf.
Achtung: Werden nicht für alle Arbeitsgruppen Passwörter vergeben, so kann man ein Projekt über eine
Arbeitsgruppe, für die keines vergeben wurde, öffnen!
4-48 CoDeSys V2.3
Loading...
Buy Points How it Works FAQ Contact Us Questions and Suggestions Privacy Policy Cookie Policy Terms of Use