Syntax

VAR | VAR_INPUT | VAR_OUTPUT | VAR_GLOBAL | VAR_EXTERNAL
   name_3, name_4, ..., name_n : STRING[length] := 'initial-value';
   ...
END_VAR 
 
TYPE
   name_5: ARRAY [x..y] OF STRING[length] := ['initial-value_1', 'initial-value_2', .., 'initial-value_n'];   (* Bis zu 3 Dimensionen sind möglich. *)
   ...
   name_1: STRUCT
      name_e1 : STRING := 'initial-value';
      ...
   END_STRUCT; 
END_TYPE

Bedeutung
Deklaration einer oder mehrerer Variablen vom →Datentyp `STRING` (auch als `STRING`-Variablen oder →Zeichenfolgen-Variablen bezeichnet) mit einer maximalen Länge (`length`), wobei `name_3`, `name_4` usw. →IEC-Bezeichner sein müssen. Mit dem optionalen →Initialisierungswert `:= 'initial-value'` weisen Sie der Variable einen Wert zu (Details: siehe "Initialisierung von Variablen in ST").

logi.CAD 3 erlaubt STRING-Variablen mit einer maximalen Länge von bis zu 32.767 Zeichen.
Sonderzeichen, wie z.B. Umlaute, im Initialisierungswert oder im Wert für eine Zuweisung müssen als eine Kombination von 3 Zeichen, beginnend mit dem Dollar-Zeichen ($) und gefolgt von 2 Hexadezimal-Ziffern eingegeben werden. Beispiel: StringVar1 : STRING[10] := 'Schlie$DFen'; (für den Initialisierungswert Schließen) – Siehe →Zeichenfolge-Literal, unter "Beispiele für Zeichenfolge-Literale" für eine Liste mit ausgewählten Sonderzeichen.

Die Deklaration von STRING-Variablen ist innerhalb dieser Abschnitte möglich:

Abschnitt	Die Deklaration der STRING-Variable erfolgt als:
`VAR ... END_VAR`	interne Variable (siehe "Deklaration von internen Variablen und Funktionsbaustein-Instanzen in ST")
`VAR_INPUT ... END_VAR`	Eingangsvariable (siehe "Deklaration von Eingangsvariablen in ST")
`VAR_OUTPUT ... END_VAR`	Ausgangsvariable (siehe "Deklaration von Ausgangsvariablen in ST")
`VAR_GLOBAL ... END_VAR`	globale Variable (siehe "Deklaration von externen Variablen in ST")
`VAR_EXTERNAL ... END_VAR`	externe Variable (siehe "Deklaration von externen Variablen in ST")
`TYPE ... END_TYPE`	`ARRAY`-Element (siehe "Deklaration eines ARRAY-Datentyps in ST") oder Strukturelement (siehe "Deklaration eines strukturierten Datentyps in ST")

logi.CAD 3 bietet außerdem die Möglichkeit, zusätzliche Daten bei der Deklaration anzugeben. Siehe "Beschreibung, Kommentar oder JSON-String für Variablen und Datentypen angeben" für Details.

Beispiel

VAR
  var4 : STRING[10];                         (* 'var4' hat eine maximale Länge von 10 Zeichen. *)
END_VAR
 
VAR_OUTPUT
  OUT4 : STRING[5] := 'ABC';                 (* 'OUT4' hat eine maximale Länge von 5 Zeichen und wird mit der Zeichenfolge 'ABC' initialisiert. *)
END_VAR
 
TYPE
   myString : ARRAY [1..3] OF STRING[4] := ['ABC', 2('DEF')];
                                             (* 3 ARRAY-Elemente vom Datentyp 'STRING' haben eine maximale Länge von 4 Zeichen,             *)
                                             (* Initialiserung des 1. Elements mit 'ABC', Initialisierung der anderen 2 Elemente mit 'DEF'. *)
 
   RangeString : STRUCT                      (* Strukturdatentyp mit 2 Elementen *)
    min : STRING[6];                         (* 1. Element vom Datentyp 'STRING' hat eine maximale Länge von 6 Zeichen, keine Initialisierung.      *)
    max : STRING[7] := 'ABCD';               (* 2. Element vom Datentyp 'STRING' hat eine maximale Länge von 7 Zeichen, Initialisierung mit 'ABCD'. *)
   END_STRUCT;
END_TYPE

Zugriff auf STRING-Variablen

Falls Sie auf einzelne Zeichen einer STRING-Variable in →Zuweisungen zugreifen wollen, geben Sie den Namen der Variable (z.B. var4) und die entsprechende Position des Zeichens (z.B. 2) in [] eingeschlossen ein (z.B. var4[2]). Die Positionen starten mit "1".

Zuweisungen von einer STRING-Variable auf eine andere STRING-Variable mit unterschiedlicher maximaler Länge sind möglich. Hat die STRING-Variable, auf die zugewiesen wird, eine kleinere Länge als die STRING-Variable, von der zugewiesen wird, so führt logi.CAD 3 die Zuweisung nur bis zur maximalen Länge der STRING-Variable durch, auf die zugewiesen wird. Außerdem wird der Ausgang ENO der umfassenden →POE auf den Wert FALSE (bzw. einer Entsprechung) gesetzt.

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 terminiert.
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.

Bei einer kleineren Länge der zugewiesenen STRING-Variable und der Zeichenkombination '$00' darin führt logi.CAD 3 die Zuweisung nur bis zur maximalen Länge der STRING-Variable durch, auf die zugewiesen wird. In diesem Fall wird der Ausgang ENO der umfassenden POE nicht auf den Wert FALSE (bzw. einer Entsprechung) gesetzt.

Beispiele

VAR
  var4, var5 : STRING[10];    (* 'var4' und 'var5' haben eine maximale Länge von 10 Zeichen. *)
  var6 : STRING[5];           (* 'var6' hat eine maximale Länge von 5 Zeichen. *)
  Char1 : CHAR;
END_VAR
 
VAR_OUTPUT
  OUT4 : STRING[5] := 'ABC';             (* 'OUT4' hat eine maximale Länge von 5 Zeichen und wird mit der Zeichenfolge 'ABC' initialisiert. *)
  OUT5 : STRING[10] := '1234567890';     (* 'OUT5' hat eine maximale Länge von 10 Zeichen und wird mit der Zeichenfolge '1234567890' initialisiert. *)
END_VAR
 
(* Zuweisungen: Zugriff auf einzelne Zeichen einer STRING-Variable *)
Char1       := OUT4[3];     (* Das Zeichen auf der 3. Position von 'OUT4', d.h. 'C', wird 'Char1' zugewiesen. Ergebnis: Char1 := 'C' *) 
OUT4[2]     := 'D';         (* Das Zeichen 'D' wird der 2. Position von 'OUT4' zugewiesen. Ergebnis für 'OUT4' := 'ADC' *) 
var4[1]     := 'A';         (* Das Zeichen 'A' wird der 1. Position von 'var4' zugewiesen. Ergebnis für 'var4' := 'A' *)
var4[2]     := OUT4[2];     (* Das Zeichen 'D' wird der 2. Position von 'var4' zugewiesen. Ergebnis für 'var4' := 'AD' *) 
 
(* Zuweisungen: STRING-Variable auf STRING-Variable *)
var5     := OUT4;           (* OK, da max. Länge von 'OUT4' = 5 und max. Länge von 'var5' =  10. Ergebnis für 'var5' := 'ADC' und ENO der umfassenden POE := TRUE *)
var6     := OUT5;           (* OK, aber Zuweisung nur bis zur max. Länge von 'var6', d.h. bis zur Zeichenposition '5'. Ergebnis für 'var6' := '12345' und ENO der umfassenden POE := FALSE *)

 
(* Spezialfall: Zeichenfolgen mit $00 *)
VAR
  varA, varB : STRING[10] := '1234567890'; (* 'varA' und 'varB' werden mit der Zeichenfolge '1234567890' initialisiert. *)
  varC, varD : STRING[10];
  varE       : STRING[10] := '1234567890'; (* 'varE' wird mit der Zeichenfolge '1234567890' initialisiert. *) 
  varF       : STRING[5];
  CharA, CharB : CHAR;
END_VAR
VarA[6] := '$00';  (* Aufgrund dieser Zuweisungen enden nun 'varA' und 'varB' an der 6. Stelle. Anzeige in Sicht 'Variablenwerte': '12345' *)
VarB[6] := '$00';
VarE[4] := '$00';  (* Aufgrund dieser Zuweisung endet nun 'varE' an der 4. Stelle. Anzeige in Sicht 'Variablenwerte': '123' *)  

varC := varA;              (* Trotz $00 wird die vollständige Zeichenfolge für 'varC' übernommen. Ergebnis für 'varC' := '12345$007890' - Anzeige in Sicht 'Variablenwerte' jedoch: '12345' - und ENO der umfassenden POE := TRUE *)
varD := MOVE(IN := varB);  (* Trotz $00 wird die vollständige Zeichenfolge für 'varD' übernommen. Ergebnis für 'varD' := '12345$007890' - Anzeige in Sicht 'Variablenwerte' jedoch: '12345' - und ENO der umfassenden POE := TRUE *)
varF := varE;              (* Trotz $00 wird die Zeichenfolge bis zur max. Länge von 'varF' übernommen. Ergebnis für 'varF' := '123$005' - Anzeige in Sicht 'Variablenwerte' jedoch: '123' - und ENO der umfassenden POE := TRUE *)

CharA := varC[8];   (* Ergebnis für 'CharA' := '8' - trotz $00 an der 6. Stelle von 'varC' *)
CharB := varF[5];   (* Ergebnis für 'CharB' := '5' - trotz $00 an der 4. Stelle von 'varF' *)

Deklaration und Zugriff auf STRING-Variablen vom ARRAY-Datentyp

Falls Sie eine STRING-Variable basierend auf einem ARRAY-Datentyp deklarieren wollen, geben Sie den STRING-Datentyp mit der maximalen Länge als Datentyp bei der Deklaration des ARRAY-Datentyps ein.

Beispiel für Deklaration

TYPE
	myArray : ARRAY [1..3] OF STRING[4];   (* 3 STRING-Elemente deklarieren, jedes Element hat die maximale Länge von 4 Zeichen *)
END_TYPE

Auf einzelne Zeichen einer solchen Variable können Sie mit Hilfe des folgenden Konstrukts zugreifen:

Beispiel für den Zugriff

VAR
  var2 : myArray;
  accessA, accessB : CHAR;	      (* Variablen für Zugriff/Alternativ-Zugriff *)
  accessC : STRING[4];            (* Hilfs-Variable für den Alternativ-Zugriff *)
END_VAR

accessA := var2[1][2];    (* Zugriff auf das 2. Zeichen des 1. ARRAY-Elements *)

(* Alternative für den Zugriff *)
accessC := var2[1];       (* Zugriff auf das 1. ARRAY-Element *)
accessB := accessC[2];    (* Zugriff auf das 2. Zeichen des 1. ARRAY-Elements *)