TO_WSTRING

Typ Funktion

Beschreibung Konvertiert den am Eingang anliegenden Wert in einen Wert vom Datentyp WSTRING. Der am FORMAT-Eingang anliegende String legt fest, in welchem Format der konvertierte String ausgegeben werden soll.

Hinweise

Ist der zurückgegebene String länger als 80 Zeichen und die FU ist direkt mit einer anderen FU verbunden, werden temporäre String-Variablen mit einer Größe von 80 verwendet. Bei der Berechnung bzw. Verwendung tritt ein Fehler auf. Ist der zurückgegebene String länger als 80 Zeichen, wird die Meldung 'String zu kurz' ausgegeben und am Ausgang ein leerer String zurückgegeben oder es wird der letzte Wert gehalten. Verwenden Sie für diesen Fall eine lokale Zwischenvariable.

Der am Eingang anliegende Wert wird nicht auf Validität geprüft. Im Fehlerfall (siehe "Fehlerverhalten" oben) wird das Programm weiter ausgeführt und ein String-Fehler in das Online-Protokoll des MELDUNGEN-Fensters geschrieben.

Die überladene Funktion kann mit verschiedenen Eingangsdatentypen arbeiten.

Parameter Eingänge
IN

Datentyp: Die Funktion unterstützt folgende Datentypen:

BOOL, BYTE, WORD, DWORD, LWORD

Integer: SINT, INT, DINT, LINT, USINT, UINT, UDINT, ULINT

Gleitkommazahlen: REAL, LREAL

Zeitdauer: TIME, LTIME

Datum: LDATE, LTIME_OF_DAY, LDATE_AND_TIME

STRING

FORMAT

Datentyp: Format (Datentyp WSTRING), in das der String konvertiert werden soll (siehe nachfolgende Beschreibung).
Der Formatstring kann ein leerer String ("") oder ein Standardformatbezeichner (leerer String "", "{0}" oder "{0:I}") sein oder auch in den Formatstring eingeschlossen werden (z.B. d für einen Integer-Wert). Bei einem leeren Formatstring wird der Standardformatbezeichner für den am Eingang anliegenden Wert verwendet (siehe "Standardformatbezeichner" unten).
Beispiele in ST

     StringOut := TO_WSTRING(INT#256,"Zeitdauer beträgt {0:d} ms");   (* liefert "Zeitdauer beträgt 256 ms" *)
     StringOut := TO_WSTRING(INT#256,"{0}");   (* liefert "256" *)

Ausgang
OUT

Datentyp: WSTRING

Formatstring Der Formatstring kann Platzhalter (Formatbezeichner, Genauigkeitsangabe) für den erzeugten Ausgangsstring enthalten. Die Bezeichner legen fest, wie der Ausgangsstring dargestellt werden soll. Mit Hilfe des Formatstrings kann der erzeugte String entsprechend den jeweiligen Anforderungen formatiert werden.
Der Formatstring verwendet folgende Syntax:
     {0[:format_specifier][precision]}
(Die geschweiften Klammen müssen angegeben werden. Optionale Parameter stehen in eckigen Klammern.)
Numerische Formatbezeichner

In der folgenden Tabelle sind die verfügbaren numerischen Formatbezeichner aufgeführt. Zu jedem Bezeichner finden Sie Beispiele für die jeweils erzeugten Ausgangsstrings (eine Beschreibung der Genauigkeitsangabe finden Sie im Anschluss an diese Tabelle):

Formatbezeichner Beschreibung Beispiele

"{0}" oder "{0:I}" oder "{0:i}" oder "" Standardwerte werden verwendet (siehe "Standardformatbezeichner" unten). Die IEC-Form des Datentyps wird erzeugt. TO_WSTRING(BYTE#16#FF, "");(* liefert "16#FF" *)
TO_WSTRING(lint#-1234567890123456789, "{0}");(* liefert "-1234567890123456789" *)
TO_WSTRING(real#1.23456789E+015, "{0:I}");(* liefert "1.234568E+15" *)

"d", "D", "D8", "D16" Dezimale Ganzzahl.
Konvertiert den Eingangswert in einen String aus Dezimalzahlen (0-9). Bei einem negativen Wert wird dem String ein Minuszeichen vorangestellt. TO_WSTRING(BYTE#16#FF, "{0:d}"); (* liefert "255" *)
TO_WSTRING(BYTE#16#FF, "{0:d}"); (* liefert "255" *)
TO_WSTRING(BYTE#16#FF, "{0:D8}"); (* liefert "00000255" *)
TO_WSTRING(UDINT#4294967295, "{0:D16}"); (* liefert "0000004294967295" *)

"e", "E", "E10", "e4" Gleitpunktzahl Exponential.
Konvertiert den Eingangswert in einen String in Exponentialschreibweise mit dem Buchstaben e oder E (z.B. 1.23E+01) vor dem Exponenten.
Bei Exponenten <= 99 ist der Exponent zweistellig; andernfalls dreistellig. TO_WSTRING(REAL#12.123456789, "{0:e}"); (* liefert "1.212346e+01" *)
TO_WSTRING(REAL#12.123456789, "{0:E}"); (* liefert "1.212346E+01" *)
TO_WSTRING(LREAL#-12.123456789, "{0:E10}"); (* liefert "-1.2123456789E+01" *)
TO_WSTRING(LREAL#-12.123456789, "{0:e4}"); (* liefert "-1.2123e+01" *)

"f", "F", "F6", "f4" Gleitkommazahl.
Konvertiert den Eingangswert in einen String im Festkomma-Zahlenformat (z.B. 12.1256). Bei einem negativen Wert wird dem String ein Minuszeichen vorangestellt.
Standard: 6 Dezimalstellen nach dem Punkt. TO_WSTRING(REAL#12.123456789, "{0:f}"); (* liefert "12.123457" *)
TO_WSTRING(REAL#12.123456789, "{0:F}"); (* liefert "12.123457" *)
TO_WSTRING(LREAL#-12.123456789, "{0:F6}"); (* liefert "-12.123457" *)
TO_WSTRING(LREAL#-12.123456789, "{0:f4}"); (* liefert "-12.1235" *)

"x", "X", "x8", "X8" Hexadezimale Ganzzahl.
Konvertiert den Eingangswert in einen String von Hexadezimalzahlen. TO_WSTRING(WORD#16#FFFF, "{0:x}"); (* liefert "ffff" *)
TO_WSTRING(WORD#16#FFFF, "{0:X}"); (* liefert "FFFF" *)
TO_WSTRING(WORD#16#FFFF, "{0:x8}"); (* liefert "0000ffff" *)
TO_WSTRING(WORD#16#FFFF, "{0:X8}"); (* liefert "0000FFFF" *)

Zeichen-Formatbezeichner

In der folgenden Tabelle sind die verfügbaren Zeichen-Formatbezeichner mit entsprechenden Beispielen für den erzeugten Ausgangsstring aufgeführt:

Formatbezeichner Beschreibung Beispiele

"c", "C" Einzelnes Zeichen.
Konvertiert den Eingangswert in ein einzelnes Zeichen (einschließlich Sonderzeichen).
Die Konvertierung erfolgt auf Basis der ASCII-Kodierung.
Der Eingangswert muss vom Datentyp BYTE, WORD, DWORD oder LWORD sein. TO_WSTRING(BYTE#65, "{0:C}"); (* liefert "A" *)
TO_WSTRING(WORD#16#3A, "{0:C}"); (* liefert ":" *)
TO_WSTRING(DWORD#16#40, "{0:C}"); (* liefert "@" *)
TO_WSTRING(LWORD#16#61, "{0:C}"); (* liefert "a" *)
TO_WSTRING(BYTE#7, "{0:c}"); (* liefert "" , da Ausgangswert ein Steuerzeichen wäre *)

Datum- und Zeit-Formatbezeichner

Hinweis
.Net Standardmäßige Formatzeichenfolgen und benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit
Obwohl die gleichen Formatbezeichner verwendet werden, ist das Ergebnis der Formatierung unterschiedlich. Das Verhalten is wie folgt: Es wird zuerst nach einem Standardformatbezeichner und anschließend nach einem benutzerdefinierten Bezeichner gesucht. Ein Standardformatbezeichner ist immer ein einzelnes Zeichen. Bei Kombinationen mit anderen Bezeichnern wird immer der benutzerdefinierte Bezeichner verwendet. Um den benutzerdefinierten Bezeichner zu erzwingen, muss ein "%"-Zeichen vorangestellt werden. Überprüfen Sie die Ergebnisse der formatierten Zeichenfolge, um sicherzustellen, dass das gewünschte Ergebnis erzielt wird.

Beispiele:
TO_WSTRING(LTOD#11:57:31.123.456.789, "{0:s}"); (* Standardbezeichner; liefert "1970-01-01T11:57:31" *)
TO_WSTRING(LTOD#11:57:31.123.456.789, "{0:ss}"); (* benutzerdefinierter Bezeichner; liefert "31" *)
TO_WSTRING(LTOD#11:57:31.123.456.789, "{0:m:s}"); (* benutzerdefinierter Bezeichner; liefert "57:31" *)
TO_WSTRING(LTOD#11:57:31.123.456.789, "{0:%s}"); (* benutzerdefinierter Bezeichner (erzwungen mit "%"-Zeichen); liefert '31' *)

In der folgenden Tabelle sind die verfügbaren Formatbezeichner für Datum und Uhrzeit aufgeführt. Zu jedem Bezeichner finden Sie Beispiele für die jeweils erzeugten Ausgangsstrings (eine Beschreibung der Genauigkeitsangabe finden Sie im Anschluss an diese Tabelle):

Formatbezeichner Beschreibung Beispiele

"{0}", "{0:I}", "{0:i}" oder "" Standardwerte werden verwendet (siehe "Standardformatbezeichner" unten). Die IEC-Form des Datentyps wird erzeugt.
("I" zusätzlicher Bezeichner für Datum und Uhrzeit) TO_WSTRING(TIME#2s, ""); (* liefert "T#2s" *)
TO_WSTRING(LTIME#2s, "{0}"); (* liefert "LT#2s" *)
TO_WSTRING(LDATE#2007-10-05, "{0:I}"); (* liefert "LD#2007-10-05" *)
TO_WSTRING(LTOD#09:07:01.123456789, ""); (* liefert "LTOD#09:07:01.123_456_789" *)
TO_WSTRING(LDT#2012-10-03-16:06:07.123456789, "{0:I}"); (* liefert "LDT#2012-10-03-16:06:07.123_456_789" *)

"D" Ganzzahlige Ziffer (zusätzlicher Bezeichner für Datum und Uhrzeit) TO_WSTRING(LDATE#1999-09-09, "{0:D}"); (* liefert "936835200000000000" *)
TO_WSTRING(LDATE#1970-01-01, "{0:D}"); (* liefert "Thursday, 01 January 1970" *)

"x", "X" Hexadezimale Zeichenfolge (zusätzlicher Bezeichner für Datum und Uhrzeit) TO_WSTRING(LDATE#1999-09-09, "{0:x}"); (* liefert ""d004ea69d150000" " *)
TO_WSTRING(LDATE#1999-09-09, "{0:X}"); (* liefert "D004EA69D150000" *)

"y", "yy", "yyy", "yyyy" Liefert das Jahr des Datumwertes.
Standard-Formatbezeichner für Datum und Uhrzeit: Jahr-Monat-Muster TO_WSTRING(LDATE#2007-10-05, "{0:y yy yyy yyyy}"); (* liefert "7 07 2007 2007" *)
TO_WSTRING(LDATE#1999-09-09, "{0:y}"); (* liefert "1999 September" *)

"Y" Standard-Formatbezeichner für Datum und Uhrzeit: Jahr-Monat-Muster TO_WSTRING(LDATE#1999-09-09, "{0:Y}"); (* liefert "1999 September" *)

"M", "MM", "MMM", "MMMM" Liefert den Monat des Datumwertes als numerischen Wert (1 bis 12) oder als Zeichenfolge (vollständiger Name oder Kurzform).
Standard-Formatbezeichner für Datum und Uhrzeit: Monat-Tag-Muster TO_WSTRING(LDATE#2007-10-05, "{0:M MM MMM MMMM}"); (* liefert "10 10 Oct October" *)
TO_WSTRING(LDATE#1999-09-09, "{0:M}"); (* liefert " September 09" *)

"d", "dd", "ddd", "dddd" Liefert den Tag des Monats des Datumwertes als numerischen Wert (1 bis 31) oder als Zeichenfolge (vollständiger Name oder Kurzform).
Standard-Formatbezeichner für Datum: kurzes Datumsmuster
Standard-Formatbezeichner für Uhrzeit: kurze dezimale Ganzzahl TO_WSTRING(LDATE#2007-10-05, "{0:d dd ddd dddd}"); (* liefert "5 05 Fri Friday" *)
TO_WSTRING(LDATE#1970-01-30, "{0:d}"); (* liefert "01/30/1970" *)
TO_WSTRING(TIME#5S, 2{0:d}"); (* liefert "5000" *)

"h", "hh", "H", "HH" Liefert die Stunde des Datum-Zeit-Wertes (LDATE, LDATE_AND_TIME und LTIME_OF_DAY) im 24-Stunden- oder 12-Stunden-Format. TO_WSTRING(LDT#2012-10-03-16:06:07.123456789, "{0:h hh H HH}"); (* liefert "4 04 16 16" *)

"m", "mm" Liefert die Minuten des Datum-Zeit-Wertes (LDATE, LDATE_AND_TIME und LTIME_OF_DAY).
Standard-Formatbezeichner für Datum und Uhrzeit: Monat-Tag-Muster TO_WSTRING(LDT#2012-10-03-16:06:07.123456789, "{0:m mm}"); (* liefert "6 06" *)
TO_WSTRING(LDATE#1999-09-09, "{0:m}"); (* liefert "September 09" *)

"s", "ss" Liefert die Sekunden des Datum-Zeit-Wertes (LDATE, LDATE_AND_TIME und LTIME_OF_DAY).
Standard-Formatbezeichner für Datum und Uhrzeit: sortierbares Datums-/Zeitmuster im 24-Stunden-Format. Die Zeitzone ist nicht angegeben. TO_WSTRING(LDT#2012-10-03-16:06:07.123456789, "{0:s ss}"); (* liefert "7 07" *)
TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:s}"); (* liefert "1970-01-01T13:57:31" *)

"f", "ff", "fff", "ffff", "fffff", "ffffff", "fffffff" Liefert die Nachkommastellen einer Sekunde des Datum-Zeit-Wertes (LDATE, LDATE_AND_TIME und LTIME_OF_DAY).
Standard-Formatbezeichner für Datum und Uhrzeit: vollständiges Datums-/Zeitmuster (kurze Zeit) im 12-Stunden-Format TO_WSTRING(LTOD#09:07:01.123456789, "{0:f ff fff ffff}"); (* liefert "1 12 123 1234" *)
TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:f}"); (* liefert "Thursday, 01 January 1970 13:57" *)

"F", "FF", "FFF", "FFFF", "FFFFF", "FFFFFF", "FFFFFFF" Liefert die Nachkommastellen ohne Nullen einer Sekunde des Datum-Zeit-Wertes (LDATE, LDATE_AND_TIME und LTIME_OF_DAY).
Standard-Formatbezeichner für Datum und Uhrzeit: vollständiges Datums-/Zeitmuster (lange Zeit) im 12-Stunden-Format TO_WSTRING(LTOD#09:07:01.123456789, "{0:F FF FFF FFFF}"); (* liefert "1 12 123 1234" *)
TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:F}"); (* liefert "Thursday, 01 January 1970 13:57:31" *)

"g", "gg" Liefert den Zeitraum.
Standard-Formatbezeichner für Datum und Uhrzeit: allgemeines Datums-/Zeitmuster (kurze Zeit) im 12-Stunden-Format TO_WSTRING(LDATE#1999-09-09, "{0:gg}"); (* liefert "A.D." *)
TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:g}"); (* liefert "01/01/1970 13:57" *)

"G" Standard-Formatbezeichner für Datum und Uhrzeit: allgemeines Datums-/Zeitmuster (lange Zeit) TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:G}"); (* liefert "01/01/1970 13:57:31" *)

"o", "O" Standard-Formatbezeichner für Datum und Uhrzeit: Datums-/Uhrzeitmuster für Roundtrip. Die Zeitzone ist nicht angegeben. TO_WSTRING(LDT#1970-01-01-11:57:31.123456789, "{0:o}"); (* liefert "1970-01-01T11:57:31.1234567" *)

"r", "R" Standard-Formatbezeichner für Datum und Uhrzeit: RFC1123-Muster. Die Zeitzone ist nicht angegeben, daher begrenzte Verwendung. TO_WSTRING(LDT#1970-01-01-11:57:31.123456789, "{0:r}"); (* liefert "Thu, 01 Jan 1970 11:57:31 GMT" *)

"t", "tt" Liefert das erste Zeichen des AM/PM-Kennzeichners ('t') bzw. den AM/PM-Kennzeichner ('tt').
Standard-Formatbezeichner für Datum und Uhrzeit: kurzes Zeitmuster im 12-Stunden-Format TO_WSTRING(LDT#1970-01-01-11:57:31.123456789, "{0:t tt}"); (* liefert "A AM" *)
TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:t}"); (* liefert "13:57" *)

"T" Standard-Formatbezeichner für Datum und Uhrzeit: langes Zeitmuster im 12-Stunden-Format TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:T}"); (* liefert "13:57:31" *)

"u" Standard-Formatbezeichner für Datum und Uhrzeit: universelles, sortierbares Datums-/Zeitmuster im 24-Stunden-Format.
Zeitzone nicht angegeben. TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:u}"); (* liefert "1970-01-0113:57:31Z" *)

"U" Standard-Formatbezeichner für Datum und Uhrzeit: universelles, vollständiges Datums-/Zeitmuster im 12-Stunden-Format.
Zeitzone nicht angegeben. TO_WSTRING(LDT#1970-01-01-13:57:31.123456789, "{0:U}"); (* liefert "Thursday, 01 January 1970 13:57:31" *)

"K" Information zur Zeitzone
Zeitzone nicht angegeben - wird nicht unterstützt. -

"z", "zz", "zzz" Offset von UTC in Stunden und Minuten.
Signierter Offset der Zeitzone des lokalen Betriebssystems aus UTC. TO_WSTRING(LDT#1970-01-01-11:57:31.123456789, "{0:z zz zzz}"); (* liefert "+0 +00 +00:00" )
(UTC-Format ist nicht verfügbar.)

":", "/", "+" und andere Zeichen Die Trennzeichen ":" und "/" werden unverändert in die Ergebniszeichenfolge kopiert. Kulturspezifische Zeichen werden nicht verwendet. TO_WSTRING(LDT#1970-01-01-11:57:31.123456789, "{0:mm:mm/mm+mm}"); (* liefert "57:57/57+57" *)

"%" Definiert das nächste Zeichen als benutzerdefinierten Formatbezeichner. TO_WSTRING(LDT#2012-10-03-16:06:07.123456789, "{0:%h%F}"); (* liefert "41" *)

"\" Escapezeichen. TO_WSTRING(LDT#2012-10-03-16:06:07.123456789, "{0:h \\h}"); (* liefert "4 h" *)

"{0:hh:mm:ss.fff}" Liefert das vollständige Datum ohne Mikrosekunden und Nanosekunden des Datum-Zeit-Wertes (LDATE, LDATE_AND_TIME und LTIME_OF_DAY). TO_WSTRING(LTOD#09:07:01.123456789, "{0:hh:mm:ss.fff}"); (* liefert "09:07:01.123" *)

Genauigkeit

Die optionale Genauigkeitsangabe ist eine Dezimalzahl (ohne Vorzeichen), die direkt auf den Formatbezeichner folgt. Der Wert legt fest, mit welcher Genauigkeit der Eingangswert konvertiert werden soll. Die Genauigkeitsangabe wirkt sich unterschiedlich für die verschiedenen Formatbezeichner aus.

Formatbezeichner Genauigkeit

"d", "D", "x", "X" Mindestanzahl von Ziffern für die resultierende Zeichenfolge. Bei Bedarf werden links von der Zeichenfolge Nullen ergänzt, bis das Ergebnis die durch den Genauigkeitswert vorgegebene Anzahl an Ziffern enthält.
Beispiel:
TO_WSTRING(BYTE#16#FF, "{0:D8}"); (* liefert "00000255" *)

"e", "E", "f", "F" Anzahl von Ziffern nach dem Dezimaltrennzeichen.
Standard: 6 Ziffern nach dem Dezimaltrennzeichen.
Beispiel:
TO_WSTRING(LREAL#-12.123456789, "{0:E4}"); (* liefert "-1.2123E+01" *)

Standard-Formatbezeichner

Die folgende Tabelle zeigt die Standardformatbezeichner für die verschiedenen Datentypen der am Eingang anliegenden Werte. Das Standardformat wird bei leerem Formatstring "", leerem Platzhalter "{0}" oder dem IEC-Format "{0:I}" verwendet.

Eingangsdatentyp Standardformat

SINT, INT, DINT, LINT {0:D}

USINT, UINT, UDINT {0:D}

BYTE, WORD, DWORD, LWORD 16#{0:X}

REAL, LREAL {0:E}

TIME T#{0:hh}:{0:mm}:{0:ss}.{0:fff}s
(Leerstellen am Anfang und Ende werden gelöscht)

LTIME LT#{0:hh}:{0:mm}:{0:ss}.{0:fff}_{us}_{ns}s
(Leerstellen am Anfang und Ende werden gelöscht)

LDATE LD#{0:yyyy}-{0:MM}-{0:dd}

LTOD LTOD#{0:hh}:{0:mm}:{0:ss}.{0:fff}_{us}_{ns}
(µs und ns nur für Standardformat)

LDT LDT#{0:yyyy}-{0:MM}-{0:dd}-{0:hh}:{0:mm}:{0:ss}.{0:fff}_{us}_{ns}
(µs und ns nur für Standardformat)

Fehlerverhalten Fehlerverhalten

Die folgende Tabelle zeigt die Fehler, die bei der Ausführung der Funktion auftreten können, und den von der Funktion im entsprechenden Fehlerfall zurückgegebenen Wert. Der Wert, den die Funktion im Fehlerfall zurückgibt, hängt vom Eingangswert ab (wenn z.B. der Eingangswert vom Datentyp REAL keine gültige Zahl (NaN) ist, gibt die Funktion den String 'NaN' zurück).

Fehlerfall Ausgabewert

Ergebnisstring zu kurz (Eingangsstring > Ausgangsstring) Leerer String ("")

Formatstringfehler Leerer String ("")

REAL/LREAL: NaN "NaN"

REAL/LREAL: Inf+ "INF"

REAL/LREAL: Inf- "-INF"

Tritt einer der aufgeführten Fehler auf, wird ein String-Fehler im Online-Protokoll des MELDUNGEN-Fensters ausgegeben.

Hinweis
Steuerungstopp bei String-Fehler: Sie können einstellen, ob die Steuerung bei einem String-Fehler automatisch gestoppt werden soll. Dies gibt Ihnen im Fehlerfall die Möglichkeit, den Fehler in Ihrem Projekt zu lokalisieren. Um bei einem String-Fehler die Steuerung automatisch zu stoppen, aktivieren Sie das Symbol in der Symbolleiste des Cockpits.

Zusätzliche Informationen EN/ENO-Verhalten

Die POE wird nur dann ausgeführt, wenn TRUE am Eingang EN anliegt. Wenn EN = FALSE ist, wird die POE nicht ausgeführt und ENO auf FALSE gesetzt (FU/FB inaktiv).

Wenn bei der Ausführung der Funktion einer der unter "Fehlerverhalten" aufgeführten Fehler auftritt, wird ENO auf FALSE gesetzt.

Weitere Infos
Weitere Informationen finden Sie im Thema "Allgemeine Informationen zur Ausführungssteuerung mit EN/ENO".