Skip to main content

Variabile: VAR_GENERIC CONSTANT

Variabile costante generica

Panoramica

Le VAR_GENERIC l'estensione fornisce supporto per costanti generiche in fase di compilazione in blocchi funzionali. Ciò consente la creazione di blocchi funzionali flessibili e riutilizzabili che possono essere adattati a diverse configurazioni (ad esempio, dimensioni del buffer o senza basandosi sull'allocazione dinamica della memoria.

Questa funzionalità è particolarmente utile per i blocchi funzione che gestiscono array o altre strutture di memoria. Inoltre, consente progetti ottimizzati per le prestazioni, sicuri per i tipi e completamente risolti in fase di

Una costante generica è una variabile in VAR_GENERIC CONSTANT ambito di un blocco funzionale. La variabile è definita solo quando viene dichiarata l'istanza del blocco funzione.

costanti generiche possono essere utilizzate nei metodi. Ciò può essere particolarmente utile in VAR_IN_OUT o VAR_IN_OUT CONSTANT ambito.

Sintassi della dichiarazione del tipo

Dichiarazione

Sintassi della dichiarazione del tipo di un blocco funzionale con costanti generiche

FUNCTION_BLOCK <function block name>
VAR_GENERIC CONSTANT
    <generic constant name> : <integer data type> := <initial value> ; //Initial value will be overwritten
END_VAR

<function block name>

Nome del blocco funzionale

VAR_GENERIC CONSTANT

END_VAR

Ambito per costanti generiche

È possibile dichiarare un numero qualsiasi di costanti generiche nel VAR_GENERIC CONSTANT ambito.

<generic constant name>

Nome variabile delle costanti generiche

: <integer data type>

Costruisci quale digita la costante generica.

È consentito un tipo di dati intero o il sottoscopio di un tipo di dati intero.

Esempio:

maxlen1 : INT := 4;

maxlen2 : INT(5..10) := 5;

:= <initial value>

Facoltativo

Inizializzazione

Importante

Il valore iniziale è necessario solo per i controlli di compilazione. In fase di esecuzione, il valore viene sovrascritto

Esempio:

FUNCTION BLOCK FB
VAR_GENERIC CONSTANT
    size : INT;
END_VAR
VAR
    buffer : ARRAY[0..size] OF BYTE;
END_VAR

Istanziazione

Un blocco funzione con costanti generiche può essere i stanziato tramite un parametro che passa esplicitamente come espressione o implicitamente utilizzando un valore letterale.

Si applica quanto segue:

  • La parte del passaggio dei parametri che influisce sul VAR_GENERIC CONSTANT l'oscilloscopio è racchiuso tra parentesi angolari.

  • I blocchi funzione generici devono essere i stanziati con parametri per tutti variabili generiche. Il passaggio dei parametri deve essere completo. Una specifica parziale non è consentita e comporterà un errore.

  • Tutti i parametri sono specificati in modo esplicito o sono tutti specificati implicitamente. Non è consentita una combinazione di specifiche esplicite e implicite

    • Implicito

      Quando vengono passati parametri per più variabili generiche, i valori desiderati devono essere messi insieme come valori letterali e separati da virgole nell'ordine in cui sono stati dichiarati nel VAR_GENERIC CONSTANT ambito.

      <5,10>

    • Esplicito con nome

      Quando vengono passati parametri per più variabili generiche, tutti i parametri desiderati devono essere messi insieme come un'espressione tra parentesi e separati da virgole in un gratuito ordine. Come al solito, un'espressione è racchiusa tra parentesi

      L'espressione assegna un valore letterale, una variabile o un'espressione alla costante generica denominata utilizzando l'operatore di assegnazione :=. È importante racchiudere questo trasferimento esplicito dei parametri

      <(Array2Size := 10), (Array1Size := 5)>

      Il vantaggio è che il trasferimento dei parametri è facilmente leggibile, quindi tracciabile e facilmente mantenibile dopo le modifiche.

  • Se sono state dichiarate più variabili, è necessario passare loro parametri aggiuntivi. Utilizzo dell'operatore di assegnazione :=, sono messi insieme e racchiusi tra parentesi.

Esempio 91. Esempio

Blocco funzionale FB con costanti generiche

FUNCTION_BLOCK FB
VAR_GENERIC CONSTANT
    Array1Size : INT := 0;
    Array2Size : INT := 0;
END_VAR
VAR_INPUT
    MyArray1 : ARRAY[0..Array1Size-1] OF REAL;
    MyArray2 : ARRAY[0..Array2Size-1] OF REAL;
END_VAR
VAR
    SomeOtherParameter : INT;
END_VAR


Esempio 92. Esempio

Istallazione del blocco funzionale FB con semplice passaggio di parametri.

PROGRAM PLC_PRG
VAR
    MyFB1 : FB<5,10> := (SomeOtherParameter:=20);
END_VAR

VAR
    liArray1Size: LINT;
END_VAR
liArray1Size := UPPER_BOUND(MyFB1.MyArray1,1) + 1;


Esempio 93. Esempio

Istanza del blocco funzionale MyFB2 con passaggio esplicito di parametri

PROGRAM PLC_PRG
VAR
    MyFB1 : FB<5,10> := (SomeOtherParameter:=20);
    MyFB2 : FB<(Array2Size:=10), (Array1Size:=5)> := (SomeOtherParameter := 10);
END_VAR

VAR
    Array1Size, Array2Size : LINT;
END_VAR
Array1Size := UPPER_BOUND(MyFB1.MyArray1,1) + 1;
Array2Size := UPPER_BOUND(MyFB1.MyArray2,1) + 1;


Ereditarietà con costanti generiche

Le costanti generiche possono anche essere passate ai blocchi funzione di base tramite ereditarietà.

Uso delle costanti in un blocco funzione

La costante può essere utilizzata in un blocco funzione come qualsiasi altra costante (ad esempio, negli array o nelle dichiarazioni di stringhe). Può essere utilizzata nei metodi, nelle proprietà o nelle azioni del blocco funzione, ma non è accessibile esternamente. Ciò significa che si comporta come una

Controlli di precompilazione

Poiché il valore finale delle costanti generiche non è disponibile nel blocco funzione, i controlli di precompilazione sono limitati. È possibile definire un valore di inizializzazione

FUNCTION_BLOCK FB
VAR_GENERIC CONSTANT  
    size : INT := 1;
END_VAR
VAR 
   buffer : ARRAY[0..size] OF BYTE;
END_VAR

Questo valore di inizializzazione (valore 1 nell'esempio) viene utilizzato per i controlli di precompilazione all'interno del blocco funzione, ma non ha altri effetti.

Esempi

Esempio 94. Esempio di utilizzo di più costanti generiche
FUNCTION_BLOCK FB_Pou
VAR_GENERIC CONSTANT
    lnstring : DINT := 10;
    numstring : DINT := 100;
END_VAR
VAR
    arraystring : ARRAY[0..numstring-1] OF STRING(lnstring);
END_VAR
PROGRAM PLC_PRG
VAR
    fbPou : FB_Pou<100, 1000>;
END_VAR


Esempio 95. Esempio: costante generica di un tipo di sottoscopio

Un tipo di sottointervallo può essere utilizzato come parametro generico per specificare un intervallo di valori consentito che viene controllato dal compilatore.

FUNCTION_BLOCK FB_SrString 
VAR_GENERIC CONSTANT
    maxlen2 : INT(5..10) := 5;    //subrange data type
END_VAR
VAR
    arrTest : ARRAY[0..maxlen-1] OF BYTE;
END_VAR
;
PROGRAM SrMain
VAR CONSTANT
    cconst: INT(5..10) := 5;
END_VAR
VAR    
    fbMyString1 : FB_SrString<5>;
    fbMyString2 : FB_SrString<(2 * cconst)>;
    fbMyString3 : FB_SrcString<123>;
    // ERROR: An error is reported here because 123 is not within the value range 5..10.
    arrMyString : ARRAY [0..5] OF FB_SrString<6>;
END_VAR


Esempio 96. Esempio: blocco funzione generico con variabile di matrice parametrizzabile

Il codice seguente dimostra come definire un blocco funzione in grado di elaborare array di lunghezza arbitraria. Il blocco funzionale ha una matrice con una lunghezza generica ma costante. «Costante» significa che, sebbene ogni istanza del blocco funzione vari nella lunghezza dell'array, è costante per tutta la durata dell'oggetto.

Questo tipo di costrutto è utile, ad esempio, per un programmatore di librerie che desidera implementare una POU di libreria generica.

FUNCTION_BLOCK FB_MyString 
VAR_GENERIC CONSTANT
    maxlen : UDINT := 1;
END_VAR
VAR
    test : ARRAY[0..maxlen-1] OF BYTE;
END_VAR
PROGRAM PLC_PRG
VAR CONSTANT
    cconst: DINT := 1000;
END_VAR
VAR    
    fbMyString1 : FB_MyString<100>;
    fbMyString2 : FB_MyString<(2 * cconst)>;   
    arrMyString : ARRAY[0..5] OF FB_MyString<6>;    
END_VAR


Eredità

Un blocco funzione può ereditare da un blocco funzione di base con una costante generica (EXTENDS). Il blocco funzione ereditario richiede una propria costante generica. Un valore specifico può quindi essere trasferito esternamente

Sintassi:

FUNCTION_BLOCK <function block name> 
VAR_GENERIC CONSTANT        
    <generic constant name> : <integer data type> ; 
END_VAR 
EXTENDS <function block base> < <generic constant name> >

Un modulo funzione con una costante generica può implementare un'interfaccia (IMPLEMENTS). L'interfaccia dichiara una proprietà (PROPERTY) che può essere utilizzato per accedere al valore specificato dall'esterno. L'interfaccia stessa non deve dichiarare costanti generiche o variabili locali. Le interfacce non hanno alcuna implementazione

Sintassi:

FUNCTION_BLOCK <function block name>
VAR_GENERIC CONSTANT
    <generic constant name> : <integer data type> ;
END_VAR
IMPLEMENTS <interface name>

Importante

Durante la codifica, assicurati che la dichiarazione delle costanti generiche sia inserita per prima, seguita da EXTENDS e IMPLEMENTS. Ci vuole un po' di tempo per abituarsi, ma il motivo è che le costanti generiche possono essere utilizzate anche con le classi base

Esempio 97. Esempio

Definizione di IString interfaccia per un blocco funzione generico.

It is strongly recommended to define an interface for generic function blocks. The interface should allow the generic function block instance to be used without knowledge of the generic constants.

Le Length la proprietà consente l'accesso alla costante generica.

INTERFACE IString 
METHOD Append : BOOL 
VAR_INPUT     
    strAppend : IString; 
END_VAR 

METHOD Assign : BOOL
VAR_INPUT     
    stringIn : STRING; 
END_VAR 

METHOD ToString : STRING
VAR_INPUT 
END_VAR 

PROPERTY Length : DINT

Dichiarazione del blocco funzionale FB_MyString con la costante generica maxlen

FUNCTION_BLOCK FB_MyString 
VAR_GENERIC CONSTANT        
    maxlen : UDINT; 
END_VAR 
IMPLEMENTS IString

Il blocco funzionale FB_LongString è un'estensione del blocco funzione specificato FB_MyString.

FUNCTION_BLOCK FB_LongString EXTENDS FB_MyString<1000>

Dichiarazione del blocco funzionale FB_MySpecialString con la costante generica maxlen2 come estensione del blocco funzione specificato FB_MyString. Il blocco funzionale viene esteso con il metodo METH_ToLatin.

FUNCTION_BLOCK FB_MySpecialString 
VAR_GENERIC CONSTANT        
    maxlen2 : UDINT:= 1; 
END_VAR 
EXTENDS FB_MyString<maxlen2>

METHOD METH_ToLatin : STRING
VAR_INPUT
END_VAR

Istanziazione dei blocchi funzionali con costanti specifiche

PROGRAM PLC_PRG 
VAR CONSTANT     
    cconst: DINT := 1000; 
END_VAR
VAR     
    string1 : FB_MyString<100>;
    string2 : FB_MyString<(2 * cconst)>;
    derived1 : FB_LongString;
    derived2 : FB_MySpecialString<100>;
END_VAR

Chiamate

string1.METH_Assign ('Welt'); 
string2.METH_Assign ('Hallo '); 
string2.METH_Append(string1); 
derived2.METH_ToLatin('Hello World');


In questa sezione: