Array mit fester Länge

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

Eindimensionales Array mit fester Länge

Syntax

Deklaration eines eindimensionalen Arrays:

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

`<variable name>`	Name des Arrays Beispiel: `aCounter`
`<dimension>`	Dimension (untere 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 Benutzerdefinierter Datentyp Funktionsbaustein Hinweis: Referenzen und Pointer auf BIT-Variablen sind ungültige Deklarationen, ebenso wie Arraykomponenten mit Basistyp BIT.
`<initialization>`	Initialwerte des Arrays (optional)

Zugriff auf ein Element eines eindimensionalen Arrays:

<variable name>[<index>]

<variable name>

Name des Arrays

Beispiel: aCounter

<index>

Index des Elements, auf das zugegriffen wird

Beispiel: 2

Der Index ist beginnend beim Indexminimum bis zum Indexmaximum gültig. Beispiel: 1..100

Beispiel: Eindimensionales Array

Deklaration 1:

Eindimensionales Array von 10 Integerelementen

Untere Indexgrenze: 0
Obere Indexgrenze: 9

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

Initialisierung 1:

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

Datenzugriff 1:

Der lokalen Variablen wird der Wert 20 zugewiesen.

nLocalVariable := aCounter[2];

Deklaration 2:

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

Datenzugriff 2:

Auf das Array wird mit Hilfe einer Indexvariablen zugegriffen. Vor dem Zugriff wird überprüft, ob der Wert der Indexvariable innerhalb der gültigen Arraygrenzen liegt.

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

Mehrdimensionales Array fester Länge

Syntax

Deklaration eines mehrdimensionalen Arrays


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

`<1st dimension>`	Erste Dimension (untere bis obere Indexgrenze)
`<next dimensions>`	Weitere Dimensionen, durch Komma separiert

Zugriff auf ein Element eines mehrdimensionalen Arrays:

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

`<index of 1st dimension>`	Index der ersten Dimension
`<index of next dimensions>`	Indizes der weiteren Dimensionen

	Beachten Sie die Möglichkeit, die Verletzung der Feldgrenzen während der Laufzeit durch die implizite Überwachungsfunktion CheckBounds zu überwachen.

Beispiel: Zweidimensionales Array

Deklaration:

1. Dimension: 1 bis 2 (zwei Arrayelemente)
2. Dimension: 3 bis 4 (zwei Arrayelemente)

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

Initialisierung:

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

Datenzugriff:

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

Beispiel: Dreidimensionales Array

Deklaration:

1. Dimension: 1 bis 2
2. Dimension: 3 bis 4
3. Dimension: 5 bis 6
2 * 2 * 2 = 8 Arrayelemente

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

Initialisierung 1:

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

Datenzugriff 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

Initialisierung 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]

Datenzugriff 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

Beispiel: Dreidimensionales Array einer benutzerdefinierten Struktur

Deklaration:

Das Array aData besteht aus insgesamt 3 * 3 * 10 = 90 Arrayelementen des Datentyps 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

Teilweises Initialisieren:

Im Beispiel werden nur die 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[2, 1, 1] mit 0 initialisiert.

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

Datenzugriff:

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

Beispiel: Array eines Funktionsbausteins

Deklaration:

Das Array aObjects besteht aus 4 Elementen. Jedes Element instanziiert einen Funktionsbaustein FB_Object.

FUNCTION BLOCK FB_Object
VAR
nCounter : INT;
END_VAR

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

Funktionsaufruf:

aObjects[2]();

Beispiel: Array eines Funktionsbausteins mit FB_init-Methode

Deklaration:

Implementierung von FB_Sample mit Methode FB_init

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

Der Funktionsbaustein FB_Sample hat eine Methode FB_init, die zwei Parameter benötigt.

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

nId := nIdInit;
fIn := fInInit;

Deklaration des Arrays mit Initialisierung:

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

	Einstellen des Monitoring-Bereichs für große Arrays Wenn ein Array über mehr als 1000 Elemente verfügt, werden in der Online-Ansicht standardmäßig 1000 Elemente angezeigt. Diesen Monitoring-Bereich können Sie ändern, indem Sie in der Online-Ansicht im Deklarationsbereich auf die Arraydeklaration doppelklicken. Daraufhin öffnet sich ein Dialog, in welchem Sie den Start- und Endindex des gewünschten Monitoring-Bereichs einstellen können. Beachten Sie, dass die Anzeigeperformance abnimmt, je mehr Elemente gleichzeitig angezeigt werden (maximal 20000 Elemente).