Arrays

Überblick

Ein Array ist eine Sammlung von Datenelementen des gleichen Typs. Ein- und mehrdimensionale Arrays von fester oder variabler Länge werden unterstützt. Arrays können im Deklarationsteil einer POU und in den globalen Variablenlisten definiert werden. Beachten Sie die Möglichkeit, Prüfung impliziter Feldgrenzen einzusetzen.

Der Datentyp ARRAY mit variabler Länge kann nur deklariert werden für VAR_IN_OUT-Variablen von Funktionsbausteinen, Methoden und Funktionen. Verwenden Sie die Operatoren LOWER_BOUND(<array name>,<dim>) und UPPER_BOUND(<array name>,<dim>), um die Ober- und Untergrenze dieses Arrays zu erhalten.

HINWEIS: Für Arrays mit variabler Länge können statisch deklarierte Arrays übergeben werden. Durch den Operator __NEW generierte Arrays sind nicht zulässig.

Syntax der Deklaration eines Arrays mit fester Länge

<Array_Name> : ARRAY [<ll1>..<ul1>,<ll2>..<ul2>,..,<lln>..<uln>] OF <Elem.-Typ>

ll1, ll2, lln identifizieren die Untergrenze des Feldbereichs.

ul1, ul2 und uln identifizieren die Obergrenze des Feldbereichs.

Die Grenzwerte müssen Ganzzahlwerte (Integer) sein.

Beispiel für die Deklaration eines Arrays mit fester Länge

Card_game: ARRAY [1..13, 1..4] OF INT;

Syntax der Deklaration eines Arrays mit variabler Länge

<Array name> :ARRAY[* ( , * )+ ] OF <data type>;

// (...)+: Eine oder mehrere weitere Dimensionen

Beispiel für die Deklaration eines Arrays mit variabler Länge

FUNCTION SUM: INT; // Onedimensional
arrays of variable lengths can be
passed to this addition function.
VAR_IN_OUT
A: ARRAY [*] OF INT;
END_VAR
VAR
  i, sum2 : DINT;
END_VAR
sum2:= 0;
FOR i:= LOWER_BOUND(A,1) TO UPPER_BOUND(A, 1) DO // The length of the respective array is determined.
  sum2:= sum2 + A[i];
END_FOR;
SUM:= sum2;

Initialisierung von Arrays

Beispiel für die komplette Initialisierung eines Arrays

arr1 : ARRAY [1..5] OF INT := [1,2,3,4,5];
arr2 : ARRAY [1..2,3..4] OF INT := [1,3(7)]; (* short for 1,7,7,7 *)
arr3 : ARRAY [1..2,2..3,3..4] OF INT := [2(0),4(4),2,3];
      (* short for 0,0,4,4,4,4,2,3 *)

Beispiel für die Initialisierung eines Arrays einer Struktur

Strukturdefinition

TYPE STRUCT1
STRUCT
 p1:int;
 p2:int;
 p3:dword;
END_STRUCT
END_TYPE

Array-Initialisierung

ARRAY[1..3] OF STRUCT1:= [(p1:=1,p2:=10,p3:=4723),(p1:=2,p2:=0,p3:=299),(p1:=14,p2:=5,p3:=112)];

Beispiel für die teilweise Initialisierung eines Arrays.

arr1 : ARRAY [1..10] OF INT := [1,2];

Elemente, denen kein Wert im Voraus explizit als Initialisierungswert zugewiesen wird, werden mit dem Standard-Initialisierungswert des Basisdatentyps initialisiert. Im vorigen Beispiel werden die Elemente arr1[3]...arr1[10] daher mit 0 initialisiert.

Beispiel für die Initialisierung eines Arrays von Funktionsbausteinen mit zusätzlichen Parametern in FB_Init

Beispiel für einen Funktionsbaustein FB und eine Methode FB_Init mit zwei Parametern:

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

Beispiel für eine Array-Deklaration mit Initialisierung:

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

Zugreifen auf die Elemente eines Arrays

Gehen Sie für den Zugriff auf die Elemente in zweidimensionalen Arrays vor wie folgt:

<Arrayname>[Index1,Index2]

Beispiel:

Card_game [9,2]

Funktionen zur Prüfung der Array-Grenzen

Um während der Laufzeit ordnungsgemäß auf ein Array-Element zugreifen zu können, muss die Funktion CheckBounds für die Anwendung verfügbar sein. Für Informationen zum Einfügen der Funktion siehe die Beschreibung der Funktion POUs für implizite Checks.

Aufgabe dieser Prüffunktion ist eine angemessene Behandlung der Verletzung von Feldgrenzen (z. B. durch Setzen eines Fehler-Flags oder durch Anpassen des Index). Die Funktion wird implizit aufgerufen, sobald eine Variable des Typs ARRAY zugewiesen wird.

Beispiel für die Verwendung der Funktion CheckBounds

Standardmäßig ist die Funktion auf folgende Weise implementiert:

Deklarationsteil:

// Implicitly generated code : DO NOT EDIT
FUNCTION CheckBounds : DINT
VAR_INPUT
index, lower, upper: DINT;
END_VAR

Implementierungsteil:

// Implicitly generated code : Only an Implementation suggestion
IF  index < lower THEN
CheckBounds := lower;
ELSIF  index > upper THEN
CheckBounds := upper;
ELSE
CheckBounds := index;
END_IF

Beim Aufruf erhält die Funktion folgende Eingangsparameter:

index: Feldelement-Index
lower: Untergrenze des Feldbereichs
upper: Obergrenze des Feldbereichs

Rückgabewert ist der Index selbst, sofern sich dieser im gültigen Bereich befindet. Ansonsten wird je nach Verletzung des Grenzbereichs die Ober- oder Untergrenze des Feldbereichs zurückgegeben.

Überschreiten der Obergrenze des Arrays a

Die Obergrenze des Arrays a wird im folgenden Beispiel überschritten:

PROGRAM PLC_PRG
VAR
 a: ARRAY[0..7] OF BOOL;
    b: INT:=10;
END_VAR
a[b]:=TRUE;

In diesem Beispiel bewirkt der implizite Aufruf der Funktion CheckBounds, der der Zuweisung vorangeht, dass der Indexwert von 10 in den oberen Grenzwert 7 geändert wird. Daher wird dem Element a[7] des Arrays der Wert TRUE zugewiesen. Auf diese Weise können Sie versuchte Zugriffe außerhalb des Array-Bereichs über die Funktion CheckBounds korrigieren.