Array mit fester Länge

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

Syntax zur 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 zur 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 zum Datenzugriff

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

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

Siehe auch:

Array mit fester Länge 2:

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).

Beispiel: 1-dimensionales 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

Beispiel: 2-dimensionales Array

Deklaration:

1te Dimension: 1 bis 2
2te Dimension: 3 bis 4

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: 3-dimensionales Array

Deklaration:

1te Dimension: 1 bis 2
2te Dimension: 3 bis 4
3te 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: 3-dimensionales 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;
    nId          : INT;
    fIn          : LREAL;
END_VAR
_nId := nId;
_fIn := fIN;

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