Section 8 Structured Text (ST)

General description of structured text

Structured text is a text-oriented program language of IEC 61131-3. Program processing is determined by statements All functions and function blocks in Control Builder F can also be called up in ST programs. The scope of the functions is partly covered by the ST operators. Function blocks can be used after declaration in the ST program. They are parameterized in the same way as in the ladder diagram or in the function block diagram. Unlike the function block diagram (FBD), the functional scope of the structured text is extended by conditional statements and loop statements that are called up by corresponding keywords. The processing sequence is obtained by the arrangement of the statements in the ST editor (left to right and top to bottom). The sequence can only be deliberately altered by inserting loop statements. There is no limit to the working range of an ST program. After loading the programs and if there is a connection to the process stations, the ST editor can be called up in commissioning mode. The current values in the ST program can be displayed. See also Engineering manual, System configuration, Commissioning.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

247

Creating an ST program

Section 8 Structured Text (ST)

Creating an ST program
ST programs are created in the Project tree. Project tree > Select the target position in the project tree > Edit > Insert above, Insert below or Insert next level > ST program from "Object selection" > Specify a program name, with a short comment if necessary Every new ST program has a program body: PROGRAM Program name END_PROGRAM. The program comment is empty. The creation date is entered as the version number. The editing state is implausible. The program name is already preset as the name in the program list (PL). The short comment in the program list is adopted and can be modified.

Calling the program

A program is selected. Project tree > Edit > Program or double-click on Program The program is displayed with its contents and can be altered.

248

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

ST program editor interface

ST program editor interface

Structure of the configuration interface

The configuration interface of an ST program consists of:Menu barfor calling processing functionalities. Text area The application is programmed in the ST editor text area. The cursor can be positioned anywhere in the text area. The tabulator width is adjustable. The text area for an ST program is unlimited. There is a mark column on the left of the text field. Displays the current program state.

State line

Menu bar

Text area

State line
to001us.bmp

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

249

ST program editor interface

Section 8 Structured Text (ST)

Syntax colouring

All input in the ST editor is text-oriented. Certain important words in the text are colour-highlighted for emphasis. These are: Comments Keywords Keywords not supported (acc. to IEC 61131-3)1 Numeric constants Numeric constants are defined in the program flow. Symbolic constants Symbolic constants are defined in a CONST END_CONST block. Strings Blocks that cannot be edited

All other text is shown in black.

1.

These include data types such as SINT, for example, that are not supported.

250

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

ST program editor interface

Changing the settings

Changing the program colour settings Options > Colours > Select the object for which the colour is to be changed (for example, the colour for symbolic constants) > Choose the desired colour

to002us.bmp

Select colour The colour for the selected object can be chosen. The current colour is marked. Reset all The colours for all objects are reset to the default colours. Reset The colour for the selected object is reset to the default colour.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

251

ST program editor interface

Section 8 Structured Text (ST)

Tabulator width Options > Tabulator width > Enter the desired tabulator width.

to003us.bmp

The program code already created is not changed by the alteration in tabulator width. The new tabulator width is used for all subsequent editing steps.
Display program information

Program version and project assignment Options > Version The program name, date of the latest program change (version) and the assignment of the program to the project, the resource, the task and the program list are displayed. The program assignment can be displayed as long text or short text. The setting for this is in the project tree, under Options.

to004us.bmp

Program state The state line shows the name of the program currently being edited, the editing position and mode and the current user.

252

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Description of the ST program elements

Editing position (4,1) - Shows the current position of the cursor (row and column). Editing mode (INS) - Insert (OVR) - Overwrite

Description of the ST program elements

Language elements
Special symbols and reserved words

Special symbols and words control the flow in an ST program and these must not be used as identifiers in the program. Each special symbol has a particular meaning. ST interprets the following characters as special symbols: +-*/&=<>[].,():;@#$ In addition, combinations of special symbols are used as operators and/or delimiters: := => <> <= >= ** .. (* *) Assignment operators Relational operators Exponentiation operator Subareas Beginning and end of comment

There is no case distinction for reserved words. ST reserves the following words, which are all printed in boldface in this manual: AND ARRAY BY CASE CONST(1) DO ELSE ELSIF FUNCTION_BLOCK(2) IF MOD NOT OF OR PROGRAM REPEAT

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

253

Description of the ST program elements

Section 8 Structured Text (ST)

END_CASE END_CONST(1) END_IF END_FOR END_FUNCTION_BLOCK(2) END_PROGRAM END_REPEAT END_VAR END_WHILE EXIT FALSE FOR

RETURN THEN TO TRUE UNTIL VAR VAR_EXTERNAL VAR_INPUT(2) VAR_OUTPUT(2) WHILE XOR

(1) These keywords are extensions of IEC 61131-3. (2) These keywords are only used in user-defined function blocks.

All standard data types are also treated as keywords. Names of function block inputs and outputs that are identical with keywords start with an underline character to distinguish them from the keywords, e.g.:
pin_dt(_DT => dt1); Identifier

All types, variables, constants, functions, function blocks and arrays are identified by identifiers. Identifiers within an ST program are words with more than one letter (leading numeric characters are allowed) one letter, except E or e the letter E or e at the beginning or end. Examples of identifiers:
123block 123e 123e2 123.0e2 block-e

Valid identifier Valid identifier Syntax error Real number Syntax error

Case is significant in identifiers. Identifiers must not include any special symbols (see Special symbols and reserved words on page 253). Therefore a dash (which

254

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Description of the ST program elements

could also be a minus sign) must not occur in a identifier. There is no limit to the length of identifiers within ST programs. The following identifiers are already defined for standard data types: BOOL BYTE DINT DT DWORD INT REAL STR8 STR16 STR32 STR64 STR128 STR256 TIME UDINT UINT WORD

There is no distinction between upper and lower case in standard data types. Identifiers of global variables must also obey the rules for variable names. See Structure of variable list on page 28. Identifiers for function blocks also follow the rules for tag names. See Structure of Tag List on page 62. Unlike other programming languages such as ladder diagram and function block diagram, tag names consisting only of numeric characters are not allowed in ST programs.
Constant

A constant declaration declares a identifier which stands for a particular value within the ST program. Constants are declared in a block CONST END_CONST. The constant is only valid within the ST program. Constant expressions must not contain any variables or function calls but they can include constants that have already been defined. Example:
CONST max := 100; max2 := max * 2; END_CONST

The value of a constant expression is calculated by code generation. Constants can be used in expression and for defining areas in arrays. Example:
VAR MyArray: ARRAY [0..max-1] OF int; END_VAR The data type of constants is only defined when they are used. The defaults for data types must be observed when entering

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

255

Description of the ST program elements

Section 8 Structured Text (ST)

constants. See Overview of simple data types on page 26. Integer constants are always processed internally as DINT values. If a different data type is needed in the program flow then an explicit type change must be inserted. Example: CONST BITFIELD := 16#c2420000; END_CONST VAR var1 : UINT; var2 : REAL; END_VAR var1 := BITFIELD; (* This statement leads to a plausibility error. *) (* The constant BITFIELD is greater than MAX-DINT. *) var1 := to_di(BITFIELD); (* With the external type change the value of *) (* BITFIELD is limited to MAX-DINT. *) var2 := to_re(to_dw(BITFIELD)); (* Bit field is converted to a REAL value *) Program

An ST program is enclosed between the keywords PROGRAM and END_PROGRAM.

PROGRAM STprg1 ; END_PROGRAM

No executable statements may be written before PROGRAM. All statements after END_PROGRAM will be disregarded. Every ST program needs a program name. The name of the ST program is preset as a program name in the project tree. The program name is a identifier in the ST program. In the ST program the declarations of constants and variables must be entered at the beginning. The program code follows. An empty ST program must contain at least one empty statement.

256

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Types

User-defined function block

User-defined function blocks in structured text are included in the keywords FUNCTION_BLOCK and END_FUNCTION_BLOCK.
FUNCTION_BLOCK UFBprg1 ; END_FUNCTION_BLOCK

No executable statements may be written before FUNCTION_BLOCK. All statements after END_FUNCTION_BLOCK will be disregarded. The name of the userdefined function block is a identifier in the ST program. The interface definition is added into the user-defined function block as a non-editable block. In other respects the programming rules for ST programs apply.
Comment

The purpose of comments is to clarify the program code. They are not taken into account when the code is generated. Comments are enclosed in brackets with a star:
(* This is a comment *)

Comments can be included at any point in an ST program. Nested comments are allowed:
(* Comment (*This is a nested comment *) *)

Nested comments are an extension of IEC 61131-3.

Program line

There is no limit to the length of a program line. A program line may include more than one statement.

Types
Every declaration of a variable must give the type of the variable. The type defines the value range of the variable and determines the operations that can be executed with it. See also Overview of simple data types on page 26.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

257

Types

Section 8 Structured Text (ST)

Simple types

Simple types define ordered quantities of similar values. Integer types Integer values are a partial quantity of the whole numbers. The following integer types can be used in ST programs: INT, UINT, DINT and UDINT. Two integer values can only be linked via a binary operator (i.e. addition, multiplication etc.) if the types are the same. If the types are different, an explicit type conversion must be used, e.g.:
VAR myInt: INT; myDint2, myDint1: DINT; END_VAR myDint2 := TO_DI(myInt) + myDint1;

Bitfield types Bitfield types define bit fields of differing length. Bitfield types BYTE, WORD and DWORD can be used in ST programs. Operations on two bit fields via a binary operator (i.e. bit-by-bit AND, bit-by-bit OR etc.) are only possible if the types are the same. Boolean types Boolean types can only take on the predefined values FALSE or TRUE, Where FALSE = 0 and TRUE = 1. REAL type The real type is a subset of the real numbers. A real value n has three components. Here m*2e = n, where m and e are whole numbers. Strings A string is a fixed-length sequence of characters. The following string types can be used in ST programs: STR8, STR16, STR32, STR64, STR128 and STR256. Strings are stored in ASCII code.

258

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Types

Structured types

A structured type, identified by the type of structure, contains more than one value. All defined structured data types can be used in ST programs. For a definition of structured data types, see Structured data types on page 47. The components of structured types can be accessed with variable name.component name .
Arrays

Arrays have a set number of components of a single type. Simple and structured types are both permissible data types. The validity range of the data type for the array index is defined as DINT (-2 147 483 648 .. +2 147 483 647). The number of elements of each dimension is determined by the data type of the array index. The start and end of the definition of the range must be within the range of validity of the array index. Arrays are defined by the keyword ARRAY, the range and the data type, e.g.
ARRAY [0..100] OF REAL;

If the component type of a array is also a array, it is treated as a multidimensional array. Up to four dimensions can be used for each array declaration, e.g.
ARRAY [0..100, 0..10, -2..2] OF INT;

The components of arrays can be accessed with variable name[Index1, Index2] . The components of structured data type arrays can be accessed with variable name[Index1, Index2].component name . Arrays can only be used within ST programs. It is not possible to exchange arrays between different ST programs. The array index is checked for validity at the time of running in the process station. If the array index is outside the defined range, the task state changes to unrunnable.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

259

Variables and function blocks

Section 8 Structured Text (ST)

Variables and function blocks

Declaration of variables

Variables must be declared before use. The variable declaration states the type of variable. All standard data types and structured data types that have already been defined can be used. The variable name and data type are separated by a colon, e.g.
VAR x, y: INT; END_VAR

ST programs distinguish between local variables and global variables. If a local variable has the same name as a global variable, the local variable takes precedence.
Global variables

Global variables are also valid outside the ST program. All variables defined in the variable list can be used as global variables in ST programs. New variables can also be created in an ST program. After declaration in the ST program, new variables also have to be entered in the variable list, i.e. they must be instantiated. Instantiate on page 285 gives further details. Global variables are declared within the keywords VAR_EXTERNAL END_VAR, e.g.
VAR_EXTERNAL TIC1379_PV: REAL; TIC1379_MODE: INT; TCP_Data_IN01: structTCP12; (* structTCP12 is a structured data type *) END_VAR

It is not possible to assign the data type to a list of global variables. Each global variable must be declared individually. I/O components of hardware objects cannot be declared directly. The hardware object has to be declared as a function block in the ST program.
Local variables

Local variables are only valid within the ST program. The names of local variables only need to be unique within the ST program. The same data type can be assigned

260

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Variables and function blocks

directly to a comma-delimited list of variables. Arrays can only be defined as local variables. Initialization is possible at the variable declaration point. Local variables are declared within the keywords VAR END_VAR, e.g.
VAR x, y, z: INT F1: ARRAY [0..40] OF REAL; TIC1379_OUT: REAL := 10.0; a, b, c: INT := 1; (* a, b and c are initialized at 1 *) END_VAR

When initializing multidimensional arrays the elements of each individual dimension are given in square brackets. A bracketed pair at the same level is separated by a comma. The initialization
VAR F2: ARRAY [-1..1, 10..11] OF INT :=[[1,2],[3,4],[5,6]]; END_VAR

is equivalent to assignment with the following values:

F2[-1, F2[-1, F2[ 0, F2[ 0, F2[ 1, F2[ 1, 10] 11] 10] 11] 10] 11] := := := := := := 1; 2; 3; 4; 5; 6;

Initial values are assigned to the variables when the program is loaded.
System variables

By definition, system variables are known in the ST program. There is no need to declare them explicitly. The ST program uses system variables as variables with a structured data type, e.g.
Date_Time := ps12.DateTime; Inputs and outputs

Inputs and outputs can be defined for user-defined function blocks. They are defined in the interface editor of the user-defined function block and the definition is

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

261

Variables and function blocks

Section 8 Structured Text (ST)

displayed within the keywords VAR_INPUT END_VAR and VAR_OUTPUT END_VAR , e.g.
VAR_INPUT (* declaration of inputs *) IN: REAL; MD: BOOL; END_VAR VAR_INPUT (* declaration of outputs *) IN: REAL; STA: INT; END_VAR

Inputs and outputs can only be edited in the interface editor of the user-defined function block. Keywords must not be used for the names of inputs and outputs. The names of inputs and outputs should not exceed 3 characters. Longer names are permissible. The long name (>3 characters) must be used in the class definition. If instances of this function block are used in ST programs the long name is truncated to the first 3 characters.
Function blocks

Like variables, function blocks must be declared before they are used in an ST program. The names of function blocks must be unique throughout the project, i.e. they may only be called up once in the project. In ST programs all standard function blocks and plausible user-defined function blocks can be used (see also Limits of the system on page 275). Local variables and function blocks can be declared in the same block. All function blocks defined in the tag list can be used in ST programs. New function blocks can also be created directly in an ST program. After declaration in the ST program, new function blocks also have to be entered in the tag list, i.e. they must be instantiated. Instantiate on page 285 gives further details. Function blocks are declared within the keywords VAR END_VAR, e.g.
VAR TI1379: AI_TR; TIC1379: C_CU; TY1379: AO_TR;

262

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Expressions

TI1379_LIN: LIN2; (* LIN2 is a user-defined function block type *) m: INT; END_VAR

It is not possible to assign the function block type to a list of function blocks. Every function block must be declared individually. To access the I/O components of hardware objects, the hardware object must be declared as a function block in the ST program in the section VAR_EXTERNAL END_VAR , e.g.
VAR_EXTERNAL DAI02_1_0_1: DAI02; END_VAR

The components are then accessed, with

h := DAI02_1_0_1.Ch0;

Expressions
Syntax of expressions

An expression is a construct which supplies a value when calculated. Expressions consist of operators and operands. An operand can be a constant, a variable or another expression. Most operators in ST link two operands and are therefore referred to as binary. The remaining operators work with one operand and are therefore referred to as unary. Binary operators use the common algebraic form, as in A + B. A unary operator always immediately precedes its operand, as in -B.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

263

Expressions

Section 8 Structured Text (ST)

Operators

Operators have an order of precedence which governs the sequence of calculation.

Operation brackets function evaluation exponentiation negation complement multiplication division modulo addition subtraction comparison equality inequality Boolean AND Boolean AND Boolean exclusive or Boolean OR Symbol (expression) identifier (argument list) e.g. MAX(x, y), LN(a), etc. ** NOT * / MOD + <, > <=, >= = <> & AND XOR OR lowest Order of precedence highest

Calculation of an expression consists in applying the operators to the operands in the sequence defined by the order of precedence. The following rules apply to the calculation of long expressions: An operand between two operators of different priorities is always associated with the higher-ranking operator.

264

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Expressions

An operand between two operators of the same priority is always associated with the operator to the left of it. Expressions in brackets are considered as a single operand and always evaluated first.

The expressions below give the following results:

a := 1; a * b + a + b * (a + b) a * b + a + b * (a + b) b c c * c c * := 2; c := 3; (* (* c (* * d (* + d (* (c + d) (* d := 4; Result = Result = Result = Result = Result = Result = 5 *) 7 *) 9 *) 14 *) 11 *) 21 *)

Function calls

Functions must be called as elements of expressions that consist of the function name followed by a list of arguments in brackets. All standard functions can be used. It is not possible to define user-specific functions. Examples of function calls:
SQRT(a) SIN(a) MAX(a, b, c)

The function call

ADD(a, b)

has the same value as the expression

a + b

If constants are transferred exclusively to a polymorphic function as the argument, at least one explicit type change is needed, e.g.
CONST CstVal := 12; END_CONST

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

265

Statements

Section 8 Structured Text (ST)

VAR i: INT; END_VAR i := add(to_in(CstVal), 42);

Statements
Statements are all constructs that declare an action that can be carried out by the process station. Statements must end with a semicolon.
Simple statements

Simple statements are assignments.

Variable := Expression ;

Assignments replace the value of a variable with a new value that is given by an expression. This expression can include identifiers of functions that are thereby activated and supply the corresponding values. An assignment must consist of a variable on the left, followed by the assignment operator :=, followed by the expression to be evaluated. The statement
A := B;

replaces the value of the variable A by the value of the variable B. Both variables A and B must be of the same data type. The following are valid assignments:
x := Done m := a := y + z; := (i >= 1) AND (i<100); 3.0 + SIN(n); feld[i, j].content;

The assignment of arrays is not possible. The following assignment leads to a check error:
VAR Arr1 [1..10] OF BOOL; Arr2 [1..10] OF BOOL; END_VAR

266

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Statements

Arr2 := Arr1

Global variables can be accessed directly in statements, or via the process image. As in other program editors, an @ must be placed in front of variable names to access the process image:
A := SQRT(B); @A := SQRT(@B); (* direct access *) (* access via process image *)

Constants in expressions are always calculated internally with the data type DINT. If constants with data type UDINT are appropriate, an explicit type change must be provided, e.g.
VAR L_Int: UDINT; END_VAR L_Int := 10; L_Int := L_Int * TO_UD(256345984);

Unlike other program editors, ST programs no longer require explicit assignment of data types to functions with more than one data type set. The ST editor recognizes the data types needed and automatically assigns the appropriate data type set. An empty statement consists of just a semicolon.
Function block calls

Function blocks are called by an statement consisting of the name of the function block followed by a list of value assignments in brackets.
Tag name (
Input

:= ,

Value

Output

=> ,

Variable

);

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

267

Statements

Section 8 Structured Text (ST)

The sequence of input and output assignments is not significant. When the function block is called, assignments only have to be supplied to and retrieved from the mandatory pins. Inputs are supplied by := and outputs are retrieved by =>, e.g.
VAR LI347_LIN: LIN; END_VAR VAR_EXTERNAL LI347_CH0: REAL; LI347: REAL; END_VAR LI347_LIN (IN:= LI347_CH0, OUT=> LI347);

Each function block may only be used in one assignment in the ST program. Optional function block pins can also be accessed outside the function block assignment with function block name.pin name .
VAR FIC251: C_CU; RATIO, BIAS: REAL; END_VAR VAR_EXTERNAL FIC251_PV: REAL; FIC251_OUT: REAL; TIC251_OUT: REAL; TRD3_ASP: REAL; END_VAR (* supplying inputs *) FIC251.SP := TIC251_OUT * RATIO + BIAS; (* calling the function block *) FIC251(PV:= FIC251_PV, OUT=> FIC251_OUT); (* sending outputs *) TRD3_ASP := FIC251.ASP; Conditional statements

A conditional statement chooses one of its assignments (or a group of them), of which it is made up, on the basis of a specified condition. Conditional statements are IF and CASE.

268

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Statements

IF statement

The IF statement can be shown with the following syntax diagram:

IF Expression THEN Statement

ELSE

Statement

END_IF;

The result of the expression must be of the data type BOOL. If the result is TRUE, the part following THEN is carried out, if it is not, the part following ELSE is carried out. ELSE is optional. If this branch is not available, the IF statement has no effect, i.e. it carries nothing out whatever. A couple of examples:
IF y<>0.0 THEN z := x / y; ELSE z := 3.4e38; END_IF; IF p <> 0 THEN a := SIN(b + c); END_IF;

If the statement in an ELSE part is another IF statement, this can be summarized as ELSIF. The following IF statement:
IF e1 THEN s1:=1; ELSE IF e2 THEN s1:=2; END_IF; END_IF;

is the same as:

IF e1 THEN s1:=1; ELSIF e2 THEN s1:=2; END_IF;

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

269

Statements

Section 8 Structured Text (ST)

Serial nesting levels with IF .. THEN .. ELSE are syntactically ambiguous. In the following example, it is not possible to determine without doubt which IF the last ELSE refers to:
IF e1 THEN IF e2 THEN s1:=1; ELSE s1:=0; END_IF; END_IF;

It is therefore specified that for each definition, ELSE refers to the most recent IF. The statement shown above is therefore interpreted as follows:
IF e1 THEN ( IF e2 THEN s1:=1; ELSE s1:=0; END_IF; ) END_IF CASE statement

A CASE consists of an expression (the selector) and a list of branches, which can be of any length. Each of these branches is preceded by one or more constants or the keyword ELSE. The selector must be an integer data type.
CASE Expression OF Constant

Constant

..

Constant

ELSE

Statement

Statement

END_CASE;

Constants must not be defined more than once and must also conform to an integer data type that is compatible with the selector type. A branch that is preceded by a constant is carried out if the value of the constant is equal to that of the selector. The

270

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Statements

same applies if a range includes the value of the selector. If the value of the selector does not agree with either a constant or a range, the branch following ELSE is carried out. If no ELSE branch is defined, the program continues with the next statement following the CASE statement. A few examples:
CONST plus:= 1; minus:= 2; times:= 3; END_CONST CASE operator OF plus: a := b + c; minus: a := b - c; times: a := a * b; END_CASE; CASE state OF 0: display_text := O.K.; 1,5: display_text := Excessive temperature; 2 .. 4: display_text := Torque; 7: display_text := No feedback; 6, 8 .. 10: display_text := No auxiliary power; ELSE display_text := Unknown error; END_CASE; Loops

Loops specify parts of programs that are repeated. If the number of repetitions is known in advance, use of the FOR statement is recommended. If not, WHILE or REPEAT should be used.
FOR statement

The FOR statement carries out a loop in which new values are assigned to a variable (the controlled variable). The controlled variable must be an integer data type. The definition of a loop with FOR includes identification of a starting and ending value and a step size. The starting value, step size and ending value are expressions. These expressions must be of an integer data type that is compatible with the type of

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

271

Statements

Section 8 Structured Text (ST)

the controlled variables. Identification of the step size with BY is optional. If the step size is not explicitly stated the loop is carried out with step size 1. At the start of the loop the controlled variable is set to the starting value and each time the loop is run through it changes by the step size until the ending value is reached or exceeded. The expressions for the step size and ending value are calculated once at the start of the loop and stored as constants for subsequent use in the loop. Every time the loop is run through the statement in the body of the loop is carried out once.
FOR Controlled variable := Start value TO

End value

BY

Step size

DO

Statement

END_FOR;

After the loop is completed the controlled variable has the value ending value + step size. This value must not exceed the maximum value that is defined by the data type of the controlled variable. A couple of examples:
Maximum := MAX_VAL; FOR lw := 2 TO 63 DO IF Data[lw] > Maximum THEN Maximum := Data[lw]; MaxIdx := lw; END_IF; END_FOR; Sum := 0; FOR i := 10 TO 1 BY -1 DO FOR j := 1 TO 2 DO IF FLag THEN EXIT; END_IF; Sum := Sum + j;

272

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Statements

END_FOR; Sum := Sum + i; END_FOR;

If the ending condition of a loop is already satisfied before it runs the first time (i.e. ending value < starting value), the loop and all the statements it contains are skipped. The following loop is skipped:
FOR lw := 2 TO 1 DO s1:=5; END_FOR; REPEAT statement

The REPEAT statement contains an expression whose truth value determines whether it is to be repeated by the REPEAT UNTIL block that is included. The result of the expression must be of the data type BOOL.
REPEAT Statement UNTIL Expression END_REPEAT;

The statement is carried out repeatedly until the expression takes on the value TRUE. The statement is carried out at least once because the expression is not evaluated until UNTIL is reached. A couple of examples of the REPEAT statement:
j := -4; REPEAT j := j + 2; UNTIL j > 60 END_REPEAT; REPEAT a := in1 + in2; b := 2 * in1; c := in1 * in2; UNTIL EndCondition END_REPEAT;

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

273

Statements

Section 8 Structured Text (ST)

WHILE statement

The WHILE statement contains an expression whose truth value determines whether or not the statement that follows DO is to be carried out again. The result of the expression must be of the data type BOOL.
WHILE Expression DO Statement END_WHILE;

The expression is evaluated each time before the part of the program to be repeated is carried out. If the value FALSE is returned before the statement is carried out for the first time, the block that follows DO is not carried out at all. Otherwise it is repeated until the expression takes on the value FALSE. A couple of examples:
WHILE i > 0 DO i := i - in1; lw := lw+ 1; END_WHILE; i := StartValue; WHILE Data[i] <> x DO i := i + 1; END_WHILE; Index := i;

The essential difference between WHILE and REPEAT is that WHILE repeats a loop for as long as the expression returns TRUE. REPEAT repeats the loop until the expression takes on the value TRUE. Unlike WHILE, a REPEAT statement is run through at least once.
Control statements

The statement EXIT offers the option of exiting a loop before the ending condition is reached. If the EXIT statement is inside nested loops, only the loop level concerned is exited with EXIT, e.g.
WHILE i > 0 DO lw := lw+ 1; IF lw > MAX_LW THEN EXIT;

274

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Limits of the system

END_IF; i := i - in1; END_WHILE;

After the EXIT statement, the program continues with the statement that follows END_WHILE. The statement RETURN causes an ST program to be prematurely abandoned. RETURN interrupts the processing of the current program and control of the program flow is transferred to the next level up. That can be: the program list which called an ST program or the program that called a user-defined function block.
RETURN is used first and foremost in user-defined function blocks, e.g. CASE error_state OF 2 .. 4: OUT := hold_value; 5: OUT := 0.0; RETURN; 6, 8 .. 10: OUT := fix_value; ELSE OUT := 0.0; END_CASE;

Limits of the system

Local elements

The number of local elements is limited to 65526 for each ST program. Local elements are the local variables, every element of a structured variable and every individual array element and intermediate store within the program.
Programming of loops

Every ST program is processed in the context of a user task. In other words, the ST program is carried out once in the space of the task cycle time. When loops are used, a part of the ST program, the statements within the loops, is run through many times in a task cycle. This leads to increased runtime for the user task. The time spent executing a loop should not exceed 5 ms. When programming loops, there is a risk of creating endless loops. The following loop is not ended:

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

275

Limits of the system

Section 8 Structured Text (ST)

REPEAT i := i +1; sEnd := FALSE; UNTIL sEnd END_REPEAT;

This loop is repeated continuously with the result that none of the other programs in the user task can be processed.
Memory occupancy

Structured text is a high-level language that is translated into machine code by code generation. The complex statements mean that the machine code produced is substantially longer than the source text. In multidimensional arrays the number of individual elements increases very rapidly. The array
ARRAY 1 .. 100, 1 .. 100] OF REAL

contains 10,000 elements and requires approximately 39 KBytes of storage space.

User-defined function blocks

Names of inputs and outputs User-defined function blocks with identical input and output names cannot be used in ST programs. During class definition these blocks have acquired input and output names with more than 3 characters. The first three characters of some inputs and/or outputs are identical. In ST programs, the inputs and outputs of function blocks are accessed by their names, not their position on the block. There is no unambiguous supply to inputs or collection from outputs for identical names of a user-defined function block. Class names Class names of user-defined function blocks must not contain any special ST symbols +-*/&=<>[].,():;@#$ These user-defined function blocks cannot be used in ST programs. Since the class name of the user-defined function block is interpreted in ST as a identifier, the use of special symbols is not allowed.

276

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Examples

Examples
Simple control loop

The following example shows the programming of a simple control loop in ST. The I/O signals are accessed using component names. The external set point is set as a function of the global variable TIC2106_AUTO, which also determines the operating mode. The global variables and I/O components are accessed via the process image.
PROGRAM control loop CONST (* Definition of constants *) MAN_SP := 20.0; END_CONST VAR (* declaration of function blocks *) FI2104: AI_TR; FIC2104: C_CU; FY2104: AO_TR; (* declaration of local variables *) rLocalVar1, rLocalVar2: REAL; END_VAR VAR_EXTERNAL (* declaration of HW objects for I/O access *) DAI01_2_0_3: DAI01; DAO02_2_0_4: DAO01; (* declaration of global variables *) FIC2104_SETP: REAL; TIC2106_AUTO: BOOL; FIC2104_ALM: BOOL; END_VAR (* call input transformation *) FI2104(IN:= @DAI01_2_0_3.Ch3, OUT=> rLocalVar1); (* assign external set point *) IF @TIC2106_AUTO THEN FIC2104.SP := @FIC2104_SETP; ELSE FIC2104.SP := MAN_SP;

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

277

Examples

Section 8 Structured Text (ST)

END_IF; (* assign operating mode *) FIC2104.MA := @TIC2106_AUTO; FIC2104.MM := NOT(@TIC2106_AUTO); (* call control function blocks *) FIC2104(PV:= rLocalVar1, OUT=> rLocalVar2); (* further use of outputs *) @FIC2104_ALM := FIC2104.SL1 OR FIC2104.SL2 OR FIC2104.SL3; (* call output transformation *) FY2104(IN:= rLocalVar2, OUT=> @DAO02_2_0_4.Ch2); END_PROGRAM

This ST program carries out the same functionality as the following FBD program:

to005.bmp

Linearization

The following is an example of linearization. The array Curve is initialized at the declaration position. A FOR loop is used to search through the array for the appropriate input range. When the condition is satisfied the loop is terminated after calculation of the output value.
PROGRAM lin VAR (* declaration of local variables *) Curve : ARRAY [1..10, 1..2] OF REAL := 0.0, 0.0, (* X1, Y1 *) 8.0, 12.0, (* X2, Y2 *)

278

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Examples

13.0, 32.6, 47.0, 62.0, 78.4, 83.5, 92.0, 100.0, Index : INT; END_VAR VAR_EXTERNAL (* declaration IN: REAL; OUT: REAL; END_VAR

24.4, 28.4, 16.0, 58.0, 82.0, 85.0, 63.7, 100.0;

(* (* (* (* (* (* (* (*

X3, Y3 *) X4, Y4 *) X5, Y5 *) X6, Y6 *) X7, Y7 *) X8, Y8 *) X9, Y9 *) X10, Y10 *)

of global variables *)

(* start of linearization *) FOR Index:=1 TO 10 DO IF IN <= Curve[Index,1] THEN (* range found*) IF Index = 1 THEN (* low limit *) OUT := Curve[Index,2]; EXIT; (* exit FOR loop *) END_IF; (* calculate output from straight line equation *) (* Y := (((Y2 - Y1) / (X2 - X1)) * (X - X1)) + Y1; *) OUT := (((Curve[Index,2] - Curve[Index-1,2]) / (Curve[Index,1] - Curve[Index-1,1])) * (IN -Curve[Index-1,1])) + Curve[Index-1,2]; EXIT; (* exit FOR loop *) ELSE IF Index = 10 THEN (* high limit *) OUT := Curve[Index,2]; EXIT; END_IF; END_IF; END_FOR; END_PROGRAM

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

279

Examples

Section 8 Structured Text (ST)

MIN_MAX - user-defined function block

In its running time the user-defined function block MIN_MAX determines the maximum and the minimum of the sampled input signal IN. The maximum and minimum can be reset via the RES input.
FUNCTION_BLOCK MIN_MAX (* the following declarations originate from the interface- *) (* definition of the user-defined function block *) (* and cannot be altered in the ST program. *) VAR_INPUT IN : REAL; RES : BOOL; END_VAR VAR_OUTPUT MAX : REAL; MIN : REAL; END_VAR VAR (* VAR_DPS *) END_VAR VAR (* PARA_DPS *) END_VAR (* PARA_VIS ClassName : TEXT; TagName : TEXT; ShortText : TEXT; LongText : TEXT; SelState : BOOL; END_VAR *) (* End of interface definition *) (* declarations *) CONST MAX_REAL := 1.0e38; END_CONST VAR intMax : REAL := -MAX_REAL; intMin : REAL := MAX_REAL; END_VAR (* program *)

280

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Editing an ST program

IF RES THEN (* RES input is set *) MAX := 0.0; MIN := 0.0; intMax := -MAX_REAL; intMin := MAX_REAL; ELSE (* normal function *) intMax := Max(IN, intMax); intMin := Min(IN, intMin); MAX := intMax; MIN := intMin; END_IF; END_FUNCTION_BLOCK

Editing an ST program
Inserting ST elements
To simplify the processing of ST programs, ST elements with the basic syntax can be inserted directly into the text. ST Elements > Insert ST syntax An IF statement is inserted into the ST program in the following form:
IF Expression THEN ThenStatementList; ELSE ElseStatementList; END_IF;

For the following ST elements the syntax can be inserted into the program: VAR VAR_EXTERNAL CONST Date & Time Time

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

281

Inserting of variables and function blocks

Section 8 Structured Text (ST)

IF CASE FOR WHILE REPEAT RETURN EXIT Assignment

Inserting of variables and function blocks

Before variables and function blocks are used in ST programs they must be declared, i.e. made known to the ST program. Variables and function blocks can be directly entered as text. This does not enter them in the variable list or the tag list. Entering them there is done via instantiate. Functions can be used in ST programs without declaration. Variables that are already available can be used directly in an ST program.
Insert variable

Within an ST program, variables that have already been defined can be inserted directly. If the cursor is in the VAR_EXTERNAL END_VAR block a variable declaration is inserted. The variable name is inserted in the program code for subsequent use in the program: ST Elements > Select global variable or F2 > select an existing variable in the project from the list New variables can also be created directly in an ST program: Position the cursor in the VAR_EXTERNAL END_VAR block > ST Elements > create global variable The following dialog appears for inserting the variable into the variable list:

282

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Inserting of variables and function blocks

di0133us.bmp

Name Data type

name of the new variable. Identify the data type of the newly defined variable. The standard data types and all user-defined data types can be selected from the list. Specify the assignment of the variable to the resource. Every variable is assigned to exactly one resource. Access to this variable by other resources is read-only.

Resource

Variable via process image Access via the process image is preset for all uses of the variables. Export Comment Variable is enabled for reading by other resources. Any desired text can be added to a variable for clarification.

After definition of the variables is terminated this is automatically adopted in the system-wide variable list and can be used in other programs (see Section 1, Variables). New variables can also be declared as text. The data type must also be entered as text, e.g.
VAR_EXTERNAL TI203: REAL; TI203_MODE: BOOL; END_VAR

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

283

Inserting of variables and function blocks

Section 8 Structured Text (ST)

With text declaration, the variable is not yet entered in the list of variables. The variable still has to be instantiated for this to take place. See also Global variables on page 260.
Insert function blocks

Function blocks can be declared directly within a VAR END_VAR block. User-defined function blocks with special symbols in class names cannot be used in ST programs. See Limits of the system on page 275. Position the cursor in the VAR END_VAR block > Select the function block from the Blocks menu > The ST editor opens the dialog mask > Enter a new valid tag name in the dialog mask > If desired, carry out further parameterization > Click OK to close the dialog mask Outside a VAR END_VAR block, the following syntax is entered into the ST program, e.g.
<TagName> : LIN;

This text can be moved into an VAR END_VAR block. Function blocks can only be declared within a VAR END_VAR block.

New function blocks can also be declared as text. The function block type must also be entered as text, e.g.
VAR TI203: AI_TR; END_VAR

With text declaration, the function block is not yet entered in the tag list. It still has to be instantiated for this to take place. See also Function blocks on page 262.

284

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Inserting of variables and function blocks

Instantiate

After variables and function blocks have been textually defined (declared) they still do not appear in the corresponding lists (variable list and tag list). A further step, instantiate, is needed for this. ST Elements > Instantiate Instantiate links the parameter data for the function blocks to the ST program. After the function block declaration has been deleted the parameter data is still stored in the ST program and can be erased by instantiate. The dialog mask summarizes the objects to be instantiated and/or those no longer required:

to006us.bmp

These variables will be created The variables in the field will be entered in the variable list. These blocks will be created The function blocks in the field will be entered in the tag list. These blocks will lose their parameterization These function blocks have been deleted from the ST program. The

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

285

Working with variables

Section 8 Structured Text (ST)

parameter settings for these function blocks are still included in the ST program and will be deleted when the instantiate is confirmed. Info-Message OK This field displays information on objects that cannot be instantiated. Instantiate is carried out and the parameters for function blocks that are no longer needed are deleted

Working with variables

Before variables are used in ST programs they must be declared, i.e. made known to the ST program. Information on inserting variables is given in Insert variable on page 282.
Access to variables

There is read access and write access to variables. Variables to the left of the assignment operator have write access. All applications to the right of the assignment operator are read-only access, e.g.
var4 := var1 + SIN(var2 * var3); (* var4 can be written to *) (* var1, var2 and var3 are read from *)

Multiple write access to the same variable is allowed in an ST program and does not lead to errors, e.g.
var1 := 5: var2 := 3 * var1; var1 := 42; Process image

As with other program editors, access to a variable in ST programs can be direct or via the process image. Access is gained via the process image by placing @ in front of the variable name, e.g.
var1 := @var4 + var2; (* var1 can be written to directly *) (* var4 is read via the process image and var2 is read directly *)

286

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Working with functions

@var3 := var4 + var5; (* var3 is written to via the process image *) (* var4 and var5 are read directly *)

If a variable is read many times in an statement, the same type of access should be used every time. In the statement
var1 := var2 + SIN(@var2); inconsistent data supply of var2 may occur, as var2 is read from two different

places (directly and via the process image).

Using system variables

System variables are declared by definition. Explicit declaration in the ST program is not necessary. System variables can be used like global variables. Access via the process image is possible, e.g.
load := @ps12.CPU_Load; date := @ps12.DateTime;

Working with functions

Using functions

Functions can be used directly in ST programs without a declaration. Block > Select function from library Functions can also be inserted directly in ST programs by giving the name. See Engineering reference manual, Functions and function blocks. Values are transferred in a bracketed argument list. The individual arguments are separated by commas: Function name(Argument_1, Argument_2, .. , Argument_n) It is also possible to call a function within the argument transfer of another function, e.g.
CONST AllChar :='0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ';

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

287

Working with functions

Section 8 Structured Text (ST)

END_CONST VAR B1, B2: BYTE; S1, S2: STR8; END_VAR B1 (* S2 (* := EXTCT(1, TO_WO(S_FIND(AllChar, S_LEFT(S1, 1)) + 48)); changes a 1 character STR8 into a BYTE *) := TO_STR8(S_MID(AllChar, 1, TO_IN(PBYWO(B2))-48)); changes a BYTE into a 1 character STR8 *)

Data type of functions

In ST programs the data types of functions are automatically adapted to suit the transferred arguments. There is no need for the data type to be adapted explicitly to the transferred arguments. If necessary, the data type of the argument can be changed to suit by conversion functions, e.g.
VAR i1, i2: INT END_VAR (* extract the root from an INT value *) i2 := to_in(SQRT(to_re(i1)));

The possible data types for a function must be taken from the relevant function description. See Engineering reference manual, Functions and function blocks. If constants are transferred exclusively to a polymorphic function (with different data types) as the argument, at least one explicit type change is needed, e.g.
CONST CONST_VAL := 12; END_CONST VAR i1: INT; END_VAR i1 := add(to_in(CONST_VAL), 42);

288

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Working with function blocks

Number of function inputs

In ST programs the number of function inputs is determined by the argument list, e.g.
VAR b1, b2, b3, b4, b5, b6: BOOL END_VAR b1 := AND(b2, b3, b4); b1 := OR(b2, b4, b5, b6);

The number of arguments must not exceed the maximum input number. It is not possible to set the input number explicitly in ST programs.

Working with function blocks

Before function blocks are used in ST programs they must be declared, i.e. made known to the ST program. Information on inserting function blocks is given in Insert function blocks on page 284.
Positioning function blocks in the program

Function blocks in ST programs are called in statements (see Statements on page 266). The tag name of the function block must be used in the statement to call it, e.g.
VAR TI104: LIN; (* Declaration of the function block*) in, out: REAL; (* Declaration of local variables *) END_VAR (* calling the function block *) TI104(IN := in, OUT => out);

Function blocks may only be called once in the ST program.

Using function blocks in loops

Certain function blocks need uniform sampling to fulfil their functionality, i.e. they must be calculated at uniform intervals. Controller blocks are examples of these. They must not be called within loops.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

289

Working with function blocks

Section 8 Structured Text (ST)

Supplying function block pins.

A distinction is made between mandatory pins and optional pins for block inputs and outputs. The two types of pin are represented in the same way in ST programs. User-defined function blocks with identical input and output names cannot be used in ST programs. See Limits of the system on page 275. Supply to and retrieval from mandatory pins must take place with the block call. All mandatory pins can be inserted directly behind the function block call. Position the cursor on the function block call (tag name) > ST Elements > insert mandatory parameter A comma-delimited argument list with all mandatory pins is created, e.g.
TI104(IN:= (*REAL*), OUT=> (*REAL*));

The data type is given for each pin in the form of a comment. Inputs are supplied via the assignment operator :=. They can be supplied directly with constants. Outputs are written to variables with =>, e.g.
TI104(IN:= 45.0 (*REAL*), OUT=> out (*REAL*));

Supply to and retrieval from optional pins can take place with the block call or at any point in the ST program. They can be inserted directly at the function block call. Position the cursor on the function block call (tag name) > ST Element > Insert a parameter > Select input or output from the list (Inputs and outputs are separated by a horizontal line). An additional pin is appended to the comma-delimited argument list, e.g.
TI104(IN:= (*REAL*), OUT=> (*REAL*), STA=> (*INT*));

Inputs and outputs that support more than one data type have the comment text
(*Other*), e.g. VAR TIR104: TREND; END_VAR TIR104(IN1:= (*Other*),IN2:= (*Other*),IN3:= (*Other*));

290

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Working with function blocks

In addition to block call, optional pins are supplied via assignments. The pin name is then appended to the tag name with a dot separator, e.g.
(* Assignment of inputs for a PID controller *) IF @TIC2106_AUTO THEN FIC2104.SP := @FIC2104_SETP; ELSE FIC2104.SP := MAN_SP; END_IF; FIC2104.MA := @TIC2106_AUTO; FIC2104.MM := NOT(@TIC2106_AUTO); (* calling the controller block *) FIC2104(PV:= @FIC2104_PV, OUT=> @FIC2104_OUT); (* further use of outputs *) @FIC2104_ALM := FIC2104.SL1 OR FIC2104.SL2 OR FIC2104.SL3;

The names of the function block pins are described in the Engineering reference manual, Functions and function blocks. If the name of a function block pin is the same as a keyword (see Special symbols and reserved words on page 253), an underline must precede the pin name, e.g.
VAR pin_dt: P_DT; END_VAR pin_dt(DAY := 18, MON := 6; YEA:= 2002, _DT=> dt1);

Function block outputs cannot be written to.

If an input is supplied before the block call and in the block call, the supply in the block call has precedence, e.g.
VAR ana_mon: M_ANA; END_VAR ana_mon.L1 := 12.0; ana_mon(IN := In12, L1 := 42.0);

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

291

Working with function blocks

Section 8 Structured Text (ST)

The limit value L1 in the function block has the value 42.0. If the value of an output is used before the block call, the initial value or the value from the most recent calculation cycle is transferred.
Function block pin and parameters

In certain function blocks it is possible to select use as an input (pin) or as a parameter, e.g. the limit value in the M_ANA for individual inputs. Function block inputs can also be used in ST programs outside the function block call. For this reason it has been laid down that in cases of simultaneous use as an input and as a parameter, the input has priority. If both the input and the parameter are used the ST program issues a plausibility warning. In the following configuration example:

to014us.bmp

VAR pin_ana: M_ANA; END_VAR pin_ana.L1 := Limit1; pin_ana.L2 := Limit2; pin_ana(IN := Input);

the limit values are assigned as follows: Limit value 1 Limit value 2 Limit value 3 Limit value 4 Only the input is configured. The limit present at input L1 is used as the limit value. Input and parameter are configured. The limit present at input L2 is used as the limit value. Only the parameter is configured and the parameter value is used as the limit value. Not configured.

292

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Working with function blocks

Inputs that can also be configured as parameters have priority over the parameter in the ST program.
Negating function block pins.

The values of the Boolean inputs and outputs of a function block can be inverted at every point of use. The complement operator NOT must be used to do this, e.g.
FIC2104.MM := NOT(@TIC2106_AUTO);

All function blocks have non-negated input and output pins as default. The function block terminal to be inverted must be of the data type BOOL (i.e. binary).
Parameter definition of function blocks

Select the tag name of the function block to be parameterized > Edit > Parameters or Double-click on the tag name of the function block The first parameter definition mask of the function block is called. The function block can be parameterized as described in Handling the parameter definition masks on page 148.
Check function blocks

In ST programs it is not possible to check function blocks for plausibility from the parameter mask. Function blocks may only be checked in the context of the ST program. ST program > Check Activation from the error list takes place as in other program editors.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

293

Programming user-defined function blocks

Section 8 Structured Text (ST)

Programming user-defined function blocks

A user-defined function block is created as described in Section 10, User Function Blocks. If structured text is used as the program, certain special features have to be observed (see also Limits of the system on page 275). An ST program is enclosed between the keywords FUNCTION_BLOCK and END_FUNCTION_BLOCK.
FUNCTION_BLOCK STufb1 ; END_FUNCTION_BLOCK Interface definition

The interface definition of the user-defined function block (see Interface editor on page 377) is adopted as a non-editable (grey) block in the ST program. The interface cannot be modified in the ST program, this must always be done in the interface editor. All variables defined in the interface that are loaded onto the process station can be used in the ST program. See also Inputs and outputs on page 261.

294

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Programming user-defined function blocks

to013.bmp

Local variables can be declared in the ST program. There is no access to local variables from the faceplate. The keyword VAR_EXTERNAL for declaring global variables must not be used in user-defined function blocks.
Blocks in the UFB

Function blocks that are used in user-defined function blocks must be declared in a VAR END_VAR block. This ensures that they always have a name in the class definition. In the instance (Zoom to user FB) every embedded function block can be given an individual name. > Open parameter mask for the function block > Enter tag name This individual tag name is not displayed in the ST program.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

295

General processing functions

Section 8 Structured Text (ST)

General processing functions

Bookmarks
Bookmarks are used to identify individual lines in an ST program for rapid selection. Bookmarks are displayed as a light blue rectangle in the mark column.

to007us.bmp

Bookmarks can be switched on and off. If there is no bookmark in the line the switch sets it, if there is one it deletes it. Set the cursor in the desired line > Edit > Toggle bookmark or CTRL + F7 You can jump to a bookmark from any point in the ST program. Thereafter it jumps to the next bookmark, and so on: Jump forwards (towards the end of the program): Edit > Goto next bookmark or F7

296

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Breakpoints

Jump backwards (towards the beginning of the program): Edit > Goto previous bookmark or SHIFT + F7

Breakpoints
Breakpoints are used for tracing faults in programs. See Section 11, Debugger. Breakpoints are displayed as a brown circle in the mark column.

to008us.bmp

Breakpoints can be switched on and off. If there is no breakpoint in the line the switch sets it, if there is one it deletes it. Position the cursor on the desired line > Edit > Toggle breakpoint or F9 Breakpoints that have been set can be disabled and enabled Position the cursor on the desired line > context menu > Disable breakpoint / Enable breakpoint

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

297

Find and replace

Section 8 Structured Text (ST)

Find and replace

In ST programs, any text can be found and also replaced. > Edit > Find & Replace or F3 Find and replace starts at the current cursor position. At the end of the ST program the find continues automatically from the program start and vice versa. If a text area is selected when the find & replace dialog is opened, this text area is shown as the default in the Find field.

to007us.bmp

Find Replace

The term entered is searched for in the ST program. Every find term is saved in a list and can be recalled from the list later. Replaces the find term with the term that has been entered. Every replacement term is saved in a list and can be recalled from the list later. If the field is empty, the find term is deleted.

Match whole words only The find term is looked for as a whole word. If the find term is part of another word it is ignored. Thus, for example, the find term linear is not found in the word linearization. Match case sensitive The find only finds words with upper and lower case exactly as in the find term. Only exact matches are found. Differences of case are ignored. Up The find proceeds from the current position towards the beginning of the program

298

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Goto line

Down Find next Replace Replace all Close window

The find proceeds from the current position towards the end of the program The next occurrence of the find term is found according to the settings in the ST program. The find term is replaced with the term in the Replace field. All occurrences of the find term in the ST program are replaced by the term in the Replace field without prior confirmation. Ends the search and closes the Find & Replace dialog.

Goto line
In ST programs it is possible to jump to any line Edit > Goto line The current line is offered when the dialog is called.

to007us.bmp

Line number

Enter the number of the line to jump to.

The current line number is displayed in the state line.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

299

Block operations

Section 8 Structured Text (ST)

Block operations
Select program elements

Select individual program elements Select by placing the cursor on the desired program element and clicking the left button. The selection area is the whole text of the program element (e.g. variable name or tag name). The selection of individual program elements is not highlighted in the ST program. After the selection it is possible to open e.g. the parameter masks of function blocks Mark areas of text Hold down the left mouse button and mark an area of text.

to011.bmp

Inside a line, characters are marked. Otherwise complete lines are marked. After marking, the desired operation can now be carried out. Example: > Edit > Cut. Extending an area of marked text Press the SHIFT key and hold it down > to select more characters or lines The additional characters or lines are included in the marked area.
Deselect program elements

Deselect text area Left-click on an unmarked point in the ST program. The text area is deselected and shown as such.

300

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Block operations

A selection is automatically cancelled by opening a different window. Reducing an area of marked text Press SHIFT and hold it down while positioning the cursor within the marked text. The marking is reduced to coincide with the selected cursor position.
Copy

Edit > Copy or CTRL + C Before an area of text can be copied it must be marked. Copying places the marked text into an internal store. Areas of text that have been placed in the internal store by a previous copying operation are overwritten. To find out whether an area of text is in the internal store, look at menu item Insert in the Edit menu or in the context menu. If the menu item is inactive, the internal store is empty. Marked areas of text can also be copied into other ST programs.

Cut and delete

Edit > Cut or Delete or CTRL + X or DEL If areas of marked text have been cut, they can be put back into the program again using Paste. When text is cut, areas of text already present in the internal store are overwritten. If areas of text are deleted they can only be inserted again immediately afterwards with Undo, they cannot be re-inserted later. Areas of deleted text can only be restored by exiting the program without saving. When function blocks are cut the associated parameter data is not transferred to the internal store but stored in the ST program. When a function block is pasted into the

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

301

Block operations

Section 8 Structured Text (ST)

same ST program the parameter data is retained but when the block is pasted into a different one it loses its parameter data.
Paste

The following methods of pasting areas of text that have previously been copied or cut are available: Edit > Paste or CTRL + V The copied or cut area of text is inserted at the current cursor position.
Write file

A marked area of text can be written to a file for exchange with other projects and other editors. Edit > Write file A Unicode text file with the file type .TXT, which can be edited in any Unicodeenabled text editor, is created. The parameter data associated with function blocks is not written to the text file. The file thus created can be used for program exchange with other ST editors.
Read file

An ST program that has been created with another text editor can be read into the ST editor. Edit > Read file The text file to be read in can be in Unicode or ASCII format. The file format is automatically recognized when the file is read in. The contents of the text file are inserted at the current cursor position.

302

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Define user menu

Export block

A marked area of text in an ST program can be exported to a file. Edit > Export block A file is created in a Control Builder F specific format. This includes the parameter data associated with a function block. The complete tag name of the function block declaration must be included in the area of marked text if the parameter data is to be exported.
Import block

A block that has been exported from an ST program can be imported. Edit > Import block The contents of the imported file are inserted at the current cursor position. Function blocks contained in the file are imported, together with their parameter data. If the tag name already exists, a new tag name is created by appending a serial number. The function blocks are automatically instantiated, i.e. the new tag names are entered in the tag list. Imported parameter data is assigned to the function blocks.
Undoing an action

Edit > Undo This function allows the last action taken to be undone. Irrespective of this, the state of the program remains implausible until the next plausibility check.

Define user menu

Functions and function blocks that are often needed for project creation can be brought together in a block menu of their own for clarity.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

303

Define user menu

Section 8 Structured Text (ST)

Adding blocks Options > Define user menu > Select block in right-hand window > Add or double-click The selected function block or the separating lines to Group blocks together are added one at a time to the end of their own block menu.

di0128us.bmp

The left-hand list in the window shows all the blocks that are entered in this menu. The right-hand list shows all the blocks that are available in the block libraries. Horizontal lines can be inserted into the user menu to visually separate groups of blocks. Sorting blocks Options > Define user menu> Select block in left-hand window > Position the mouse between two block entries > single click Deleting blocks Options > Define user menu> Select block in left-hand list > Delete A block is removed from its own block menu

304

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Cross references

Cross references
Cross references can be selected directly from the ST editor: Select a variable, I/O component or tag Cross reference or F5 The window offers a number of sorting and filtering options and the window setting is stored. For tags, unlike variables, there is no definition of read or write access. Show program For a variable: Call a program with prior selection of these variables, or call the module with prior selection of the I/O component. For a tag: Call the program with prior selection of this tag, or call the module in the hardware structure. Show declaration For a tag, the tag list is called, for a variable the variable list is called. If an I/O component is used directly in the program, the I/O editor of this component is opened. Filter A filter enables only those variables to be displayed for which readonly access or write-only access exists in the programs concerned.

After activation it is possible to branch to the programs that are listed as crossreferences. Activating the menu item Back! in the branched program returns the user to the original editor. Display next / previous cross reference Cross reference > Find next or Find previous The next or previous place where the selected variable is used within the current program is displayed.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

305

Program administration functions

Section 8 Structured Text (ST)

Program administration functions

Saving the program

ST program > Save The program is saved without exiting. Programs that are not correct can also be saved and then completed at any time. If the project is not saved in the project tree on closing or before, changes made to the program are ineffective.

Documenting the program

ST program > Document Documentation administration is opened. This is where user-specific project documentation is defined and output. For a description, see Engineering manual System configuration, Documentation.
Program header

ST program > Header A program-specific short comment can be added to the program documentation header, or this can be edited. Drawing header / footer See Engineering manual System configuration, Documentation.

306

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Program administration functions

Edit program comment

ST program > Comment A longer program-specific comment can be edited here to describe the functionality. For a description, see Engineering manual System configuration, Project Manager, Editing a project comment.
Back!

Back! This leaves the ST program and calls the application from which the program editor was last called (back one stage only).
Exit ST program

ST program > Exit The ST program is closed and the project tree called up.
Change to the variable list

System > Variable list The variable list is opened. This is described in Section 1, Variables. The variable list contains all the variables in the system.
Change to the tag list

System > Tag list The tag list is called. This is described in Section 2, Tags.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

307

Program administration functions

Section 8 Structured Text (ST)

The tag list contains all the tags specified in the system. If tag names that were given to function block calls in the ST program are deleted from the tag list, then after returning from the tag list the default parameters for the function block are set and the function block is no longer instantiated.
Create hard copy

Options > Hard copy The contents of the screen are output to the standard printer.
Plausibility check

ST program: > Check All inputs relevant to operation are checked for syntactical and contextual correctness. Errors, warnings and notes that are found are displayed in an error list. If the plausibility check finds errors, the processing state of the program is implausible. The processing state of program elements that are newly entered, copied or moved is implausible.
Deleting an ST program

Project tree > Select program > Edit > Delete. The variables and tag names are retained in other programs and in the variable and tag lists and can be re-assigned.

308

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Commissioning structured text

Copying and pasting an ST program

Project tree > Select program to be copied > Edit > Copy or CTRL+C > Select position to which program is to be copied > Edit > Paste or CTRL+V > Select above, below or at, depending on position chosen > Provide program name. The program is copied and assigned to a program list in the project under a new unique name. The program is copied in its current configuration, including the program header and comment. The function block tag names are copied with the addition of a serial number. The function blocks are automatically instantiated, i.e. the new tag names are entered in the tag list. Copying an ST program has no effect on the declaration of variables. The copied program is identified as implausible. Its version number is the date and time of the copying process.
Connecting programs

Programs are connected via variables or with the input and/or output boards.

Commissioning structured text

User interface for commissioning
When structured text is commissioned, the program is displayed in the same way as during configuration, except that in commissioning mode the structure of the program cannot be changed.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

309

Display of online data

Section 8 Structured Text (ST)

tl027us.bmp

The individual function blocks can be selected and parameterized. Operating modes can also be modified from the commissioning mode.

Display of online data

Online data in the ST program

On going through the text of the ST program the currently calculated values are displayed. If the text is found in the variable list or the local variables, the current value of the variables is displayed. If global and local variables have the same name, the value of the local variables is displayed. If the text is a tag name, the processing state of the function block is displayed. The value of function block pins cannot be displayed in the ST program.

310

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

Section 8 Structured Text (ST)

Error tracing

Moreover, values within a cycle can be described once. Right-click on a variable or a function block pin > Write value > Enter value > OK Writing a value must not be confused with enforced setting on the I/O module. The value that is written can be overwritten from the program in the next cycle.
Window for online data

As with other program editors, the value window and the trend window can be used in ST programs. Local variables can be entered in both windows. To support error tracing, ST programs have an additional window, the watch window, for online data. Select variable > Window > Add value to watch window The values in the watch window are not updated on each cycle. See also Section 11, Debugger, Watch window on page 430.

Error tracing
The debugger can be used for ease of error tracing in ST programs. The debugger is described in Section 11, Debugger.

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming

311

Error tracing

Section 8 Structured Text (ST)

312

3BDD012504R0501_Eng_Manual_IEC61131-3_Programming