Speaker A
Ein Enum ist ein Aufzählungsdatentyp, bei dem ihr selber festlegen könnt, was denn genau in diesem Datentypen aufgezählt werden soll.
Dieses Video erklärt die Verwendung von ENUMs in der SPS-Programmierung anhand eines Ampelfarben-Beispiels und zeigt Best Practices.
Key Takeaways
- ENUMs erleichtern die Verwaltung von Zuständen in SPS-Programmen durch benannte Aufzählungen.
- Die eindeutige ID jedes ENUM-Elements ermöglicht einfache Auswertung in Case-Statements.
- Qualified_Only verhindert Namenskonflikte und sorgt für klaren Geltungsbereich bei ENUM-Elementen.
- Manuelle Zuweisung von IDs ist möglich, aber meist nicht notwendig.
- ENUM-Variablen sollten nicht wie normale Integer behandelt werden, um Fehler zu vermeiden.
Summary
- ENUM ist ein benutzerdefinierter Aufzählungsdatentyp, der eine Liste von benannten Werten definiert.
- Beispielhafte Verwendung eines ENUMs mit Ampelfarben: rot, rot-gelb, grün, gelb.
- Jedes Element im ENUM hat eine eindeutige Integer-ID, die manuell oder automatisch vergeben werden kann.
- ENUMs werden in SPS-Programmen genutzt, um Zustände einer Steuerung übersichtlich und sicher abzubilden.
- Deklaration von ENUMs erfolgt im Ordner DUT (Data Unit Types) mit Type, Name, Elementen und End_Type.
- ENUM-Elemente können in Case-Statements ausgewertet werden, da sie intern Integer-Werte sind.
- Probleme können auftreten, wenn lokale Variablen dieselben Bezeichner wie ENUM-Elemente haben; Lösung ist die Verwendung des Geltungsbereichs (Qualified_Only).
- Das Attribut Qualified_Only erzwingt die Verwendung des Geltungsbereichs bei ENUM-Elementen und verbessert die Lesbarkeit und Sicherheit.
- ENUM-Variablen können intern wie Integer behandelt werden, was zu unerwarteten Werten führen kann, wenn Werte außerhalb der definierten ENUM-Elemente zugewiesen werden.
- Das Video zeigt praxisnah, wie ENUMs sicher und effektiv in SPS-Steuerungen eingesetzt werden.
Full Transcript — Download SRT & Markdown
Speaker A
Ihr könnt euch also ein Enum als eine Art Liste vorstellen.
Speaker A
Ein sehr einfaches Beispiel dafür ist eine Aufzählung von Ampelfarben, also rot, gelb und grün.
Speaker A
In der SPS-Programmierung werden Enums aber auch häufig eingesetzt für eine Auflistung von möglichen Zuständen, die eine Steuerung einnehmen kann, bei einer Ampelsteuerung würde also diese Aufzählung der Farben noch ergänzt werden um die Farbe rot-gelb.
Speaker A
So, ich werde euch gleich zeigen, dass die Deklaration und die Verwendung von Enums wirklich einfach ist.
Speaker A
Es gibt aber auch noch sozusagen Optionen bei Enums, die deren Verwendung sicherer machen, aber gleichzeitig eben auch etwas einschränken und wie das Ganze funktioniert, zeige ich euch ja auch.
Speaker A
Als erstes zeige ich euch jetzt, wie ihr einen Aufzählungsdatentypen anlegt.
Speaker A
Weil ein Enum ein benutzerdefinierter Datentyp ist, sollte der in diesem Ordner DUT, abgekürzt für Data Unit Types, erstellt werden.
Speaker A
Dazu klicke ich also mit Rechtsklick hier auf diesen Ordner.
Speaker A
Und wähle aus diesem Menü hinzufügen DUT.
Speaker A
In dem Menü, das sich jetzt hier öffnet, seht ihr schon, dass es verschiedene benutzerdefinierte Datentypen gibt.
Speaker A
Unter anderem eben auch eine Enumeration, also der Aufzählungsdatentyp, um den es jetzt hier geht.
Speaker A
Den wähle ich aus und nenne diesen Datentypen dann noch I_Farbe.
Speaker A
Weil ich für dieses Beispiel eine Aufzählung der Ampelfarben wähle.
Speaker A
So, hier gibt's noch die Option Textlistenunterstützung.
Speaker A
Womit ich die Möglichkeit schaffe, die Bezeichner meiner Aufzählungsliste später in einer Visualisierung verwenden zu können.
Speaker A
Das brauche ich jetzt hier aber nicht.
Speaker A
So, dann bestätige ich das Ganze mit Öffnen.
Speaker A
Und dann wird die Definition dieses Aufzählungsdatentypens hier erstellt.
Speaker A
Die Bedeutung dieser beiden Befehle hier oben in den geschweiften Klammern erkläre ich später.
Speaker A
Für den Moment kommentiere ich die also erstmal aus.
Speaker A
So, die Typendefinition wird also mit Type eingeleitet.
Speaker A
Danach kommt der Name des Aufzählungstypen mit einem Doppelpunkt.
Speaker A
Und in den runden Klammern stehen dann die Elemente meiner Aufzählungsliste.
Speaker A
Enum_Member ist hier nur ein Standardeintrag, den ich gleich ersetzen werde.
Speaker A
Und abgeschlossen wird die Definition mit End_Type.
Speaker A
So, in die runden Klammern schreibe ich jetzt also die Elemente meiner Aufzählung.
Speaker A
Und das sind die Farben rot, rot-gelb, grün und gelb.
Speaker A
Und die einzelnen Elemente trenne ich durch ein Komma.
Speaker A
Ihr fragt euch jetzt vielleicht noch, was diese Zuweisung mit dem Wert Null hier im ersten Element soll.
Speaker A
Die Erklärung dafür ist, dass alle Elemente in der Aufzählungsliste eine eindeutige ID haben.
Speaker A
Und das ist eine ganze Zahl.
Speaker A
Die ID von Element rot ist hier die Null.
Speaker A
Und die IDs der nächsten Elemente werden dann immer um eins erhöht.
Speaker A
Rot-gelb hat also den Wert eins, grün den Wert zwei und gelb den Wert drei.
Speaker A
Der Wert des ersten Elements muss nicht immer Null sein.
Speaker A
Das könnte auch eine andere ganze Zahl sein.
Speaker A
Sogar auch eine negative Zahl.
Speaker A
Grundsätzlich sind für die IDs der Listenelemente hier Werte aus dem Wertebereich eines Integers erlaubt.
Speaker A
Wenn ihr also hinter den Bezeichner keine andere Angabe macht, wird die ID immer um eins inkrementiert.
Speaker A
Wenn ihr es braucht, könnt ihr auch jedem Bezeichner sozusagen händisch eine ID zuweisen.
Speaker A
Wichtig ist nur, dass ihr dabei keinen Wert doppelt vergebt.
Speaker A
Und das Ganze könntet ihr auch nur bei einzelnen Elementen machen.
Speaker A
Also z.B. sowas hier.
Speaker A
Hier hat rot den Wert Null.
Speaker A
Rot-gelb wird dann der Wert eins zugewiesen.
Speaker A
Grün wird dann von uns auf den Wert vier gesetzt.
Speaker A
Und gelb bekommt dann wieder den Wert fünf.
Speaker A
In den meisten Fällen braucht man aber diese Möglichkeit, die Werte selber vorzugeben, gar nicht.
Speaker A
So, was könnt ihr jetzt mit einem solchen Enum-Datentypen anfangen?
Speaker A
Zu Beginn hatte ich ja schon erwähnt, dass ihr damit Zustände einer Steuerung angeben könnt.
Speaker A
Und das demonstriere ich jetzt einmal an einem kleinen Beispiel.
Speaker A
Im Main-Programm deklariere ich zunächst eine Variable vom Typ I_Farbe.
Speaker A
Und initialisiere die mit dem Wert rot.
Speaker A
Der Initialisierungswert muss hier natürlich ein Bezeichner aus dem Aufzählungsdatentypen sein.
Speaker A
Und dann brauche ich gleich noch eine Textvariable, also ein String, in die ich den Zustand der Steuerung schreibe.
Speaker A
Und eine Bool-Variable, um die Zustände weiter zu schalten.
Speaker A
So, weil ja die Werte eines Enums intern Integer-Variablen sind.
Speaker A
Kann ich die auch in einem Case-Statement auswerten.
Speaker A
Die einzelnen Fälle sind dann eben die Farben aus meinem Aufzählungsdatentypen.
Speaker A
Und da gebe ich einfach immer nur die Farbe aus und warte darauf, dass B_Switch wieder auf True gesetzt wird.
Speaker A
Dann wechsle ich den Wert von I_Farbe auf den jeweils nächsten Zustand.
Speaker A
Und ganz am Ende nach dem Case setze ich dann noch B_Switch wieder zurück.
Speaker A
So, das Programm kann ich nun laufen lassen.
Speaker A
Und dann seht ihr, dass hier die einzelnen Phasen einer Ampel zyklisch durchlaufen werden.
Speaker A
Der Zustand der Ampel wechselt also immer, wenn ich B_Switch auf True setze.
Speaker A
Bis hierhin habe ich euch also gezeigt, dass die Deklaration und die Verwendung eines Enums wirklich simpel ist.
Speaker A
So einfach ein Enum ist, so nützlich ist dieser Datentyp aber auch für den Aufbau von sogenannten Schrittketten, also Steuerungen, die eben verschiedene Zustände haben.
Speaker A
Und die in Abhängigkeit von bestimmten Ereignissen zwischen diesen Zuständen wechseln.
Speaker A
Bei einem Enum, wie ich den jetzt hier implementiert und genutzt habe, gibt es aber auch ein paar Sachen zu beachten.
Speaker A
Und die zeige ich euch jetzt.
Speaker A
Das erste ist, dass ich in meinem Programm hier die Bezeichner aus dem Enum, also rot, grün und so weiter.
Speaker A
Wie konstante Variablen verwendet habe.
Speaker A
Ohne dass dabei aber der Bezug zum Aufzählungsdatentypen tatsächlich ersichtlich ist.
Speaker A
Das heißt, diese Enum-Elemente hier werden losgelöst von ihrem Geltungsbereich verwendet.
Speaker A
Zu einem Problem kann das werden, wenn ich in meinem Programm Variablen habe.
Speaker A
Die denselben Bezeichner haben, also z.B. sowas hier.
Speaker A
Grün ist jetzt also eine lokale Variable in dem Programm.
Speaker A
Die das Enum-Element grün sozusagen überdeckt.
Speaker A
Das seht ihr insbesondere an diesem Fehler hier.
Speaker A
Das nämlich eine veränderliche Variable nicht in dem Case-Statement ausgewertet werden kann.
Speaker A
So, durch die Deklaration der Variablen grün vom Typ Integer hier oben kann ich also schon mal das Programm nicht mehr kompilieren.
Speaker A
Wenn ich jetzt die Variable grün hier zu einer Konstanten mache.
Speaker A
Dann gibt es zumindest keinen Fehler mehr, aber die lokale Variable grün überdeckt immer noch das Enum-Element.
Speaker A
Um dieses Problem zu lösen, gibt es eine einfache Möglichkeit.
Speaker A
Nämlich den Bezeichner grün hier seinen Geltungsbereich voranzustellen.
Speaker A
Also I_Farbe.
Speaker A
So, auch wenn die lokale Variable grün und der Enum-Bezeichner jetzt also gleich heißen, kann ich jetzt aber durch die Angabe des Geltungsbereichs sauber zwischen beiden trennen.
Speaker A
Das ist also guter Programmierstil bei der Verwendung eines Enums.
Speaker A
Diesen Bereich immer mit anzugeben.
Speaker A
Und damit ihr euch immer an diesen Stil haltet, könnt ihr euch auch selber dazu zwingen.
Speaker A
Indem ihr nämlich bei der Enum-Deklaration dieses Attribut Qualified_Only angebt.
Speaker A
So, jetzt seht ihr also in der Main, dass die Bezeichner rot, rot-gelb und gelb alle rot unterkringelt sind.
Speaker A
Diese Bezeichner sind jetzt also nur gültig zusammen mit dem Geltungsbereich.
Speaker A
Ein zweites Problem beim Enum kann sein.
Speaker A
Dass ihr eine Enum-Variable noch wie eine ganz normale Integer-Variable verwenden könnt.
Speaker A
Das heißt, ich könnte der Variablen I_Ampel hier irgendeinen Integer-Wert zuweisen.
Speaker A
Also z.B. den Wert sechs.
Speaker A
Das Problem ist jetzt, dass ich gar keinen Bezeichner definiert habe, der den Wert sechs hat.
Speaker A
In dem Case-Statement wird hier der Fall, dass I_Ampel gleich sechs ist, also gar nicht behandelt.
Speaker A
Die Enum-Variable wird also wie eine ganz normale Integer-Variable behandelt, mit der ihr sogar rechnen könnt.
Speaker A
In der Regel sind solche Berechnungen aber ziemlich sinnlos.
Speaker A
Damit euch solche Rechnungen nicht aus Versehen passieren, gibt es eine Möglichkeit, wie ihr euch davor schützen könnt.
Speaker A
Nämlich, indem ihr bei der Deklaration des Enum das Attribut Strict angebt.
Speaker A
Jetzt seht ihr im Main-Programm, dass bei den Berechnungen mit dem Enum Fehler aufpoppen.
Speaker A
Sodass das Programm also auch wieder nicht kompiliert werden kann, wenn darin eben solche Berechnungen enthalten sind.
Speaker A
So, ich hoffe, dass ihr bis hierhin erkannt habt, dass die Attribute Qualified_Only und Strict ganz sinnvoll sind.
Speaker A
Und die deswegen auch standardmäßig bei der Erstellung eines Enum immer mit angegeben werden.
Speaker A
Neben diesen beiden Attributen gibt es für Enums noch ein weiteres Attribut, das manchmal ganz hilfreich sein kann.
Speaker A
Und das ist das Attribut To_String.
Speaker A
Um zu erklären, wofür das gut ist, kommentiere ich das zunächst noch einmal aus.
Speaker A
So, hier im Main-Programm nutze ich ja diese String-Variable S_Text.
Speaker A
Um den jeweils aktiven Zustand da rein zu schreiben.
Speaker A
Das mache ich hier also in jedem Fall dieser Case-Anweisung.
Speaker A
Komfortabler wäre es ja aber, wenn ich den Bezeichner meiner Enum-Elemente direkt in S_Text schreiben könnte.
Speaker A
Also z.B. in dieser Form.
Speaker A
Eine direkte Zuweisung von I_Ampel zu S_Text funktioniert nicht, weil das ja zwei völlig verschiedene Datentypen sind.
Speaker A
Und deswegen musste ich I_Ampel zunächst in einen String konvertieren.
Speaker A
Mit der Funktion To_String.
Speaker A
Die Zuweisung in den Fallunterscheidungen brauche ich dann nicht mehr und deswegen kommentiere ich die dort mal aus.
Speaker A
Wenn ich jetzt das Programm laufen lasse, seht ihr, dass in dem String S_Text nicht die eigentlichen Bezeichner meiner Enum-Elemente stehen.
Speaker A
Sondern deren IDs.
Speaker A
Also die Werte Null bis drei.
Speaker A
Diese Werte sind aber nicht wirklich sprechend.
Speaker A
Eine Ausgabe von diesem String erfüllt also nicht wirklich den Zweck, Transparenz darüber zu schaffen, in welchem Zustand sich die Steuerung befindet.
Speaker A
Was man insbesondere bei der Entwicklung von Steuerungen häufiger mal braucht.
Speaker A
Wenn ich jetzt aber in der Enum-Deklaration das Attribut To_String hinzufüge.
Speaker A
Dann hat das die folgende Auswirkung.
Speaker A
Dann wird nämlich bei dieser Zuweisung hier in Zeile eins nicht die ID des Elements.
Speaker A
Sondern tatsächlich dessen Bezeichner übergeben.
Speaker A
Ich habe also jetzt nur das Attribut hinzugefügt, den restlichen Code aber gar nicht verändert.
Speaker A
Und dass das dann also tatsächlich so stimmt, wie ich behauptet habe.
Speaker A
Seht ihr jetzt hier im laufenden Programm.
Speaker A
In S_Text steht also nicht mehr die ID, sondern wirklich die Bezeichner der Enum-Elemente.
Topics:SPS-ProgrammierungENUMAufzählungsdatentypAmpelfarbenSteuerungData Unit TypesQualified_OnlyCase-StatementProgrammierungChristian Stöcker
