Type de données : ARRAY OF
Un tableau est une collection d'éléments de données du même type de données. Les tableaux simples et multidimensionnels de longueur fixe ou variable sont pris en charge.
Tableau unidimensionnel de longueur fixe
Vous pouvez déclarer des tableaux dans la partie déclaration d'un POU ou dans des listes de variables globales.
Syntaxe de déclaration de tableau unidimensionnel :
<variable name> : ARRAY[ <dimension> ] OF <data type> := <initialization> ;
| Nom de la baie Exemple: |
| Dimension (limite d'index inférieure à supérieure) Exemple: Une dimension peut avoir n'importe quel nombre d'éléments indexés, déterminé par les limites inférieure et supérieure de l'index Les limites d'index sont des nombres entiers, maximum du type de données |
| Type de données d'un élément :
AstuceRéférences et pointeurs vers |
| Optionnel Valeurs initiales du tableau |
VAR aiCounter : ARRAY[0..9] OF INT; END_VAR
Limite inférieure de l'indice : 0
Limite supérieure de l'indice : 9
Initialisation pour les 10 éléments :
aiCounter : ARRAY[0..9] OF INT := [0, 10, 20, 30, 40, 50, 60, 70, 80, 90];
accès aux données
iLocalVariable := aiCounter[2];
La valeur 20 est affectée à la variable locale.
Tableau multidimensionnel de longueur fixe
<variable name> : ARRAY[ <1st dimension> , <next dimensions> ] OF <data type> := <initialization> ;
<variable name> [ <index of 1st dimension> , <index of next dimensions> ]
| Première dimension (limite inférieure de l'index à la limite supérieure de l'index) |
| Les dimensions suivantes (séparées par des virgules) |
Syntaxe d'accès aux données
| Limite d'index de la première dimension |
| Limite d'index des dimensions suivantes |
VAR aiCardGame : ARRAY[1..2, 3..4] OF INT; END_VAR
1ère dimension : 1 à 2 (2 éléments de tableau)
2ème dimension : 3 à 4 (2 éléments de tableau)
Initialisation pour les éléments 2*2 :
aiCardGame : ARRAY[1..2, 3..4] OF INT := [2(10),2(20)]; // Short notation for [10, 10, 20, 20]
accès aux données
iLocal_1 := aiCardGame[1, 3]; // Assignment of 10 iLocal_2 := aiCardGame[2, 4]; // Assignment of 20
VAR aiCardGame : ARRAY[1..2, 3..4, 5..6] OF INT; END_VAR
1ère dimension : 1 à 2
2ème dimension : 3 à 4
3ème dimension : 5 à 6
2 * 2 * 2 = 8 éléments de tableau
initialisation
aiCardGame : ARRAY[1..2, 3..4, 5..6] OF INT := [10, 20, 30, 40, 50, 60, 70, 80];
accès aux données
iLocal_1 := aiCardGame[1, 3, 5]; // Assignment of 10 iLocal_2 := aiCardGame[2, 3, 5]; // Assignment of 20 iLocal_3 := aiCardGame[1, 4, 5]; // Assignment of 30 iLocal_4 := aiCardGame[2, 4, 5]; // Assignment of 40 iLocal_5 := aiCardGame[1, 3, 6]; // Assignment of 50 iLocal_6 := aiCardGame[2, 3, 6]; // Assignment of 60 iLocal_7 := aiCardGame[1, 4, 6]; // Assignment of 70 iLocal_8 := aiCardGame[2, 4, 6]; // Assignment of 80
initialisation
aiCardGame : 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]
accès aux données
iLocal_1 := aiCardGame[1, 3, 5]; // Assignment of 10 iLocal_2 := aiCardGame[2, 3, 5]; // Assignment of 10 iLocal_3 := aiCardGame[1, 4, 5]; // Assignment of 20 iLocal_4 := aiCardGame[2, 4, 5]; // Assignment of 20 iLocal_5 := aiCardGame[1, 3, 6]; // Assignment of 30 iLocal_6 := aiCardGame[2, 3, 6]; // Assignment of 30 iLocal_7 := aiCardGame[1, 4, 6]; // Assignment of 40 iLocal_8 := aiCardGame[2, 4, 6]; // Assignment of 40
TYPE DATA_A STRUCT iA_1 : INT; iA_2 : INT; dwA_3 : DWORD; END_STRUCT END_TYPE PROGRAM PLC_PRG VAR aData_A : ARRAY[1..3, 1..3, 1..10] OF DATA_A; END_VAR
Le tableau aData_A
se compose d'un total de 3 * 3 * 10 = 90 éléments de tableau du type de données DATA_A
.
Initialiser partiellement
aData_A : ARRAY[1..3, 1..3, 1..10] OF DATA_A := [(iA_1 := 1, iA_2 := 10, dwA_3 := 16#00FF),(iA_1 := 2, iA_2 := 20, dwA_3 := 16#FF00),(iA_1 := 3, iA_2 := 30, dwA_3 := 16#FFFF)];
Dans l'exemple, seuls les 3 premiers éléments sont explicitement initialisés. Les éléments auxquels une valeur d'initialisation n'est pas explicitement attribuée sont initialisés en interne avec la valeur par défaut du type de données de base. Ainsi, les composants structuraux de l'élément aData_A[2, 1, 1]
initialisé avec 0.
accès aux données
iLocal_1 := aData_A[1,1,1].iA_1; // Assignment of 1 dwLocal_2 := aData_A[3,1,1].dwA_3; // Assignment of 16#FFFF
FUNCTION BLOCK FBObject_A VAR iCounter : INT; END_VAR ... ; PROGRAM PLC_PRG VAR aObject_A : ARRAY[1..4] OF FBObject_A; END_VAR
Le tableau aObject_A
se compose de 4 éléments. Chaque élément instancie un bloc fonction FBObject_A
.
appel de fonction
aObject_A[2]();
implémentation de FB_Something
avec méthode FB_Init
FUNCTION_BLOCK FB_Something 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;
Le bloc fonction FB_Something
a une méthode FB_Init
, qui prend 2 paramètres.
Instanciation du tableau avec initialisation
PROGRAM PLC_PRG VAR fb_Something_1 : FB_Something(nId := 11, lrIn := 33.44); a_Something : ARRAY[0..1, 0..1] OF FB_Something[(nId := 12, lrIn := 11.22), (nId := 13, lrIn := 22.33), (nId := 14, lrIn := 33.55),(nId := 15, lrIn := 11.22)]; END_VAR
Astuce
Notez la possibilité d'observer les bornes d'index lors de l'exécution via la fonction de surveillance impliciteCheckBounds()
contrôller.
Tableau de tableaux
Déclarer un "tableau de tableaux" est une notation alternative pour les tableaux multidimensionnels. Une collection d'éléments est imbriquée au lieu de dimensionner les éléments. La profondeur de la boîte peut être arbitraire.
Syntaxe à la déclaration
<variable name> : ARRAY[ <any dimension> ] OF ARRAY[ <any dimension> ] OF <data type> := <initialization> ;
Syntaxe d'accès aux données
<variable name> [<index of first array> ] [<index of next array> ]
| Nom de la baie Exemple: |
| Tableau imbriqué triple Exemple: NoteLa profondeur de la boîte peut être arbitraire. |
| Type de données d'un élément :
|
| Optionnel Valeurs initiales du tableau imbriqué |
PROGRAM PLC_PRG VAR aiPoints : ARRAY[1..2,1..3] OF INT := [1,2,3,4,5,6]; ai2Boxes : ARRAY[1..2] OF ARRAY[1..3] OF INT := [ [1, 2, 3], [ 4, 5, 6]]; ai3Boxes : ARRAY[1..2] OF ARRAY[1..3] OF ARRAY[1..4] OF INT := [ [ [1, 2, 3, 4], [5, 6, 7, 8 ], [9, 10, 11, 12] ], [ [13, 14, 15, 16], [ 17, 18, 19, 20], [21, 22, 23, 24] ] ]; ai4Boxes : ARRAY[1..2] OF ARRAY[1..3] OF ARRAY[1..4] OF ARRAY[1..5] OF INT; END_VAR aiPoints[1, 2] := 1200; ai2Boxes[1][2] := 1200;
Les Variables aiPoints
et ai2Boxes
collectent les mêmes éléments de données, mais les notations utilisées pour la déclaration et l'accès aux données diffèrent.


Tableau de longueur variable
Dans les blocs fonctionnels, les fonctions ou les méthodes, vous pouvez utiliser la section de déclaration VAR_IN_OUT
Déclarez des tableaux de longueur variable.
Vous pouvez utiliser les opérateurs pour déterminer les limites d'index du tableau réellement utilisé lors de l'exécution LOWER_BOUND
et UPPER_BOUND
à l'élimination.
Astuce
Un tableau de longueur variable ne peut être déclaré que statiquement, sans utiliser l'opérateur __NEW
les tableaux générés sont passés.
Syntaxe de la déclaration de tableau unidimensionnel de longueur variable
<variable name> : ARRAY[*] OF <data type> := <initialization> ;
| Nom de la baie Exemple: |
| Type de données d'un élément :
|
| Optionnel Valeurs initiales pour le tableau de tableaux |
Syntaxe de la déclaration d'un tableau multidimensionnel de longueur variable
<variable name> : ARRAY[*, *] OF <data type> := <initialization> ;
| Nom de la baie Exemple: |
| Déclaration pour un tableau à deux dimensions de longueur variable Formellement, un astérisque représente chaque dimension de longueur variable. Les dimensions sont séparées par des virgules. NoteN'importe quel nombre de dimensions de longueur variable est autorisé. |
Syntaxe des opérateurs de calcul de l'indice limite
LOWER_BOUND( <variable name> , <dimension number> ) UPPER_BOUND( <variable name> , <dimension number> )
le SUM
La fonction ajoute les valeurs entières des éléments du tableau et renvoie la somme calculée en conséquence. La somme est calculée sur tous les éléments du tableau disponibles au moment de l'exécution. Comme le nombre réel d'éléments du tableau ne sera connu qu'au moment de l'exécution, la variable locale est déclarée comme un tableau unidimensionnel de longueur variable.
FUNCTION SUM: INT; VAR_IN_OUT aiData : ARRAY[*] OF INT; END_VAR VAR diCounter : DINT; iResult : INT; END_VAR iResult := 0; FOR diCounter := LOWER_BOUND(aiData, 1) TO UPPER_BOUND(aiData, 1) DO // Calculates the length of the current array iResult := iResult + aiData[diCounter]; END_FOR; SUM := iResult;