Structured Text (ST) ist die wichtigste textuelle Programmiersprache für Speicherprogrammierbare Steuerungen (SPS). Sie wurde von der Norm IEC 61131-3 definiert und erinnert stark an Pascal: Statt Strompfade zu zeichnen, schreibt der Programmierer Zuweisungen, Bedingungen und Schleifen. Seit der Ausgabe 4 des Standards (2025) ist ST die einzige rein textuelle SPS-Sprache — die frühere Instruction List (IL) wurde bereits in der Ausgabe 3 von 2013 als veraltet markiert.

Zuweisungen und Operatoren

A := B;                  (* Zuweisung *)
C := A AND B;             (* boolesches UND *)
D := NOT E;               (* Negation *)
F := X + Y * 2;           (* Arithmetik *)
G := (X > 5) AND (Y <= 10); (* Vergleich *)

Verfügbar sind die logischen Operatoren AND, OR, XOR, NOT, die Vergleichsoperatoren =, <>, <, >, <=, >= sowie die arithmetischen +, -, *, / und MOD.

Kontrollstrukturen

IF start THEN
    lampe := TRUE;
ELSIF notrue THEN
    lampe := FALSE;
ELSE
    lampe := merker;
END_IF;

CASE zustand OF
    0: ausgang := 1;
    1: ausgang := 2;
ELSE
    ausgang := 0;
END_CASE;

FOR i := 1 TO 10 DO
    summe := summe + werte[i];
END_FOR;

WHILE notrue DO
    warte := warte + 1;
END_WHILE;

Funktionsbausteine aufrufen

ton_inst(IN := start, PT := T#5s);  (* Einschaltverzögerung 5 s *)
fertig := ton_inst.Q;

Zeiten werden mit T# geschrieben (T#5s, T#100ms), Datentypen sind BOOL, INT, REAL, STRING und viele mehr. Kommentare stehen in (* ... *).

Praxis

ST eignet sich besonders für komplexe Logik, Analogwert-Berechnung, Regelungsalgorithmen und Datenverarbeitung — genau die Aufgaben, bei denen Kontaktplan und Funktionsbaustein-Diagramm an Grenzen stoßen. Umsetzungen von ST heißen bei Siemens SCL, bei Beckhoff (TwinCAT) und im CODESYS-Umfeld direkt Structured Text. Die Syntax ähnelt Pascal/Delphi, weshalb sich klassische Programmierer schnell zurechtfinden.

Function Block Diagram (FBD), auf Deutsch Funktionsbaustein-Diagramm, ist neben dem Kontaktplan (Ladder) die zweite grafische Programmiersprache der SPS-Norm IEC 61131-3. Statt Kontakten und Spulen verdrahtet man hier fertige Logik-Bausteine: Jeder Baustein hat Ein- und Ausgänge, die durch Verbindungslinien miteinander verknüpft werden — das Ergebnis ähnelt einem Signalflussplan.

Logik-Bausteine

Die grundlegenden Bausteine sind die booleschen Verknüpfungen:

Eingang A ----|  AND  |---- Ausgang
Eingang B ----|       |
Eingang C ----|  OR   |---- Ausgang
Eingang D ----|       |
Eingang E ----| NOT   |---- Ausgang

Neben AND, OR, XOR und NOT stellt der Standard vordefinierte Funktionsbausteine bereit: TON (Einschaltverzögerung), TOF (Ausschaltverzögerung), TP (Impuls), CTU/CTD (Zähler), SR/RS (Flipflops) sowie die Flankenerkennung R_TRIG/F_TRIG.

Beispiel: Einschaltverzögerung

start ----| TON  |---- fertig
PT: T#3s  |      |
          |      |---- ET (abgelaufene Zeit)

Der Baustein TON setzt den Ausgang Q erst, wenn der Eingang IN länger als die Zeit PT (hier 3 Sekunden) TRUE war. Die Ausgabe ET zeigt die bereits verstrichene Zeit.

Praxis

FBD eignet sich besonders für analoge Signalverarbeitung, Regelkreise und alles, was sich als Datenfluss beschreiben lässt — bei reiner Schützlogik ist dagegen der Kontaktplan oft anschaulicher, bei Rechenaufgaben Structured Text. Typische Werkzeuge sind CODESYS, TwinCAT, Siemens TIA Portal (dort FUP) und B&R Automation Studio. Da die Bausteine wiederverwendbar sind, lassen sich eigene Funktionsbausteine (ET-Bausteine) einmal entwickeln und in vielen Programmen einsetzen.

GW-BASIC ist der BASIC-Interpreter von Microsoft, der zwischen 1983 und 1991 als Bestandteil von MS-DOS (bis Version 4.02) an die ersten IBM-kompatiblen PCs ausgeliefert wurde. Anders als ein Compiler führt der Interpreter Zeile für Zeile aus und erzeugt keine EXE-Datei — klassische GW-BASIC-Programme tragen daher feste Zeilennummern und wimmeln oft von GOTO und GOSUB (der berüchtigte „Spaghetti-Code“). 2020 gab Microsoft den Quellcode als Open Source frei.

Direktmodus und Programmzeilen

GW-BASIC startet mit der Eingabeaufforderung Ok
LIST    zeigt das Programm an
RUN     startet das Programm ab der kleinsten Zeilennummer
NEW     löscht das aktuelle Programm
SAVE "name.bas" / LOAD "name.bas"  speichert bzw. lädt Programme

Klassische BASIC-Befehle

• PRINT und INPUT: Ausgabe auf dem Bildschirm bzw. Eingabe von der Tastatur
• GOTO und GOSUB…RETURN: Sprunganweisungen; GOSUB ruft ein Unterprogramm auf, RETURN kehrt zurück
• FOR…NEXT: Zählschleife mit Schrittweite (STEP)
• IF…THEN…ELSE: bedingte Verzweigung
• DIM: Feldvereinbarung (z.B. DIM A(10,10))
• DEF FN: eigene Funktionen definieren (z.B. DEF FNQ(X)=X*X)
• PEEK und POKE: Speicherzellen direkt lesen bzw. beschreiben
• CLS: Bildschirm löschen, COLOR: Farben setzen

Praxis-Tipps

• Zeilennummern in Zehnerschritten vergeben (10, 20, 30…) — so lassen sich später Korrekturen einschieben.
• RENUM nummeriert das Programm automatisch neu, wenn die Nummern zu eng werden.
• Für Töne und Grafik stehen SOUND, PLAY, SCREEN und DRAW bereit — typische Hobbyprogrammier-Projekte der 80er-Jahre.

Nachfolger von GW-BASIC waren QuickBASIC und Visual Basic; die Zeilennummern-Programmierung prägte auch Batch-Dateien. Das Sprung-Konzept lebt in Fortrans GOTO weiter. Verwandt: Turbo Pascal als strukturierter Nachfolger auf dem PC und Oberon als Wirth-Design.

Turbo Pascal ist die integrierte Entwicklungsumgebung (IDE) von Borland für die Sprache Pascal, erschienen im November 1983 — entwickelt von Anders Hejlsberg, der später Delphi, C# und TypeScript prägte. Die IDE vereinte erstmals Editor, Compiler und (ab Version 4) Debugger in einem einzigen Werkzeug und wurde damit in den 80er-Jahren zum De-facto-Standard der Softwareentwicklung auf dem PC. Der Compiler erzeugt echte EXE-Dateien und war mit ca. 49,95 US-Dollar konkurrenzlos günstig.

Programmgerüst

program Hallo;
uses Crt;
begin
  ClrScr;
  WriteLn('Hallo, Welt!');
end.

Wichtige Befehle und Sprachmittel

• program / uses / begin…end: Grundgerüst, Einbindung von Units, Blockstruktur
• Write, WriteLn, Read, ReadLn: formatierte Ausgabe und Eingabe
• if…then…else, case: Verzweigungen
• for, while, repeat…until: Schleifen
• const, type, var: Deklarationen; Records für strukturierte Daten
• procedure / function: Unterprogramme mit strikter Typisierung
• Unit: Modultechnik mit Interface/Implementation-Trennung

Praxis-Tipps

• Die Crt-Unit liefert ClrScr, GotoXY, ReadKey und TextColor — Standard für Konsolenprogramme.
• Turbo Pascal 7.0 (1992) war die letzte DOS-Version; mit 6.0 kamen Objekte (Object Pascal), mit Delphi (1995) die visuelle RAD-Umgebung.
• Der Compiler ist extrem schnell: ganze Projekte übersetzt er in Sekunden — damals eine Sensation.

Turbo Pascal setzt die Sprache Pascal/Delphi fort und beeinflusste Oberons Modulkonzept. Der strukturierte Ansatz grenzt sich bewusst vom Sprungstil des GW-BASIC ab.