Die Welt der Automatisierung ist faszinierend und dynamisch. Im Herzen vieler moderner Maschinen und Anlagen schlägt ein kleines, aber mächtiges Gerät: die Speicherprogrammierbare Steuerung, kurz SPS (oder PLC im Englischen). Wenn du den Wunsch hast, zu verstehen, wie Fabriken laufen, Maschinen Befehle ausführen oder komplexe Prozesse automatisiert werden, dann bist du hier genau richtig. Dieser Artikel ist dein umfassender Guide für den Einstieg in die SPS-Programmierung, speziell mit einem Klassiker unter den Entwicklungsumgebungen: CoDeSys V2.3.
Warum CoDeSys V2.3, fragst du dich vielleicht? Obwohl es neuere Versionen gibt, ist V2.3 eine exzellente Wahl für Anfänger. Sie ist weit verbreitet, einfach zu installieren und bietet alle grundlegenden Funktionen, um die Konzepte der SPS-Programmierung nach dem internationalen Standard IEC 61131-3 zu erlernen. Viele ältere, aber immer noch in Betrieb befindliche Anlagen laufen mit dieser Version, und die hier erworbenen Kenntnisse sind eine solide Basis für den Umstieg auf neuere CoDeSys-Versionen (wie V3) oder andere SPS-Plattformen.
Grundlagen der SPS-Programmierung: Was ist eine SPS und warum CoDeSys V2.3?
Eine SPS ist im Wesentlichen ein Industriecomputer, der für die Automatisierung von Prozessen konzipiert wurde. Sie überwacht Eingänge (z.B. Sensoren, Taster) und steuert Ausgänge (z.B. Motoren, Ventile, Lampen) basierend auf einem gespeicherten Programm. Im Gegensatz zu einem normalen PC sind SPSen robust, zuverlässig und für den Dauerbetrieb in rauen Industrieumgebungen ausgelegt. Ihre Kernaufgabe ist es, logische Verknüpfungen und Abläufe extrem schnell und zyklisch abzuarbeiten.
CoDeSys (Controller Development System) ist nicht selbst eine SPS, sondern eine unabhängige, herstellerübergreifende Softwareumgebung zur Programmierung von SPSen. Das bedeutet, dass du mit CoDeSys V2.3 Programme schreiben kannst, die auf Hunderten von verschiedenen SPS-Hardware-Plattformen laufen, die CoDeSys als Laufzeitsystem nutzen. Diese Offenheit macht CoDeSys zu einem idealen Werkzeug für den Einstieg, da du nicht an einen spezifischen Hardware-Hersteller gebunden bist und die Grundlagen der Programmierung erlernen kannst, bevor du in teure Hardware investieren musst. Die integrierte SoftSPS in CoDeSys V2.3 ermöglicht es dir sogar, deine Programme direkt auf deinem PC zu simulieren und zu testen.
Dein erster Schritt mit CoDeSys V2.3: Die Installation und Benutzeroberfläche
Die Installation von CoDeSys V2.3 ist meist unkompliziert. Oftmals findest du die Installationsdateien als kostenlosen Download auf den Webseiten von SPS-Herstellern, die CoDeSys nutzen, oder direkt bei 3S Smart Software Solutions, dem Entwickler von CoDeSys. Achte darauf, dass du die Version mit der SoftSPS-Funktionalität herunterlädst.
Nach der Installation und dem Start der Software wirst du mit der Benutzeroberfläche vertraut gemacht. Sie mag auf den ersten Blick etwas altmodisch wirken, ist aber funktional und logisch aufgebaut:
- Projekt-Explorer: Auf der linken Seite findest du den Projekt-Explorer. Hier werden alle Elemente deines SPS-Projekts hierarchisch angezeigt: Programme, Funktionsbausteine, Funktionen, globale Variablenlisten, Task-Konfiguration und die Hardware-Konfiguration.
- Editorbereich: Der größte Teil des Fensters ist der Editor. Hier schreibst du deinen Code in der gewählten Programmiersprache.
- Deklarationsteil: Oberhalb des Editors befindet sich der Deklarationsteil, in dem du Variablen für deinen Code definierst.
- Meldungsfenster/Statusleiste: Am unteren Rand siehst du Meldungen über Fehler, Warnungen oder den aktuellen Kompilierungsstatus.
Um dein erstes Projekt zu starten, wähle im Menü „Datei” -> „Neues Projekt”. Wähle dann den Gerätetyp „Standard (SPS Win)” oder „Standard (SPS Win V3)” aus – dies aktiviert die SoftSPS, mit der du deine Programme direkt auf deinem PC simulieren kannst, ohne physische Hardware zu benötigen. Das ist perfekt zum Üben und Testen!
Die Sprachen der Automatisierung: IEC 61131-3 verstehen
Der Standard IEC 61131-3 definiert fünf Programmiersprachen für SPSen, die alle in CoDeSys V2.3 verfügbar sind. Jede Sprache hat ihre Stärken für unterschiedliche Aufgaben:
- Kontaktplan (KOP) / Ladder Diagram (LD): Grafische Darstellung, die an elektrische Schaltpläne erinnert. Ideal für einfache logische Verknüpfungen und Einsteiger.
- Funktionsbausteinsprache (FUP) / Function Block Diagram (FBD): Ebenfalls grafisch, aber mit Fokus auf Funktionsblöcke (z.B. Timer, Zähler) und deren Verknüpfung.
- Anweisungsliste (AWL) / Instruction List (IL): Textbasierte, maschinennahe Sprache, die an Assembler erinnert. Sehr effizient, aber schwer zu lesen für komplexe Aufgaben.
- Strukturierter Text (ST) / Structured Text (ST): Eine textbasierte Hochsprache, die modernen Programmiersprachen wie Pascal oder C ähnelt. Ideal für komplexe Berechnungen, Schleifen und bedingte Anweisungen.
- Ablaufsprache (AS) / Sequential Function Chart (SFC): Grafische Sprache für die Darstellung von Prozessabläufen mit Schritten, Transitionen und Aktionen.
Für den Einstieg konzentrieren wir uns auf die populärsten und zugänglichsten Sprachen: KOP und ST.
Kontaktplan (KOP) – Logik wie ein Stromkreis
KOP ist ideal, um grundlegende logische Verknüpfungen zu verstehen. Stell dir eine Leiter vor, deren Sprossen logische Operationen darstellen. Links ist die „Stromschiene”, von der der „Strom” (die Logik) fließt, wenn bestimmte Bedingungen erfüllt sind. Rechts sind die Ausgänge, die geschaltet werden.
Beispiel in KOP: Lichtschalter steuern
|-----| |-----| |------| | E_Taster_1|-----| E_Taster_2|-----| A_Lampe_1 | |-----| |-----| |------| ^UND^
Hier: Wenn E_Taster_1 UND E_Taster_2 gedrückt sind, wird A_Lampe_1 eingeschaltet.
|-----| |-----| | E_Taster_3|-----| A_Lampe_2 | |-----| |-----| | |-----| | E_Taster_4|-----| |-----| ^ODER^
Hier: Wenn E_Taster_3 ODER E_Taster_4 gedrückt sind, wird A_Lampe_2 eingeschaltet.
Strukturierter Text (ST) – Die Sprache für komplexe Aufgaben
ST ist leistungsstark und flexibel, ähnlich wie andere Hochsprachen. Es ist die bevorzugte Wahl für komplexe Berechnungen, Datenverarbeitung und wenn du bedingte Anweisungen (IF-THEN-ELSE) oder Schleifen (FOR, WHILE) benötigst.
Beispiel in ST: Temperaturüberwachung
IF Temperatur > 25.0 THEN
Heizung_An := FALSE;
Kuehlung_An := TRUE;
ELSIF Temperatur < 20.0 THEN
Heizung_An := TRUE;
Kuehlung_An := FALSE;
ELSE
Heizung_An := FALSE;
Kuehlung_An := FALSE;
END_IF;
Sollwert_Erreicht := ABS(Aktueller_Wert - Zielwert) < Toleranz;
Dieses Beispiel zeigt, wie du mit IF/ELSIF/ELSE logische Bedingungen prüfen und Zuweisungen vornehmen kannst. Die zweite Zeile ist eine mathematische Berechnung und Zuweisung.
Variablen und Datentypen: Die Bausteine deiner Logik
In der SPS-Programmierung sind Variablen essenziell, um Werte zu speichern und zu verarbeiten. Jede Variable muss einen bestimmten Datentyp haben, der festlegt, welche Art von Daten sie speichern kann (z.B. eine Zahl, einen Wahrheitswert oder eine Zeit). Die Deklaration erfolgt im Deklarationsteil deines Programms oder global für das gesamte Projekt.
Wichtige Datentypen:
- BOOL: Boolean (Wahrheitswert) – kann nur TRUE (wahr) oder FALSE (falsch) sein. Ideal für Schalter, Sensoren, Ausgänge.
- INT: Integer (Ganzzahl) – Zahlen ohne Dezimalstellen (z.B. -32768 bis 32767). Für Zählwerte, Stückzahlen.
- REAL: Real (Gleitkommazahl) – Zahlen mit Dezimalstellen (z.B. 3.14). Für Temperaturen, Druckwerte, Berechnungen.
- WORD / DWORD: Word / Double Word – Sammlungen von Bits, die oft für Bitmuster oder spezielle Register verwendet werden.
- TIME: Zeitdauer (z.B. T#5S für 5 Sekunden).
- DATE / TOD / DT: Datum, Tageszeit, Datum und Zeit.
Deklaration in CoDeSys V2.3:
VAR
Eingang_Sensor_1 : BOOL;
Ausgang_Motor_1 : BOOL;
Anzahl_Teile : INT;
Temperatur_Istwert : REAL;
Timer_Verzoegerung : TIME := T#10S; (* Initialwert 10 Sekunden *)
END_VAR
Variablen können lokal (nur innerhalb eines bestimmten Programms, Funktionsbausteins oder einer Funktion gültig) oder global (im gesamten Projekt zugänglich) sein. Globale Variablen werden in einer Globalen Variablenliste (GVL) deklariert, lokale direkt im jeweiligen POU.
Unverzichtbare Funktionen: Timer und Zähler
Timer und Zähler sind grundlegende Bausteine in der SPS-Programmierung, um zeitbasierte oder zählbasierte Abläufe zu steuern. CoDeSys V2.3 bietet standardisierte Funktionsbausteine für diese Zwecke.
Timer:
- TON (Timer ON Delay): Einschaltverzögerung. Der Ausgang (Q) wird TRUE, nachdem die Eingangsbedingung (IN) für die voreingestellte Zeit (PT) TRUE war.
- TOFF (Timer OFF Delay): Ausschaltverzögerung. Der Ausgang (Q) bleibt TRUE für die voreingestellte Zeit (PT), nachdem die Eingangsbedingung (IN) FALSE geworden ist.
- TP (Timer Pulse): Impulsgeber. Der Ausgang (Q) wird für die voreingestellte Zeit (PT) TRUE, sobald die Eingangsbedingung (IN) von FALSE auf TRUE wechselt, unabhängig davon, wie lange IN TRUE bleibt.
Beispiel TON in KOP: Lampe nach 5 Sekunden einschalten
+--------------------+
E_Taster_Start --| EN |
| TON |
| IN |
| PT := T#5S |
| | A_Lampe_Verzoegert
| Q |-----
| ET |
+--------------------+
Zähler:
- CTU (Counter Up): Aufwärtszähler. Zählt bei jedem TRUE-Impuls am Eingang (CU) hoch. Der Ausgang (Q) wird TRUE, wenn der Zählwert (CV) den voreingestellten Wert (PV) erreicht. R (Reset) setzt den Zähler zurück.
- CTD (Counter Down): Abwärtszähler. Zählt bei jedem TRUE-Impuls am Eingang (CD) herunter. Der Ausgang (Q) wird TRUE, wenn der Zählwert (CV) den Wert Null erreicht. LD (Load) lädt den PV-Wert in CV.
- CTUD (Counter Up/Down): Auf-/Abwärtszähler. Kombiniert die Funktionen von CTU und CTD.
Beispiel CTU in ST: Stückzähler
VAR
MeinZaehler : CTU;
E_Lichtschranke : BOOL;
S_ResetZaehler : BOOL;
AnzahlTeile : INT;
END_VAR
MeinZaehler(CU := E_Lichtschranke, PV := 10, R := S_ResetZaehler);
AnzahlTeile := MeinZaehler.CV; (* Aktuellen Zählwert auslesen *)
IF MeinZaehler.Q THEN
(* 10 Teile erreicht, Aktion ausführen *)
Maschine_Stopp := TRUE;
END_IF;
Simulation und Debugging: Dein Weg zur fehlerfreien Steuerung
Das Schreiben von Code ist nur die halbe Miete. Fehler sind unvermeidlich, aber das Beherrschen von Simulation und Debugging macht dich zu einem effektiven Programmierer. CoDeSys V2.3 bietet hervorragende Tools dafür.
Der wichtigste Schritt ist die Aktivierung der SoftSPS (SPS Win oder SPS Win V3). Gehe dazu in CoDeSys auf „Online” -> „Login”. Wenn du ein neues Projekt mit der SoftSPS-Option erstellt hast, wird dein Programm kompiliert und auf die virtuelle Steuerung geladen. Die SoftSPS emuliert das Verhalten einer realen SPS auf deinem PC.
Im Online-Modus (nach dem Login) siehst du den aktuellen Status deiner Variablen und Programmbausteine. Dies ist entscheidend für die Fehlersuche:
- Variablen beobachten: Im Deklarationsteil oder in speziellen Beobachtungsfenstern (z.B. „Variablen”) kannst du die aktuellen Werte deiner Variablen in Echtzeit sehen. Dies hilft dir, zu überprüfen, ob deine Eingänge korrekt gelesen und deine Logik die erwarteten Zwischenergebnisse liefert.
- Forcen/Setzen von Variablen: Du kannst Variablen manuell auf TRUE/FALSE oder bestimmte Werte setzen, um bestimmte Zustände zu simulieren oder zu erzwingen (z.B. einen Sensor-Eingang für Testzwecke zu simulieren). Aber Vorsicht: Forcen sollte sparsam und nur zu Testzwecken eingesetzt werden, da es in der realen Anlage unerwünschte Zustände hervorrufen kann.
- Schrittbetrieb (Single Cycle): CoDeSys erlaubt es dir, das Programm Schritt für Schritt oder Zyklus für Zyklus auszuführen, um zu sehen, wie sich Werte ändern und welche Pfade der Code nimmt.
- Breakpoint: Setze Haltepunkte im Code, um die Ausführung an einer bestimmten Stelle anzuhalten und den Zustand der Variablen zu analysieren.
Tipps für das Debugging:
1. Systematisches Vorgehen: Beginne bei den Eingängen. Kommen die Signale wie erwartet an? Arbeite dich dann durch die Logik bis zu den Ausgängen vor.
2. Kleine Schritte: Teste Teilfunktionen deines Programms einzeln, bevor du sie zu einem großen Ganzen zusammenfügst.
3. Kommentare nutzen: Gute Kommentare im Code helfen enorm beim Verständnis, auch nach längerer Zeit.
Struktur und Stil: So schreibst du wartbaren SPS-Code
Guter Code ist nicht nur funktionsfähig, sondern auch lesbar, wartbar und erweiterbar. Dies ist besonders wichtig in der Industrie, wo Programme oft über Jahre hinweg von verschiedenen Personen gepflegt werden.
Modulare Programmierung mit POUs (Program Organization Units):
- Programme (PRG): Sind die Hauptbausteine, die zyklisch abgearbeitet werden. Ein Projekt kann mehrere Programme enthalten, die in der Task-Konfiguration aufgerufen werden.
- Funktionsbausteine (FB): Sind Code-Einheiten mit eigenem Speicher, die Instanzen bilden können (d.h., du kannst sie mehrfach verwenden und jede Instanz hat ihre eigenen Daten). Timer und Zähler sind typische Beispiele für FBs. Ideal für wiederverwendbare Logikblöcke mit internem Zustand.
- Funktionen (FUN): Sind Code-Einheiten ohne eigenen Speicher. Sie erhalten Eingabewerte, führen Berechnungen durch und geben ein Ergebnis zurück. Sie sind ideal für mathematische Operationen oder einfache logische Abfragen, die keinen internen Zustand benötigen.
Gute Programmierpraxis:
- Kommentierung: Erkläre, was dein Code tut und warum. Komplexe Logik, besondere Bedingungen oder Annahmen sollten unbedingt kommentiert werden.
- Benennungskonventionen: Verwende aussagekräftige Namen für Variablen und Bausteine (z.B.
E_NotAusstattE1,Motor_StartstattM_St). Einheitliche Präfixe (z.B.E_für Eingang,A_für Ausgang,V_für Variable) verbessern die Lesbarkeit. - Lesbare Formatierung: Nutze Einrückungen und Leerzeilen, um deinen Code übersichtlich zu gestalten, besonders in ST. In KOP/FUP achte auf klare Linienführung.
- Vermeide unnötige Komplexität: Versuche, die einfachste Lösung für ein Problem zu finden. Komplexer Code ist fehleranfälliger und schwerer zu debuggen.
Typische Stolpersteine und Profi-Tipps für Einsteiger
Jeder Anfänger macht Fehler – das ist Teil des Lernprozesses. Hier sind einige häufige Stolpersteine und Tipps, wie du sie vermeidest:
- Variablen nicht deklariert oder falsch deklariert: CoDeSys wird dies mit Kompilierungsfehlern melden. Prüfe immer den Deklarationsteil. Achte auf korrekte Datentypen (z.B. keine REAL-Werte einer INT-Variablen zuweisen ohne Konvertierung).
- Logikfehler: Das Programm tut nicht das, was du erwartest. Hier hilft der Online-Modus und systematisches Debugging. Geh Schritt für Schritt durch deine Logik und prüfe die Werte.
- Timing-Probleme: SPSen arbeiten zyklisch. Manchmal sind Aktionen zu schnell oder zu langsam. Timer sind dein Freund, um Abläufe zu verzögern oder Impulse zu erzeugen.
- Nicht berücksichtigte Randbedingungen: Was passiert, wenn ein Sensor ausfällt? Was, wenn der Not-Aus gedrückt wird? Gute Programme berücksichtigen auch unerwartete Zustände.
- Übersehen des SoftSPS-Status: Achte darauf, dass deine SoftSPS im Run-Modus ist und nicht im Stop-Modus, sonst wird dein Programm nicht ausgeführt.
- CoDeSys Hilfe: Die integrierte Hilfe in CoDeSys V2.3 ist umfassend. Nutze sie, um Funktionsbausteine, Syntax und Konzepte nachzuschlagen.
Der Blick nach vorn: Was kommt nach CoDeSys V2.3?
CoDeSys V2.3 ist eine hervorragende Basis, aber die Welt der Automatisierung entwickelt sich ständig weiter. Wenn du dich mit V2.3 sicher fühlst, gibt es viele Wege, dein Wissen zu vertiefen:
- Physische Hardware: Der nächste logische Schritt ist der Kauf einer kleinen Trainings-SPS, die mit CoDeSys V2.3 kompatibel ist (z.B. von WAGO, Beckhoff, Eaton oder anderen Herstellern). So lernst du, wie du deine Programme auf echte Hardware lädst und mit realen Ein- und Ausgängen interagierst.
- Visualisierung: Viele CoDeSys-basierte SPSen bieten integrierte Web-Visualisierungen (WebVisu) oder Target-Visualisierungen, mit denen du grafische Benutzeroberflächen für deine Steuerung erstellen kannst.
- Feldbusse und Kommunikation: Lerne über industrielle Kommunikationsprotokolle wie Modbus TCP/RTU, Profibus, EtherCAT oder PROFINET, um deine SPS mit anderen Geräten (z.B. Antrieben, HMI-Panels) zu vernetzen.
- CoDeSys V3: Die aktuelle Generation von CoDeSys (oft als CoDeSys V3 oder CoDeSys Development System bezeichnet) bietet eine modernere Benutzeroberfläche, objektorientierte Erweiterungen und verbesserte Debugging-Tools. Die grundlegenden IEC 61131-3 Konzepte bleiben jedoch gleich, sodass dein Wissen aus V2.3 direkt übertragbar ist.
Fazit: Dein Start in die Welt der SPS-Programmierung
Die SPS-Programmierung ist eine unglaublich lohnende Fähigkeit, die dir Türen zu spannenden Karrieren in der Automatisierungstechnik, im Maschinenbau und in der Prozesssteuerung öffnet. Mit CoDeSys V2.3 hast du ein robustes und zugängliches Werkzeug an der Hand, um die Grundlagen dieser komplexen Materie zu meistern.
Sei geduldig mit dir selbst, experimentiere viel mit der SoftSPS, nutze die Beispiele und die Online-Hilfe. Jeder Fehler ist eine Lernchance. Bald wirst du in der Lage sein, deine eigenen Steuerungslogiken zu entwerfen und deine „Maschinen” zum Leben zu erwecken. Viel Erfolg auf deiner Reise in die faszinierende Welt der Automatisierung!