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/

Makro>]

$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>]

$IF SIZEOF

[V.P.MYARRAY,2] == 3

P1 = SIZEOF[P10,2]

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

Verschlüsselungsfunktionen:

Mit Hilfe dieser Funktionen können Strings verschlüsselt und wieder entschlü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" ]
String entschlüsseln	DECRYPT ["Schluessel", "Verschluesselter String" ]

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

Bei ENCRYPT muss die Stringvariable mindestens die doppelte Länge des zu verschlüsselnden Strings haben.
Bei DECRYPT muss die Stringvariable mindestens die halbe Länge des zu entschlü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 ]

Verschlüsselten String entschlüsseln und als Meldung ausgeben:

N10 V.E.decrypted = DECRYPT[ "Key", V.E.encrypted ]

N20 #MSG ["%s", V.E.decrypted ]

M30