Array with fixed length

Arrays can be declared in the declaration part of a POU or in global variable lists.

One-dimensional array with fixed length

Syntax

Declaration of a one-dimensional array:

<variable name> : ARRAY[<dimension>] OF <data type> := [<initialization>];

`<variable name>`	Array name Sample: `aCounter`
`<dimension>`	Dimension (lower to upper index limit) Sample: `1..100` A dimension can have any number of indexed elements, determined by the lower and upper index limits. The index limits are integers up to data type DINT.
`<data type>`	Data type of the element: Elementary data type User-defined data type Function block Note: References and pointers to BIT variables are invalid declarations, as are array components with the base type BIT.
`<initialization>`	Initial values of the array (optional)

Access to an element of a one-dimensional array:

<variable name>[<index>]

<variable name>

Array name

Sample: aCounter

<index>

Index of the element being accessed

Sample: 2

The index is valid from the index minimum to the index maximum. Sample: 1..100

Sample: One-dimensional array

Declaration 1:

One-dimensional array of 10 integer elements

Lower index limit: 0
Upper index limit: 9

VAR
    aCounter : ARRAY[0..9] OF INT;
END_VAR

Initialization 1:

aCounter : ARRAY[0..9] OF INT := [0, 10, 20, 30, 40, 50, 60, 70, 80, 90];

Data access 1:

The local variable is assigned the value 20.

nLocalVariable := aCounter[2];

Declaration 2:

VAR CONSTANT
    cMin    : INT := 0;
    cMax    : INT := 5;
END_VAR
VAR
    aSample : ARRAY [cMin..cMax] OF BOOL;
END_VAR

Data access 2:

The array is accessed by means of an index variable. Before the array is accessed, the system checks whether the value of the index variable is within the valid array boundaries.

IF nIndex >= cMin AND nIndex <= cMax THEN
    bValue := aSample[nIndex];
END_IF

Multidimensional array of fixed length

Syntax

Declaration of a multidimensional array


<variable name> : ARRAY[<1st dimension> , <next dimensions>] OF <data type> ( := <initialization> )? ;

`<1st dimension>`	First dimension (lower to upper index limit)
`<next dimensions>`	Further dimensions, separated by a comma

Access to an element of a multidimensional array:

<variable name>[<index of 1st dimension>, <index of next dimensions>]

`<index of 1st dimension>`	Index of the first dimension
`<index of next dimensions>`	Indices of the other dimensions

	Note the option to monitor violation of field bounds during runtime using the CheckBounds implicit monitoring function.

Sample: Two-dimensional array

Declaration:

1st dimension: 1 to 2 (two array elements)
2nd dimension: 3 to 4 (two array elements)

VAR
    aCardGame : ARRAY[1..2, 3..4] OF INT;
END_VAR

Initialization:

aCardGame : ARRAY[1..2, 3..4] OF INT := [2(10),2(20)]; // Short notation for [10, 10, 20, 20]

Data access:

nLocal1 := aCardGame[1, 3]; // Assignment of 10
nLocal2 := aCardGame[2, 4]; // Assignment of 20

Sample: Three-dimensional array

Declaration:

1st dimension: 1 to 2
2nd dimension: 3 to 4
3rd dimension: 5 to 6
2 * 2 * 2 = 8 array elements

VAR
    aCardGame : ARRAY[1..2, 3..4, 5..6] OF INT;
END_VAR

Initialization 1:

aCardGame : ARRAY[1..2, 3..4, 5..6] OF INT := [10, 20, 30, 40, 50, 60, 70, 80];

Data access 1:

nLocal1 := aCardGame[1, 3, 5]; // Assignment of 10
nLocal2 := aCardGame[1, 3, 6]; // Assignment of 20
nLocal3 := aCardGame[1, 4, 5]; // Assignment of 30
nLocal4 := aCardGame[1, 4, 6]; // Assignment of 40
nLocal5 := aCardGame[2, 3, 5]; // Assignment of 50
nLocal6 := aCardGame[2, 3, 6]; // Assignment of 60
nLocal7 := aCardGame[2, 4, 5]; // Assignment of 70
nLocal8 := aCardGame[2, 4, 6]; // Assignment of 80

Initialization 2:


aCardGame : ARRAY[1..2, 3..4, 5..6] OF INT := [2(10), 2(20), 2(30), 2(40)]; // Short notation for [10, 10, 20, 20, 30, 30, 40, 40]

Data access 2:

nLocal1 := aCardGame[1, 3, 5]; // Assignment of 10
nLocal2 := aCardGame[1, 3, 6]; // Assignment of 10
nLocal3 := aCardGame[1, 4, 5]; // Assignment of 20
nLocal4 := aCardGame[1, 4, 6]; // Assignment of 20
nLocal5 := aCardGame[2, 3, 5]; // Assignment of 30
nLocal6 := aCardGame[2, 3, 6]; // Assignment of 30
nLocal7 := aCardGame[2, 4, 5]; // Assignment of 40
nLocal8 := aCardGame[2, 4, 6]; // Assignment of 40

Sample: Three-dimensional array of a user-defined structure

Declaration:

The array aData consists of a total of 3 * 3 * 10 = 90 array elements of data type ST_Data.

TYPE ST_Data
STRUCT
n1 : INT;
n2 : INT;
n3 : DWORD;
END_STRUCT
END_TYPE

PROGRAM MAIN 
VAR
aData : ARRAY[1..3, 1..3, 1..10] OF ST_Data;
END_VAR

Partial initialization:

In the sample, only the first 3 elements are explicitly initialized. Elements to which no initialization value is explicitly assigned are internally initialized with the default value of the basic data type. Thus the structure components are initialized with 0 starting from the element aData[2, 1, 1].

aData : ARRAY[1..3, 1..3, 1..10] OF ST_Data := [(n1 := 1, n2 := 10, n3 := 16#00FF),
(n1 := 2, n2 := 20, n3 := 16#FF00),
(n1 := 3, n2 := 30, n3 := 16#FFFF)];

Data access:

nLocal1 := aData[1,1,1].n1; // Assignment of 1
nLocal2 := aData[1,1,3].n3; // Assignment of 16#FFFF

Sample: Array of a function block

Declaration:

The array aObjects consists of 4 elements. Each element instantiates a function block FB_Object.

FUNCTION BLOCK FB_Object
VAR
nCounter : INT;
END_VAR

PROGRAM MAIN
VAR
aObjects : ARRAY[1..4] OF FB_Object;
END_VAR

Function call:

aObjects[2]();

Sample: Array of a function block with FB_init method

Declaration:

Implementation of FB_Sample with FB_init method

FUNCTION_BLOCK FB_Sample
VAR
nId : INT;
fIn : LREAL;
END_VAR

The function block FB_Sample has an FB_init method that requires two parameters.

METHOD FB_init : BOOL
VAR_INPUT
bInitRetains : BOOL;
bInCopyCode : BOOL;
nIdInit : INT;
fInInit : LREAL;
END_VAR

nId := nIdInit;
fIn := fInInit;

Array declaration with initialization:

PROGRAM MAIN
VAR
fbSample : FB_Sample (nId := 11, fIn := 33.44);
aSample : ARRAY[0..1, 0..1] OF FB_Sample [(nId := 12, fIn := 11.22),
(nId := 13, fIn := 22.33),
(nId := 14, fIn := 33.55),
(nId := 15, fIn := 11.22)];
END_VAR

	Setting the monitoring range for large arrays If an array has more than 1000 elements, then 1000 elements are displayed by default in the online view. You can change this monitoring range by double-clicking the array declaration in the declaration section in the online view. A dialog then opens in which you can set the start and end index of the desired monitoring range. Please note that as the number of simultaneously displayed elements increases (maximum 20000 elements), the display quality deteriorates.