Skip to main content

Tipo de datos: __VECTOR

Nota

Las operaciones vectoriales se admiten de forma nativa solo en procesadores de 64 bits y ofrecen una ventaja de rendimiento solo en estos procesadores. La hoja de datos del controlador proporciona información sobre el procesador utilizado en el controlador.

Actualmente, las operaciones vectoriales en las plataformas x86/64 bits con SSE2 y ARM64 con NEON se admiten de forma nativa. En todas las demás plataformas, las operaciones vectoriales se traducen en declaraciones individuales. Por ejemplo, la suma de vectores se ejecuta luego con múltiples operaciones de suma única.

Las extensiones del conjunto de comandos de los procesadores son extensiones SIMD. SIMD (Instrucción única, datos múltiples) describe una arquitectura de computadora en la que múltiples conjuntos de datos del mismo tipo se procesan simultáneamente en paralelo y, por lo tanto, más rápido con una llamada de comando. En operaciones vectoriales, por ejemplo, se pueden sumar 4 pares de números al mismo tiempo.

Sintaxis

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

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

La inicialización de variables es opcional.

Un tipo de dato vectorial es una matriz de números de punto flotante con un máximo de 8 elementos. El __vc<operator name> Hay operadores disponibles para este tipo de datos. Puede usarlos para implementar operaciones vectoriales sin llamadas a funciones adicionales.

Sintaxis para el acceso al índice

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

Al indexar una variable vectorial, puede acceder a un solo elemento del vector. El índice comienza en 0 y continúa hasta <tamaño del vector> - 1.

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

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

Determinación del tamaño óptimo del vector

Sugerencia

Utilice el tamaño de vector óptimo según su sistema de destino como tamaño de vector para programar el código más eficiente posible.

Para los sistemas de destino cuya arquitectura informática es generalmente adecuada para el procesamiento de vectores, no recomendamos utilizar vectores de tamaño arbitrario. Existe un tamaño de vector óptimo dependiendo del tipo de procesamiento de datos del procesador. Los vectores que se declaran con este tamaño de matriz se procesan lo más rápido posible. Los vectores que se declaran como una matriz más grande no tienen ventaja en la velocidad. Los vectores que se declaran como arreglos más pequeños no aprovechan al máximo las capacidades del procesador.

Puede consultar el tamaño óptimo en tiempo de ejecución. Puedes encontrar la información en las constantes. Constants.vcOptimalREAL (para vectores con REAL elementos) y Constants.vcOptimalLREAL (para vectores con LREAL elementos). Las constantes tienen la LREAL tipo de datos. Si una constante devuelve el valor 1 como el valor óptimo, esto significa que el procesamiento vectorial acelerado no está disponible para el sistema de destino.

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;

Una aplicación que se carga en el CODESYS El sistema de destino Control Win V3 x64 devuelve los siguientes valores en tiempo de ejecución:

_cds_img_read_optimal_vector_size.png

Operador: __VCADD

El operador calcula la suma de dos vectores.

Sintaxis

<vector variable> := <1st vector operand> __VCADD <2nd vector operand>;
ejemplo 241. Adición
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;


Operador: __VCSUB

El operador calcula la diferencia entre dos vectores.

Sintaxis

<vector variable> := <vector minuend> __VCSUB <vector subtrahend>;
ejemplo 242. Sustracción
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;


Operador: __VCMUL

El operador calcula el producto de dos vectores o un escalar (número de coma flotante) y un vector.

Sintaxis

<vector variable> := <1st vector operand> __VCMUL <2nd vector operand> | <scalar operand> __VCMUL <vector operand> | <vector operand> __VCMUL <scalar operand> ;
ejemplo 243. Multiplicación
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;


Operador: __VCDIV

El operador calcula el cociente de dos vectores o un vector y un escalar.

Sintaxis

<vector variable> := <vector dividend> __VCDIV <vector divisor> | < vector dividend> __VCMUL <scalar divisor> ;
ejemplo 244. División
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;


Operador: __VCDOT

El operador calcula el producto punto (producto escalar) de dos vectores.

Sintaxis

<skalar variable> := <1st vector operand> __VCDOT <2nd vector operand> ;
ejemplo 245. Producto punto
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


Operador: __VCSQRT

El operador calcula la raíz cuadrada de cada elemento en el vector.

Sintaxis

<vector variable> := __VCSQRT( <vector operand> );
ejemplo 246. Raíz cuadrada
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);


Operador: __VCMAX

El operador calcula el vector máximo de dos vectores. El máximo se determina elemento por elemento.

Sintaxis

<vector variable> := __VCMAX( <1st vector operand>, <2nd vector operand>);
ejemplo 247. Vector máximo
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);


Operador: __VCMIN

El operador calcula el vector mínimo de dos vectores. El mínimo se determina elemento por elemento.

Sintaxis

<vector variable> := __VCMIN( <1st vector operand>, <2nd vector operand>);
ejemplo 248. Ejemplo de un vector mínimo
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);


Operador: __VCSET_REAL

El operador establece todos los elementos de un vector en una declaración. Los elementos tienen la REAL tipo de datos.

Sintaxis

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

Operador: __VCSET_LREAL

El operador establece todos los elementos de un vector a la vez en una declaración. Los elementos tienen la LREAL tipo de datos.

Se pueden usar siempre que las variables sean válidas, como en asignaciones en implementaciones o como parámetros en llamadas a funciones.

Sintaxis

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

Operador: __VCLOAD_REAL

El operador interpreta cualquier área de memoria arbitraria como un vector. Esto es útil para conectar variables vectoriales al código existente. El operador requiere 2 parámetros. El primer parámetro indica el número de elementos del vector. El segundo parámetro es un puntero a la REAL datos.

Importante

__VCLOAD_REAL(<n>,<ptr>) leer <n> valores REALES consecutivos en la dirección <ptr>. Si menos de <n> Los valores en esta dirección pueden hacer que el controlador se bloquee o lea memoria no deseada.

Sintaxis

<vector variable> := __VCLOAD_REAL( <vector size>, <pointer to data of type REAL> ) ;
<vector size> : 2 | 3 | 4 | 5| 6 | 7| 8
ejemplo 249. Vectorizar
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]));


Operador: __VCLOAD_LREAL

El operador interpreta cualquier área de memoria arbitraria como un vector. Esto es útil para conectar variables vectoriales al código existente. El operador requiere 2 parámetros. El primer parámetro indica el número de elementos del vector. El segundo parámetro es un puntero a la LREAL datos.

Importante

__VCLOAD_LREAL (<n>,<ptr>) lee <n> valores LREAL sucesivos en el <ptr> habla a. Si hay menos de <n> valores en esta dirección, esto puede hacer que el controlador se bloquee o lea memoria no deseada.

Sintaxis

<vector variable> := __VCLOAD_LREAL( <vector size>, <pointer to data of type LREAL> );
<number of vector elements> : 1 | 2 | 3 | 4 | 5| 6 | 7| 8
ejemplo 250. Vectorizar
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]));


Operador: __VCSTORE

El operador guarda/copia el contenido del vector en la dirección de memoria especificada. El número y los tipos de elementos se aplican automáticamente a partir de las variables vectoriales.

Importante

__VCSTORE(<n>,<ptr>) escribe <n> valores consecutivos en la dirección <ptr>. Si menos de <n> Los valores en esta dirección pueden hacer que el controlador se bloquee o escriba memoria no deseada.

Sintaxis

__VCSTORE( <pointer to data>, <vector variable> );
ejemplo 251. Ahorrar
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);


En esta sección: