Tipo di dati: ARRAY OF

Un array è una raccolta di elementi di dati dello stesso tipo di dati. Sono supportati array singoli e multidimensionali di lunghezza fissa o variabile.

Matrice unidimensionale di lunghezza fissa

È possibile definire gli array nella parte di dichiarazione di una POU o negli elenchi di variabili globali.

Sintassi della dichiarazione di un array unidimensionale:

<variable name> :  ARRAY[ <dimension> ] OF <data type> := <initialization> ;

`<variable name>`	Nome dell'array Esempio: `aiCounter`
`<dimension>`	Dimensione (limite di indice da inferiore a superiore) Esempio: `1..100` Una dimensione può avere un numero qualsiasi di elementi indicizzati, determinato dal limite di indice inferiore e superiore. I limiti dell'indice sono numeri interi; massimo del tipo di dati `DINT`.
`<data type>`	Tipo di dati di un elemento: Tipo di dati elementare Tipo di dati definito dall'utente Blocco funzione Suggerimento Riferimenti e puntatori a `BIT` le variabili sono non valido dichiarazioni, nonché elementi di matrice con tipo base `BIT`.
`<initialization>`	Opzionale Valori iniziali dell'array

Esempio 217. Matrice unidimensionale di 10 elementi interi

VAR
    aiCounter : ARRAY[0..9] OF INT;
END_VAR

Limite indice inferiore: 0

Limite superiore dell'indice: 9

Inizializzazione per i 10 elementi:

aiCounter : ARRAY[0..9] OF INT := [0, 10, 20, 30, 40, 50, 60, 70, 80, 90];

Accesso ai dati

iLocalVariable := aiCounter[2];

Il valore 20 è assegnato alla variabile locale.

Matrice multidimensionale di lunghezza fissa

<variable name> :  ARRAY[ <1st dimension> , <next dimensions> ] OF <data type> := <initialization> ;

<variable name> [ <index of 1st dimension> , <index of next dimensions> ]

`<1st dimension>`	Prima dimensione (limite di indice da inferiore a superiore)
`, <next dimensions>`	Le dimensioni successive (separate da virgole)

Sintassi per l'accesso ai dati

`<index of 1st dimension>`	Limite indice della prima dimensione
`, <next dimensions>`	Limite indice delle dimensioni successive

Esempio 218. Matrice bidimensionale

VAR
    aiCardGame : ARRAY[1..2, 3..4] OF INT;
END_VAR

1a dimensione: da 1 a 2 (2 elementi dell'array)

2a dimensione: da 3 a 4 (2 elementi dell'array)

Inizializzazione per gli elementi 2 * 2:

aiCardGame : ARRAY[1..2, 3..4] OF INT := [2(10),2(20)]; // Short notation for [10, 10, 20, 20]

Accesso ai dati

iLocal_1 := aiCardGame[1, 3]; // Assignment of 10
iLocal_2 := aiCardGame[2, 4]; // Assignment of 20

Esempio 219. Matrice tridimensionale

VAR
    aiCardGame : ARRAY[1..2, 3..4, 5..6] OF INT;
END_VAR

1a dimensione: da 1 a 2

2a dimensione: da 3 a 4

3a dimensione: da 5 a 6

2 * 2 * 2 = 8 elementi dell'array

Inizializzazione

aiCardGame : ARRAY[1..2, 3..4, 5..6] OF INT := [10, 20, 30, 40, 50, 60, 70, 80];

Accesso ai dati

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

Inizializzazione

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]

Accesso ai dati

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

Esempio 220. Array tridimensionale di una struttura definita dall'utente

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

La matrice aData_A è costituito da un totale di 3 * 3 * 10 = 90 elementi di matrice di tipo di dati DATA_A.

Inizializzare parzialmente

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)];

Nell'esempio, solo i primi 3 elementi vengono inizializzati in modo esplicito. Gli elementi a cui non è assegnato alcun valore di inizializzazione in modo esplicito vengono inizializzati internamente con il valore predefinito del tipo di dati di base. Questo inizializza i componenti della struttura a 0 a partire dall'elemento aData_A[2, 1, 1].

Accesso ai dati

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

Esempio 221. Matrice di un blocco funzione

FUNCTION BLOCK FBObject_A
VAR
    iCounter : INT;
END_VAR
...
;

PROGRAM PLC_PRG
VAR
    aObject_A : ARRAY[1..4] OF FBObject_A;
END_VAR

La matrice aObject_A composto da 4 elementi. Ogni elemento istanzia a FBObject_A blocco funzione.

Chiamata di funzione

aObject_A[2]();

Esempio 222. Array bidimensionale di un blocco funzione

Implementazione di FB_Something con metodo 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;

Il blocco funzione FB_Something ha un metodo FB_Init che richiede 2 parametri.

Istanziazione dell'array con inizializzazione

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

Suggerimento

Notare la possibilità di utilizzare la funzione di monitoraggio implicito CheckBounds() per monitorare il mantenimento dei limiti dell'indice in fase di esecuzione.

Array di array

La dichiarazione di un "array di array" è una sintassi alternativa per gli array multidimensionali. Una raccolta di elementi viene nidificata invece di quotare gli elementi. La profondità di nidificazione è illimitata.

Sintassi per la dichiarazione

<variable name> :  ARRAY[ <any dimension> ] OF ARRAY[ <any dimension> ] OF <data type> := <initialization> ;

Sintassi per l'accesso ai dati

<variable name> [<index of first array> ] [<index of next array> ]

`<variable name>`	Nome dell'array Esempio: `aaaiCounter`
`ARRAY[ <any dimension> ] OF ARRAY[ <any dimension> ] OF ARRAY[ <any dimension> ] OF`	Array annidato su tre livelli Esempio: `ARRAY[1..2, 1..3] OF ARRAY[1..3] OF ARRAY[1..4] OF ARRAY[1..5]` Nota La profondità di nidificazione è illimitata.
`<data type>`	Tipo di dati di un elemento: Tipo di dati elementare Tipo di dati definito dall'utente Blocco funzione
`<initialization>`	Opzionale Valori iniziali per l'array nidificato

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;

Le variabili aiPoints e ai2Boxes raccogliere gli stessi dati, tuttavia la sintassi per la dichiarazione differisce da quella dei dati di accesso.

Matrice di lunghezza variabile

Nei blocchi funzione, nelle funzioni o nei metodi, è possibile dichiarare array di lunghezza variabile nel file VAR_IN_OUT sezione dichiarazione.

Il LOWER_BOUND e UPPER_BOUND gli operatori vengono forniti per determinare i limiti dell'indice dell'array effettivamente utilizzato in fase di esecuzione.

Suggerimento

Solo array dichiarati staticamente (non array generati tramite l'operatore __NEW) può essere passato a un array con lunghezza variabile.

Sintassi della dichiarazione di un array unidimensionale di lunghezza variabile

<variable name> :  ARRAY[*] OF <data type> := <initialization> ;

<variable name>

Nome dell'array

Esempio: aMyVariableArray

<data type>

Tipo di dati di un elemento:

Tipo di dati elementare
Tipo di dati definito dall'utente
Blocco funzione

<initialization>

Opzionale

Valori iniziali per l'array di array

Sintassi della dichiarazione di un array multidimensionale di lunghezza variabile

<variable name> :  ARRAY[*, *] OF <data type> := <initialization> ;

<variable name>

Nome dell'array

Esempio: aMyVariableArray

ARRAY[*, *]

Dichiarazione per un array bidimensionale di lunghezza variabile

Formalmente, un asterisco sta per ogni dimensione di lunghezza variabile. Le dimensioni sono separate da virgole.

Nota

È consentito un numero qualsiasi di dimensioni di lunghezza variabile.

Sintassi degli operatori per il calcolo dell'indice limite

LOWER_BOUND( <variable name> , <dimension number> )
UPPER_BOUND( <variable name> , <dimension number> )

Il SUM La funzione aggiunge i valori interi degli elementi dell'array e restituisce la somma calcolata come risultato. La somma viene calcolata su tutti gli elementi dell'array disponibili in fase di esecuzione. Poiché il numero effettivo di elementi dell'array sarà noto solo in fase di esecuzione, la variabile locale viene dichiarata come un array unidimensionale di lunghezza variabile.

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;

In questa sezione:

Tipo di dati: ARRAY OF

Matrice unidimensionale di lunghezza fissa

Suggerimento

Matrice multidimensionale di lunghezza fissa

Suggerimento

Array di array

Nota

Matrice di lunghezza variabile

Suggerimento

Nota

Risultati della ricerca