SPS-Programmierung #14: Objektorientierte SPS-Programmi… — Transcript

In diesem und in einigen weiteren Videos in dieser Reihe geht's um Objektorientierte SPS-Programmierung.

Damit ihr den Erklärungen hier folgen könnt, wäre es schon hilfreich, wenn ihr das Paradigma der Objektorientierung in der Softwareentwicklung schon verstanden habt.

Wenn ihr euch dazu noch mal schlau machen wollt, findet ihr oben einen Link zu einem Video, indem ich die Grundidee der Objektorientierten Programmierung in kompakter Form vorstelle.

Okay, ohne dass es euch vielleicht bewusst war, habt ihr schon einen kleinen Teil der Objektorientierung in der SPS-Programmierung angewendet, nämlich indem ihr Funktionsbausteine instanziiert habt und diese Instanzen dann in eurem Programm verwendet habt.

Ein Funktionsbaustein ist also schon so etwas wie eine Klasse, in der ein Verhalten in allgemeiner Form beschrieben ist.

Beispiele dafür sind ein RS Flipflop oder der Blinker aus dem Video zu Programmorganisationseinheiten oder eine Ansteuerung eines Aktors aus dem Video zu Einzelsteuerfunktionen.

Und das Anlegen von Variablen vom Typ eines Funktionsbausteins ist dann also die Instanziierung.

Das heißt, ihr erzeugt ein Objekt von einer Klasse und natürlich könnt ihr nicht nur ein Objekt einer Klasse erzeugen, sondern auch gleich mehrere und all diese Objekte sind unabhängig voneinander, haben also alle ihre eigenen lokalen Variablen.

Aber die Tatsache, dass ich dem Thema Objektorientierte SPS-Programmierung gleich mehrere Videos widme, zeigt euch ja, dass es mehr geben muss, als nur die Möglichkeit, ein Funktionsbaustein als Klasse zu betrachten und den beliebig oft instanziieren zu können.

Wenngleich das auch schon ein Teil eines wichtigen Konzepts der Objektorientierung ist, das Abstraktion genannt wird.

Abstraktion ist aber nur ein Konzept von vieren, die zusammengenommen die DNA der Objektorientierten Programmierung ausmachen.

Diese Konzepte werden auch häufig als die vier Säulen der Objektorientierten Programmierung beschrieben, neben Abstraktion sind die anderen drei Säulen Datenkapselung, Vererbung und Polymorphie.

In diesem Video gehe ich auf die Details der Abstraktion ein, denn dazu gehört nämlich auch das Verstecken von Komplexität, für die SPS-Programmierung bedeutet das konkret, dass euer Code des Funktionsbausteins nicht nur im Anweisungsteil steht, sondern dass ihr den teilweise auch in Methoden auslagern könnt und hier zeige ich euch erstmal, was Methoden sind, wie ihr die anlegt und aufruft, sowohl mit Übergabe als auch mit Rückgabeparametern und was in dem Zusammenhang die Zugriffsmodifizierer Public und Private bedeuten.

Das Beispiel, an dem ich euch diese Dinge hier erkläre, ist eine Einzelsteuerfunktion zur Ansteuerung eines Antriebs mit variabler Geschwindigkeit, die ich in dem vorherigen Video aufgebaut habe.

Keine Sorge, ihr müsst das Video ja nicht gesehen haben, um hier mitkommen zu können.

Wichtig ist nur, wie der FB funktioniert und nicht, wie er implementiert ist.

Und die Erklärung der Funktionsweise kommt jetzt.

Der Antrieb ist hier ein Schrittmotor, der an eine Schrittmotorklemme angeschlossen ist und diese Klemme macht die Ansteuerung des Motors über eine Pulsweitenmodulation.

Wie das passiert, ist hier egal, denn wir übergeben der Klemme nur ein Enable Signal zum Aktivieren oder Deaktivieren des Antriebs und eine Geschwindigkeit als Vorzeichen behafteter Integerwert.

Und den Rest erledigt dann die Klemme für uns.

Ist die Geschwindigkeit negativ, läuft der Motor rückwärts, ist der Wert positiv, läuft der Motor entsprechend vorwärts.

Diese Werte will ich aber nicht direkt vorgeben, sondern die Ansteuerung soll über diese Signale passieren, die die Eingangssignale in den FB sind.

Zum Aktivieren muss an B on eine steigende Flanke anliegen und B off muss false sein.

Zum Stoppen wird B off auf True gesetzt und B lock ist ein zusätzliches Signal, über das man den Motor sperren kann, wenn nämlich B lock True ist.

Die Richtung und Geschwindigkeit werden dann über die Signale B FWD und B BWD bzw. über N Speed angegeben.

Der Motor dreht vorwärts, wenn B FWD True und B BWD False sind.

Andersherum fährt der Motor rückwärts und bei allen anderen Kombinationen steht der Motor.

Also, die Ansteuerung des Motors über diesen FB ist in gewisser Weise etwas umständlich, weil man nämlich die richtige Kombination der Eingangssignale vorgeben muss, um den gewünschten Effekt zu erzielen.

Einfacher und auch intuitiver lässt sich das Ganze unter Verwendung von Methoden lösen und wie das geht, zeige ich euch jetzt.

Zunächst einmal lege ich einen ganz normalen Funktionsbaustein an, den ich IDF 2 Dir Var Speed nenne.

Als Eingangssignal soll dieser FB das Signal B lock zum Sperren des Antriebs behalten und die Ausgangssignale sind natürlich weiterhin die Freigabe B enable und die Geschwindigkeit N vel.

Das einzige, was ich jetzt im Anweisungsteil programmiere, ist die Logik für das Sperren des Antriebs.

Das ist so eine Art Sicherheitslogik, die immer überprüft werden soll, wenn der FB aufgerufen wird.

Die restlichen Funktionalitäten, das heißt, das Aktivieren und Deaktivieren des Antriebs und die Wahl der Richtung der Geschwindigkeit, realisiere ich jetzt aber über Methoden.

Als erstes lege ich jetzt eine Methode zum Aktivieren des Antriebs an, dazu klicke ich mit Rechtsklick auf den FB und wähle dann Hinzufügen Methode.

Eine Methode verhält sich genauso wie eine Funktion, die braucht also einen Namen, über den sie aufgerufen werden kann und diese Methode hier nenne ich M on.

Dann kann eine Methode einen Rückgabewert liefern und den Typ des Rückgabewerts muss ich hier angeben, in meinem Fall soll das jetzt Bool sein.

Und dann kann man hier noch einen Zugriffsmodifizierer wählen und wenn ich hier nichts angebe, bedeutet das dasselbe wie Public und damit kann die Methode dann von außen aufgerufen werden.

Was das bedeutet und welche Auswirkung der Zugriffsmodifizierer Private hat, zeige ich gleich, wenn ich den FB anwende.

So, dann seht ihr hier im Projektmappen Explorer, dass die Methode angelegt wurde.

Und im Editor seht ihr dann den Deklarationsteil und den noch leeren Anweisungsteil.

Gerade habe ich schon erwähnt, dass sich eine Methode wie eine Funktion verhält, die allerdings einem Funktionsbaustein zugeordnet ist.

Eine Methode kann also Übergabeparameter entgegennehmen, die hier in diesem Block deklariert werden müssen.

Und der Typ des Rückgabewerts steht hier hinter dem Doppelpunkt.

Wenn eine Methode keinen Wert zurückliefern soll, werden Doppelpunkt und natürlich der Rückgabetyp einfach weggelassen.

So, diese Methode soll also den Antrieb aktivieren und dazu das Ausgangssignal B enable auf True setzen, allerdings nur, wenn B lock nicht gesetzt ist.

Die Wertzuweisung an B enable ist hier also vom Signal B lock abhängig, dass man vielleicht beim Aufruf der Methode B on nicht kennt.

Also könnte es hier Sinn machen, den tatsächlich gesetzten Wert zurückzugeben, der Name der Methode ist hier also wie eine Variable, der man den Rückgabewert zuweisen muss.

So, hier habe ich jetzt noch eine zweite Methode M off zum Deaktivieren des Antriebs angelegt.

Und die liefert keinen Rückgabewert, weil das Ausschalten eben immer funktionieren soll.

Soweit habe ich jetzt also schon mal die Möglichkeiten, einen Antrieb über das Signal B lock zu sperren und über die Methoden M on und M off zu aktivieren bzw. zu deaktivieren.

Und wie das funktioniert, zeige ich euch jetzt in einem ersten kleinen Test im Main Programm.

Im Deklarationsteil instanziere ich hier zunächst den FB und zum Testen der Methoden brauche ich dann noch diese Bool Variablen hier.

Und B check nimmt den Rückgabewert der Methode M on auf.

Im Programm rufe ich dann zunächst den Anweisungsteil des FBs auf und übergebe hier das Signal B manual lock.

So, und wenn B on True ist, dann soll die Methode M on aufgerufen werden.

Der Aufruf von Methoden eines Funktionsbausteins funktioniert also so, dass ihr zunächst den Bezeichner des FBs angebt.

Und über diesen Punkt Operator bekommt ihr dann Zugriff auf all die Methoden, für die ihr beim Anlegen keinen Zugriffsspezifizierer oder eben explizit Public gewählt habt.

Und deswegen sagt man auch, dass also Public Methoden nach außen sichtbar sind und hier bei M on seht ihr jetzt auch noch mal, wie der Rückgabewert einer Methode aufgenommen und in der Variablen B check gespeichert wird.

Das funktioniert also auch genauso wie bei Funktion.

So, wenn B off True ist, soll entsprechend die Methode M off ausgeführt werden.

Im Online Modus seht ihr jetzt, dass ich über den Aufruf von M on den Motor aktivieren kann.

Und mit M off wird der Motor deaktiviert.

Und wenn das Lock Signal gesetzt ist, dann hat der Aufruf der Methode M on eben keine Auswirkung mehr.

Das seht ihr auch daran, dass der zurückgegebene Wert in B check False ist.

Und wenn der Motor zuvor aktiviert war, wird er durch das Lock Signal eben wieder deaktiviert.

Bis hierhin habe ich euch gezeigt, wie ihr Methoden mit und ohne Rückgabewert erstellt und diese dann im Programm aufruft.

Jetzt erweitere ich das Beispiel noch um Methoden für die Richtungs- und Geschwindigkeitsteuerung, die einen Übergabewert aufnehmen.

Und dafür habe ich hier schon mal die Methode M forward angelegt, in der soll also der eingeschaltete Antrieb rechts herum gedreht werden.

Und zwar mit einer Geschwindigkeit, die hier als Übergabeparameter vom Typ Integer angegeben wird.

Weil ja der übergebene Wert theoretisch negativ sein könnte, bilde ich hier im Anweisungsteil den Betrag und weise diesen Wert dann der Ausgangsvariablen für die Geschwindigkeit zu.

Entsprechend habe ich auch die Methode M backward implementiert, darüber soll der Antrieb also in die entgegengesetzte Richtung bewegt werden.

Die Geschwindigkeit muss also negativ sein.

So, um euch die Verwendung dieser neuen Methoden zu zeigen, habe ich das Main Programm etwas erweitert.

In gleicher Weise wie beim ersten Testen habe ich wieder zwei Variablen B forward und B backward, die ich nutze, um die Methoden M forward bzw. M backward aufzurufen.

Beim Aufruf von M forward übergebe ich die Geschwindigkeit von 2000.

Und bei M backward soll der Antrieb mit doppelter Geschwindigkeit in die entgegengesetzte Richtung drehen.

Damit das Ganze noch etwas anschaulicher wird, verwende ich jetzt wieder richtige Hardware, also habe ich hier noch die Variablen B stepper N und N stepper vel angelegt.

An die ich hier unten die Ausgangssignale des FBs übergebe und die Variablen sind wiederum mit den entsprechenden Signalen an der Schrittmotorklemme verbunden.

Und zusätzlich mache ich das Sperren des Antriebs noch über diesen Schalter hier und mit diesen beiden LEDs zeige ich noch an, ob der Antrieb aktiviert bzw. gesperrt ist.

Also, dann gehe ich in den Online Modus.

Und zuerst aktiviere ich hier den Antrieb wieder über die Methode M on.

Dann lasse ich den Antrieb vorwärts laufen, indem ich M forward aufrufe.

Und dann rufe ich die Methode M backward auf, wodurch sich die Drehrichtung umkehrt und der Antrieb eben entsprechend schneller läuft.

Wenn ich jetzt die Methode M off ausführe, bleibt der Antrieb stehen, aber die Geschwindigkeit ist hier immer noch auf -4000 gesetzt.

Wenn ich also jetzt wieder M on aufrufe, läuft der Motor weiterhin rückwärts.

Anders ist das, wenn ich jetzt den Antrieb sperre über diesen Schalter.

Dann bleibt der Antrieb stehen und die Geschwindigkeit wird auf Null gesetzt.

Wenn ich also dann den Motor über die Methode M on erneut aktiviere, läuft der erstmal noch nicht.

Dazu muss ich dann also erst wieder eine der Methoden M forward oder M backward ausführen.

So, bis hierhin habt ihr also verstanden, wie ihr einem Funktionsbaustein Methoden hinzufügen könnt, sowohl mit Rückgabe als auch mit Übergabeparametern.

Und wie ihr diese Methoden anwendet, um das Verhalten des Funktionsbausteins zu beeinflussen.

In meinem einfachen Beispiel beschränkt sich diese Einflussnahme nur auf das Schreiben der Ausgangsvariablen.

Aber prinzipiell könnt ihr die Werte sämtlicher Variablen des FBs verändern, worauf ich gleich auch noch mal eingehen werde.

Die Methoden, die ich erstellt habe, waren ja alle ohne explizite Angabe eines Zugriffsmodifizierers, was eben Public entspricht.

Aber wie ihr ja gerade schon gesehen habt, gibt es auch die Möglichkeit, Methoden als Private zu deklarieren und solche Methoden können eben nicht mehr über den Punkt Operator von außen aufgerufen werden.

Sondern sind sozusagen lediglich für interne Zwecke des FBs bestimmt.

Die können also nur aus dem Anweisungsteil oder aus anderen Methoden des FBs aufgerufen werden.

Und so eine private Methode werde ich jetzt in meinem Beispiel hier noch einbauen.

Und zwar soll diese Methode dafür sorgen, dass die Geschwindigkeit beim Anfahren, vorwärts oder rückwärts, rampenförmig ansteigt.

So dass die Bewegung des Antriebs ohne Ruck ist.

Also lege ich erstmal diese Methode an.

Ich nenne die M ramp, der Rückgabewert ist vom Typ Integer.

Das soll nämlich die Geschwindigkeit sein, die an den Antrieb nachher ausgegeben wird.

Und dann deklariere ich die Methode noch als Private.

So, die Methode ist jetzt also angelegt, aber noch leer.

Und jetzt zeige ich euch erstmal, was es heißt, dass private Methoden nicht von außen aufgerufen werden können.

Und dazu gehe ich in das Main Programm.

Und hier versuche ich jetzt die Methode M ramp aufzurufen.

Wenn ich hier den Punkt Operator anwende, seht ihr schon, dass mir M ramp in diesem Kontextmenü gar nicht angezeigt wird.

Ist also nach außen schon nicht sichtbar.

Jetzt kann ich mich aber darüber hinwegsetzen und einfach die Methode angeben.

Dann wird mir erstmal kein Fehler angezeigt, aber wenn ich dann versuche, das Programm zu kompilieren, seht ihr hier unten in der Fehlerliste, dass auf die private Methode M ramp nicht zugegriffen werden kann.

So, bevor ich jetzt aber in die Programmierung der Methode M ramp springe, will ich einmal kurz erklären.

Wie diese Vorgabe eines rampenförmigen Geschwindigkeitsverlaufs realisiert werden kann.

Ich werde dazu gleich eine Einschaltverzögerung einsetzen, also einen Tonbaustein.

Wenn an dem In Eingang eine steigende Flanke anliegt, dann läuft der Timer hoch, bis ja die Zeit erreicht ist.

Die an PT Eingang angegeben ist.

Dieser Ausgang ET hier hat dann ja schon die Charakteristik des Verlaufs, den die Geschwindigkeit haben soll.

Allerdings muss ich jetzt noch die Amplitude anpassen.

Und dazu teile ich den Ausgang ET durch die Dauer der Einschaltverzögerung.

Und multipliziere das Ergebnis dann wieder mit dem Zielwert der Geschwindigkeit.

Und in der Implementierung der Methode sieht das dann so aus.

Die Dauer für den Anstieg der Geschwindigkeit bis zum Zielwert ist hier T ramp und der Zielwert steht in der Variablen N vel inp.

Bei der Berechnung muss ich nur darauf achten, die Zeiten des Timerbausteins in den Datentyp Real zu konvertieren und das Ergebnis nachher wieder in ein Int zu wandeln.

Und das Ergebnis dieser Berechnung wird dann zurückgegeben.

Hier seht ihr, dass ich den Timer und die neuen Variablen in dem Funktionsbaustein deklariert habe.

Und dann Timer und M ramp im Anweisungsteil des FBs aufrufe.

Das ist ein bisschen Erklärungsbedürftig, weil ihr euch vielleicht auch fragt.

Warum ich den Timer nicht direkt in der Methode M ramp deklariere und aufrufe.

Der Grund ist einfach, dass eine Methode genau wie eine Funktion keinen persistenten Speicher hat, also vereinfacht gesagt, eben kein Gedächtnis.

Und würde ich einen Timer in der Methode deklarieren, dann würde bei jedem Aufruf dieser Methode ein neuer Timer angelegt werden und nach Abarbeitung wird der Timer wieder gelöscht.

Daten, die also über mehr als ein SPS Zyklus gespeichert werden müssen.

Müssen also zwangsläufig in Variablen des FBs abgelegt werden, so wie z.B. dieser Timer.

So, jetzt muss ich noch erklären, wie die Rampe denn tatsächlich zustande kommt, wenn ja der In Eingang des Timers hier immer auf True gesetzt ist.

Und dazu muss ich die Methoden M forward, M backward und M on noch ein bisschen verändern.

Hier ist noch mal die Methode M forward vor der Einbindung der Rampe.

Und diese Methode soll jetzt nicht mehr direkt den Ausgang N vel schreiben, sondern nur den Zielwert N vel inp.

Und in der Methode soll der In Eingang des Timers zurückgesetzt werden.

So, im nächsten Zyklus, nachdem die Methode ausgeführt wurde, wird dann im Anweisungsteil der In Eingang hier wieder erneut auf True gesetzt.

Das heißt, hier kommt dann die steigende Flanke.

Und dadurch wird der Timer gestartet.

Streng genommen startet also die Rampe nicht im Zyklus, indem die Methode M forward aufgerufen wird.

Sondern in dem danach.

So, die gleichen Änderungen mache ich dann auch in M backward.

Und im M on setze ich auch noch einmal den Timer zurück.

Und das Ergebnis seht ihr jetzt wieder hier in der Demo.

Immer wenn ich also eine neue Richtung wähle oder die Methode M on erneut aufrufe, wird also die Zielgeschwindigkeit rampenförmig angefahren.

Okay, ihr habt in diesem Video also gesehen, was Methoden sind.

Nämlich Funktionen, die einem FB zugeordnet sind.

Wie ihr Methoden erstellen und aufrufen könnt.

Und was die Modifizierer Private und Public bewirken.

Mit Methoden könnt ihr also den Code eines FBs klarer strukturieren.

Und Komplexität hinter Methodenaufrufen verstecken.