Skip to main content

Tipo di dati: __VECTOR

Nota

Le operazioni vettoriali sono supportate in modo nativo solo su processori a 64 bit e offrono un vantaggio in termini di prestazioni solo su questi processori. La scheda tecnica del titolare fornisce informazioni sul responsabile del trattamento utilizzato dal titolare.

Attualmente, le operazioni vettoriali sulle piattaforme x86/64-bit con SSE2 e ARM64 con NEON sono supportate in modo nativo. Su tutte le altre piattaforme, le operazioni vettoriali vengono tradotte in singole istruzioni. Ad esempio, l'addizione vettoriale viene quindi eseguita con più operazioni di addizione singola.

Le estensioni del set di comandi dei processori sono estensioni SIMD. SIMD (Single Instruction, Multiple Data) descrive un'architettura di computer in cui più set di dati dello stesso tipo vengono elaborati simultaneamente in parallelo e quindi più velocemente con una chiamata di comando. Nelle operazioni vettoriali, ad esempio, è possibile aggiungere contemporaneamente 4 coppie di numeri.

Sintassi

<variable name> :  __VECTOR[ <vector size> ] OF <element type> := <initialization> ;

<vector size> : 1 |2 | 3 | 4 | 5| 6 | 7| 8
<element type> : REAL | LREAL

L'inizializzazione delle variabili è facoltativa.

Un tipo di dati vettoriale è una matrice di numeri a virgola mobile con un massimo di 8 elementi. Il __vc<operator name> sono disponibili operatori per questo tipo di dati. Puoi usarli per implementare operazioni vettoriali senza chiamate di funzioni aggiuntive.

Sintassi per l'accesso all'indice

<variable name>[ <index> ]
<index> : 0 | 1 | 2| 3 | 4 | 5| 6 | 7

Quando si indicizza una variabile vettoriale, è possibile accedere a un singolo elemento del vettore. L'indice inizia da 0 e va fino a <dimensione vettore> - 1.

PROGRAM PLC_PRG
VAR
        vcA : __VECTOR[3] OF REAL;
END_VAR

vcA[0] := 1.1;
vcA[1] := 2.2;
vcA[2] := 3.3;

Determinazione della dimensione ottimale del vettore

Suggerimento

Utilizzare la dimensione del vettore ottimale a seconda del sistema di destinazione come dimensione del vettore per programmare il codice più efficiente possibile.

Per i sistemi di destinazione la cui architettura del computer è generalmente adatta per l'elaborazione vettoriale, non è consigliabile utilizzare vettori di dimensioni arbitrarie. Esiste una dimensione del vettore ottimale a seconda del tipo di elaborazione dei dati del processore. I vettori dichiarati con questa dimensione dell'array vengono elaborati il più rapidamente possibile. I vettori dichiarati come un array più grande non hanno un vantaggio in termini di velocità. I vettori dichiarati come array più piccoli non sfruttano appieno le capacità del processore.

È possibile interrogare la dimensione ottimale in fase di esecuzione. Puoi trovare le informazioni nelle costanti Constants.vcOptimalREAL (per vettori con REAL elementi) e Constants.vcOptimalLREAL (per vettori con LREAL elementi). Le costanti hanno il LREAL tipo di dati. Se una costante restituisce il valore 1 come valore ottimale, significa che l'elaborazione vettoriale accelerata non è disponibile per il sistema di destinazione.

PROGRAM PLC_PRG
VAR
        iOVS_REAL : INT; // Optimal vector size for REAL eleements
        iOVS_LREAL : INT; // Optimal vector size for LREAL eleements
END_VAR

iOVS_REAL := Constants.vcOptimalREAL;
iOVS_LREAL := Constants.vcOptimalLREAL;

Un'applicazione caricata su CODESYS Il sistema di destinazione Control Win V3 x64 restituisce i seguenti valori in fase di esecuzione:

_cds_img_read_optimal_vector_size.png

Operatore: __VCADD

L'operatore calcola la somma di due vettori.

Sintassi

<vector variable> := <1st vector operand> __VCADD <2nd vector operand>;
Esempio 241. Aggiunta
FUNCTION_BLOCK FB_ADD
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
    vcResult : __VECTOR[3] OF REAL;
END_VAR
vcResult := vcA __VCADD vcB;


Operatore: __VCSUB

L'operatore calcola la differenza tra due vettori.

Sintassi

<vector variable> := <vector minuend> __VCSUB <vector subtrahend>;
Esempio 242. Sottrazione
FUNCTION_BLOCK FB_SUB
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
    vcResult0 : __VECTOR[3] OF REAL;
    vcResult1 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := vcA __VCSUB vcB;
vcResult1 := vcB __VCSUB vcA;


Operatore: __VCMUL

L'operatore calcola il prodotto di due vettori o uno scalare (numero in virgola mobile) e un vettore.

Sintassi

<vector variable> := <1st vector operand> __VCMUL <2nd vector operand> | <scalar operand> __VCMUL <vector operand> | <vector operand> __VCMUL <scalar operand> ;
Esempio 243. Moltiplicazione
FUNCTION_BLOCK FB_MUL
VAR
    rScalar : REAL := 1.1;
    vcA : __VECTOR[3] OF REAL;
    vcB : __VECTOR[3] OF REAL;
    vcResult0 : __VECTOR[3] OF REAL;
    vcResult1 : __VECTOR[3] OF REAL;
    vcResult2 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := vcA __VCMUL vcB;
vcResult1 := rScalar __VCMUL vcB;
vcResult2 := vcA __VCMUL 3.3;


Operatore: __VCDIV

L'operatore calcola il quoziente di due vettori o un vettore e uno scalare.

Sintassi

<vector variable> := <vector dividend> __VCDIV <vector divisor> | < vector dividend> __VCMUL <scalar divisor> ;
Esempio 244. Divisione
FUNCTION_BLOCK FB_DIV
VAR
    iScalar : INT := 3;
    rScalar : REAL := 1.5;
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
    vcResult0 : __VECTOR[3] OF REAL;
    vcResult1 : __VECTOR[3] OF REAL;
    vcResult2 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := vcA __VCDIV vcB;
// ERROR CODE vcResult1 := rScalar __VCDIV vcB;
// ERROR CODE vcResult1 := iScalar __VCDIV vcB;
// ERROR CODE vcResult1 := 3.3 __VCDIV vcB;
vcResult2 := vcA __VCDIV 1.5;
vcResult2 := vcA __VCDIV iScalar;
vcResult2 := vcA __VCDIV rScalar;


Operatore: __VCDOT

L'operatore calcola il prodotto scalare (prodotto scalare) di due vettori.

Sintassi

<skalar variable> := <1st vector operand> __VCDOT <2nd vector operand> ;
Esempio 245. Prodotto a punti
FUNCTION_BLOCK FB_DOT
VAR
    rResult : REAL;
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
END_VAR
rResult := vcA __VCDOT vcB; // = 18


Operatore: __VCSQRT

L'operatore calcola la radice quadrata di ogni elemento nel vettore.

Sintassi

<vector variable> := __VCSQRT( <vector operand> );
Esempio 246. Radice quadrata
FUNCTION_BLOCK FB_SQRT
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(4, 9, 16);
    vcResult0 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := __VCSQRT(vcA);


Operatore: __VCMAX

L'operatore calcola il vettore massimo di due vettori. Il massimo è determinato elemento per elemento.

Sintassi

<vector variable> := __VCMAX( <1st vector operand>, <2nd vector operand>);
Esempio 247. Massimo vettore
FUNCTION_BLOCK FB_MAX
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 6);
    vcResult0 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := __VCMAX(vcA, vcB);


Operatore: __VCMIN

L'operatore calcola il vettore minimo di due vettori. Il minimo è determinato elemento per elemento.

Sintassi

<vector variable> := __VCMIN( <1st vector operand>, <2nd vector operand>);
Esempio 248. Esempio di vettore minimo
FUNCTION_BLOCK FB_MIN
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 6);
    vcResult0 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := __VCMIN(vcA, vcB);


Operatore: __VCSET_REAL

L'operatore imposta tutti gli elementi di un vettore in un'istruzione. Gli elementi hanno il REAL tipo di dati.

Sintassi

<vector variable> := __VCSET_REAL( <first literal>, ( < next literal> )+ ) ;
( ... )+ // number of elements have to match
FUNCTION_BLOCK FB_SET
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
END_VAR
vcA := __VCSET_REAL(4, 4, 4);
vcB := __VCSET_REAL(1.1, 2.2, 3.3);

Operatore: __VCSET_LREAL

L'operatore imposta tutti gli elementi di un vettore contemporaneamente in un'istruzione. Gli elementi hanno il LREAL tipo di dati.

Possono essere utilizzati ovunque siano valide variabili, ad esempio nelle assegnazioni nelle implementazioni o come parametri nelle chiamate di funzione.

Sintassi

<vector variable> := __VCSET_LREAL( <first literal>, ( < next literal> )+ ) ;
( ... )+ // number of elements have to match
FUNCTION_BLOCK FB_SET
VAR
    vclA : __VECTOR[3] OF LREAL := __VCSET_LREAL(3, 3, 3);
    vclB : __VECTOR[3] OF LREAL := __VCSET_LREAL(1, 2, 3);
END_VAR
vclA := __VCSET_LREAL(-1.7976931348623158E+308, 0.0, 1.7976931348623158E+308);
vclB := __VCSET_LREAL(-1.7976931348623158E+308, 0.0, 1.7976931348623158E+308);

Operatore: __VCLOAD_REAL

L'operatore interpreta qualsiasi area di memoria arbitraria come un vettore. Questo è utile per connettere variabili vettoriali al codice esistente. L'operatore richiede 2 parametri. Il primo parametro indica il numero di elementi vettoriali. Il secondo parametro è un puntatore a REAL dati.

Importante

__VCLOAD_REAL(<n>,<ptr>) leggere <n> valori REAL consecutivi all'indirizzo <ptr>. Se inferiore a <n> I valori a questo indirizzo possono causare l'arresto anomalo del controller o la lettura di memoria indesiderata.

Sintassi

<vector variable> := __VCLOAD_REAL( <vector size>, <pointer to data of type REAL> ) ;
<vector size> : 2 | 3 | 4 | 5| 6 | 7| 8
Esempio 249. Vettorizzazione
FUNCTION_BLOCK FB_LOAD
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    rData : ARRAY[0..2] OF REAL := [1.234, 5.678, 9.123];
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
END_VAR

vcA := __VCLOAD_REAL(3, ADR(rData[0]));


Operatore: __VCLOAD_LREAL

L'operatore interpreta qualsiasi area di memoria arbitraria come un vettore. Questo è utile per connettere variabili vettoriali al codice esistente. L'operatore richiede 2 parametri. Il primo parametro indica il numero di elementi vettoriali. Il secondo parametro è un puntatore a LREAL dati.

Importante

__VCLOAD_LREAL (<n>,<ptr>) legge <n> valori LREAL successivi al <ptr> indirizzo. Se ci sono meno di <n> valori a questo indirizzo, ciò può causare l'arresto anomalo del controller o la lettura di memoria indesiderata.

Sintassi

<vector variable> := __VCLOAD_LREAL( <vector size>, <pointer to data of type LREAL> );
<number of vector elements> : 1 | 2 | 3 | 4 | 5| 6 | 7| 8
Esempio 250. Vettorizzazione
FUNCTION_BLOCK FB_LOAD
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    rData : ARRAY[0..3] OF LREAL := [-1.7976931348623158E+308, 1.6E+308, 1.7E+308, -1.6E+308];
    vcA : __VECTOR[3] OF LREAL := __VCSET_LREAL(1, 2, 3);
END_VAR

vcA := __VCLOAD_LREAL(3, ADR(rData[0]));


Operatore: __VCSTORE

L'operatore salva/copia il contenuto del vettore nell'indirizzo di memoria specificato. Il numero ed i tipi di elementi vengono applicati automaticamente dalle variabili vettoriali.

Importante

__VCSTORE(<n>,<ptr>) scrive <n> valori consecutivi all'indirizzo <ptr>. Se inferiore a <n> I valori a questo indirizzo possono causare l'arresto anomalo del controller o la scrittura di memoria indesiderata.

Sintassi

__VCSTORE( <pointer to data>, <vector variable> );
Esempio 251. Salva
FUNCTION_BLOCK FB_STORE
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
        rData : ARRAY[0..2] OF REAL := [1, 2, 3];
        pData: POINTER TO REAL := ADR(rData[0]);

        lrData : ARRAY [0..3] OF LREAL := [1, 2, 3, 4];
        plData: POINTER TO LREAL := ADR(lrData[0];


        vcA : __VECTOR[3] OF REAL := __VCSET_REAL( 1.234, 5.678, 9.123);
        vclA : __VECTOR[4] OF LREAL := __VCSET_LREAL(-1.7976931348623158E+308, 1.6E+308, 1.7E+308, -1.6E+308);
END_VAR

__VCSTORE(pData, vcA);
__VCSTORE(plData, vclA);


In questa sezione: