Skip to main content

Variable: VAR_IN_OUT

Eine VAR_IN_OUT-Variable ist eine Ein- und Ausgabevariable, die Teil einer Bausteinschnittstelle ist und als formaler Durchgangsparameter dient.

Syntax

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

<keyword> : FUNCTION | FUNCTION_BLOCK | METHOD | PRG

Sie können eine Ein- und Ausgabevariable in den Programmierbausteinen PRG,FUNCTION_BLOCK, METHOD oder FUNCTION im Deklarationsabschnitt VAR_IN_OUT deklarieren. Die VAR_IN_OUT-Variable kann gelesen und beschrieben werden.

. Verwendung

  • Aufruf: Bei Aufruf des Programmierbausteins erhält die formale VAR_IN_OUT-Variable als Argument die tatsächliche Variable, die so genannte „Durchgangsvariable“. Zur Laufzeit bei der Parameterübergabe wird dann keine Kopie erzeugt, sondern die formale Variable erhält eine Referenz auf die von außen übergebene tatsächliche Variable. Die referenziellen Variablen enthalten intern als Wert eine Speicheradresse auf den eigentlichen Wert (Übergabe als Pointer, Call-by-Reference). Es ist nicht möglich als Argument direkt eine Konstante (Literal) oder eine Bitvariable anzugeben.

  • Schreib-/Lesezugriff innerhalb des Programmierbausteins: Wenn innerhalb des Programmierbausteins auf die Variable geschrieben wird, wirkt dies auf die übergebene Variable durch. Wenn der Programmierbaustein verlassen wird, bleiben vorgenommene Änderungen somit erhalten. Das bedeutet, dass ein Programmierbaustein seine VAR_IN_OUT-Variablen so verwendet, wie der aufrufende Programmierbaustein seine Variablen verwendet. Ein Lesezugriff ist immer erlaubt.

  • Schreib-/Lesezugriff von außen: VAR_IN_OUT-Variablen können nicht via <function block instance name>.<variable name> direkt von außen gelesen oder beschrieben werden. Dies funktioniert nur bei VAR_INPUT und VAR_OUTPUT-Variablen.

  • Übergabe von Stringvariablen: Wenn als Argument eine Stringvariable übergeben wird, sollten die tatsächliche Variable und die formale Variable die gleiche Länge haben. Andernfalls kann der übergebene String unbeabsichtigt manipuliert werden. Bei VAR_OUTPUT CONSTANT-Parametern tritt dieses Problem nicht auf.

  • Übergabe von Bitvariablen: Eine Bitvariable kann nicht direkt an eine VAR_IN_OUT-Variable übergeben werden, sondern benötigt eine Zwischenvariable.

  • Übergabe von Propertys: Nicht erlaubt

Tipp

Wenn eine Zeichenkette als Variable oder auch als Konstante an eine formale VAR_IN_OUT CONSTANT-Variable übergeben wird, dann wird sie automatisch vollständig übergeben. Sie müssen nicht auf die Stringlänge achten.

Für weitere Informatioen siehe: Übergabevariable VAR_IN_OUT CONSTANT

Beispiel 85. Beispiel

Übergabe eines Arrays

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

Stringübergabe

{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

Die Variable sDeviceStatus ist Teil der Bausteinschnittstelle von FB_B. Bei Aufruf von fbDoB wird dem String zunächst ein Gerätenamen zugewiesen, dann wird der String manipuliert.

_cds_varinouts_string.png

Übergabe einer Bitvariablen

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;

Das Programm ruft die Funktionsbaustein-Instanzen DoSomething_1 und DoSomething_2 auf. Wegen der direkten Zuweisung der Bitvariablen xBit0 an den VAR_IN_OUT-Eingang wird beim Aufruf der Instanz DoSomething_1 ein Compilerfehler erzeugt. Der Aufruf der Instanz DoSomething_2 mit Zuweisen einer Zwischenvariablen ist dagegen ein korrekter Code.



Übergabevariable VAR_IN_OUT CONSTANT

Eine VAR_IN_OUT CONSTANT-Variable dient als konstanter Durchgangsparameter, an den eine Variable aber auch eine Konstante (Literal) vom Typ STRING oder WSTRING übergeben werden kann. Der Parameter kann gelesen, aber nicht beschrieben werden. Die Übergabe von Propertys Ist nicht erlaubt.

Syntax Deklaration

<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-Variablen werden deklariert, ohne einen Initialisierungswert zuzuweisen.

. Verwendung

  • Bei Aufruf des Programmierbausteins kann eine konstante Variable oder ein Literal vom Typ STRING oder WSTRING übergeben werden. Folglich sind Schreibzugriffe nicht erlaubt.

  • Bei Parameterübergabe einer Stringkonstanten: Die Stringlänge der Konstanten kann beliebig sein und hängt nicht von der Stringlänge der VAR_IN_OUT CONSTANT-Variablen ab.

Tipp

Wenn in Projekt → Projekteinstellungen in Kategorie Compile-Optionen die Option Konstanten ersetzen aktiviert ist, dann erzeugt die Parameterübergabe einer Konstanten mit Basisdatentyp oder einer konstanten Variablen mit Basisdatentyp einen Compilerfehler.

Tipp

Die Variable wird ab Compilerversion >= 3.5.2.0 unterstützt.

Beispiel 86. Beispiel

Parameterübergabe von Stringkonstanten und Stringvariablen

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);

Im Code werden Strings über verschiedene VAR_IN_OUT-Variablen an die Funktion funManipulate übergeben. Bei Übergabe eines Stringliterals an eine VAR_IN_OUT-Variable wird ein Compilerfehler ausgegeben. Bei Übergabe einer konstanten Variablen an eine VAR_IN_OUT CONSTANT-Variable wird korrekter Code erzeugt, ebenso bei der Übergabe von Stringvariablen.



In diesem Abschnitt: