Arithmetische Ausdrücke <expr>

Bei der Behandlung von arithmetischen Ausdrücken gelten die üblichen Rechenregeln:

Punkt-vor-Strich-Rechnung
die Klammer-Regel, wobei eckige Klammern "[ ]" zu verwenden sind. Runde "(...)" entsprechen Kommentaren.

In arithmetischen Ausdrücken werden oft Parameter verwendet. Die Schreibweise von Parametern ist:

P gefolgt von einer ganzen Zahl, z.B. P12

Beispiel für einen arithmetischen Ausdruck:

P5 = [[sin[R1*30.00] + P2] / P5]

Makros (Strings) können arithmetischen Ausdrücken und Teilen davon zugewiesen werden.

Ein Makroname führt zu dem Makroinhalt, der analysiert wird. Dabei ist auch eine rekursive Behandlung möglich.

Makronamen müssen in Anführungszeichen eingeschlossen sein. Bei deren Decodierung wird zwischen Groß- und Kleinschreibung unterschieden.

Die Schachtelung von Makros wird durch ein vorangestelltes ´\´-Zeichen vor den begrenzenden Anführungszeichen angezeigt. Es ist darauf zu achten, dass immer komplette Schachtelungsebenen in einem Makro zusammengefasst sind, d.h. das Einfügen von ´[´ am Anfang und ´]´ am Ende des Makroinhaltes darf sich nicht auf das Ergebnis des mathematischen Ausdrucks auswirken.

Programmierbeispiel

Geschachtelte Makros

Richtig:

N10 "STRING1" = "COS[\"STRING2\"]"

N20 "STRING2" = "5 * 12"

N30 "STRING3" = "SIN[89.5 + \"STRING1\"]"

N40 X[-2 * "STRING1" + "STRING2" + "STRING3"] (Fahren nach X60)

M30

Falsch:

Nur komplette Schachtelungsebenen dürfen im String

zusammengefasst werden

N10 "STRING1" = "COS["

N20 "STRING2" = "90]"

N30 "STRING3" = "\"STRING1\" \"STRING2\" "

Die im NC-Programm definierten Makros sind programmübergreifend gültig!

Die Programmierung von Makros außerhalb mathematischer Ausdrücke wird in "Makroprogrammierung (#INIT MACRO TAB) " beschrieben.

Übersicht über alle verfügbaren Rechenoperationen:

Grundrechenarten:

Addition	+	P1 = P2 + P3 + 0.357
Subtraktion	-	P1 = P2 - 0.031
Multiplikation	*	P1 = P2 * [P3 + 0.5]
Division	/	P1 = P2 * P3 / [P5 + P6]
Exponentenrechnung	**	P1 = 2**P3 (zwei hoch P3)
Modulorechnung	MOD	P1 = 11 MOD 3 (-> 2)

Zahlenfunktionen:

Absolutwertbildung	ABS [..]	P1 = ABS [P2 - P4]
Quadrieren	SQR [..]	P1 = SQR [P2] + SQR [P3]
Quadratwurzel	SQRT [..]	P1 = SQRT [SQR[P2]+SQR[P3]]
e - Funktion	EXP [..]	P1 = EXP [P2 * P4]
Natürlicher Logarithmus	LN [..]	P1 = LN [P2] + LN [P3]
Zehner - Exponent	DEXP [..]	P1 = DEXP [P2]
Zehner - Logarithmus	LOG [..]	P1 = LOG [P2]

Achtung

Bei LN, LOG und SQRT muss das Argument immer größer 0 sein!

Bitoperatoren:

UND-Verknüpfung	&	P1 = P2 & P3
ODER-Verknüpfung	\|	P1 = P2 \| P3
Exklusives ODER	^	P1 = P2 ^ P3
Komplement	INV[..]	P1 = INV[P2]

Achtung

Die Operanden können beliebige positive mathematische Ausdrücke oder Zahlen im Bereich 0 ... 2^32-1 (UNS32) sein. Negative Ausdrücke oder Zahlen sind nicht erlaubt. Gleitkommazahlen werden in ganze Zahlen konvertiert.

Das Ergebnis der Bitoperation liegt immer im Bereich 0 ... 2^32-1 (UNS32).

Logische Operatoren:

UND-Verknüpfung	&& / AND	P1 = P2 && P3 P1 = P2 AND P3
ODER-Verknüpfung	\|\| / OR	P1 = P2 \|\| P3 P1 = P2 OR P3
Exklusive ODER-Verknüpfung	XOR	P1 = P2 XOR P3
NICHT-Operator	NOT[..]	P1 = NOT[P2] P1 = NOT[1] (P1 = 0) P1 = NOT[0.5] (P1 = 0) P1 = NOT[0.49] (P1 = 1) P1 = NOT[0] (P1 = 1)

Achtung

Die Operanden können beliebige positive mathematische Ausdrücke oder Zahlen sein. Negative Ausdrücke oder Zahlen sind nicht erlaubt.

Eine Gleitkommazahl wird mit TRUE (1) bewertet, wenn ihr Wert > oder = 0.5 ist.

Vergleichsoperatoren:

Bei Schleifen (Kapitel Anweisungen zur Beeinflussung des NC-Programmablaufes) sind Vergleichsoperationen erforderlich. Es kann wie folgt geprüft werden auf:

Gleichheit	==	$IF P1 == 10
Ungleichheit	!=	$IF P1 != 10
größer gleich	>=	$IF P1 >= 10
kleiner gleich	<=	$IF P1 <= 10
kleiner	<	$IF P1 < 10
größer	>	$IF P1 > 10

Operator – Prioritäten:

Die verfügbaren Operatoren sind nach absteigender Priorität aufgelistet. 10 ist die höchste und 1 die niedrigste Priorität.

Priorität	Operator	Beschreibung
10	**	Potenz
9	*, /	Multiplikation, Division
8	+, -	Addition, Subtraktion
7	&	Bitweises UND
6	^	Bitweises exklusives ODER
5	\|	Bitweises ODER
4	<=, >=, ==, <, >, !=	Vergleichsoperatoren
3	&&, AND	Logisches UND
2	XOR	Logisches exklusives ODER
1	\|\|, OR	Logisches ODER

Mögliche Wahrheitswerte sind:

Wahr	TRUE	$IF V.A.MERF.X == TRUE
Nicht wahr	FALSE	$WHILE V.G.WZ[2].OK == FALSE

Achtung

Behandlung der Wahrheitswerte:

Für TRUE wird steuerungsintern der Wert 1 verwendet.

Für FALSE wird steuerungsintern der Wert 0 verwendet.

Winkelfunktionen (Angabe von Winkeln in Grad):

Sinus	SIN [..]	P1 = SIN [P2]
Kosinus	COS [..]	P1 = COS [P2]
Tangens	TAN [..]	P1 = TAN [P2]
Kotangens	COT [..]	P1 = COT [P2]
Arkus Sinus	ASIN [..]	P1 = ASIN [P2]
Arkus Kosinus	ACOS [..]	P1 = ACOS [P2]
Arkus Tangens	ATAN [..]	P1 = ATAN [P2]
Arkus Tangens mit 2 Argumenten	ATAN2 [y,x]	P1 = ATAN2[100,100] (-> Ergebnis ist 45°)
Arkuskotangens	ACOT [..]	P1 = ACOT [P2]

Achtung

Bei den Zahlenfunktionen ASIN und ACOS muss das Argument immer zwischen -1 und +1 sein.

Bei der Zahlenfunktion TAN darf das Argument nicht die Werte ... -90, 90, 270 ... Grad annehmen.

Bei der Zahlenfunktion COT darf das Argument nicht die Werte ... -180, 0, 180 ... Grad annehmen.

Die Zahlenfunktion ATAN2 liefert für x != 0 den Winkel einer Position zur X-Achse im korrekten Quadranten.

Sonderfall: Für ATAN2[0,0] (x = 0 und y = 0) ist das Ergebnis immer 0.

Umwandlungsfunktionen:

Nachkommastellen abschneiden	INT [..]	P1 = INT [123.567] (P1 = 123)
Ganzzahligen Anteil entfernen	FRACT [..]	P1 = FRACT [123.567] (P1 = 0.567)
Auf ganze Zahl runden	ROUND [..]	P1 = ROUND [77.5] (P1 = 78) P1 = ROUND [45.4] (P1 = 45)
Aufrunden	CEIL [..]	P1 = CEIL [8.3] (P1 = 9)
Abrunden	FLOOR [..]	P1 = FLOOR [8.7] (P1 = 8)

Konstanten:

3.141592654 (π)

P2 = 2*PI (P2 = 6.283185307)

Spezielle Funktionen:

Test der

Existenz von

Variablen (V.P., V.L., V.S., V.E.) /

Parametern /

M/H-Funktionen /

Makros

EXIST [<Variable/

Parameter/

M Funktion/

H Funktion/

Makroname>]

$IF EXIST[V.P.MYVAR] == TRUE

$IF EXIST[V.L.MYARRAY[0]] == TRUE *

$IF EXIST[P1] != TRUE

$IF EXIST[M55] == TRUE

$IF EXIST[H20] == TRUE

$IF EXIST["Macro1"] == TRUE

*Bei Arrays mit Angabe gueltiger Indizes!

Bestimmung der Größe einer Array-Dimension von Variablen

(V.P., V.L., V.S., V.E.) / Parametern

SIZEOF [<Array_name>,

<Dimension>]

oder für 1. Dim.

SIZEOF [<Array_name>]

#VAR

P99[3][4]= [1,2,3,4,
5,6,7,8,
11,12,13,14]

#ENDVAR

(P12 u. P13 für 1.Dimension)

P12 = SIZEOF[P99] (P12 = 3)

P13 = SIZEOF[P99,1] (P13 ==P12 =3)

(P14 für 2.Dimension)

P14 = SIZEOF[P99,2] (P14 = 4)

(P15 für 3.Dimension, die nicht existiert)

P15 = SIZEOF[P99,3] (P15= -1)

SIZEOF liefert für nicht vorhandene Arraydimensionen und für Variablen, die keine Arrays sind, immer -1.

Kleineren Wert

ermitteln

MIN [x,y]

P1 = MIN [P2, P3]

Größeren Wert

ermitteln

MAX [x,y]

P1 = MAX [P2, P3]

Vorzeichen

bestimmen

SIGN [..]

P1 = SIGN [P2] liefert für

positive Werte: 1

negative Werte: -1

Null: 0

Bestimmung der Stringlänge eines Makroinhaltes.

[ab V2.11.2841.00]

MACRO_LENGTH [<Makroname>]

"Macro53" = "G53 X0 Y0 Z0"

"Empty" = ""

P1 = MACRO_LENGTH["Macro53"]
(P1 = 12)

P1 = MACRO_LENGTH["Empty"]
(P1 = 0)

MACRO_LENGTH liefert für nicht existierende Makros immer -1

Lesen und Auflösung eines Makroinhaltes. Der Rückgabewert ist ein String.

[ab V3.1.3081.4]

<MACRO_CONTENT[<Makroname>]

"MACRO_1" = "1 + 2"

"MACRO_2" = "SIN[\"MACRO_1\"]"

MACRO_CONTENT["MACRO_1"] gibt "1 + 2" zurück

MACRO_CONTENT["MACRO_2"] gibt "SIN[1 + 2]" zurück

Verschlüsselungsfunktion:

Mit Hilfe dieser Funktion können Strings verschlüsselt werden. Der zugehörige Schlüssel ist vom Anwender frei definierbar. Die Strings können z.B. wichtige Daten beinhalten, welche man durch Verschlüsselung schützen möchte.

Die verschlüsselten Daten können dann z.B. mit #MSG SAVE in einer Datei gesichert oder über V.E.-Variablen der SPS zur Verfügung gestellt werden.

String verschlüsseln

ENCRYPT ["Schluessel", "String"]

Hinweis

Aufgrund einer EU-Exportbestimmung ist die Funktion zur Entschlüsselung nicht mehr verfügbar.

Das Ergebnis von ENCRYPT wird Variablen vom Typ String zugewiesen. Dabei ist folgendes zu beachten:

Die Stringvariable muss mindestens die doppelte Länge des zu verschlüsselnden Strings haben.

Programmierbeispiel

String verschlüsseln und sichern in einer Datei

N10 V.E.encrypted = ENCRYPT[ "Key", "String zum Verschluesseln" ]

N20 #MSG SAVE ["Encrypted Text = %s", V.E.encrypted ]

M30