Datentyp 'ARRAY'

Ein Array ist eine Sammlung von Datenelementen des gleichen Datentyps. CODESYS unterstützt ein- und mehrdimensionale Arrays von fester oder variabler Länge.

Array mit fester Länge

Sie können Arrays im Deklarationsteil einer POU oder in globalen Variablenlisten deklarieren.

Syntax der Deklaration eines eindimensionalen Arrays

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

<dimension> :  <lower index bound>..<upper index bound>
<data type> : elementary data types | user defined data types | function block types 
// (...)? : Optional

Syntax der Deklaration eines mehrdimensionalen Arrays

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

<1st dimension> :  <1st lower index bound>..<1st upper index bound>
<next dimension> : <next lower index bound>..<next upper index bound>
<data type> : elementary data types | user defined data types | function block types 
// (...)+ : One or more further dimensions
// (...)? : Optional

Die Indexgrenzen sind ganzzahlige Zahlen, maximal des Datentyps ‎DINT‎.

Syntax bei Datenzugriff

<variable name>[ <index of 1st dimension> ( , <index of next dimension> )* ]
// (...)* : 0, one or more further dimensions

Beachten Sie die Möglichkeit, während der Laufzeit die Einhaltung der Indexgrenzen durch die implizite Überwachungsfunktion ‎CheckBounds()‎ zu kontrollieren.

Beispiel

Eindimensionales Array von 10 Integerelementen

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

Untere Indexgrenze: 0

Obere Indexgrenze: 9

Initialisierung

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

Datenzugriff

iLocalVariable := aiCounter[2];

Der lokalen Variablen wird der Wert 20 zugewiesen.

Beispiel

2-dimensionales Array

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

1te Dimension: 1 bis 2

2te Dimension: 3 bis 4

Initialisierung

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

Datenzugriff

iLocal_1 := aiCardGame[1, 3]; // Assignment of 10
iLocal_2 := aiCardGame[2, 4]; // Assignment of 20

Beispiel

3-dimensionales Array

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

1te Dimension: 1 bis 2

2te Dimension: 3 bis 4

3te Dimension: 5 bis 6

2 * 2 * 2 = 8 Arrayelemente

Initialisierung

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

Datenzugriff

iLocal_1 := aiCardGame[1, 3, 5]; // Assignment of 10
iLocal_2 := aiCardGame[2, 3, 5]; // Assignment of 20
iLocal_3 := aiCardGame[1, 4, 5]; // Assignment of 30
iLocal_4 := aiCardGame[2, 4, 5]; // Assignment of 40
iLocal_5 := aiCardGame[1, 3, 6]; // Assignment of 50
iLocal_6 := aiCardGame[2, 3, 6]; // Assignment of 60
iLocal_7 := aiCardGame[1, 4, 6]; // Assignment of 70
iLocal_8 := aiCardGame[2, 4, 6]; // Assignment of 80

Initialisierung

aiCardGame : 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]

Datenzugriff

iLocal_1 := aiCardGame[1, 3, 5]; // Assignment of 10
iLocal_2 := aiCardGame[2, 3, 5]; // Assignment of 10
iLocal_3 := aiCardGame[1, 4, 5]; // Assignment of 20
iLocal_4 := aiCardGame[2, 4, 5]; // Assignment of 20
iLocal_5 := aiCardGame[1, 3, 6]; // Assignment of 30
iLocal_6 := aiCardGame[2, 3, 6]; // Assignment of 30
iLocal_7 := aiCardGame[1, 4, 6]; // Assignment of 40
iLocal_8 := aiCardGame[2, 4, 6]; // Assignment of 40

Beispiel

3-dimensionales Array einer benutzerdefinierten Struktur

TYPE DATA_A
STRUCT
 iA_1 : INT;
 iA_2 : INT;
 dwA_3 : DWORD;
END_STRUCT
END_TYPE

PROGRAM PLC_PRG
VAR
	aData_A : ARRAY[1..3, 1..3, 1..10] OF DATA_A;
END_VAR

Das Array ‎aData_A‎ besteht aus insgesamt 3 * 3 * 10 = 90 Arrayelementen des Datentyps ‎DATA_A‎.

Teilweise initialisieren

aData_A : ARRAY[1..3, 1..3, 1..10] OF DATA_A := [(iA_1 := 1, iA_2 := 10, dwA_3 := 16#00FF),(iA_1 := 2, iA_2 := 20, dwA_3 := 16#FF00),(iA_1 := 3, iA_2 := 30, dwA_3 := 16#FFFF)];

Im Beispiel werden nur der ersten 3 Elemente explizit initialisiert. Elemente, denen explizit kein Initialisierungswert zugewiesen wird, werden intern mit dem Standardwert des Basisdatentyps initialisiert. Somit werden die Strukturkomponenten ab dem Element ‎aData_A[2, 1, 1]‎ mit 0 initialisiert.

Datenzugriff

iLocal_1 := aData_A[1,1,1].iA_1; // Assignment of 1
dwLocal_2 := aData_A[3,1,1].dwA_3; // Assignment of 16#FFFF

Beispiel

Array eines Funktionsbausteins

FUNCTION BLOCK FBObject_A
VAR
	iCounter : INT;
END_VAR
...

PROGRAM PLC_PRG
VAR
	aObject_A : ARRAY[1..4] OF FBObject_A;
END_VAR

Das Array ‎aObject_A‎ besteht aus 4 Elementen. Jedes Element instanziert einen Funktionsbaustein ‎FBObject_A‎.

Funktionsaufruf

aObject_A[2]();

Beispiel

Implementierung von ‎FB_Something‎ mit Methode ‎FB_Init‎

FUNCTION_BLOCK FB_Something
VAR
	_nId : INT;
	_lrIn : LREAL;
END_VAR
...

METHOD FB_Init : BOOL
VAR_INPUT
	bInitRetains : BOOL;
	bInCopyCode : BOOL;
	nId : INT;
	lrIn : LREAL;
END_VAR

_nId := nId;
_lrIn := lrIN;

Der Funktionsbaustein ‎FB_Something‎ hat eine Methode ‎FB_Init‎, die 2 Parameter benötigt.

Instanzierung des Arrays mit Initialisierung

PROGRAM PLC_PRG
VAR
	fb_Something_1 : FB_Something(nId := 11, lrIn := 33.44);
	a_Something : ARRAY[0..1, 0..1] OF FB_Something[(nId := 12, lrIn := 11.22), (nId := 13, lrIn := 22.33), (nId := 14, lrIn := 33.55),(nId := 15, lrIn := 11.22)];
END_VAR

Array von Arrays

Die Deklaration eines "Array von Arrays" ist eine alternative Schreibweise für multidimensionale Arrays. Eine Sammlung von Elementen wird dabei verschachtelt, statt die Elemente zu dimensionieren. Die Schachteltiefe kann beliebig sein.

Syntax bei Deklaration

<variable name> :  ARRAY[<first>] ( OF ARRAY[<next>] )+ OF <data type> ( := <initialization> )? ;

<first> :  <first lower index bound>..<first upper index bound>
<next> : <lower index bound>..<upper index bound> // one or more arrays
<data type> : elementary data types | user defined data types | function block types 
// (...)+ : One or more further arrays
// (...)? : Optional

Syntax bei Datenzugriff

<variable name>[<index of first array>] ( [<index of next array>] )+ ;
// (...)* : 0, one or more further arrays

Beispiel

PROGRAM PLC_PRG
VAR
	aiPoints : ARRAY[1..2,1..3] OF INT := [1,2,3,4,5,6];
	ai2Boxes : ARRAY[1..2] OF ARRAY[1..3] OF INT := [ [1, 2, 3], [ 4, 5, 6]];	
	ai3Boxes : ARRAY[1..2] OF ARRAY[1..3] OF ARRAY[1..4] OF INT := [ [ [1, 2, 3, 4], [5, 6, 7, 8 ], [9, 10, 11, 12] ], [ [13, 14, 15, 16], [ 17, 18, 19, 20], [21, 22, 23, 24] ] ];
	ai4Boxes : ARRAY[1..2] OF ARRAY[1..3] OF ARRAY[1..4] OF ARRAY[1..5] OF INT;
END_VAR

aiPoints[1, 2] := 1200;
ai2Boxes[1][2] := 1200;

Die Variablen ‎aiPoints‎ und ‎ai2Boxes‎ sammeln die gleichen Datenelemente, aber die Schreibweisen bei der Deklaration und beim Datenzugriff unterscheiden sich.

Array mit variabler Länge

In Funktionsbausteinen, Funktionen oder Methoden können Sie im Deklarationsabschnitt ‎VAR_IN_OUT‎ Arrays mit variabler Länge deklarieren.

Um zur Laufzeit die Indexgrenzen des tatsächliche verwendeten Arrays zu ermitteln, stehen Ihnen die Operatoren ‎LOWER_BOUND‎ und ‎UPPER_BOUND‎ zur Verfügung.

An ein Array mit variabler Länge dürfen nur statisch deklarierte, nicht mit Hilfe des Operators ‎__NEW‎ erzeugte Arrays übergeben werden.

Syntax der Deklaration eines eindimensionalen Arrays mit variabler Länge

<variable name> :  ARRAY[*] OF <data type> ( := <initialization> )? ;

<data type> : elementary data types | user defined data types | function block types 
// (...)? : Optional

Syntax der Deklaration eines mehrdimensionalen Arrays mit variabler Länge

<variable name> :  ARRAY[* ( , * )+ ] OF <data type> ( := <initialization> )? ;

<data type> : elementary data types | user defined data types | function block types 
// (...)+ : One or more further dimensions
// (...)? : Optional

Syntax der Operatoren zur Grenzindexberechnung

LOWER_BOUND( <variable name> , <dimension number> )
UPPER_BOUND( <variable name> , <dimension number> )

Beispiel

Die Funktion ‎SUM‎ addiert die Integerwerte der Arrayelemente und gibt als Ergebnis die ermittelte Summe zurück. Die Summe wird über alle zur Laufzeit vorhandenen Arrayelemente berechnet. Da die tatsächliche Anzahl an Arrayelementen erst zur Laufzeit bekannt sein wird, wird die lokale Variable als eindimensionales Array variabler Länge deklariert.

FUNCTION SUM: INT;
VAR_IN_OUT
	aiData : ARRAY[*] OF INT;
END_VAR
VAR
 diCounter, diResult : DINT; 
END_VAR

diResult := 0;
FOR diCounter := LOWER_BOUND(aiData, 1) TO UPPER_BOUND(aiData, 1) DO // Calculates the length of the current array
 diResult := diResult + A[i];
END_FOR;
SUM := diResult;

Siehe auch