Syntax

TYPE
(* ARRAY mit einer Dimension, mit Initialisierung *)
   name_1: ARRAY [x..y] OF data-type := [initial-value_1, initial-value_2, ..., initial-value_n];
   name_2: ARRAY [x..y] OF data-type := [n(initial-value_1), n(initial-value_2), ...];
   name_A: ARRAY [x..y] OF FB-type := [(input_1 := initial-value, input_2 := initial-value, ...), (input_1 := initial-value, input_2 := initial-value, ...), ...];
   name_B: ARRAY [x..y] OF FB-type := [n((input_1 := initial-value, input_2 := initial-value, ...), n((input_1 := initial-value, input_2 := initial-value, ...), ...];
 
(* ARRAY mit zwei Dimensionen, mit Initialisierung *)  
   name_3: ARRAY [x1..y1, x2..y2] OF data-type :=                                                 
                 [[initial-value_1_1, ..., initial-value_1_n], [initial-value_2_1, ..., initial-value_2_n]];  
(* ARRAY mit zwei Dimensionen, Initialisierung ist möglich *)  
   name_C: ARRAY [x..y , x2..y2] OF FB-type;
 
(* ARRAY mit drei Dimensionen, Initialisierung ist möglich *)  
   name_4: ARRAY [x1..y1, x2..y2, x3..y3] OF data-type;
   name_D: ARRAY [x1..y1, x2..y2, x3..y3] OF FB-type;
 
(* ARRAY mit vier Dimensionen, Initialisierung ist möglich *)  
   name_5: ARRAY [x1..y1, x2..y2, x3..y3, x4..y4] OF data-type;
   name_E: ARRAY [x1..y1, x2..y2, x3..y3, x4..y4] OF FB-type;
 
(* beliebige Wiederholungen sind möglich *)  
   ... 
   name_n: ARRAY [x..y] OF data-type := [initial-value_1, n(initial-value_2), ...];
END_TYPE

Bedeutung

Deklaration eines oder mehrerer →ARRAY-Datentypen (name_1, name_2 usw.) mit einer Sammlung von Elementen, die von einem gleichen Typ (type oder FB-type) sind.
Die Anzahl der ARRAY-Elemente wird durch den Index-Unterbereich [x..y] bestimmt. Es sind bis zu 4 Index-Unterbereiche [x1..y1, x2..y2, x3..y3, x4..y4] möglich. Die Grenzen (z.B. x und y ) müssen ein →konstanter Ausdruck sein, dessen ausgewerteter Wert im Bereich des →Datentyps DINT liegt. Außerdem muss die Grenze x kleiner als die Grenze y ausgewertet werden bzw. sie müssen als gleich ausgewertet werden (x ≤ y). Siehe nachfolgender Abschnitt "Benannte Werte als Array-Grenzen verwenden" für mehr Informationen, falls Sie benannte Werte eines entsprechenden Datentyps für die Grenzen verwenden wollen.

ARRAY und OF sind die →Schlüsselwörter für die Deklaration eines ARRAY-Datentyps. Diese Deklaration ist innerhalb der Deklaration eines anwenderdefinierten Datentyps (TYPE ... END_TYPE) möglich.
name_1, name_2 usw. müssen →IEC-Bezeichner sein. Datentypen und →Funktionsbausteine sind als Typ für die Array-Elemente möglich. Informieren Sie sich unter "Unterstützte Datentypen", welche Datentypen Sie für die Deklaration angeben können. Details zu STRING-Variablen vom ARRAY-Datentyp finden Sie unter "Deklaration von STRING-Variablen (inkl. Zugriff)".

Mit dem optionalen →Initialisierungswert weisen Sie den ARRAY-Elementen einen Wert zu. Mit := beginnen die Initialisierungsangaben. Pro Array-Dimension ist ein Paar an eckigen Klammern [] erforderlich, in denen Sie die Initialisierungsangaben spezifizieren. Wiederholungen sind mit runden Klammern () möglich. Bei mehrdimensionalen Arrays wird der ganz rechte Index-Unterbereich zuerst aus den Initialisierungsangaben befüllt (siehe die nachfolgenden Beispiele für Arrays mit mehreren Dimensionen).
Die Initialisierungsangaben unterscheiden sich für die Array-Elemente von Datentypen und für jene von Funktionsbausteinen.

Mehr über mögliche Initialisierungsangaben

Mögliche Initialisierungsangaben für Array-Elemente von Datentypen (ohne strukturieren Datentyp):

eine Liste in eckigen Klammern
Beispiel für Array mit einer Dimension: [1, 2, 3]
Beispiele für Array mit 2 Dimensionen: [[9, 8, 7]] oder [[9, 8, 7], [6, 5, 4]]
Beispiele für Array mit 3 Dimensionen: [[[9, 8, 7]]] oder [[[9, 8, 7]], [[6, 5, 4]]]Beispiele für Array mit 4 Dimensionen: [[[[9, 8, 7]]]] oder [[[[9, 8, 7]]], [[[6, 5, 4]]]]
optionale Wiederholungen in runden Klammern
Beispiel 1: [3(TRUE)] entspricht: [TRUE, TRUE, TRUE]
Beispiel 2: [2(1.0), 3(2.0), 3.0] entspricht: [1.0, 1.0, 2.0, 2.0, 2.0, 3.0]Beispiel 3: [2([9, 8, 7])] entspricht: [[9, 8, 7], [9, 8, 7]]
Beispiel 4: [2([3(25)])] entspricht: [[25, 25, 25], [25, 25, 25]]
Beispiel 5: [2([3([4(15)])])] entspricht: [[[15, 15, 15, 15], [15, 15, 15, 15], [15, 15, 15, 15]], [[15, 15, 15, 15], [15, 15, 15, 15], [15, 15, 15, 15]]]
Falls keine Angabe in der runden Klammer steht, gilt der Initialisierungswert des zugehörigen Datentyps (siehe die nachfolgenden Beispiele für Arrays).

Mögliche Initialisierungsangaben für Array-Elemente mit einem strukturierten Datentyp oder einem Funktionsbaustein als Typ:

die Strukturelemente (beim strukturierten Datentyp) oder die Eingangsvariablen (beim Funktionsbaustein) mit den zugewiesenen Werten, wobei diese pro Array-Element in runden Klammern eingeschlossen und durch das Zeichen , voneinander getrennt werden müssen. Der Wert muss mit dem Datentyp des deklarierten Strukturelements oder der deklarierten Eingangsvariable übereinstimmen oder ein Datentyp sein, der aufgrund der impliziten Konvertierung in diesen umgewandelt werden kann.
Beispiele für Strukturelemente min und max bei 2 Array-Elemente des strukturierten Datentyps Range:
Bei einer Dimension: [(min := 100, max:=400), (min := 200, max:=500)]
Initialisierungsangaben bei mehr Dimensionen sind analog möglich, bei 2 Dimensionen z.B. [[(min := 100, max:=400), (min := 200, max:=500)]] oder [[(min := 100, max:=400), (min := 200, max:=500)], [(min := 100, max:=400), (min := 200, max:=500)]]
Beispiele für Eingänge IN und PT bei 3 Array-Elemente des TON-Bausteins:
Bei einer Dimension: [(IN := TRUE, PT:=T#100ms), (IN := FALSE, PT:=T#50ms), (IN := TRUE, PT:=T#200ms)]
Initialisierungsangaben bei mehr Dimensionen sind analog möglich.
optionale Wiederholungen in runden Klammern
Beispiele für eine Dimension:
8 Array-Elemente des strukturierten Datentyps Range: [8((min := 100, max:=400))]
50 Array-Elemente des TON-Bausteins: [50((IN := TRUE, PT:=T#100ms))] oder [2((IN := TRUE, PT:=T#50ms), 48((IN := TRUE, PT:=T#100ms))]
Wiederholungen bei mehr Dimensionen sind analog möglich.

Falls Sie mehr Elemente in der Initialisierung eingeben, als ARRAY-Elemente vorhanden sind, kennzeichnet logi.CAD 3 die Initialisierungsangaben als fehlerhaft. Falls Sie weniger Elemente in der Initialisierung eingeben, als ARRAY-Elemente vorhanden sind, werden die restlichen ARRAY-Elemente mit dem Initialisierungswert des zugehörigen Datentyps initialisiert.

Aktuelle Einschränkungen

Sie können für type keine →Referenz-Typen (REF_TO ...) angeben.
Sie können ARRAY-Datentypen mit bis zu 4 Dimensionen deklarieren. 5 Index-Unterbereiche und mehr werden nicht unterstützt.

Informationen über den Zugriff auf ARRAY-Elemente finden Sie unter "Zugriff auf ARRAY-Datentyp und ARRAY-Elemente".
logi.CAD 3 bietet außerdem die Möglichkeit, zusätzliche Daten bei der Deklaration anzugeben. Siehe "Beschreibung, Kommentar, JSON-String oder Typ für Variablen oder Datentypen angeben" für Details.

Beispiele für Arrays mit einer Dimension

TYPE
   myType    : ARRAY [1..9] OF INT := [1, 2, 3];                     (* 9 Elemente vom Datentyp 'INT' deklarieren - die ersten 3 Array-Elemente werden mit den eingegebenen Werten initialisiert *)
   Test      : ARRAY [-10..-2] OF REAL := [2(1.0), 3(2.0), 3.0];     (* 9 Elemente vom Datentyp 'REAL' deklarieren - die ersten 6 Array-Elemente werden mit den eingegebenen Werten initialisiert *)
   inputData : ARRAY [0..1] OF BOOL := [2(TRUE)];                    (* 2 Elemente vom Datentyp 'BOOL' deklarieren - beide Array-Elemente werden mit 'TRUE' initialisiert *)
   scalings  : ARRAY [1..5] OF INT := [2(5), 2(), 4];                (* 5 Elemente vom Datentyp 'INT' deklarieren - die ersten 2 Array-Elemente werden mit '5' initialisiert, *)
                                                                     (* die nächsten 2 Array-Elemente mit dem Standard-Initialisierungwert '0' für INT, das letzte Array-Element mit '4'  *)
   Test2     : ARRAY [3..5] OF Range := [2((min := 100, max:=400))]; (* 3 Elemente vom Datentyp 'Range' deklarieren; 'Range' ist ein anwenderdefinierter Datentyp *)
                                                                     (* die Strukturelemente der ersten 2 Array-Elemente werden mit den eingegebenen Werten initialisiert *)
 
   TONArr1 : ARRAY [0..2] OF TON;                                    (* 3 Elemente vom TON-Baustein deklarieren - keine Initialisierung der Eingänge *)
   TONArr2 : ARRAY [0..2] OF TON := [(PT:=T#100ms), (PT:=T#50ms)];   (* 3 Elemente vom TON-Baustein deklarieren - bei den ersten 2 Elementen wird der Eingang 'PT' initialisiert *)
   TONArr3 : ARRAY [1..50] OF TON := [50((PT:=T#100ms))];            (* 50 Elemente vom TON-Baustein deklarieren - bei allen Elementen wird der Eingang 'PT' initialisiert *)
END_TYPE

Beispiele für Arrays mit mehreren Dimensionen

TYPE
   Dim2 : ARRAY [1..2, 1..3] OF INT := [2([3(25)])];
          (* 2 ARRAY-Dimensionen "2 x 3" vom Datentyp 'INT' mit diesen Initialisierungswerten deklarieren:
               Dim2[1,1] := 25, Dim2[1,2] := 25, Dim2[1,3] := 25,
               Dim2[2,1] := 25, Dim2[2,2] := 25, Dim2[2,3] := 25 *)
   Dim3 : ARRAY [1..2, 1..3, 1..4] OF INT := [2([3([4(15)])])];
          (* 3 ARRAY-Dimensionen "2 x 3 x 4" vom Datentyp 'INT' mit diesen Initialisierungswerten deklarieren:
               Dim3[1,1,1] := 15, Dim3[1,1,2] := 15, Dim3[1,1,3] := 15, Dim3[1,1,4] := 15,
               Dim3[1,2,1] := 15, Dim3[1,2,2] := 15, Dim3[1,2,3] := 15, Dim3[1,2,4] := 15,
               Dim3[1,3,1] := 15, Dim3[1,3,2] := 15, Dim3[1,3,3] := 15, Dim3[1,3,4] := 15, 
               Dim3[2,1,1] := 15, Dim3[2,1,2] := 15, Dim3[2,1,3] := 15, Dim3[2,1,4] := 15, 
               Dim3[2,2,1] := 15, Dim3[2,2,2] := 15, Dim3[2,2,3] := 15, Dim3[2,2,4] := 15, 
               Dim3[2,3,1] := 15, Dim3[2,3,2] := 15, Dim3[2,3,3] := 15, Dim3[2,3,4] := 15  *)
 
   Dim2a : ARRAY [1..2, 1..3] OF INT := [[9, 8, 7], [6, 5, 4]];
           (* 2 ARRAY-Dimensionen "2 x 3" vom Datentyp 'INT' mit diesen Initialisierungswerten deklarieren:
                Dim2a[1,1] := 9, Dim2a[1,2] := 8, Dim2a[1,3] := 7,
                Dim2a[2,1] := 6, Dim2a[2,2] := 5, Dim2a[2,3] := 4 *)
 
   Dim2b : ARRAY [1..5, 1..4] OF DINT := [2([9, 8, 7, 6]), [2(), 4], [5, 3(1)]];
           (* 2 ARRAY-Dimensionen "5 x 4" vom Datentyp 'DINT' mit diesen Initialisierungswerten deklarieren:
                Dim2b[1,1] := 9, Dim2b[1,2] := 8, Dim2b[1,3] := 7, Dim2b[1,4] := 6,
                Dim2b[2,1] := 9, Dim2b[2,2] := 8, Dim2b[2,3] := 7, Dim2b[2,4] := 6,
                Dim2b[3,1] := 0, Dim2b[3,2] := 0, Dim2b[3,3] := 4, Dim2b[3,4] := 0,  - Hinweis: Die Initialisierungswerte '0' stammen vom Datentyp 'DINT'.
                Dim2b[4,1] := 5, Dim2b[4,2] := 1, Dim2b[4,3] := 1, Dim2b[4,4] := 1,
                Dim2b[5,1] := 0, Dim2b[5,2] := 0, Dim2b[5,3] := 0, Dim2b[5,4] := 0   - Hinweis: Die Initialisierungswerte '0' stammen ebenfalls vom Datentyp 'DINT'. *)
 
   Dim3a : ARRAY [1..2, 1..3, 1..6] OF SINT := [[[9, 8, 7, 6, 5, 4]], [2([3, 2, 1])]];
           (* 3 ARRAY-Dimensionen "2 x 3 x 6" vom Datentyp 'SINT' mit diesen Initialisierungswerten deklarieren:
                Dim3a[1,1,1] := 9, Dim3a[1,1,2] := 8, Dim3a[1,1,3] := 7, Dim3a[1,1,4] := 6, Dim3a[1,1,5] := 5, Dim3a[1,1,6] := 4,
                Dim3a[1,2,1] := 0, Dim3a[1,2,2] := 0, Dim3a[1,2,3] := 0, Dim3a[1,2,4] := 0, Dim3a[1,2,5] := 0, Dim3a[1,2,6] := 0, - Hinweis: Alle Initialisierungswerte '0' stammen vom Datentyp 'SINT'.
                Dim3a[1,3,1] := 0, Dim3a[1,3,2] := 0, Dim3a[1,3,3] := 0, Dim3a[1,3,4] := 0, Dim3a[1,3,5] := 0, Dim3a[1,3,6] := 0,
                Dim3a[2,1,1] := 3, Dim3a[2,1,2] := 2, Dim3a[2,1,3] := 1, Dim3a[2,1,4] := 0, Dim3a[2,1,5] := 0, Dim3a[2,1,6] := 0,
                Dim3a[2,2,1] := 3, Dim3a[2,2,2] := 2, Dim3a[2,2,3] := 1, Dim3a[2,2,4] := 0, Dim3a[2,2,5] := 0, Dim3a[2,2,6] := 0,
                Dim3a[2,3,1] := 0, Dim3a[2,3,2] := 0, Dim3a[2,3,3] := 0, Dim3a[2,3,4] := 0, Dim3a[2,3,5] := 0, Dim3a[2,3,6] := 0  *)
END_TYPE

Benannte Werte als Array-Grenzen verwenden

Falls Sie für die Grenze benannte Werte verwenden wollen, benötigen Sie einen Datentyp mit benannten Werten dafür. Um einen benannten Wert verwenden zu können, g eben Sie einfach den Namen als Grenze an. Um den Namen eindeutig anzusprechen, ist diese Syntax zulässig : data_type_name#named_value – siehe das folgenden Beispiel

Abweichung von IEC-Norm

Die →IEC-Norm erlaubt keine Verwendung von benannten Werten.

Am besten verwenden Sie einen Datentypen, der mit dem Basis-Datentyp DINT deklariert wurde. So ist gewährleistet, dass ein gültiger Index-Unterbereich für den ARRAY-Datentyp oder die ARRAY-Variable spezifiziert ist. Bei Bedarf können Sie aber Datentypen mit benannten Werten von einem Basis-Datentyp verwenden, der zum →allgemeinen Datentyp ANY_INT gehört. logi.CAD 3 informiert Sie, falls die verwendeten Werte für den Index-Unterbereich nicht im Bereich von DINT liegen.

Beispiele für Arrays mit einer Dimension und benannten Werten

TYPE
  myType1 : ARRAY [Colors3#Red..Colors3#Green] OF INT;     (* Der ARRAY-Datentyp verwendet benannte Werte. *)
  myType2 : ARRAY [Colors4#Red..Colors4#Orange] OF INT;    (* Der ARRAY-Datentyp verwendet benannte Werte. *)
 
  Colors3 : DINT(Red := 1, Green := 100);  (* Hier die Deklaration eines Datentypes mit den benannten Werten. *)
  Colors4 : DINT(Red := 1, Orange := 100); (* Hier die Deklaration eines anderen Datentypes mit den benannten Werten. *)
END_TYPE