Arithmetische Ausdrücke <expr>

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

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

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

prg_example

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 im Kapitel "Makros " 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

attention

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

attention

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

attention

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

attention

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

attention

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 (π)

PI

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 function/

         H function/

            macro>]

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

$IF EXIST[P1] != TRUE

$IF EXIST[M55] == TRUE

$IF EXIST[H20] == TRUE

$IF EXIST["Macro1"] == TRUE

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 verschluesseln

ENCRYPT ["Schluessel", "String" ]

String entschluesseln

DECRYPT ["Schluessel", "Verschluesselter String" ]

Das Ergebnis von ENCRYPT bzw. DECRYPT wird einer Stringvariable zugewiesen. Dabei ist folgendes zu beachten:

Programmierbeispiel

prg_example

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