Deklaration eines ARRAY-Datentyps in ST

Syntax 
TYPE
(* array with one dimension, with intialization *)
   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 with 2 dimensions, with intialization *)  
  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 with 2 dimensions, intialization is possible *)  
   name_C: ARRAY [x..y , x2..y2] OF FB-type;
 
(* array with 3 dimensions, intialization is possible *)  
   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 with 4 dimensions, intialization is possible *)  
   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;
 
(* as many repetitions as you like are possible *)  
   ... 
   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 etc. muss ein →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. Spezifizieren Sie in diesen [] die Initialisierungsangaben. 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))]
    Initialisierungsangaben bei mehr Dimensionen sind analog möglich.

Falls Sie mehr Elemente in der Initialisierung eingeben, als ARRAY-Elemente vorhanden sind, kennzeichnet Neuron Power Engineer 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.

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".
Neuron Power Engineer 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];                   (* declaring 9 elements of data type 'INT' - the first 3 array elements are initialized with the entered values *)
   Test      : ARRAY [-10..-2] OF REAL := [2(1.0), 3(2.0), 3.0];   (* declaring 9 elements of data type 'REAL' - the first 6 array elements are initialized with the entered values *)
   inputData : ARRAY [0..1] OF BOOL := [2(TRUE)];                  (* declaring 2 elements of data type 'BOOL' - both array elements are initialized with 'TRUE' *)
   scalings  : ARRAY [1..5] OF INT := [2(5), 2(), 4];              (* declaring 5 elements of data type 'INT' - the first 2 array elements are initialized with '5', *)
                                                                   (* the next 2 array elements with default initial value '0' for INT, the last array element with '4'  *)
   Test2     : ARRAY [3..5] OF Range := [2((min := 100, max:=400))]; (* declaring 3 elements of data type 'Range'; 'Range' is a user-defined data type; *)
                                                                     (* the structure elements of the first 2 array elements are initialized with the entered values *)
 
   TONArr1 : ARRAY [0..2] OF TON;                                    (* declaring 3 elements of TON block - no initialization of the inputs *)
   TONArr2 : ARRAY [0..2] OF TON := [(PT:=T#100ms), (PT:=T#50ms)];   (* declaring 3 elements of TON block - the input 'PT' is initialized for the first 2 elements *)
   TONArr3 : ARRAY [1..50] OF TON := [50((PT:=T#100ms))];            (* declaring 50 elements of TON block - the input 'PT' is initialized for all elements *)
END_TYPE

Beispiele für Arrays mit mehreren Dimensionen

 
TYPE
   Dim2 : ARRAY [1..2, 1..3] OF INT := [2([3(25)])];
          (* declaring 2 array dimensions "2 by 3" of data type 'INT' with these initial values:
               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)])])];
          (* declaring 3 array dimensions "2 by 3 by 4" of data type 'INT' with these initial values:
               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]];
           (* declaring 2 array dimensions "2 by 3" of data type 'INT' with these initial values:
                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)]];
           (* declaring 2 array dimensions "5 by 4" of data type 'DINT' with these initial values:
                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,  - Note: The initial values '0' derive from data type '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   - Note: The initial values '0' derive from data type 'DINT'. *)
 
   Dim3a : ARRAY [1..2, 1..3, 1..6] OF SINT := [[[9, 8, 7, 6, 5, 4]], [2([3, 2, 1])]];
           (* declaring 3 array dimensions "2 by 3 by 6" of data type 'SINT' with these initial values:
                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, - Note: All initial values '0' derive from data type '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, geben 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 zur 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. Neuron Power Engineer 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..Colors3Green] OF INT;     (* The array data type uses named values. *)
  myType2 : ARRAY [Colors4#Red..Colors4#Orange] OF INT;    (* The array data type uses named values. *)
 
  Colors3 : DINT(Red := 1, Green := 100);  (* Here the declaration of the data type with the named values. *)
  Colors4 : DINT(Red := 1, Orange := 100); (* Here the declaration of the data type with the named values. *)
END_TYPE