Skip to main content

Operador: __NEW

El operador es una extensión del estándar IEC 61131-3.

el __NEW-El operador asigna memoria dinámicamente para crear instancias de bloques de funciones, tipos de datos definidos por el usuario o matrices de tipos de datos estándar. El operador devuelve un puntero correctamente escrito.

Requisito: En el cuadro de diálogo de propiedades de la aplicación superior, en la pestaña Opciones de creación de aplicaciones, es la opción Usar asignación de memoria dinámica activado.

sintaxis

<pointer name> := __NEW( <type> ( , <size> )? );
__DELETE( <pointer name> );

<type> : <function block> | <data unit type> | <standard data type>

El operador crea una instancia del tipo <type> y devuelve un puntero a esta instancia. Luego se llama a la inicialización de la instancia. si es en <type> es un tipo de datos escalares estándar, también se usa el operando opcional <size> evaluado. Luego, el operador crea una matriz de tipo <standard data type> el tamaño <size>. Si falla el intento de asignar memoria, __NEW el valor 0 espalda.

Utilice el operador dentro de la asignación ":=", de lo contrario, se muestra un mensaje de error.

Un bloque de funciones o tipo de datos definido por el usuario cuya instancia con __NEW generada dinámicamente, ocupa un área de memoria fija. Esto requiere que uses los objetos con el pragma {attribute 'enable_dynamic_creation'} Marcos. Esto no es necesario para los bloques de funciones que forman parte de una biblioteca.

Sugerencia

Si cambia el diseño de datos del bloque de función en el modo online, no podrá iniciar sesión posteriormente con el cambio online. El área de memoria de la instancia del bloque de funciones se ha vuelto inválida. Cambia el diseño de los datos cuando agrega nuevas etiquetas al bloque de funciones, elimina etiquetas existentes o cambia los tipos de datos de las etiquetas.

ejemplo 150. Ejemplos

Array (DWORD)

PROGRAM PLC_PRG
VAR
        pdwScalar : POINTER TO DWORD; //Typed pointer
        xInit : BOOL := TRUE;
        xDelete : BOOL;
END_VAR

IF (xInit) THEN
        pdwScalar := __NEW(DWORD, 16); // Allocates memory (16 dwords) and assigns them to pointer pdwScalar
END_IF
IF (xDelete) THEN
        __DELETE(pdwScalar); // Frees memory of pointer
END_IF

bloque de funciones

{attribute 'enable_dynamic_creation'}
FUNCTION_BLOCK FBComputeGamma
VAR_INPUT
        iAlpha : INT;
        iBeta : INT;
END_VAR
VAR_OUTPUT
        iGamma : INT;
END_VAR
VAR
END_VAR

iGamma := iAlpha + iBeta;

PROGRAM PLC_PRG
VAR
        pComputeGamma : POINTER TO FBComputeGamma;      // Typed pointer
        xInit : BOOL := TRUE;
        xDelete : BOOL;
        iResult : INT;
END_VAR

IF (xInit) THEN
        pComputeGamma := __NEW(FBComputeGamma); // Allocates memory
        xInit := FALSE;
END_IF
pComputeGamma^.iAlpha := (pComputeGamma^.iAlpha + 1)MOD 100; // Sets first input of pComputeGamma
pComputeGamma^.iBeta := 10; // Sets second input of pComputeGamma
pComputeGamma^(); // Calls the FB pComputeGamma is pointing to
iResult := pComputeGamma^.iGamma; // Reads output of pComputeGamma
IF (xDelete) THEN
    __DELETE(pComputeGamma); // Frees memory
END_IF

Tipo de datos definido por el usuario (DUT)

{attribute 'enable_dynamic_creation'}
TYPE ABCDATA :
STRUCT
             iA, iB, iC, iD : INT;
END_STRUCT
END_TYPE

PROGRAM PLC_PRG
VAR
        pABCData : POINTER TO ABCDATA; // Typed pointer
        xInit : BOOL := TRUE;
        xDelete : BOOL;
END_VAR

IF (xInit) THEN
    pABCData := __NEW(ABCDATA); // Allocates memory
    xInit := FALSE;
END_IF
IF (xDelete) THEN
    __DELETE(pABCData); // Frees memory
END_IF

Array (BYTE)

PROGRAM PLC_PRG
VAR
        pbDataAlpha : POINTER TO BYTE;
        pbDataBeta : POINTER TO BYTE;
        xInit : BOOL := TRUE;
        xDelete : BOOL;
        usiCnt : USINT;
        bTestC: BYTE;
END_VAR

IF (xInit) THEN
        pbDataAlpha := __NEW(BYTE, 16); // Allocates 16 bytes for pbDataAlpha
        pbDataBeta := __NEW(BYTE);  // Allocates memory for pbDataBeta
        xInit := FALSE;

        FOR usiCnt := 0 TO 15 DO
                pbDataAlpha[usiCnt] := usiCnt; // Writes to new array
        END_FOR
        pbDataBeta^:= 16#FF; // Writes to new data
END_IF

bTestC := pbDataAlpha[12];  // Reads new array by index access

IF (xDelete) THEN // Frees memory
        __DELETE(pbDataAlpha);
        __DELETE(pbDataBeta);
END_IF


Importante

No es recomendable ejecutar dos tareas al mismo tiempo que ambas usan el __NEWoperador de llamadas. O usas un semáforo (SysSemEnter) o una técnica similar para realizar una llamada simultánea a __NEW para prevenir. Sin embargo, esto significa que con el uso extensivo de __NEW se produce una fluctuación mayor.

Recomendado es solo en una tarea __NEW-Invocar operadores.

En esta sección: