__NEW

Definizione

Questo operatore non è prescritto dallo standard IEC 61131-3.

L'operatore __NEW alloca memoria per le istanze dei blocchi funzione o array dei tipi di dati standard. L'operatore restituisce un puntatore di tipo adatto per l'oggetto. Se l'operatore non è utilizzato in un'assegnazione, viene visualizzato un messaggio.

Attivare l'opzione Usare allocazione di memoria dinamica nella vista Opzioni creazione applicazione (Visualizza > Proprietà... > Opzioni creazione applicazione) per usare l'operatore __NEW. Consultare la Guida alla programmazione del controller specifico per vedere se le opzioni sono disponibili sul controller.

Se non è stato possibile allocare memoria, __NEW restituirà 0.

Per annullare l'allocazione, usare __DELETE.

Sintassi

__NEW (<tipo>, [<dimensione>]

L'operatore crea un nuovo oggetto del tipo specificato <type> e restituisce un puntatore per questo <type>. Dopo la creazione viene chiamata l'inizializzazione dell'oggetto. Se viene restituito 0, l'operazione non è stata eseguita correttamente.

NOTA: Utilizzare il tipo di dati esatto del blocco funzionale derivato e non quello del blocco funzionale di base. Non utilizzare una variabile di tipo POINTER TO BaseFB. Ciò è necessario in quanto, se il blocco funzionale di base non implementa alcuna funzione FB_Exit, a un successivo uso di __DELETE(pBaseFB), non viene chiamato alcun FB_Exit.

Se <type> è scalare, deve essere impostato anche l'operando opzionale <length> e l'operatore crea un array di tipi scalari con la dimensione lunghezza.

Esempio

pScalarType := __New(ScalarType, length);

NOTA: Un blocco funzione creato con __NEW dispone di area di memoria fissa. Non è possibile modificare il layout dei dati tramite modifica online. Perciò, non è possibile aggiungere o eliminare nuove variabili e non è possibile modificare i tipi.

Pertanto, solo i blocchi funzione delle librerie (dato che non possono essere modificati) e i blocchi funzione con l'attributo enable_dynamic_creation sono ammessi per l'operatore __NEW. Se un blocco funzionale cambia con questo flag ed è necessario il codice di copia, viene emesso un messaggio.

NOTA: Il codice per l'assegnazione della memoria deve essere non rientrante.

Per evitare che due task tentino di allocare memoria contemporaneamente viene utilizzato un semaforo (SysSemEnter). Di conseguenza, l'uso ricorrente di __New può produrre disturbi più intensi.

Esempio con un tipo scalare:

TYPE DUT :
    STRUCT
        a,b,c,d,e,f : INT;
    END_STRUCT
END_TYPE
PROGRAM PLC_PRG
VAR
    pDut : POINTER TO DUT;
    bInit: BOOL := TRUE;
    bDelete: BOOL;
END_VAR
IF (bInit) THEN
    pDut := __NEW(DUT);
    bInit := FALSE;
END_IF
IF (bDelete) THEN
    __DELETE(pDut);
END_IF

Esempio con un blocco funzionale:

{attribute 'enable_dynamic_creation'}
FUNCTION_BLOCK FBDynamic
VAR_INPUT
    in1, in2 : INT;
END_VAR
VAR_OUTPUT
    out : INT;
END_VAR
VAR
    test1 : INT := 1234;
    _inc : INT := 0;
    _dut : POINTER TO DUT;
END_VAR
out := in1 + in2;

PROGRAM_PLC_PRG
VAR
    pFB : POINTER TO FBDynamic;
    loc : INT;
    bInit: BOOL := TRUE;
    bDelete: BOOL;
END_VAR

IF (bInit) THEN
    pFB := __NEW(FBDynamic);
    bInit := FALSE;    
END_IF
IF (pFB <> 0) THEN
    pFB^(in1 := 1, in2 := loc, out => loc);
    pFB^.INC();
END_IF
IF (bDelete) THEN
    __DELETE(pFB);
END_IF

Esempio con un array:

PLC_PRG(PRG)
VAR
    bInit: BOOL := TRUE;
    bDelete: BOOL;
    pArrayBytes : POINTER TO BYTE;
    test: INT;
    parr : POINTER TO BYTE;
END_VAR
IF (bInit) THEN
    pArrayBytes := __NEW(BYTE, 25);
    bInit := FALSE;
END_IF
IF (pArrayBytes <> 0) THEN
    pArrayBytes[24] := 125;
    test := pArrayBytes[24];
END_IF
IF (bDelete) THEN
    __DELETE(pArrayBytes);
END_IF