Variable : `VAR_GENERIC CONSTANT`

Variable constante générique

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

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 .

La constante générique peut être utilisée comme d'habitude dans l'implémentation du bloc fonctionnel. Ces types de constantes peuvent être utilisés, par exemple, pour les indices de tableaux ou les longueurs de chaînes

Syntaxe de la déclaration de variable

Syntaxe de la déclaration de variable (instanciation du bloc fonctionnel) avec une constante spécifiée

Les options suivantes sont possibles :

PROGRAM <program name>
VAR
    <fb instance name> : <function block name> < <literal> > ;
    <fb instance name> : <function block name> <( <expression> )> ;
    <fb instance name> : ARRAY [ <index start > .. <index end> ] OF <function block name> < <array length> > ;
END_VAR

Tableau 10. Déclaration de variables

`<scope>` `END_...`	Portée
`<fb instance name>`	Variable ; nom de l'instance du bloc fonctionnel
`: <function block name>`	Tasse la variable avec le bloc de fonction Il s'agit d'un bloc fonctionnel avec des constantes génériques.
`< <literal> >`	Facultatif Assigne une valeur spécifique au type de données qui n'est valide que pour cette instance de bloc fonctionnel. La valeur est formellement insérée `in angle brackets` en tant que suffixe du type de données. Exemple : `fbMyString1 : FB_MyString<100&>;` Si multiple des constantes génériques ont été déclarées pour le bloc fonctionnel définissant le type, puis une liste de valeurs séparées par des virgules est passée entre crochets angulaires. Il existe une valeur pour chaque constante. Example: `fbPou : FB_Pou<100, 1000>;`
`<( <expression> )>`	Facultatif Assigne une expression spécifique au type de données qui n'est valide que pour cette instance de bloc fonctionnel. L'expression est insérée `in angle brackets` en tant que suffixe du type de données. L'expression elle-même doit être incluse entre crochets . Les crochets sont nécessaires car il est permis d'utiliser des symboles tels que `<` ou `>` dans une expression. Dans le cas contraire, l'unicité du code n'est plus garantie. Example: `fbMyString2 : FB_MyString<(2 * cconst)>;`
`ARRAY [ <start index start> .. <end index> ] OF <function block name>`	Facultatif Tome la variable à l'aide d'un tableau de blocs fonctionnels. La longueur du tableau est la suivante : `<end index>` - `<start index>` + `1` Il s'agit d'un bloc fonctionnel avec des constantes génériques. Les constantes sont utilisées comme indices de tableau. Exemple : `arrMyString`
`< <array length> >`	Assigne une longueur de tableau spécifique au type de données, qui est valide en particulier pour cette instance de bloc fonctionnel. La longueur de tableau spécifiée est formellement insérée entre crochets angulaires en tant que suffixe du type de données. La valeur spécifiée doit correspondre à la longueur du tableau telle que définie par les index de début et de fin. Example: `arrMyString : ARRAY[0..5] OF FB_MyString<6>;`

Exemples

Exemple 93. 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 94. Exemple : constante générique d'un type de sous-scope

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)>;
    arrMyString : ARRAY [0..5] OF FB_SrString<6>;
END_VAR

Exemple 95. 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 constantes 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>

Astuce

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 96. 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: