Skip to main content

Variable: VAR_GENERIC CONSTANT

Variable constante générique

Vue d'ensemble

Le VAR_GENERIC l'extension fournit un support pour constantes génériques au moment de la compilation dans des blocs fonctionnels. Cela permet de créer des blocs fonctionnels flexibles et réutilisables qui peuvent être adaptés à différentes configurations (par exemple, tailles de mémoire tampon ou plages fixes) sans en s'appuyant sur l'allocation dynamique de mémoire.

Cette fonctionnalité est particulièrement utile pour les blocs fonctionnels qui gèrent des tableaux ou d'autres structures de mémoire. En outre, il permet des conceptions optimisées en termes de performances, de sécurité de type et entièrement résolues au moment

Une constante générique est une variable dans VAR_GENERIC CONSTANT portée d'un bloc fonctionnel. La variable est définie uniquement lorsque l'instance du bloc fonctionnel est déclarée.

Les constantes génériques peuvent être utilisées dans les méthodes. Cela peut être particulièrement utile dans les VAR_IN_OUT ou VAR_IN_OUT CONSTANT portée.

Syntaxe de la déclaration de type

Déclaration

Syntaxe de la déclaration de type d'un bloc fonctionnel avec des constantes génériques

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>

Nom du bloc fonctionnel

VAR_GENERIC CONSTANT

END_VAR

Portée des constantes génériques

Vous pouvez déclarer n'importe quel nombre de constantes génériques dans le VAR_GENERIC CONSTANT champ d'application.

<generic constant name>

Nom de variable des constantes génériques

: <integer data type>

Construisez le type de la constante générique.

Un type de données entier ou la sous-étendue d'un type de données entier est autorisé.

Exemple :

maxlen1 : INT := 4;

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

:= <initial value>

Facultatif

Initialisation

Important

La valeur initiale n'est nécessaire que pour les contrôles de compilation. Au moment de l'exécution, la valeur est remplacée .

Exemple :

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

Instanciation

Un bloc de fonctions avec des constantes génériques peut être instancié via un paramètre transmis soit explicitement en tant qu'expression, soit implicitement en utilisant un littéral.

Ce qui suit s'applique :

  • La partie du paramètre qui passe qui affecte le VAR_GENERIC CONSTANT la lunette est enfermée dans des équerres.

  • Les blocs de fonctions génériques doivent être instanciés avec des paramètres pour tous variables génériques. La transmission des paramètres doit être terminée. Une spécification partielle n'est pas autorisée et entraînera une erreur.

  • Soit tous les paramètres sont spécifiés explicitement, soit tous sont spécifiés implicitement. Une combinaison de spécifications explicites et implicites n'est pas autorisée

    • Implicite

      Lorsque des paramètres sont transmis pour plusieurs variables génériques, les valeurs souhaitées doivent être enchaînées sous forme de chaîne littérale et séparées par des virgules dans l'ordre dans lequel elles ont été déclarées dans le VAR_GENERIC CONSTANT champ d'application.

      <5,10>

    • Explicite avec nom

      Lorsque des paramètres sont transmis pour plusieurs variables génériques, tous les paramètres souhaités doivent être regroupés sous la forme d'une expression entre crochets et séparés par des virgules dans un gratuit commande. Comme d'habitude, une expression est placée entre parenthèses

      L'expression assigne un littéral, une variable ou une expression à la constante générique nommée à l'aide de l'opérateur d'affectation :=. Il est important de placer ce transfert de paramètres explicite entre parenthèses

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

      L'avantage est que le transfert des paramètres est facilement lisible, donc traçable et facilement maintenable après les modifications.

  • Si d'autres variables ont été déclarées, des paramètres supplémentaires doivent leur être transmis. Utilisation de l'opérateur d'affectation :=, ils sont enchaînés et placés entre parenthèses.

Exemple 91. Exemple

Bloc fonctionnel FB avec des constantes génériques

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


Exemple 92. Exemple

Instanciation du bloc fonctionnel FB avec simple passage de paramètres.

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

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


Exemple 93. Exemple

Instance de bloc de fonctions MyFB2 avec transmission explicite de paramètres

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;


Héritage avec constantes génériques

Les constantes génériques peuvent également être transmises à des blocs fonctionnels de base par héritage.

Utilisation de constantes dans un bloc fonctionnel

La constante peut être utilisée dans un bloc fonctionnel comme n'importe quelle autre constante (par exemple, dans des tableaux ou dans des déclarations de chaînes). Il peut être utilisé dans les méthodes, les propriétés ou les actions du bloc fonctionnel, mais il n'est pas accessible de l'extérieur. Cela signifie qu'elle se comporte comme une variable privée

Contrôles de précompilation

La valeur finale des constantes génériques n'étant pas disponible dans le bloc de fonction, les vérifications de précompilation sont limitées. Il est possible de définir une valeur d'initialisation comme suit :

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

Cette valeur d'initialisation (valeur 1 dans l'exemple) est utilisée pour les vérifications de précompilation dans le bloc de fonction, mais elle n'a aucun autre effet.

Exemples

Exemple 94. Exemple d'utilisation de plusieurs constantes génériques
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


Exemple 95. Exemple : Constante générique d'un type de sous-plage

Un type de sous-plage peut être utilisé comme paramètre générique pour spécifier une plage de valeurs autorisée qui est vérifiée par le compilateur.

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


Exemple 96. Exemple : Bloc fonctionnel générique avec variable matricielle paramétrable

Le code suivant montre comment définir un bloc de fonction capable de traiter des tableaux de longueur arbitraire. Le bloc fonctionnel possède un tableau de longueur générique mais constante. « Constante » signifie que, bien que la longueur de la matrice de chaque instance de bloc fonctionnel varie, elle est constante pendant toute la durée de vie de l'objet.

Ce type de construction est bénéfique, par exemple, pour un programmeur de bibliothèque qui souhaite implémenter une bibliothèque générique POU.

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


Héritage

Un bloc fonctionnel peut hériter d'un bloc fonctionnel de base avec une constante générique (EXTENDS). Le bloc de fonction héritant nécessite sa propre constante générique. Une valeur spécifique peut ensuite être transférée en externe.

Syntaxe :

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

Un bloc fonctionnel avec une constante générique peut implémenter une interface (IMPLEMENTS). L'interface déclare une propriété (PROPERTY) avec laquelle la valeur spécifiée est accessible de l'extérieur. L'interface elle-même ne doit pas déclarer de constants génériques ou de variables locales. Les interfaces n'ont aucune implémentation.

Syntaxe :

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

Important

Lors du codage, assurez-vous que la déclaration des constantes génériques est insérée en premier, suivie de EXTENDS et IMPLEMENTS. Il faut un certain temps pour s'y habituer, mais la raison en est que les constantes génériques peuvent également être utilisées avec les classes de base.

Exemple 97. Exemple

Définition de IString interface pour un bloc fonctionnel générique.

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 Cette propriété permet d'accéder à la constante générique.

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

Déclaration du bloc fonctionnel FB_MyString avec la constante générique maxlen

FUNCTION_BLOCK FB_MyString 
VAR_GENERIC CONSTANT        
    maxlen : UDINT; 
END_VAR 
IMPLEMENTS IString

Le bloc fonctionnel FB_LongString est une extension du bloc fonctionnel spécifié FB_MyString.

FUNCTION_BLOCK FB_LongString EXTENDS FB_MyString<1000>

Déclaration du bloc fonctionnel FB_MySpecialString avec la constante générique maxlen2 en tant qu'extension du bloc fonctionnel spécifié FB_MyString. Le bloc fonctionnel est étendu par la méthode 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

Instanciation des blocs de fonctions avec des constantes spécifiques

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

Appels

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


Dans cette section​: