SPS-Programmierung #10: STRUCT (Strukturen) — Transcript

Als Struct werden Strukturvariablen bezeichnet. Das sind benutzerdefinierte Datentypen, die andere Variablen wieder wie eine Hülle zusammenfassen. Und welche Variablen in einer Struktur zusammengefasst werden, das könnt ihr selber entscheiden. Ich zeige euch in diesem Video, wie man in ST eine Strukturvariable definiert und was dabei zu beachten ist. Und dann zeige ich euch auch noch, wie man eine Variable von diesem Datentypen instanziiert und die Variable dann verwendet.

Um eine Strukturvariable anzulegen, klickt ihr mit Rechtsklick auf diesen Ordner DUTs für Data Unit Types. Grundsätzlich könnt ihr natürlich eine Strukturvariable in jedem Ordner dieses SPS-Projekts erstellen, aber wenn ihr eine vernünftige Strukturierung eures SPS-Projekts erreichen wollt, solltet ihr euch schon grob an die Aufteilung halten, die durch die Norm IEC 61131 vorgegeben ist. So dann wählt ihr Hinzufügen, DUT.

Dann öffnet sich dieser Dialog, indem ihr die Auswahl treffen könnt, was für einen benutzerdefinierten Datentypen ihr anlegen wollt. Die Enumeration habe ich euch schon in einem anderen Video erklärt. Hier geht's jetzt um die Struktur, also wähle ich diesen Datentypen aus und gebe dem den Namen ST_ListItem. Hier gibt's noch die Option, eine bestehende Struktur zu erweitern, darauf komme ich aber erst gleich, also setze ich diesen Haken hier erstmal nicht. So, dann bestätige ich das Ganze mit Öffnen.

Und dann wird für mich hier ein Grundgerüst für eine Struktur angelegt. Die Definition einer Strukturvariablen beginnt also mit dem Schlüsselwort TYPE gefolgt von dem Namen der Struktur und einem Doppelpunkt. Innerhalb dieses Blocks, der eingerahmt ist durch STRUCT und END_STRUCT, werden dann gleich die sogenannten Membervariablen angegeben, also die Variablen, die durch die Struktur zusammengefasst werden sollen. Und die Definition des Ganzen wird dann mit END_TYPE wieder abgeschlossen.

Okay, in dem Strukturblock kann ich jetzt also fast beliebige Variablen aufnehmen. Dazu muss ich, wie bei einer ganz normalen Variablendeklaration, nur den Bezeichner und den Typen angeben. Also zum Beispiel nValue vom Typ Double Int oder eine Bool Variable bFlag.

Ihr könnt hier aber auch komplexe Datentypen angeben, also zum Beispiel ein Array wie dieses Integer Array mit der Länge 10. Genauso möglich ist Funktionsbausteine als Member aufzunehmen, wie dieses RS Flip-Flop. Eine Struktur kann sogar auch andere Strukturen enthalten, wie zum Beispiel diese Struktur ST_ListOptions, die ich als separate Struktur deklariert habe. Ihr seht also, bei der Deklaration von Strukturvariablen ist vieles möglich. Was allerdings nicht möglich ist, ist eine Struktur vom gleichen Typen als Membervariablen aufzunehmen, also in diesem Fall ein Objekt vom Typ ST_ListItem.

Das wäre nämlich eine unendliche Rekursion. Hier wird zwar jetzt kein Fehler angezeigt, das würde aber zumindest beim Kompilieren zu einem Fehler führen hier.

Was aber möglich ist, ist ein Pointer auf eine Struktur vom gleichen Datentypen aufzunehmen, also das hier. Auf diese Weise könnte man dynamische Datenstrukturen wie z.B. verkettete Listen aufbauen. Darauf will ich jetzt aber nicht weiter eingehen, aber wenn ihr Interesse an dieser Datenstruktur habt, könnt ihr mal ein das Video schauen, dass ich hier oben verlinkt habe. Da erkläre ich die Implementierung einer einfach verketteten Liste in der Programmiersprache C.

So, wenn ihr wollt, dass einzelne Membervariablen der Struktur einen Defaultwert haben sollen, der nicht dem Defaultwert des jeweiligen Datentypen entspricht, dann könnt ihr den auch hier noch setzen. Also, ein Double Integer zum Beispiel hat nach der Deklaration per Default den Wert 0. Den kann ich jetzt hier durch einfache Zuweisung auf einen anderen Wert setzen, also zum Beispiel 123. Auf die gleiche Weise könnte man jetzt auch der Bool Variablen oder dem Array andere Defaultwerte vorgeben. Die Initialisierung von dem Funktionsbaustein geht nicht so einfach durch Zuweisung und deswegen blende ich das hier mal aus. So und die Defaultwerte der Struktur ST_ListOptions müssten eben in der Deklaration hier gesetzt werden.

So, jetzt zeige ich euch, wie ihr Variablen von dieser Struktur anlegen und verwenden könnt. Und dazu gehe ich in das Main Programm und deklariere da zwei Variablen vom Typ ST_List Item. Also das Erzeugen von Strukturvariablen funktioniert ganz genauso, wie auch bei Standarddatentypen.

Im Programm zeige ich euch gleich, wie ihr auf die Membervariablen der Struktur zugreifen könnt und zwar werde ich dafür alle Werte beschreiben. Und dafür brauche ich noch eine Schleifenvariable für den Zugriff auf das Array mit einer For-Schleife und eine Bool Variable, mit der ich dann das Schreiben der Werte starte.

Wenn also bWrite auf True gesetzt wird, dann sollen die Werte von Item 1 beschrieben werden. Um auf die einzelnen Membervariablen zuzugreifen, gebe ich den Namen der Strukturvariablen an, hier Item 1, gefolgt von einem Punkt. So und dann werden wir schon die Membervariablen der Struktur angeboten. Und hier wähle ich erstmal bFlag und setze die z.B. auf True. So und in gleicher Weise erfolgt der Zugriff auf alle Werte der Struktur. Hier seht ihr das noch bei dem Array, beim Double Integer und beim Pointer. Der Zugriff auf die Membervariablen einer Struktur erfolgt also immer über den Punkt Operator.

So die Strukturvariable ST_Item List hat ja jetzt noch eine andere Struktur vom Typ ST_ListOptions als Member. Auf diese Struktur kann ich auch wieder über den Punkt Operator zugreifen. Und wenn ich dann erneut den Punkt Operator anwende, greife ich dann auf die Member der Struktur von ST_ListOptions zu. Das seht ihr jetzt hier an diesem Dropdown-Menü, dass sich öffnet. Und so kann ich dann also die Werte einer Struktur ändern, die wiederum eine Membervariable einer anderen Struktur ist.

Als letztes steht jetzt noch der Aufruf des Funktionsbausteins aus der Struktur aus. Das funktioniert aber wie zuvor auch, nämlich wieder über den Punkt Operator.

So und jetzt starte ich das Programm. Und da seht ihr, wie gewohnt erstmal die deklarierten Variablen aus dem Main Programm. Die Strukturvariablen kann ich jetzt hier ausklappen, um dann eben eine Sicht auf die Membervariablen zu bekommen. Und die seht ihr jetzt hier. nValue hat also den von mir zuvor gesetzten Defaultwert 123 und bFlag ist auf False gesetzt. Die Werte im Array sind alle noch 0 und beim Flip-Flop sind auch die Ein- und Ausgänge auf False gesetzt. So und hier seht ihr noch die Membervariablen der Struktur ST_ListOptions und das hier ist der Pointer, der auch noch den Wert 0 hat. So das Flip-Flop verhält sich, auch wenn es in der Struktur eingebettet ist, eben, wie ihr seht, wie ein ganz normales Flip-Flop.

So und wenn ich jetzt bWrite auf True setze, werden dann, wie ich das gerade eben erklärt habe, die Werte aller Membervariablen verändert.

Hier habe ich übrigens nur den schreibenden Zugriff auf die Membervariablen demonstriert, aber der lesende Zugriff funktioniert ganz genauso, also auch wieder über den Punkt Operator, zum Beispiel so.

Hier in der Deklaration von ST_ListItem habe ich ja eine andere Struktur vom Typ ST_ListOptions eingebunden und habe darüber dann auch den Zugriff auf deren Member. Jetzt zeige ich euch noch eine alternative Möglichkeit, eine Struktur zu erstellen, die wiederum Gebrauch macht von einer bestehenden Struktur. Und dazu erstelle ich im Ordner DUT zunächst eine neue Struktur und die nenne ich ST_NewListItem. Jetzt wähle ich hier aber die Option Erweitert und wähle dann hier eine Strukturvariable aus, die ich eben erweitern möchte, und zwar ist das hier ST_ListOptions mit den Membervariablen, die ihr hier unten aufgelistet seht. So und dann klicke ich auf OK und anschließend auf Öffnen.

So wie zuvor wird auch jetzt wieder eine noch leere Deklaration für eine Strukturvariable erstellt. Hier seht ihr jetzt aber den Zusatz EXTENDS und dahinter steht der Name der Strukturvariablen, die erweitert werden soll. Durch diese Erweiterung beinhaltet NewListItem jetzt schon alle Membervariablen der Struktur ListOptions, also die, die ihr noch mal hier rechts seht. So und jetzt lege ich hierin also neue Membervariablen an und dazu übernehme ich einfach die Variablen aus der vorherigen Struktur mit Ausnahme von stOpt.

Und das kann ich jetzt erst einmal im Main Programm demonstrieren. Hier ändere ich jetzt den Datentypen von Item 1 und Item 2 auf ST_NewListItem. Und dann seht ihr im Anweisungsteil drei Fehler, nämlich hier, wo jeweils stOpt rot unterstrichen ist. Diese Membervariable gibt es ja in der neuen Struktur nicht, aber es gibt ja die Membervariablen bOpt1, bOpt2 und sText, die ja aus der Erweiterung von ST_ListOptions kommen. Also muss ich hier nur den Bezeichner stOpt entfernen und dann läuft das Ganze wieder wie zuvor.

Eine kleine Ergänzung möchte ich euch jetzt noch mitgeben bezüglich der Erweiterung von Strukturen. Wie ich das gerade schon erklärt habe, sind ja die Membervariablen von ST_NewListItem die, die ich hier deklariert habe und die Member von ST_ListOptions. Dabei kann ich aber auch Member der Struktur, die erweitert werden sollen, überschreiben. Also zum Beispiel könnte ich hier eine Variable bOpt1 aufnehmen, obwohl es die ja schon in ST_ListOptions gibt und die könnte dann sogar einen ganz anderen Datentypen haben, also zum Beispiel ein Integer. Die Variablen mit denselben Bezeichnern überdecken dann die Variablen, die aus der Erweiterung kommen. In der Struktur ST_NewListItem existiert dann nur eine Variable bOpt1 und das ist die, die in ST_NewListItem erstellt wurde.

Eine zweite Einschränkung ist, dass ihr immer nur eine Struktur erweitern könnt. Das heißt, wenn also mehrere Strukturvariablen in einer neuen Strukturvariablen zusammengefasst werden sollen, geht das eben nicht mit einer Erweiterung, sondern da müssen dann die Strukturen als Membervariablen aufgenommen werden. So, bis hierhin habe ich euch alles Wichtige zu Strukturen in ST erklärt.

Dass Strukturen kein abstraktes und akademisch motiviertes Konstrukt sind, sondern in der SPS-Programmierung ein wichtiges Element für eine strukturierte Programmierung sind, möchte ich euch noch zum Schluss am Beispiel der Motion Control Bibliothek zeigen. Das ist also eine Bibliothek, die unter anderem Funktionen für die Ansteuerung von Antrieben bereitstellt. Eine Übersicht über die Inhalte dieser Bibliothek bekommt ihr in dem Bibliotheksverwalter, den ihr jetzt hier seht. Die Inhalte der Bibliothek sind also in viele Unterordner gegliedert und wenn ihr einige davon öffnet, stellt ihr fest, dass darin immer wieder Strukturen auftauchen, zu erkennen an der einheitlichen Bezeichnung mit dem Präfix ST. Zum Beispiel gibt's im Ordner Motions eine Struktur ST_MoveOptions, in der einige Parameter, die eben für die Bewegungssteuerung wichtig sind, zusammengefasst werden. Das ist also nur ein Beispiel dafür, dass Strukturen eben wichtig sind. Grundsätzlich werden euch Strukturen bei der Programmierung von SPSen immer wieder begegnen.