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
 | Beachten Sie die Möglichkeit, die Verletzung der Feldgrenzen während der Laufzeit durch die implizite Überwachungsfunktion CheckBounds zu überwachen. |
Siehe auch:
| 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[2, 3, 5]; // Assignment of 20
nLocal3 := aCardGame[1, 4, 5]; // Assignment of 30
nLocal4 := aCardGame[2, 4, 5]; // Assignment of 40
nLocal5 := aCardGame[1, 3, 6]; // Assignment of 50
nLocal6 := aCardGame[2, 3, 6]; // Assignment of 60
nLocal7 := aCardGame[1, 4, 6]; // 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[2, 3, 5]; // Assignment of 10
nLocal3 := aCardGame[1, 4, 5]; // Assignment of 20
nLocal4 := aCardGame[2, 4, 5]; // Assignment of 20
nLocal5 := aCardGame[1, 3, 6]; // Assignment of 30
nLocal6 := aCardGame[2, 3, 6]; // Assignment of 30
nLocal7 := aCardGame[1, 4, 6]; // 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[3,1,1].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