Skip to main content

Variable : VAR_IN_OUT

UNE VAR_IN_OUT variable est une variable d'entrée/sortie, qui fait partie d'une interface POU et sert de paramètre formel de passage par référence.

Syntaxe

<keyword> <POU name>
VAR_IN_OUT
    <variable name> : <data type>;
END_VAR

<keyword> : FUNCTION | FUNCTION_BLOCK | METHOD | PRG

Vous pouvez déclarer une variable d'entrée/sortie dans le fichier VAR_IN_OUT section de déclaration dans les POU PRG, FUNCTION_BLOCK, METHOD, ou FUNCTION. Le VAR_IN_OUT la variable peut être lue et écrite.

. Usage

  • Appeler: Lorsqu'un POU est appelé, le formel VAR_IN_OUT reçoit la variable réelle ("variable de passage par référence") comme argument. Lors de l'exécution, aucune copie n'est générée lorsque les paramètres sont passés. Au lieu de cela, la variable formelle reçoit une référence à la variable réelle transmise à distance. Les variables de référence contiennent en interne une adresse mémoire en tant que valeur par rapport à la valeur réelle (passer comme pointeur, appel par référence). Il n'est pas possible de spécifier une constante (littérale) ou une variable binaire directement comme argument.

  • Accès en lecture/écriture au sein de la POU: Si la variable est écrite dans la POU, cela affecte la variable transmise. Lorsque vous quittez la POU, toutes les modifications effectuées sont conservées. Cela signifie qu'un POU utilise son VAR_IN_OUT variables tout comme le POU appelant utilise ses variables. L'accès en lecture est toujours autorisé.

  • Accès en lecture/écriture à distance: VAR_IN_OUT variables ne peux pas être directement lu ou écrit à distance via <function block instance name>.<variable name>. Cela ne fonctionne que pour VAR_INPUT et VAR_OUTPUT variables.

  • Passer des variables de chaîne: Si une variable chaîne est passée en argument, alors la variable réelle et la variable formelle doivent avoir la même longueur. Sinon, la chaîne transmise peut être manipulée involontairement. Ce problème ne se produit pas dans le cas de VAR_OUTPUT CONSTANT paramètres.

  • Passer des variables de bit: Une variable bit ne peut pas être passée directement à un VAR_IN_OUT variable car il a besoin d'une variable intermédiaire.

  • Passation de propriétés: Pas permis

Astuce

Si une chaîne est passée en tant que variable ou constante à un formel VAR_IN_OUT CONSTANT variable, la chaîne est automatiquement transmise complètement. Vous n'avez pas à vérifier la longueur de la chaîne.

Pour plus d'informations, consultez : Variable de transfert "VAR_IN_OUT CONSTANTE"

Exemple 85. Exemple

Passer des tableaux

TYPE DUT_A :
STRUCT
        xA: BOOL;
        iB: INT;
END_STRUCT
END_TYPE

FUNCTION_BLOCK FB_SetArray
VAR_IN_OUT
        aData_A : ARRAY[0..1] OF DUT_A; // Formal variable
END_VAR
aData_A[0].xA := TRUE;
aData_A[0].iB := 100;

PROGRAM PLC_PRG
VAR
        fbSetA : FB_SetArray;
        aSpecialData : ARRAY[0..1] OF DUT_A; // Actual variable
END_VAR
fbSetA(aData_A := aSpecialData);
_cds_varinouts_array.png

Passer des chaînes

{attribute 'qualified_only'}
VAR_GLOBAL
        g_sDEV_STATUS : STRING(25) := 'Device_A';
END_VAR

FUNCTION_BLOCK FB_SetStatus
VAR_IN_OUT
        sDeviceStatus : STRING(25); // Formal parameter
END_VAR
sDeviceStatus := CONCAT(sDeviceStatus, ' Activ');

PROGRAM PLC_PRG
VAR
        fbDoB : FB_SetStatus;
END_VAR
fbDoB(sDeviceStatus := GVL.g_sDEV_STATUS); //Call with actual parameter

La variable sDeviceStatus fait partie de l'interface POU de FB_B. Lors de l'appel fbDoB, un nom de périphérique est d'abord attribué à la chaîne, puis la chaîne est manipulée.

_cds_varinouts_string.png

Passer des variables de bit

VAR_GLOBAL
        xBit0 AT %MX0.1 : BOOL;
        xTemp : BOOL;
END_VAR

FUNCTION_BLOCK FB_DoSomething
VAR_INPUT
        xIn : BOOL;
END_VAR
VAR_IN_OUT
        xInOut : BOOL;
END_VAR
IF xIn THEN
        xInOut := TRUE;
END_IF

PROGRAM PLC_PRG
VAR
        xIn : BOOL;
        DoSomething_1  : FB_DoSomething;
        DoSomething_2  : FB_DoSomething;
END_VAR

// The following line of code causes a compiler error:
// C0201: Typ 'BIT' is not equal to type 'BOOL' of VAR_IN_OUT 'xInOut'
DoSomething_1(xIn := xIn, xInOut := xBit0);

// Workaround
xTemp := xBit0;
DoSomething_2(xIn := xIn, xInOut := xTemp);
xBit0 := xTemp;

Le programme appelle les instances du bloc fonction DoSomething_1 et DoSomething_2. En raison de l'affectation directe de la variable bit xBit0 à la VAR_IN_OUT entrée, une erreur de compilation est générée lorsque le DoSomething_1 instance est appelée. En revanche, appeler le DoSomething_2 instance avec l'affectation d'une variable intermédiaire est le code correct.



Variable de transfert VAR_IN_OUT CONSTANT

UNE VAR_IN_OUT CONSTANT variable sert de paramètre de passage par référence constant, auquel un STRING ou WSTRING type variable ou constant (littéral) peut être passé. Le paramètre peut être lu, mais pas écrit. Le passage des propriétés n'est pas autorisé.

Déclaration de syntaxe

<keyword> <POU name>
VAR_IN_OUT CONSTANT
    <variable name> : <data type>; // formal parameter
END_VAR
<keyword> : FUNCTION | FUNCTION_BLOCK | METHOD | PRG

VAR_IN_OUT CONSTANT les variables sont déclarées sans affecter de valeur d'initialisation.

. Usage

  • Lors de l'appel de la POU, un STRING ou WSTRING une variable constante ou un littéral peut être passé. Par conséquent, l'accès en écriture n'est pas autorisé.

  • Passage des paramètres d'une constante de chaîne : la longueur de la chaîne des constantes peut être de n'importe quelle taille et la longueur de la chaîne ne dépend pas de la longueur de la chaîne du VAR_IN_OUT CONSTANT variables.

Astuce

Si la Remplacer les constantes l'option est sélectionnée dans Projet → Paramètres du projet dans le Options de compilation catégorie, puis passer les paramètres d'une constante avec le type de données de base ou d'une variable constante avec le type de données de base génère une erreur du compilateur.

Astuce

La variable est prise en charge dans la version du compilateur >= 3.5.2.0.

Exemple 86. Exemple

Passage de paramètres de constantes de chaîne et de variables de chaîne

FUNCTION funManipulate : BOOL
VAR_IN_OUT
        sReadWrite : STRING(16); (* Can be read or written here in POU *)
        dwVarReadWrite : DWORD; (* Can be read or written here in POU *)
END_VAR
VAR_IN_OUT CONSTANT
        c_sReadOnly : STRING(16); (* Constant string variable can only be read here in POU *)
END_VAR

sReadWrite := 'String_from_POU';
dwVarReadWrite := STRING_TO_DWORD(c_sReadOnly);

PROGRAM PRG_A
VAR
        sVarFits : STRING(16);
        sValFits : STRING(16) := '1234567890123456';
        dwVar: DWORD;
END_VAR

// The following line of code causes the compiler error C0417:
// C0417: VAR_IN_OUT parameter 'sReadWrite' needs a variable with write access as input.
funManipulate(sReadWrite:='1234567890123456', c_sReadOnly:='1234567890123456', dwVarReadWrite := dwVar);

//  Correct code
funManipulate(sReadWrite := sValFits, c_sReadOnly := '23', dwVarReadWrite := dwVar);
funManipulate(sReadWrite := sVarFits, c_sReadOnly := sValFits, dwVarReadWrite := dwVar);

Dans le code, les chaînes sont passées au funManipulate fonction via différents VAR_IN_OUT variables. Lors du passage d'un littéral de chaîne, une erreur du compilateur est émise vers un VAR_IN_OUT variable. Lors du passage d'une variable constante à un VAR_IN_OUT CONSTANT variable, un code correct est généré même pour le passage de variables de chaîne.



Dans cette section​: