Zuweisungen in ST

Syntax

name_1 := name_2;
name_1 := literal; 
 
reference_variable_1 := REF(name) | NULL;
reference_variable_1 := reference_variable_2;
 
interface_variable_1 := function_block_instance_1;
interface_variable_1 := interface_variable_2;
interface_variable_1 := NULL;

Bedeutung

→Zuweisung auf →Variablen oder →Funktionsbaustein-Instanzen oder Zuweisung eines Ergebniswerts
Eine Zuweisung ist zulässig, sofern die Ausdrücke auf den beiden Seiten des Zuweisungsoperators ":=" auf dem gleichen Datentyp oder auf Datentypen basieren, die laut der IEC-Norm implizit konvertiert werden können – sofern es sich bei diesen Datentypen um einen abgeleiteten Datentyp oder eine elementaren Datentyp handelt. Falls es sich bei den Datentypen um einen Array-Datentyp handelt, müssen die Ausdrücke auf dem gleichen Datentyp basieren. Bei einem Strukturdatentyp müssen die Ausdrücke auf einem identischen Datentyp basieren (siehe unter "Zugriff auf strukturierten Datentyp und Strukturelemente").

Zuweisungen sind grundsätzlich innerhalb der Deklaration eines →Programms, eines →Funktionsbausteins. einer →Funktion oder einer →Methode möglich. Die Zuweisung eines Ergebniswerts ist nur innerhalb einer Funktion oder einer Methode möglich.

Der Ausdruck auf der rechten Seite des Zuweisungsoperators ":=" darf eines der folgenden Konstrukte sein (abhängig vom Ausdruck auf der linken Seite):

eine deklarierte Variable (z.B. eine interne Variable, eine Ausgangsvariable einer Funktionsbaustein-Instanz, eine STRING-Variable), ein Array-Element oder ein Element eines strukturierten Datentyps
Beispiele: var2, MyFunctionBlock.OUT, var3[1] oder MyDataType.Elem1
eine Funktionsbaustein-Instanz
Falls Sie eine Funktionsbaustein-Instanz auf eine andere Funktionsbaustein-Instanz zuweisen, werden die Instanzdaten des Funktionsbausteins auf die andere Funktionsbaustein-Instanz zugewiesen.

ein Aufruf einer Funktion (z.B. MyFunction();) oder ein Aufruf einer MethodeFalls der Aufruf mit einer Zuweisung auf den Eingang EN erfolgt, so gibt der Wert für EN den Ausschlag, ob der Aufruf und damit auch die Zuweisung ausgeführt wird. Hier die Erläuterung anhand von Beispielen:

Code	Bedeutung
`x1:=MyFunction(EN := FALSE);`	Da `EN` `:`= `FALSE`, wird `MyFunction` nicht aufgerufen und es erfolgt keine Zuweisung auf `x1`.
`x2:=MyFunction(EN := TRUE);`	Da `EN` `:`= `TRUE`, erfolgt die Zuweisung auf `x2` mit dem Wert von `MyFunction`.
`x3:=MyFunction(EN := myBoolVariable1); x4:=MyFunction(EN := myBoolVariable2);`	Falls `myBoolVariable1` `:`= `FALSE`, wird `MyFunction` nicht aufgerufen und es erfolgt keine Zuweisung auf `x3`. Falls `myBoolVariable2` `:`= `TRUE`, erfolgt die Zuweisung auf `x4` mit dem Wert von `MyFunction`.

ein boolesches →Literal
Mögliche boolesche Literale

Entsprechungen für "TRUE" Entsprechungen für "FALSE"
BOOL#TRUE BOOL#FALSE
BOOL#1 BOOL#0
TRUE FALSE
1 0

ein →Bitfolge-Literal

Beispiele für Bitfolge-Literale

Beschreibung	Beispiele
Ganzzahl	`0`, `123_4`, `+986`
Zur Basis 2 (Binär-Literal)	`2#1111_1111` (`255` dezimal), `2#1110_0000` (`224` dezimal)
Zur Basis 8 (Oktal-Literal)	`8#377` (`255` dezimal), `8#340` (`224` dezimal)
Zur Basis 16 (Hexadezimal-Literal)	`16#FF` oder `16#ff` (`255` dezimal), `16#E0` oder `16#e0` (`224` dezimal)
obige Möglichkeiten (ohne Vorzeichen) als Literal mit Typangabe `BYTE`, `WORD`, `DWORD` oder `LWORD`(sofern der Wert im Wertbereich des entsprechenden Datentyps liegt)	`WORD#986`, `WORD#16#FF` (`255` dezimal)

BOOL ist ein Bitfolge-Datentyp. Es sind jedoch nur bestimmte →Boolesche Literale möglich.

ein →Integer-Literal

Beispiele für Integer-Literale

Beschreibung	Beispiele
Ganzzahl	`-12`, `0`, `123_4`, `+986`
Zur Basis 2 (Binär-Literal)	`2#1111_1111` (`255` dezimal), `2#1110_0000` (`224` dezimal)
Zur Basis 8 (Oktal-Literal)	`8#377` (`255` dezimal), `8#340` (`224` dezimal)
Zur Basis 16 (Hexadezimal-Literal)	`16#FF` oder `16#ff` (`255` dezimal), `16#E0` oder `16#e0` (`224` dezimal)
obige Möglichkeiten als Literal mit Typangabe `SINT`, `INT`, `DINT`, `LINT`, `USINT`, `UINT`, `UDINT`,`ULINT`(sofern der Wert im Wertbereich des entsprechenden Datentyps liegt)	`INT#-12`, `INT#16#FF` (`255` dezimal)

ein →Real-Literal vom Datentyp REAL oder LREAL

Beispiele für Real-Literale

Beschreibung	Beispiele
Real-Literal	`0, 0.0, 0.4560, 3.14159_26`
Real-Literal mit Exponenten	`-1.34E-12, -1.34e-12` `1.0E+6, 1.0e+6, 1E+6` `1.234E6, 1.234e6`
obige Möglichkeiten als Literal mit Typangabe `REAL` oder `LREAL`(sofern der Wert im Wertbereich des entsprechenden Datentyps liegt)	`REAL#0.0`, `REAL#1.0E+6`

ein →Zeitliteral

Beispiele für Zeitdauer-Literale

Sie müssen Daten für Zeitdauer, wie Tage (d), Stunden (h), Minuten (m), Sekunden (s) und Sekunden-Abschnitte (ms für Millisekunden, us für Mikrosekunden, ns für Nanosekunden) oder Kombinationen davon, in der Weise angeben, wie in der folgenden Tabelle gezeigt. Sie können die Zeitdauer-Einheiten durch Unterstrich-Zeichen trennen. Außerdem können Sie die Einheiten in Groß- oder Kleinbuchstaben eingeben, zum Beispiel s oder S für Sekunden.

Beschreibung	Beispiele
Zeitdauer-Literale ohne Unterstriche
kurzes Präfix	`T#14ms`, `T#14.7s`, `T#14.7m`, `T#14.7h`, `T#14.7d`, `T#14h12m`, `t#5d14h12m18s3.5ms`
langes Präfix	`TIME#14ms`, `time#14h12m`
Zeitdauer-Literale mit Unterstrichen
kurzes Präfix	`T#14h_12m`, `t#5d_14h_12m_18s_3.5ms`
langes Präfix	`TIME#14h_12m`, `time#5d_14h_12m_18s_3.5ms`

Beachten Sie, dass Ihr eingesetztes →Zielsystem die Verwendung von Zeitdauer-Literalen in logi.CAD 3 beeinflussen kann (siehe "Zielsystem-spezifische Eigenschaften und Einschränkungen").

Beispiele für Literale für Datum und Tageszeit

Bei den Literalen für Tageszeit und für Datum und Zeit sind die Sekunden-Abschnitte (nach dem . eingegeben) optional.

Beschreibung	Beispiele
Literale für Datum
kurzes Präfix	`D#1984-06-25`
langes Präfix	`DATE#1984-06-25`
Literale für Datum und Zeit
kurzes Präfix	`DT#1984-06-25-15:36:55.360_227_400`
langes Präfix	`DATE_AND_TIME#1984-06-25-15:36:55.360227400`
Literale für Tageszeit
kurzes Präfix	`TOD#15:36:55.36`
langes Präfix	`TIME_OF_DAY#15:36:55.36`

Beachten Sie, dass Ihr eingesetztes →Zielsystem die Verwendung von diesen Literalen in logi.CAD 3 beeinflussen kann (siehe "Zielsystem-spezifische Eigenschaften und Einschränkungen").

ein →Zeichenfolge-Literal

Beispiele für Zeichenfolge-Literale

Einzel-Byte-Zeichenfolgen bestehen aus keinem oder mehreren Zeichen, denen das einfache Anführungszeichen ' vorangestellt ist und die mit diesem Zeichen geschlossen werden.
Doppel-Byte-Zeichenfolgen, die mit dem doppelten Anführungszeichen " eingeschlossen werden, werden hingegen in logi.CAD 3 für Zeichenfolge-Literal nicht unterstützt.
Einzel-Byte-Zeichenfolgen sind:

Beschreibung	Beispiele
`STRING`-Literal	`'OK'`, `'ABCDEF'`
`STRING`-Literal mit Typangabe	`STRING#'OK'`, `STRING#'ABCDEF'`
`CHAR`-Literal	'B'`,` 'T'
`CHAR`-Literal mit Typangabe	CHAR#'B'`,` CHAR#'T'

Kombinationen von 3 Zeichen, beginnend mit dem Dollar-Zeichen ($) und gefolgt von 2 Hexadezimal-Ziffern, werden in logi.CAD 3 als entsprechendes Zeichen des ANSI-C-Zeichensatzes interpretiert.

Auf diese Weise können Sie Sonderzeichen, wie z.B. Umlaute, für Einzel-Byte-Zeichenfolgen eingeben. Derzeit werden solche Sonderzeichen in logi.CAD 3 (z.B. in der Sicht Variablenwerte) jedoch so ausgegeben, wie sie eingegeben wurden.
Hier eine Auswahl an Sonderzeichen (eine Liste von Sonderzeichen und der entsprechenden Hexadezimal-Ziffernfinden Sie unter https://www.ascii-code.com/):

Dezimalwert	Hexadezimal-Ziffer	Einzugeben	Sonderzeichen
128	80	$80	€
163	A3	$A3	£
169	A9	$A9	©
174	AE	$AE	®
177	B1	$B1	±
178	B2	$B2	^²(hochgestellte Ziffer "2")
179	B3	$B3	^³ (hochgestellte Ziffer "3")
188	BC	$BC	¼
189	BD	$BD	½
190	BE	$BE	¾
196	C4	$C4	Ä
214	D6	$D6	Ö
220	DC	$DC	Ü
223	DF	$DF	ß
228	E4	$E4	ä
246	F6	$F6	ö
252	FC	$FC	ü

Falls die Zeichenkombination '$00' einem einzelnen Zeichen einer STRING-Variable zugewiesen wird, endet die Zeichenfolge der STRING-Variable an dieser Position. Solche Zeichenfolge werden auch in der Sicht Variablenwerte bei $00 beendet.
In Zuweisungen wird jedoch die vollständige Zeichenfolge übernommen. So ist es möglich, dass die Sicht Variablenwerte einzelne Zeichen hinter $00 darstellt, falls Sie auf zugewiesenen Zeichen hinter $00 zugreifen.

Zusätzlich sind die folgenden Angaben für Einzel-Byte-Zeichenfolgen möglich:

Angabe	Bedeutung
`''`	leere Zeichenfolge
`' '`	Zeichenfolge mit Leerzeichen
`'$''`	Zeichenfolge mit einfachem Anführungszeichen `'`
`'"'`	Zeichenfolge mit doppeltem Anführungszeichen `"`

Zusätzlich sind die folgenden Angaben für Zwei-Zeichen-Kombinationen in Einzel-Byte-Zeichenfolgen möglich:

Angabe	Bedeutung
`$'`	Zeichenfolge mit einfachem Anführungszeichen `'`
`$$`	Zeichenfolge mit Dollarzeichen `$`
`$L` oder `$l`	Zeichenfolge mit Zeilenvorschub ("Line feed")
`$N` oder `$n`	Zeichenfolge mit neuer Zeile ("Newline")
`$P` oder `$p`	Zeichenfolge mit Seitenvorschub ("Form feed (page)")
`$R` oder `$r`	Zeichenfolge mit Wagenrücklauf ("Carriage return")
`$T` oder `$t`	Zeichenfolge mit Tabulator

ein Ausdruck (aus Operanden in ST und Operatoren in ST zusammengesetzt)
Ausdrücke ohne einen konkreten Datentyp werden typisiert (siehe "Typisierung von Ausdrücken").
sofern die Zuweisung auf eine deklarierte →Referenz-Variable erfolgt: REF(name) oder NULL oder eine andere Referenz-Variable vom gleichen Datentyp
Details: siehe unter "Deklaration von Referenz-Variablen (inkl. Zuweisungen darauf) "
sofern die Zuweisung auf eine deklarierte Variable erfolgt, die auf einem →Interface basiert: eine Funktionsbaustein-Instanz, die das gleiche/abgeleitete Interface implementiert, eine andere Variable basierend auf dem gleichen/abgeleiteten Interface oder NULL
Details: siehe unter "Deklaration von Variablen, die auf einem Interface basieren"

Beispiel

PROGRAM TestAssignments
  VAR
    var1, var2, var3, var5, var7, var8 : INT;
    var4 : BOOL;
    var6 : TIME;
    Inst1 : MyFB1;
    Inst2 : MyFB1;
  END_VAR
  var1 := var2;  	 (* Die Variable 'var2' wird auf die Variable 'var1' zugewiesen.  *)
  Inst1 := Inst2; 	 (* Die Instanz 'Inst2' wird auf die Instanz 'Inst1' zugewiesen. *)
  var3 := Simple1(); (* Die Funktion 'MyFunction' wird aufgerufen und deren Wert auf die Variable 'var3' zugewiesen. *)  
  var4 := TRUE;   	 (* Diese und die folgenden Zeilen zeigen die Zuweisung eines Literals auf eine Variable. *)
  var5 := 12;
  var6 := T#3ms;
  var7 := 5 * 3;     (* Diese und die folgende Zeile zeigen die Zuweisung eines Ausdrucks auf eine Variable. *)
  var8 := var2 + 20;
END_PROGRAM

FUNCTION_BLOCK MyFB1
END_FUNCTION_BLOCK

Ergebniswert innerhalb einer Funktion zuweisen

Falls ein Ergebniswert innerhalb einer Funktion zugewiesen wird, müssen Sie den Datentyp des Ergebniswerts ebenfalls für die Funktion definieren. Gleiches gilt auch für eine Methode.

Beispiel für Funktion mit Ergebniswert

FUNCTION Simple1 : INT  (* Start der Deklaration mit Angabe des Datentyps INT *)
  VAR
    var1 : INT;
  END_VAR
  Simple1 := 1;         (* Ergebniswert "1" zuweisen *)
END_FUNCTION            (* Ende der Deklaration *)