Datentyp: ARRAY OF

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

Eindimensionales 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> ;

`<variable name>`	Name des Arrays Beispiel: `aiCounter`
`<dimension>`	Dimension (unterer bis obere Indexgrenze) Beispiel: `1..100` Eine Dimension kann beliebig viele indizierte Elemente haben, bestimmt durch die untere und die obere Indexgrenze Die Indexgrenzen sind ganzzahlige Zahlen, maximal des Datentyps `DINT`.
`<data type>`	Datentyp eines Elements: Elementarer Datentyp Benutzerdefiinierter Datentyp Funktionsbaustein Tipp Referenzen und Pointer auf `BIT`-Variablen sind ungültige Deklarationen, ebenso wie Arraykomponenten mit Basistyp `BIT`.
`<initialization>`	Optional Initialwerte des Arrays

Beispiel 217. Eindimensionales Array von 10 Integerelementen

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

Untere Indexgrenze: 0

Obere Indexgrenze: 9

Initialisierung für die 10 Elemente:

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.

Mehrdimensionales Array fester Länge

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

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

`<1st dimension>`	Erste Dimension (unterer Indexgrenze bis obere Indexgrenze)
`, <next dimensions>`	Die nächsten Dimensionen (durch Komma separiert)

Syntax bei Datenzugriff

`<index of 1st dimension>`	Indexgrenze der ersten Dimension
`, <next dimensions>`	Indexgrenze der nächsten Dimensionen

Beispiel 218. Zweidimensionales Array

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

1te Dimension: 1 bis 2 (2 Arrayelemente)

2te Dimension: 3 bis 4 (2 Arrayelemente)

Initialisierung für die 2 * 2 Elemente:

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 219. Dreidimensionales 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 220. Dreidimensionales 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 221. 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 222. Zweidimensionales Array eines Funktionsbausteins

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

Tipp

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

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[ <any dimension> ] OF ARRAY[ <any dimension> ] OF <data type> := <initialization> ;

Syntax bei Datenzugriff

<variable name> [<index of first array> ] [<index of next array> ]

`<variable name>`	Name des Arrays Beispiel: `aaaiCounter`
`ARRAY[ <any dimension> ] OF ARRAY[ <any dimension> ] OF ARRAY[ <any dimension> ] OF`	Dreifach verschachteltes Array Beispiel: `ARRAY[1..2, 1..3] OF ARRAY[1..3] OF ARRAY[1..4] OF ARRAY[1..5]` Anmerkung Die Schachteltiefe kann beliebig sein.
`<data type>`	Datentyp eines Elements: Elementarer Datentyp Benutzerdefiinierter Datentyp Funktionsbaustein
`<initialization>`	Optional Initialwerte für das verschachtelte Array

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.

Tipp

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> ;

<variable name>

Name des Arrays

Beispiel: aMyVariableArray

<data type>

Datentyp eines Elements:

Elementarer Datentyp
Benutzerdefiinierter Datentyp
Funktionsbaustein

<initialization>

Optional

Initialwerte für den Array von Arrays

Syntax der Deklaration eines mehrdimensionalen Arrays mit variabler Länge

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

<variable name>

Name des Arrays

Beispiel: aMyVariableArray

ARRAY[*, *]

Deklaration für einen zweidimensionalen Array variabler Länge

Formal steht ein Stern für jede Dimension variable Länge. Die Dimensionen sind mit Komma separiert.

Anmerkung

Erlaubt sind beliebig viele Dimensionen variabler Länge.

Syntax der Operatoren zur Grenzindexberechnung

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

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 : DINT;
    iResult : INT;
END_VAR

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

In diesem Abschnitt:

Datentyp: ARRAY OF

Eindimensionales Array mit fester Länge

Tipp

Mehrdimensionales Array fester Länge

Tipp

Array von Arrays

Anmerkung

Array mit variabler Länge

Tipp

Anmerkung

Suchresultat