General

Variable declaration: Where and how?

You can declare variables at the following locations:

Declaration part of a POU

The “Declare Variable” dialog helps you with this.

Hint: If you define a variable in the tabular declaration editor, the correct syntax is automatically produced.
Declaration part of the GVL or NVL editor
I/O mapping configuration of an I/O device object

Syntax

( <pragma> )*
<scope> ( <type qualifier> )?
	<identifier> (AT <address> )? : <data type> ( := <initial value> )? ;
END_VAR

	Declaration	See also ⮫ “Using the declaration editor” ⮫ “Using the 'Declare variable' dialog box” ⮫ “Command 'Auto Declare'”
<pragma>	Pragma (none, one, or multiple) Note: By adding a pragma, you can affect the behavior and the properties of one or more variables.	See also ⮫ “Using Pragmas” ⮫ “Pragmas”
`‎<scope>‎`	Scope `‎VAR‎` `‎ VAR_CONFIG‎` Note: If variables with incomplete address information are declared in function blocks (for example, `‎AT %I*‎`), then the variables in the variable declaration `‎VAR_CONFIG‎` have to be completely declared. You can access these variables in a local instance only when this is done. `‎VAR_EXTERNAL‎` `‎VAR_GLOBAL‎` `‎VAR_INPUT ‎` `‎VAR_INST ‎` `‎VAR_IN_OUT‎` `‎VAR_OUTPUT ‎` `‎VAR_STAT‎` `‎VAR_TEMP‎`	See also ⮫ “Local variables - VAR” ⮫ “Configuration variables - VAR_CONFIG” ⮫ “External variables - VAR_EXTERNAL” ⮫ “Global variables - VAR_GLOBAL” ⮫ “Object 'GVL' - Global Variable List” ⮫ “Input variables - VAR_INPUT” ⮫ “Instance variables - VAR_INST” ⮫ “Input/Output Variable (VAR_IN_OUT)” ⮫ “Output variables - VAR_OUTPUT” ⮫ “Static variables - VAR_STAT” ⮫ “Temporary variable - VAR_TEMP”
`‎<type qualifier>‎`	Type qualifier `‎CONST‎` `‎ RETAIN‎` `‎ PERSISTENT‎`	See also ⮫ “Constant Variables - 'CONSTANT'” ⮫ “Retain Variable - RETAIN” ⮫ “Persistent Variable - PERSISTENT”
`‎<identifier> ‎`	Identifier, variable name Note: The rules listed in the chapter "Identifiers" must be followed without exception when assigning an identifier. In addition, you will find recommendations for uniform naming.	See also ⮫ “Identifiers”
`‎AT <address>‎`	Assignment of an address in the input, output, or flag memory range (I, Q, or M) `‎AT % <memory area prefix> ( <size prefix> )? <memory position>‎` Example `‎AT %I* // Incomplete address‎` `‎AT %I7.5‎` `‎AT %IW0‎` `‎AT %QX7.5‎` `‎AT %MD48‎`	See also ⮫ “Configuring Devices and I/O Mapping” ⮫ “AT declaration” ⮫ “Addresses”
`‎<data type>‎`	Data type `‎<elementary data type>‎` `‎ <user defined data type>‎` `‎ <function block>‎`	See also ⮫ “Data Types” ⮫ “Object 'DUT'” ⮫ “Object 'Function Block'”
`‎<initial value>‎`	Initial value `‎<literal value> \| <identifier> \| <expression>‎`	See also ⮫ “Identifiers” ⮫ “Constants and literals” ⮫ “ST expressions”
`‎( ... )?‎`	Optional
`‎( ... )*‎`	Optional repetition

Example

‎GVL‎

{attribute 'qualified_only'}
{attribute 'linkalways'} 
VAR_GLOBAL CONSTANT
	g_ciMAX_A : INT := 100;
	g_ciSPECIAL : INT := g_ciMAX_A - 10;
END_VAR

‎GVL_CONFIG‎

{attribute 'qualified_only'}
VAR_CONFIG 
	// Generated instance path of variable at incomplete address
	PLC_PRG.fbDoItNow.XLOCINPUT AT %I*: BOOL := TRUE;
END_VAR

‎FB_DoIt (FB)‎

METHOD METH_Last : INT
VAR_INPUT
  iVar : INT;
END_VAR
VAR_INST
  iLast : INT := 0;
END_VAR

METH_Last := iLast;
iLast := iVar;

FUNCTION_BLOCK FB_DoIt
VAR_INPUT
    wInput AT %IW0 : WORD; (* Input variable *)
END_VAR
VAR_OUTPUT
    wOutput AT %QW0 : WORD; (* Output variable *)
END_VAR
VAR_IN_OUT
    aData_A : ARRAY[0..1] OF DATA_A; // Formal variable
END_VAR
VAR_EXTERNAL
	GVL.g_ciMAX_A : INT; // Declared in object GVL
END_VAR
VAR_STAT
    iNumberFBCalls : INT;
END_VAR
VAR
	iCounter: INT;
	xLocInput AT %I* : BOOL := TRUE; // VAR_CONFIG
END_VAR

iNumberFBCalls := iNumberFBCalls + 1;

‎PLC_PRG (PRG)‎

PROGRAM PLC_PRG
VAR
	iLoop: INT;
	iTest: INT;
	fbDoItNow : FB_DoIt;
	iTest_200: INT;
	aData_Now : ARRAY[0..1] OF DATA_A := [(iA_1 := 1, iA_2 := 10, dwA_3 := 16#00FF),(iA_1 := 2, iA_2 := 20, dwA_3 := 16#FF00)];
END_VAR

iTest := GVL.g_ciMAX_A;
iTest_200 :=  2 * GVL.g_ciMAX_A;
fbDoItNow(aData_A := aData_Now);
FOR iLoop := 0 TO GVL.g_ciSPECIAL DO
	;
END_FOR

Variable initialization

The standard initialization value for all declarations is ‎0‎. In the declaration part you can also specify user-defined initialization values for each variable and each data type.

The user-defined initialization starts with the assignment operator ‎:=‎ and consists of any valid expression of the programming language ST (structured text). You thus define the initialization value with the help of constants, other variables or functions. If you use a variable, you must also initialize it.

Examples

VAR

                var1:INT := 12;                 // initialization value 12

                x : INT := 13 + 8;              // initalization value defined by an expression of constants
 
                y : INT := x + fun(4);          // initialization value defined by an expression, 
                                                // that contains a function call; notice the order!
               

                z : POINTER TO INT := ADR(y);   // not described in the standard IEC61131-3: 
                                                // initialization value defined by an adress function;
                                                // Notice: In this case the pointer will not be initialized
                                                // during an Online Change *)
                END_VAR

Notes on the order of initialization

From compiler version 3.5.3.40, variables in a function block are initialized in the following order: firstly, all constants in accordance with the order of their declarations, then all other variables in accordance with the order of their declarations.

NOTICE

From compiler version 3.3.2.0, variables from global variable lists are always initialized before the local variables of a POU.