Introduction to Structured Text Programming

Structured Text is one of the five programming languages defined in the IEC 61131-3 standard for PLC programming. Its text-based nature makes it well-suited for implementing complex logic, mathematical calculations, and data processing tasks that can be cumbersome to represent in graphical languages. ST allows programmers to write concise and readable code, improving maintainability and reusability.

Key advantages of using Structured Text include:

• Readability and Maintainability: Textual code is often easier to read and understand, especially for complex logic.
• Powerful Data Handling: ST provides robust data types and operators for manipulating data efficiently.
• Algorithm Implementation: Ideal for implementing complex algorithms and mathematical functions.
• Reusability: Code can be easily reused in different parts of the program or in other projects.

Basic Syntax and Elements of Structured Text

Understanding the fundamental syntax and elements is crucial for writing effective Structured Text code. Here are the core components:

Variables and Data Types

Variables are used to store data values. In ST, you must declare variables and specify their data types. Common data types include:

• BOOL: Boolean (TRUE or FALSE)
• INT: Integer (16-bit signed)
• DINT: Double Integer (32-bit signed)
• REAL: Floating-point number (32-bit)
• STRING: Text string

Example of variable declarations:

VAR
    MotorSpeed : INT;
    IsRunning : BOOL;
    Temperature : REAL;
    ErrorMessage : STRING;
END_VAR

Operators

Operators are symbols that perform specific operations on variables and values. ST supports various types of operators:

• Arithmetic Operators: +, -, *, /, MOD (modulo), ** (exponentiation)
• Relational Operators: =, <>, <, >, <=, >=
• Logical Operators: AND, OR, NOT, XOR
• Bitwise Operators: AND, OR, NOT, XOR

Statements

Statements are instructions that perform actions. They are the building blocks of ST programs. Examples include assignment statements, conditional statements, and loop statements.

Comments

Comments are used to explain the code and are ignored by the compiler. In ST, comments are enclosed in (* *) or start with //.

(* This is a multi-line comment *)
// This is a single-line comment

Control Structures in Structured Text

Control structures allow you to control the flow of execution in your ST programs. Key control structures include:

IF Statements

IF statements execute a block of code based on a condition.

IF Temperature > 50 THEN
    IsOverheated := TRUE;
ELSE
    IsOverheated := FALSE;
END_IF

CASE Statements

CASE statements execute different blocks of code based on the value of a variable.

CASE MotorState OF
    0:  (* Motor is stopped *)
        MotorSpeed := 0;
    1:  (* Motor is running at low speed *)
        MotorSpeed := 500;
    2:  (* Motor is running at high speed *)
        MotorSpeed := 1000;
ELSE
    (* Invalid state *)
    ErrorMessage := 'Invalid Motor State';
END_CASE

FOR Loops

FOR loops execute a block of code a specified number of times.

FOR i := 1 TO 10 DO
    Result := Result + i;
END_FOR

WHILE Loops

WHILE loops execute a block of code as long as a condition is true.

WHILE Temperature < 100 DO
    HeatInput := TRUE;
END_WHILE
HeatInput := FALSE;

REPEAT Loops

REPEAT loops execute a block of code until a condition becomes true.

REPEAT
    Counter := Counter + 1;
UNTIL Counter >= 10
END_REPEAT

Functions and Function Blocks in Structured Text

Functions and function blocks are reusable code modules that encapsulate specific logic. They promote modularity and code reuse.

Functions

Functions are self-contained code blocks that perform a specific task and return a value. They do not maintain state between calls.

FUNCTION CalculateArea : REAL
    VAR_INPUT
        Length : REAL;
        Width : REAL;
    END_VAR
    CalculateArea := Length * Width;
END_FUNCTION

Function Blocks

Function blocks are similar to functions but can maintain state between calls. They have input variables, output variables, and internal variables.

FUNCTION_BLOCK MotorController
    VAR_INPUT
        Start : BOOL;
        Stop : BOOL;
    END_VAR
    VAR_OUTPUT
        Running : BOOL;
    END_VAR
    VAR
        InternalState : INT;
    END_VAR

    IF Start AND NOT Running THEN
        InternalState := 1;
        Running := TRUE;
    ELSIF Stop AND Running THEN
        InternalState := 0;
        Running := FALSE;
    END_IF
END_FUNCTION_BLOCK

Here's an SVG chart illustrating the difference between Functions and Function Blocks:

Advanced Topics in Structured Text

Beyond the basics, Structured Text offers advanced features for complex applications:

Arrays

Arrays are collections of elements of the same data type.

VAR
    Temperatures : ARRAY[1..10] OF REAL;
END_VAR

Structures

Structures are user-defined data types that group related variables.

TYPE
    MotorData :
        STRUCT
            Speed : INT;
            Current : REAL;
            Status : BOOL;
        END_STRUCT
END_TYPE

VAR
    MyMotor : MotorData;
END_VAR

Pointers

Pointers are variables that store the memory address of another variable.

VAR
    MyInt : INT := 10;
    MyPointer : POINTER TO INT;
END_VAR

MyPointer := ADR(MyInt);  (* Get the address of MyInt *)
MyInt := MyPointer^ * 2; (* Dereference the pointer and multiply by 2 *)

The following SVG chart illustrates the usage of arrays in Structured Text: