3. Script Language > Miscellaneous commands > UNI.

UNI. - Universal multi purpose command

Previous Top Next

MiniRobotLanguage (MRL)

UNI. Command

Name for multiple Subprogrammes that are currently in testing

Intention

You can use these commands but there is no warranty that they will be working in the same way in the future.

They are "subject to Improvement". Some of the Examples below are in "MPR-Skript", they use a "\" instead of the "." so they may need be changed to SPR-Skript in parts.

Many of the commands are already implemented in native SPR-Commands.

Syntax

UNI.subcommand|[Parameters]

Parameter Explanation

Paramenter - the Parameters depend on the used Subcommand

B E T A

--------------------

GRN - Dokumentation

--------------------

Das UNI.- Mnemonic ist als Universal-Mnemonic angelegt und eröffnet eine Reihe von fortschrittlichen neuen Möglichkeiten.

Die Hauptaufgabe ist dabei die graphische Erkennung von Objekten in Fenstern, wie dies typischerweise in JAVA-Programmen und JAVA-Setups erforderlich ist.

Darüberhinaus implementiert UNI. auch noch ergänzende Möglichkeiten im Umfeld der Bedienung solcher Programme.

Die Syntax ist generell wie folgt:

UNI.[Command-Name][..|Parameter1][..|Parameter2][..|Parameter3][>Variable]

Dabei sind die Command-Names in unterschiedliche Gruppen eingeteilt:

g_ ... graphische Commands

s_ ... String (Zeichenketten-Befehle)

d_ ... Befehle, die neue Datenklassen implementieren

m_ ... mathematische und Datums-Befehle

/*********************************************************************************************************************************/

Beispiel: UNI.s_unwrap

'? VAR=Variable

VAR\$$STR=a<end>c

UNI.s_unwrap|$$STR|ac>$$RES

' $$RES wäre nun "<end>" da die "linke Klammer 'a'

' und die rechte Klammer 'b'" entfernt wurden.

'? MBX=MessageBoX

MBX\$$RES

/*********************************************************************************************************************************/

Beispiel: UNI.m_calc

UNI.m_calc|13/2|x>$$RES

MBX\$$RES

/*********************************************************************************************************************************/

#######################################################################################################################

'******************************************************************************

Graphical Recognition Commands

'******************************************************************************

Diese Befehle dienen dazu, in einem Setup oder einer anderen Programm-Maske Elemente zu lokalisieren oder auf das Erscheinen dieser Elemente zu warten.

Falls dazu Text verwendet wird, wird dazu in zwei Schritten verfahren:

1. Analyze (Parameter)

2. Locate Object

Alternativ kann auch zusätzlich navigiert werden. Hierbei wird ein Objekt lokalisiert und dann mittels der "g_navigate" Anweisung ein Objekt angefahren.

Dabei wäre die Verfahrensweise dann so:

1. Analyze

2. Locate

3. Navigate ...

Unabhängig davon, was lokalisiert wurde, stehen die Koordinaten der Kanten des lokalisierten Elementes jeweils auch über die WinRobots-Spezialvariablen zur Verfügung:

$il$ = Linkskoordinate (ItemLeft),

$it$ = Obenkoordinate (ItemTop),

$ir$ = Rechtskoordinate (ItemRight),

$ib$ = Untenkoordinate (ItemBottom),

$iw$ = Breite (ItemWidth),

$ih$ = Höhe (ItemHeight),

(Siehe Hilfe "Spezialordner")

Wird eine Farbdifferenz oder ein Farbkontrast verlangt, ist die übliche Reichweite 0-765.

0 - wäre die genau gleiche Farbe, während die Maximaldifferenz bzw. der Maximalkontrast (also weiss-schwarz) 765 ist.

****************************

"ana.","g_analyze"

****************************

Dieser Befehl analysiert die Fensteroberfläche. Dies ist notwendig zur Vorbereitung späterer Suchbefehle.

Der Befehl teilt die Oberfläche des lokalisierten Fensters in Quadranten ein, und ermöglicht die Angabe in welchen der Quadranten gesucht werden soll.

Zudem ermöglicht der Befehl eine graphische Anzeige, welche Objekte mit den späteren Suchbefehlen lokalisiert werden können.

Der Befehl benötigt dazu eine Anzahl Parameter:

' TF:Textfarbe, Defaultwert ist 0 = schwarz - optional

' TL:Toleranzwert, Defaultwert 150

' PD:Pixeldistanz, 4-48, Defaultwert 6 - optional

' WH:Window Handle - optional, Default ist das zuletzt lokalisierte Fenster

' MS:Feldmaske, Default 0 - keine Einschränkung

' FL:Flags 0/1 - Picture-Mode Rest, s.u.

' UNI.g_analyze|[TF:0][,PD:4-48][,TL:150][,WH:32423][,MS:Feldmaske]

Dabei wird die Maske wie folgt in 16 Felder eingeteilt:

A1,A2,A3,A4

B1,B2,B3,B4

C1,C2,C3,C4

D1,D2,D3,D4

Damit kann man angeben, in welchen Feldern später gesucht werden soll.

Ebenso kann man angeben, ob Objekte vollständig oder nur überwiegend in den angegebenen Feldern liegen müssen oder ob es genügt, wenn das Objekt partiell im Feld liegt.

Diese Angaben macht man bei der Vorbereitung der Maske mittels "g_mask".

Beim Parameter MS: hat man die Wahl, die Felder entweder direkt anzugeben, dazu müssen Klammern wie folgt verwendet werden:

' UNI.g_analyze|MS:(A1,A2,A3,p)

oder man kann eine vordefinierte Maske aus einer Variablen benutzen, die zuvor mittels "g_mask" vorbereitet wurde.

Dieses Verfahren erlaubt es diverse Masken in Variablen vorzuhalten.

VAR\$$ARS=A1,A2

' Feldmaske vorbereiten und in $$TXT ablegen

UNI.g_mask|$$ARS|p>$$TXT

UNI.g_analyze|PD:8,FL:12,TL:50,MS:$$TXT

Beispiele:

' Direktangabe der Maske

' UNI.g_analyze|MS:(A1,A2,A3,p),TL:100

' repeat last analyze run with same parameters

' UNI.g_analyze|R

' or

' UNI.g_analyze|Repeat

' Komplettes Beispiel

' Diese Felder werden durchsucht

VAR\$$ARS=A1,A2

' Feldmaske vorbereiten und in $$TXT ablegen

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|PD:8,FL:12,TL:50,MS:$$TXT

UNI.fba.|Summen

MMV\

Flags - Bedeutung:

' 1 - Win7-Mode

' 2 - ToGrey

' 4 - Cleartype Mode

' 8 - Debug Mode, Draw Letterboxes

' 16 - Invert Boxes

' 32 - Draw Fields

****************************

"msk.","g_mask"

****************************

Mit diesem Befehl kann man den Suchbereich in der Maske auf bestimmte Felder einschränken.

Dabei wird die Maske/das Suchfenster wie folgt in 16 Felder eingeteilt:

A1,A2,A3,A4

B1,B2,B3,B4

C1,C2,C3,C4

D1,D2,D3,D4

Man kann nun angeben welche Felder für die spätere Suche initialisiert werden sollen, alle anderen werden ignoriert.

Dazu kommt eine Angabe, ob Objekte vollständig, überwiegend oder nur teilweise in den angegebenen Feldern liegen müssen.

Es genügt dazu die Angabe eines Buchstabens, dieser gilt immer für alle Felder:

p - partiell, f - full, m - much (bedeutet mehr als die Hälfte muss "inside" des Feldes sein.

Für die Spezifikation der Felder gibt es prinzipiell zwei Möglichkeiten. Die additive und die subtraktive.

Die additive Maskenangabe:

Hierbei werden einfach die Felder aufgelistet, die durchsucht werden sollen.

Beispiel:

' gesucht wird in A1 und A2, die Objekte müssen nur "p"artiell in den Feldern enthalten sein.

VAR\$$ARS=A1,A2

UNI.g_mask|$$ARS|p>$$TXT

Die subtraktive Maskenangabe:

Hierbei werden nur die Felder aufgelistet, die NICHT durchsucht werden sollen. ALLE anderen werden durchsucht.

Wird ein Feld als "subtraktiv" angegeben, sind automatisch alle weiteren Angaben auch subtraktiv!

Beispiel:

' gesucht wird in allen Feldern außer A1 und A2, die Objekte müssen vollständig in den Feldern enthalten sein (wegen des "f").

VAR\$$ARS=!A1,A2

UNI.g_mask|$$ARS|f>$$TXT

****************************

"usp.","g_use_place"

****************************

Mit diesem Befehl kann ein beliebiger Punkt in der Maske spezifiziert werden, von wo aus dann mit dem "g_navigate" Befehl ein Element angefahren werden kann.

Die Angaben erfolgen in fensterrelativen Koordinaten, die aus dem Windows Analyzer ermittelt werden können.

Beispiel:

' Element "Standardmappe" lokalisieren

UNI.g_use_place|389,292

UNI.g_navigate|RA|1

Beispiel:

VAR\$$ARS=!D1

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|FL:6,PD:6,PM:6,TL:10

UNI.g_use_place|389,292

UNI.g_navigate|RA|1

MMV\

****************************

"nav.","g_navigate"

****************************

Dieser Befehl dient dazu, von einem lokalisierten Objekt aus ein danebenliegendes anderes Objekt anzufahren.

Dies ist sinnvoll, um auch solche Objekte anzufahren, die man anders nicht sicher lokalisieren kann.

g_navigate berücksichtigt intern den Abstand zwischen dem aktuell lokalisierten Element und den in Frage kommenden Elementen.

Daher kann man auch noch eine number angeben, die angibt das wievielte Element (rechts, links etc.) man anfahren will.

Dies kann zum Beispiel genutzt werden, um in Tabellen Elemente zu überspringen.

UNI.g_navigate|[Richtung]|[number][|cc-Wert]

Für die Richtung gibt es folgende Parameter:

A - All (jede Richtung)

R - rechts

L - links

U - Oben

D - Unten

Sowie Kombinationen:

LA, RA, UA, DA.

Der Unterschied liegt darin, dass ein Feld bei der Angabe von L,R,U,D innerhalb der jeweiligen Kante liegen muss um berücksichtigt zu werden.

Wird zusätzlich ein "A" angegeben, dann kann das Element "irgendwo" auf der jeweiligen Seite liegen.

In diesem Fall wird nur noch der absolute Abstand der Elemente (Kante zu Kante) berücksichtigt.

Beispiel:

' Das nächstliegende Element rechts vom aktuellen wird angefahren

UNI.g_navigate|RA

' Das viert-nächstliegende Element (A(ll) = Umkreis) wird lokalisiert

UNI.g_navigate|A|4

****************************

"fba.","g_find_bap"

****************************

Der Befehl g_find_bap dient dazu, in der Anwendung "Bank ArbeitsPlatz" (Fiducia) Elemente zu lokalisieren.

Die Schriftgröße kann dabei zwischen 7 und 14 Punkte variieren. Es wird direkt der jeweilige Text angegeben, der angefahren werden soll.

UNI.g_find_bap|Suchbegriff|No.|Toleranzzahl für Textvergleich

Die numbernangabe ist dann wichtig, wenn man nicht den ersten passenden, sondern einen anderen passenden Begriff finden will.

Die "Toleranzzahl für Textvergleich" ist per default 2 und je höher (max. 8) desto toleranter ist der Textmustervergleich. Dieser Wert ist unabhängig von der Farbtoleranz, die bei "g_analyze" verwendet wird.

Beispiel:

UNI.g_find_bap|Standardmappe

MMV\

Beispiel mit Angabe eine alternativen Font-Namens:

UNI.fba.|Cancel01|1|4|Courier New

ITO\

OPR\0,0

SBT\2|Not found.

ELSE

MMV\

ETO\

MBX\!

****************************

"wba.","g_wait_find_bap"

****************************

Dieser Befehl dient dazu, auf das Erscheinen eines Suchbegriffes in der Maske zu warten.

UNI.g_wait_find_bap|Suchbegriff|No.|Toleranzzahl für Textvergleich|Maximale Wartezeit in Sekunden

Es kann eine maximale Wartezeit in Sekunden angegeben werden; fehlt diese Angabe wird 30 angenommen.

Beispiel:

' Es wird 6 Minuten auf das Erscheinen eines bestimmten Textes gewartet.

UNI.g_wait_find_bap|Übersicht|1|2|360

' bewirkt das Gleiche

UNI.g_wait_find_bap|Übersicht|||360

****************************

"set.","g_settings"

****************************

Dieser Befehl dient dazu interne Parameter zu setzen. Bei Angabe von:

TE:0 oder TE:1

wird zur Textfindung mittels "fba." oder "ftx." jeweils ein anderes Vergleichsverfahren verwendet.

Es ist denkbar dass zukünftig andere Verfahren dazukommen.

Das Standardverfahren ist derzeit TE:0.

Dieses Verfahren kann bei Fenstern mit vielen graphischen Mustern fälschlicherweise kleinen Text finden.

TE:1 arbeitet viel exakter, findet evtl. jedoch Text der nicht ganz genau übereinstimmt nicht.

Beispiel:

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|PD:4,FL:1,TL:1,TF:&H0,MS:$$TXT

UNI.set.|TE:1

UNI.fba.|Bestellung

MMV\

UNI.set.|TE:0

UNI.fba.|Belegübersicht ein

MMV\

eine weitere Option ist "RC:". Dieses Setting bestimmt die Auswahl der zu lesenden Zeichen für den "rab." Befehl.

Es stehen folgende Subsets und jede Kombination daraus zur Auswahl:

US-Letters_small: 1

US-Letters_big: 2

german Umlauts: 4

Zahlen: 8

Signs: 16

Kernings: 32

' 39 = Kernings + Umlauts + small Letters + big Letters

UNI.set.|RC:39

UNI.rab.

MMV\

Der defaukt Wert für RC ist 39. Sollten in einem Block zum Beispiel NUR Zahlen gelesen werden, kann man das Setting auf "8" setzen.

Eine weitere Option ist "FA:" - "Font Attributes". man kann hier auswählen ob auch Text der:

1 - Normal

2 - Bold

4 - Kursiv

6 - Bold und Kursiv

7 - Normal, Bold und Kursiv

in die Suche mit einbezogen werden soll. Dies kann Einfkluss auf die Rechenzeit der Lesebefehle haben.

Die Option: "SS:" - "smallest Size" ermöglicht die Angabe einer minimalen Font-Suchgröße.

Intern ist die minimale Suchgröße auf den Wert "6" beschränkt. Kleinere Werte werden nicht berücksichtigt.

Die Option: "LS:" - "Largest Size" ermöglicht die Angabe einer maximalen Font-Suchgröße.

Intern ist die maximale Font-Suchgröße auf den Wert "22" festgelegt. Größere Werte werden nicht berücksichtigt.

****************************

"gfa.","g_get_found_size"

****************************

Dieser Befehl kann erst angewendet werden, nachdem ein Textsuch-Befehl wie afb. oder ftx. verwendet wurde.

Er gibt als Rückgabewert eine interne Schriftgröße zurück, in zwei verschiedenen Skalierungen, unter der der jeweilige Text lokalisiert wurde.

Zudem eine dritte Zahl zurückgegeben, dabei handelt es sich um einen Bold-Wert.

VAR\$$ARS=!A1

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

'GCW\\1\shimgvw:czoomwnd\*|w74994

UNI.g_analyze|PD:6,FL:2,TL:10,TF:0,MS:$$TXT

UNI.fba.|Abbrechen||1

NTO\

UNI.gfa.>$$TXT

MBX\$$TXT

ETO\

****************************

"ftx.","g_find_text","graphic find text"

****************************

Dient zum Finden von Texten in JAVA-Setup-Programmen.

****************************

"wtx.","g_wait_find_text"

****************************

UNI.wtx.|(zu suchender Text[optional: number bei mehreren][|optional Toleranz]

****************************

"rab.","g_read_actual_block"

****************************

Dieser Befehl dient dazu den Text im aktuell lokalisierten Block zu lesen. Der Text wird dabei in einer Variable oder in $v1$ zurückgegeben.

Dieser Befehl setzt vorraus, dass ein Block lokalisiert wurde, egal mit welchen Befehlen (Beispiel: "g_find_by_number", oder "g_navigate" oder zum Beispiel g_scan_object_right).

Der Befehl wird im einfachsten Fall so aufgerufen:

' Es wird die interne Standardschrift verwendet

UNI.rab.>$$TXT

MBX\$$TXT

Man kann das Ergebnis des Lesenbefehls mit den Patternmatch-Funktionen (wie "s_wildcard_compare") gegen einen gesuchten Text "matchen", und so fehlertolerant lesen.

Dabei sollten sowohl normal,bold,kursiv als auch beides einigermassen erkannt werden.

Es ist möglich ein alternatives "Schriftarten-Set" anzugeben. Dabei kann man entweder den Namen einer Schriftart oder einfach eine number angeben.

Diese numbern bedeuten dabei folgendes:

"1" = Standardfont

"2" = "Arial"

"3" = "Times New Roman"

"4" = "OCR-A"

"5"= "Verdana"

"6" = "Symbol"

Beispielskript 1:

' Es wird die Schriftart 2 (Arial) verwendet

UNI.rab.|2>$$TXT

MBX\$$TXT

Jeweils beim ersten Aufruf des Befehls mit einem bestimmten "Font" erzeugt der Befehl eine Datendate in "?exepfad\".

So eine Datei ist für jeden Font der gelesen werden soll erforderlich.

Dies kann bis zu 10 Sekunden dauern, diese Datei ist zwischen 1 MB und 3 MB groß je nach Font.

In dieser Zeit wird auf dem System (im Installationsverzeichnis (Zugriff muss erlaubt sein!) ein Datenfile erzeugt, welches für den Befehl notwendig ist. Es hat ca. 1.3 MB. Wenn Sie das Datenfile haben, muss es nicht mehr neu erzeugt werden.

Sie können das Datenfile auch kopieren und mittels

'#INC:?exepfad\Catseye_4233042457.dat

In die EXE einfügen.

Dadurch ersparen Sie sich die 6 Sekunden Wartezeit beim allerersten Aufruf des Befehl.

Kurz: Diese Datei wird zum Lesen von BAP benötigt, falls sie nicht da ist wird sie erzeugt.

Noch in wichtiger Hinweis für die Tester:

Dieses Datenfile enthält Daten zu den zu lesenden Zeichen.

Sie müssen dieses Datenfile (bis zur Finalen Version) bei jedem Update NEU erzeugen, da es sein kann dass jeweils Zeichen dazukommen.

Beispielskript 2:

VAR\$$ARS=!D1,C1,B1

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

'GCW\\1\shimgvw:czoomwnd\*|w74994

UNI.g_analyze|PD:5,FL:2,TL:0,TF:0,MS:$$TXT

UNI.fba.|SB-Karte erfassen

MPO\

UNI.rab.>$$TXT

MBX\$$TXT

****************************

"fbn.","g_find_by_number"

****************************

Dieser Befehl kann zum Lokalisieren von Ojekten verwendet werden, die derzeit nicht gelesen werden können, jedoch als Blöcke angezeigt werden.

Dazu wählt man den erwarteten Quadranten aus und gibt die Blocknumber an.

UNI.fbn.|(Nr. zu suchendes Element)

Beispiel:

VAR\$$ARS=D3,D4

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|PD:6,FL:12,TL:10,TF:0,MS:$$TXT

UNI.fbn.|10

MMV\

****************************

"wbn.","g_wait_find_by_number"

****************************

Dieser Befehle entspricht "fbn." in der Version mit "wait".

Man kann damit zum Beispiel auf das Erscheinen von Buttons warten.

UNI.wbn.|(Nr. zu suchendes Element)|(Timeout in Sekunden)

****************************

"gqn.","get_quadrant_rect_by_name"

****************************

Dient zum Ermitteln des Rechtecks (Koordinaten) eines Feldes.

Das Kommando lokalisiert das Feld, der aktuelle Punkt wird in die Mitte des Feldes gelegt.

Die Koordinaten der Kanten des Feldes stehen dann über die WinRobots-Spezialvariablen zur Verfügung:

$il$ = Linkskoordinate (ItemLeft),

$it$ = Obenkoordinate (ItemTop),

$ir$ = Rechtskoordinate (ItemRight),

$ib$ = Untenkoordinate (ItemBottom),

$iw$ = Breite (ItemWidth),

$ih$ = Höhe (ItemHeight),

(Siehe Hilfe "Spezialordner").

Beispiele:

UNI.get_quadrant_rect_by_name|A1

MMV\

UNI.get_quadrant_rect_by_name|D4

MMV\

****************************

"sco.","g_scan_object_at_point"

****************************

Dieser Befehl ermittelt das umschreibende Rechteck und den Mittelpunkt eines Objektes, typischerweise einer Textbox.

Dazu wird ein beliebiger Punkt innerhalb des Objektes angegeben, sowie optional eine Farbe und eine Farbtoleranz.

Wird als Farbe -1 angegeben, wird die Farbe an dem angegebenen Punkt als Referenzfarbe verwendet, wird die Farbtoleranz weggelassen, wird 180 als Defaultwert verwendet.

Der Befehl benötigt vorweg ein "g_analyze".

Beispiel:

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|PD:5,FL:1,TL:1,TF:&H8C5317

' Hier ist Weiss die Referenzfarbe, die Farbtoleranz ist 180

UNI.sco.|&HFFFFFF|333,242

MMV\

' Hier wird die Referenzfarbe ermittelt und die Farbtoleranz beträgt 100

UNI.sco.|-1,100|333,242

MMV\

****************************

"scr.","g_scan_object_right"

"scl.","g_scan_object_left"

"scd.","g_scan_object_down"

"scu.","g_scan_object_up"

****************************

Die Befehle dienen dazu, rechts/links/oben/unten liegende Textboxen zu lokalisieren.

Diese Lokalisierung erfolgt anders als die reguläre Lokalisierung der Texte.Daher ist eine Navigation mittels "g_navigate" nur von diesen Objekten zu anderen Objekten möglich.

Eine Navigation zu diesen Objekten ist nur mittels dieser Befehle möglich, nicht mittels "g_navigate".

Ausgenommen davon ist jeweils das zuletzt lokalisierte Objekt.

Es nimmt einen Sonderstatus ein, damit von diesem Objekt aus zu einem Textobjekt navigiert werden kann.

Der Befehl scannt nach rechts/links/oben/unten bis er ein Objekt/Punkt/Linie findet, die einen Farbkontrast zum Hintergrund in der angegebenen Stärke aufweist.

Er versucht dann den Umfang des Objektes zu ermitteln.

UNI.scr.|(Kontrastwert beim Rechts-Scan]|[inside/outside]|[Farbtoleranz für Objekterkennung]|[Scanweite in Pixel oder 0]

+ Kontrastwert beim Scan - Wertbereich: 1-765, wird 0 angegeben, so wird der Defaultwert von 180 verwendet.

+ inside/outside Point - Wertebereich 0/1...10 - Falls die Objekte eine Umrandung haben, kann man durch Angabe von "1" erreichen, dass ein Punkt innerhalb des Objektes zur Ermittlung des Umfangs herangezogen wird.

Dies ist bei Tabellen erforderlich, da ein Scan des Randes dann die gesamte Tabelle erfassen wird.

Navigiert man Checkmarks, kann ein Wert von 2 hilfreich sein, da damit der Rand übersprungen wird.

+ Farbtoleranz für Objekterkennung - es ist möglich hier eine Farbtoleranz zwischen 0 und 765 anzugeben. Dadurch werden auch Objekte, die Farbübergänge enthalten, korrekt ermittelt.

Default ist der gleiche Wert wie beim Kontrastwert.

+ Scanweite: Default ist 1/2 der Bildbreite. Die Zahl rechnet ab Außenkante des aktuell lokalisierten Elementes.

Der Befehl benötigt ein g_analyze und ein lokalisiertes aktuelles 9er-Element.

Beispiel:

VAR\$$ARS=!B4

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|PD:5,FL:1,TL:1,TF:&H8C5317,MS:$$TXT

' Von Text

UNI.fba.|Alle Firmen

MMV\

' Zu Checkmark

UNI.scl.|230|1|180

MMV\

' Zu Checkmark darunter

UNI.scd.|130|2|180

MMV\

' Zu Checkmark darunter

UNI.scd.|130|2|180

MMV\

' Beispiel feststellen ob ein Checkmark gesetzt ist:

VAR\$$ARS=!B1

' Verwenden Sie 2, 10 oder 26 als Flag!

CAL\$$FLG=3+0

UNI.g_mask|$$ARS|p>$$TXT

STW\shimgvw:cpreviewwnd\

UNI.g_analyze|PD:6,FL:$$FLG,TL:0,TF:&H0,MS:$$TXT

UNI.fba.|telefonisch durchgeführt

UNI.g_scan_object_left|80|2

' Aktueller Punkt ist nun in der Mitte der Checkmark

' Hole aktuellen Punkt (Mitte Checkmark)

VAR\$$XPA=$ix$

VAR\$$YPA=$iy$

' kleines Rechteck drumherum ermitteln

CAL\$$XLI=$$XPA-3

CAL\$$XRE=$$XPA+3

CAL\$$YOB=$$YPA-3

CAL\$$YUN=$$YPA+3

' Toleranz für IRC auf 20% Festlegen

CTO\20

IRC\$$XLI,$$YOB,$$XRE,$$YUN|&H0

MBX\Gesetzt

ELSE

MBX\Nicht gesetzt

ERC\

#######################################################################################################################

'******************************************************************************

Datentypen

'******************************************************************************

Der Stapel / Stack

****************************

d_init_stack

****************************

Um verschachtelte Ausdrücke zu parsen, ist ein Stapel-Datentyp sehr hilfreich.

Der "Stack", zu Deutsch "Stapel", ist ein sogenannter LIFO-Datentyp. Das bedeutet "Last-In-First-Out".

Dasjenige Element, welches man zuletzt hinzugefügt hat, ist dasjenige, das man zuerst wieder zurückbekommt.

Vergleichbar mit den Karten auf einem Kartenspiel. Die oberste Karte ist die letzte Karte (Last IN), die auf den Kartenstapel gepackt wurde,

so ist sie automatisch die erste Karte (first out), die man von OBEN auch wieder herunternehmen kann.

Wir alle kennen solche Stapel aus dem täglichen Arbeitsleben: das Ein- und Ausgangskörbchen in jedem Büro ist solch ein Stapel.

Um solche Vorgänge script-technisch nachzubilden gibt es nun den Stapel-Datentyp.

Es gibt also nicht nur einen Stapel, sondern viele Stapel.

Um das Scripting damit übersichtlich zu gestalten, bekommen diese Stapel vom User jeweils Namen, damit diese vom System ansprechbar werden.

Hinweis: Wenn man sich z.B. vom Spielkartenstapel die oberste Karte herunternimmt, so ist diese EXKLUSIV in der Hand und auf dem Stapel

steht die nächste Karte zur Verfügung. Das ist das normale Verhalten, das wir alle kennen.

Mit dem Parameter "N", kann man dafür sorgen, dass man einen Blick auf die oberste Karte erhält, diese bleibt aber liegen.

Somit hat man quasi eine Kopie der Karte vor Augen.

Um nun wirklich an die nächste Karte vom Stapel zu bekommen, muss man nun manuell dem System sagen, dass die oberste Karte gelöscht werden soll (d_del_stack_item).

Wenn man einen Stapel verwenden möchte, muss man diesen zunächst benennen. Dazu dient der folgende Befehl:

UNI.d_init_stack|(Name des Stapels)|(Autodeletefunktion an/aus) durch N oder weglassen

Ab dann steht ein Stapel mit diesem Namen zur Verfügung.

Es gibt die Möglichkeit, als weiteren Parameter das "N" wie "NoAutoDelete" anzugeben.

Ist dieser Parameter gesetzt, dann wird beim Abheben eines Elementes von diesem Stack dieses Element nicht automatisch gelöscht.

Existiert ein Stack dieses Namens bereits, löscht der Befehl den Stack und setzt das "N"-Bit neu.

Nach dem Erzeugen eines Stapels, wird dieser Stapel automatisch selektiert. Das bedeutet, dass "Push" und "Pop" Befehle dann auf diesen Stapel angewendet werden.

Beispiel:

UNI.d_init_stack|Loops

' Im folgenden Beispiel wird die "N" Option verwendet.

' Bei diesem Stack werden beim Abheben die Elemente nicht automatisch gelöscht.

' Dies muss man dann explizit mit "d_del_stack_item" tun, da die N Option aktiv ist.

UNI.d_init_stack|Loops|N

****************************

d_select_stack

****************************

Zum Beispiel beim Parsen von XML genügt ein Stack nicht, man benötigt mehrere Stacks.

Um nun festzulegen, welchen der Stacks man aktuell verwendet, wird dieser Befehl benötigt.

Beispiel:

UNI.d_init_stack|Loops

' Der neuerliche "d_init_stack" selektiert automatisch den Stack "Ferz"

UNI.d_init_stack|Ferz

' Nun benötigt man den Loops-Stack; also selektiert man diesen

UNI.d_select_stack|Loops

' Löscht das oberste Item von dem gerade selektierten Stack.

UNI.d_del_stack_item

' Löscht die obersten 4 Items von dem gerade selektierten Stack.

UNI.d_del_stack_item||4

****************************

d_push_on_stack

****************************

Und wie kommen die Items nun auf den Stack? Mit "d_push_on_stack" natürlich.

Die Syntax lautet:

UNI.d_push_on_stack|(Item-String)[|(Item-String 2) ...

Beispiel:

UNI.d_init_stack|Loops

' Wir legen drei Items auf den neu erstellten Stapel

UNI.d_push_on_stack|Line 150|Line 160|Line 170

****************************

d_pop_from_stack

****************************

Sinn macht das Ganze natürlich erst, wenn wir die Items auch wieder vom Stack zurückbekommen. Das geht mit:

UNI.d_pop_from_stack>$$ITM

Man hat die Möglichkeit hier noch den Namen eines Stapels anzugeben:

UNI.d_pop_from_stack|Loops>$$ITM

Dann wird das Item von diesem Stapel genommen. Der Stapel wird aber nicht selektiert.

Ein nachfolgender

UNI.d_pop_from_stack>$$ITM

wird also das Item vom derzeit selektierten Stapel nehmen.

****************************

d_del_stack_item

****************************

Will man Items vom Stapel entfernen, zum Beispiel weil die Option "N" beim Deklarieren des Stacks (siehe: d_init_stack) verwendet wurde, so ist dies der Befehl der Wahl. Man kann optional noch den Namen eines Stacks und die Anzahl der Items, die gelöscht werden sollen, angeben.

' Löscht das oberste Item vom aktuellen Stack

UNI.d_del_stack_item

' Löscht das oberste Item vom Stack "Loops"

UNI.d_del_stack_item|Loops

' Löscht die obersten 5 Items vom Stack "Loops"

UNI.d_del_stack_item|Loops|5

' Löscht die obersten 5 Items vom aktuell selektierten Stack

UNI.d_del_stack_item||5

Der Befehl gibt auf Wunsch die Anzahl der noch auf dem Stack verbleibenden Elemente zurück.

UNI.d_del_stack_item||5>$$CNT

****************************

d_get_stack_count

****************************

Gibt die Anzahl der Elemente auf dem jeweiligen Stapel zurück. Gibt man keinen Stapelnamen an, wird der aktuelle Stapel verwendet.

Gibt man den Namen eines Stapels an, wird dieser verwendet.

' Hier bezieht sich der Befehl auf den selektierten Stack

UNI.d_get_stack_count>$$CNT

' Hier bezieht sich der Befehl auf den Stack mit Namen "Loops"

UNI.d_get_stack_count|Loops>$$CNT

****************************

d_erase_stack

****************************

Diese Funktion löscht den Stack und zwar auch den Stack-Namen. Er kann danach für einen neuen Stack erneut mit "d_init_stack" verwendet werden.

Beim Beenden des Scripts werden alle Stackspeicher sowieso freigegeben, dies ist also nicht unbedingt manuell erforderlich.

Bitte bei diesem Befehl den Namen des zu löschenden Stacks stets explizit angeben.

UNI.d_erase_stack|Loops

' Im Folgenden erhält $$STK die Anzahl noch deklarierter Stacks.

UNI.d_erase_stack|Loops>$$STK

#######################################################################################################################

'******************************************************************************

' String-Befehle

'******************************************************************************

**************

s_unwrap,unw

**************

"Unwrap" auf Deutsch "Auspacken".

Entfernt linke und rechte Klammer. Diese müssen angegeben werden.

Folgt ein weiterer Parameter "a" oder "a", dann wird sichergestellt, dass an beiden Seiten jeweils alle Klammern entfernt werden.

Das Ergebnis wird als String zurückgegeben.

UNI.s_unwrap|$$STR|()>$$RES

UNI.s_unwrap|$$STR|{}>$$RES

UNI.s_unwrap|$$STR|<>>$$RES

**************

s_wrap,unw

**************

"wrap" auf Deutsch "Einpacken".

Fügt linke und rechte Klammer zu einem String hinzu. Diese müssen angegeben werden.

Folgt ein weiterer Parameter "n" oder "no doubles", dann wird sichergestellt, dass an beiden Seiten jeweils nur eine Klammer ist.

In diesem Fall werden evtl. bereits vorhandene Einklammerungen entfernt, bevor diese Klammer hinzugefügt wird.

Das Ergebnis wird als String zurückgegeben.

UNI.s_wrap|$$STR|()>$$RES

UNI.s_wrap|$$STR|{}|no doubles>$$RES

UNI.s_wrap|$$STR|<>|n>$$RES

**************

s_replace_word

**************

Word-Replace Funktion. Ersetzt nur ganze Wörter (abgetrennt mit Leerzeichen), keine Wörter in Wörtern.

Falls der Zusatz "colon" als 4. Parameter gegeben wurde, werden Wörter innerhalb von " " (Gänsefüsschen / ASC 34) ignoriert.

Beispiele:

VAR\$$STR=Halleluja in der Halle. Er rief "Halleluja in der Halle".

UNI.s_replace_word|$$STR|Halle|Raum|colon

UNI.s_replace_word|$$STR|Halle|Raum

' Ergebnis in $v1$

UNI.s_replace_word|$$STR|Halle|Raum|colon>$$RES

UNI.s_replace_word|$$STR|Halle|Raum>$$RES

' Ergebnis in $$RES

****************************

s_no_case_instr

****************************

Diese Funktion sucht eine Zeichenkette in einer größeren Zeichenkette. Dabei wird Groß-/Kleinschreibung ignoriert.

Es gibt die Möglichkeit, die Suchrichtung durch Angabe von "back" als drittem Parameter umzukehren.

In einem vierten Parameter kann eine Startposition angegeben werden.

Beispiele:

' Diese beiden sind identisch in der Wirkung, Ergebnis jeweils in $v1$

UNI.s_no_case_instr|$$STR|findme|f|1

UNI.s_no_case_instr|$$STR|findme

' Ergebnise hier in Variable

UNI.s_no_case_instr|$$STR|findme|back|5>$$RES

UNI.s_no_case_instr|$$STR|findme|forward|88>$$RES

****************************

s_equalcase_replace

****************************

Diese Funktion ersetzt das erste oder alle (Parameter 5) Vorkommen von (Parameter 2) in der Zeichenkette (Parameter 1) ab Position (Parameter 4) durch (Parameter 3).

Dabei spielt Groß- und Kleinschreibung keine Rolle. Die originale Groß- und Kleinschreibung der Angaben wird in dem Ersetzungsvorgang trotzdem beibehalten.

Die Angaben der Zeichenketten geschehen wie folgt:

Beispiele:

VAR\$$STR=Hallo Peter.

VAR\$$IST=Peter

VAR\$$SOL=Franz

UNI.s_equalcase_replace|$$STR|$$IST|$$SOL>$$TAR

UNI.s_equalcase_replace|$$STR|$$IST|$$SOL|1|all>$$TAR

UNI.s_equalcase_replace|$$STR|$$IST|$$SOL|5>$$TAR

UNI.s_equalcase_replace|$$STR|$$IST|$$SOL|15|all

' Im letzteren Fall ist das Ergebnis in $v1$, in den anderen Beispielen ist es in der Zielvariablen $$TAR.

****************************

s_case_sensitive_replace

****************************

Diese Funktion ersetzt das erste oder alle (Parameter 5) Vorkommen von (Parameter 2) in der Zeichenkette (Parameter 1) ab Position (Parameter 4) durch (Parameter 3).

Dabei werden Groß- und Kleinschreibung beachtet. Die originale Groß- und Kleinschreibung der Angaben wird in dem Ersetzungsvorgang stets beibehalten.

Die Angaben der Zeichenketten geschehen wie folgt:

UNI.s_case_sensitive_replace|(String, in dem ersetzt werden soll)|(String, der ersetzt werden soll)|(String, der ersatzweise eingefügt wird)[|optional all]

Beispiele:

VAR\$$STR=Hallo Peter.

VAR\$$IST=Peter

VAR\$$SOL=Franz

UNI.s_case_sensitive_replace|$$STR|$$IST|$$SOL>$$TAR

UNI.s_case_sensitive_replace|$$STR|$$IST|$$SOL|all>$$TAR

UNI.s_case_sensitive_replace|$$STR|$$IST|$$SOL>$$TAR

UNI.s_case_sensitive_replace|$$STR|$$IST|$$SOL|all

' Im letzteren Fall ist das Ergebnis in $v1$, in den anderen Beispielen ist es in der Zielvariablen $$TAR.

****************************

s_generate_rnd_string

# Transfered to STR.GENERATE

****************************

Diese Funktion erzeugt einen Zufallsstring aus den Zeichen in Zeichenkette (Parameter 1) mit der Länge (Parameter 2) oder (Defaultwert) 32.

Dabei kann man (Parameter 1) auch weglassen. Dann werden alle Groß- und Kleinbuchstaben sowie das "-" verwendet.

Alternativ kann man als (Parameter 1) folgende Angaben machen:

- (beliebige Zeichenkette - diese Zeichen werden verwendet)

- leer - es werden Klein- und Großbuchstaben und das "-" verwendet

- "A" die Zeichenkette wird nur aus Großbuchstaben gebildet.

- "a" die Zeichenkette wird nur aus Kleinbuchstaben gebildet.

- "A-" die Zeichenkette wird nur aus Großbuchstaben und dem "-" Zeichen gebildet.

- "a-" die Zeichenkette wird nur aus Kleinbuchstaben und dem "-" Zeichen gebildet.

Beispiele:

' Es werden Klein- und Großbuchstaben und das "-" verwendet, Ergebnis in $$RES mit Länge 32

UNI.s_generate_rnd_string||>$$RES

' Es werden nur die Zeichen aus $$LET verwendet, die Länge des Ergebnisstrings ist hier 45

VAR\$$LET=%&_ABCDefgh

UNI.s_generate_rnd_string|$$LET|45>$$RES

' Es werden hier Großbuchstaben und das "-" Zeichen verwendet. Die Länge des Ergebnisstrings ist hier 8000 Zeichen

VAR\$$LET=A-

UNI.s_generate_rnd_string|$$LET|8000>$$RES

****************************

s_scan_for_number

****************************

Diese Funktion ermittelt die erste Ziffer in einer Zeichenkette (Parameter 1), beginnend bei Position (Parameter 2).

Rückgabe ist die Position der ersten Ziffer (0-9).

Beispiele:

VAR\$$STR=<Fontsize123>

UNI.s_scan_for_number|$$STR>$$POS

' $$POS enthält nun die Position der "1" also 10.

' Im Folgenden startet der Scan ab Position 6:

UNI.s_scan_for_number|$$STR|6>$$POS

****************************

s_fuzzy_compare

****************************

Diese Funktion vergleicht zwei Zeichenketten. Dabei wird ein gradueller Vergleich angewendet, der entweder:

- eine Übereinstimmung von 0% bis 100% zurückliefert (als Zahl 0 bis 100)

- oder (wenn Parameter 3 = "mistakes") die Anzahl der Tippfehler (Mistakes) zwischen den beiden Strings zurückgibt.

Beispiele:

VAR\$$TXA=MyCommands

VAR\$$TXB=MyCummands

UNI.s_fuzzy_compare|$$TXA|$$TXB|mistakes>$$RES

' $$RES ist nun 1, da sich der Schreiber einmal vertippt hat.

UNI.s_fuzzy_compare|$$TXA|$$TXB>$$RES

' $$RES ist nun 90, da die Übereinstimmung zwischen den beiden Strings 90% beträgt.

****************************

s_wildcard_compare

****************************

Texte einfach nach dem Schema "A = B ?" zu vergleichen, erfordert nicht besonders viel Intelligenz.

Oftmals will man wissen, ob Dinge ähnlich sind, oder bestimmte Bestandteile enthalten sind.

Dazu können Wildcards herangezogen werden.

Die Vergleichsfunktion s_wildcard_compare vergleicht einen Wildcard-String (Parameter 1) mit einem zweiten String (Parameter 2).

Das Ergebnis ist 1 (das bedeutet Übereinstimmung) oder 0 (die Strings stimmen nicht überein).

Es gibt drei verschiedene Wildcard-Sets.

Set 1:

------

Als Wildcards werden in diesem Fall primär die zwei Joker-Zeichen aus DOS-Zeiten verwendet.

* - ersetzt beliebige Zeichen

? - ersetzt ein Zeichen

Beispiel:

VAR\$$TXA="Jan?a*"

VAR\$$TXB="Januar"

UNI.s_wildcard_compare|$$TXA|$$TXB>$$RES

' Man kann in allen Fällen JIZ\ (Jump-If-Zero) verwenden, um das Resultat auszuwerten.

JIZ\$$RES:Label

' $$RES wäre hier 1, da der Vergleich erfolgreich ist. Andernfalls ist das Ergebnis 0.

Set 2:

------

Falls der Zusatz "numeric" (Parameter 3) angegeben wird, dann wird zusätzlich das Zeichen

# - ersetzt eine Ziffer

ausgewertet.

' der Zusatz "numeric" bewirkt, dass auch das # Zeichen ausgewertet wird.

UNI.s_wildcard_compare|$$TXA|$$TXB|numeric>$$RES

JIZ\$$RES:Label

Set 3:

------

' der Zusatz "all" bewirkt, dass die AGR\-Stringpatterns verwendet werden. Diese sind unten aufgeführt.

Beispiel:

VAR\$$TXA="{Janner&TOLERANT:&DOCAPS:60}"

UNI.s_wildcard_compare|$$TXA|$$TXB|all>$$RES

JIZ\$$RES:Label

Pattern Abkürzung Beispiel

{&DOCAPS:} {&0:} {&DOCAPS:ExPE} -> Groß-/Kleinschreibung beachten.

{&OR:} {&1:} {Text1&OR:Text2} -> A oder B oder beides

{&XOR:} {&2:} {Text1&XOR:Text2} -> A oder B

{&AND:} {&3:} {Text1&AND:Text2} -> A und B; Reihenfolge beliebig

{&ANDTHEN:} {&4:} {Text1&ANDTHEN:Text2} -> A dann B

{&FUZZY:} {&5:} {{Text1}&FUZZY:[value]} -> ungefähr A

{&TOLERANT:} {&6:} {{Text1}&TOLERANT:[value]} -> A zu min. X%

{&NOT:} {&7:} {&NOT:{Text1}} -> darf nicht vorkommen

{&EXACT:} {&8:} {&EXACT:Text1} -> genau A (Ohne Groß/Klein)

{&NOTEXT:} {&9:} {&9:}

{&t:} -> Always True

{&f:} -> Always False

Alle Pattern können auch mit der Abkürzung verwendet werden, also statt &EXACT: kann man einfach &0: schreiben.

Die einfachen Operatoren (&OR, &XOR, &AND, &ANDTHEN) können beliebig oft wiederholt werden, also

{Text1&OR:Text2&OR:Text3&OR:Text4&OR:Text5... usw.}

ist möglich.

Der &NOT: Operator bezieht sich auf das Nichtvorhandensein von Text; er dient nicht dazu, Pattern-Berechnungen zu negieren. Also

&NOT:{text1&AND:text2}

funktioniert so nicht, allerdings kann man die aufgelöste Variante verwenden:

{&NOT:text1}&AND:{&NOT:text2}&AND:{&NOT:text3} ... etc.

Dies funktioniert mit allen einfachen Operatoren.

Es gibt keine Beschränkung auf 2 Operatoren wie ansonsten bei den WinRobots-Suchmustern, also beispielsweise AFO\(?), STW\ etc. Dadurch sind beliebig viele Internationalisierungen im gleichen Script denkbar.

Das {&EXACT:Text1}-Pattern ersetzt das WinRobots Standard-Suchmuster "Text1&&" (&& am Ende).

Prinzipiell sind auch Verschachtelungen möglich, solange die Klammern korrekt gesetzt werden, also zum Beispiel:

{{{Text1&ORText2}&ANDTHEN:{Text1&ORText4}}&ANDTHEN:Text2}

Neu hinzugekommen ist der fortschrittliche "Tippfehler-Operator"; Beispiel:

{Text1&FUZZY:5}

Die Zahl hinter dem "&FUZZY:" gibt an, wie oft man sich vertippen darf, so dass der Text trotzdem erkannt wird.

Ebenso neu hinzugekommen ist der "&TOLERANT" Operator. Hierbei wird eine %-Zahl angegeben, die die Wortähnlichkeit angibt, ab der der Text der Bedingung entspricht.

Beispiel:

{text1&TOLERANT:89}

{text1&TOLERANT:&DOCAPS:89}

Achtung: Folgendes funktioniert nicht (und macht auch keinen Sinn)

{{text1&OR:text2}&TOLERANT:&DOCAPS:89}

da der "&TOLERANT" Operator nur Texte auswerten kann.

Bei allen Operatoren kann jeweils das "&DOCAPS:" verwendet werden. Dadurch wird die jeweilige Klammerebene auf Groß-/Klein-Schrift umgeschaltet, berücksichtigt dann also Groß- und Kleinschreibung.

#######################################################################################################################

****************************

m_calc

****************************

Diese Funktion ermöglicht das Berechnen von beliebigen, geklammerten Ausdrücken.

Ebenso werden die üblichen Rechenregeln berücksichtigt (Punkt vor Strich etc.).

Zusätzlich kann das Ergebnis auf vielfache Art und Weise gerundet werden.

Es gibt die folgenden Operatoren (Auflistung in der Reihenfolge der Priorität):

' Logische Operatoren - Allerhöchste Priorität

> Größer als

< Kleiner als

= Gleich

! Nicht gleich

^ Hoch - Zweithöchste Priorität

* Multiplikation

% Modulo-Division

/ Division

\ Rest von Division ermitteln

+ Addition

- Subtraktion

Beispiel:

UNI.m_calc|13\2>$$RES

MBX\$$RES

Das Ergebnis des Befehls kann nun auf vielfache Weise nachbearbeitet werden.

Dazu stehen unter anderem folgende Möglichkeiten zur Verfügung:

|i - Integer, rundet auf die nächste Ganzzahl, die gleich oder größer als das Ergebnis ist

|c - rundet auf die nächst kleinere Ganzzahl, die gleich oder kleiner als das Ergebnis ist

|x - schneidet einfach alle Nachkommastellen ab

|f - fractiona, gibt nur die Nachkommastellen zurück

|a - Absolutwert: Schneidet ein evtl. negatives Vorzeichen weg.

|r - rundet auf 2 Dezimalstellen

|s - Sign, gibt 1,0 oder -1 zurück, je nachdem welches Vorzeichen das Ergebnis hatte

Die Zeichen können auch kombiniert werden und werden dann der Reihe nach verarbeitet.

Beispiele:

UNI.m_calc|13\2|x>$$RES

MBX\$$RES

UNI.m_calc|-13\2|fa>$$RES

MBX\$$RES

UNI.m_calc|-13\2|xa>$$RES

MBX\$$RES

VAR.$$NAM=10

VAR.$$FOR=(100*$$NUM)+20

UNI.m_calc\$$FOR|ia>$$ERG

MBX.Das Ergebnis ist: $$ERG

****************************

m_eval

****************************

Dieser Befehl implementiert einen wissenschaftlichen Formel-Rechner, der relativ langsam arbeitet aber kaum Wünsche offen lässt.

Der Rechner ist derzeit nur in englisch implementiert.

Im Fehlerfall erhält man eine aussagekräftige Fehlermeldung, statt des Ergebnisses.

[englisch]

Using extended precision, 18 digits of precision is obtained. Factorials are computed up to 1754! without overflow.

Expressions and functions should follow strictly to standard algebraic syntax rules.

Operators and expressions which can be used are:

+ - * / \ ^ ! ( ) < = > <> >= <=

The Operator Precedence follows algebraic rules.

The only exception is the unary negation operator which in this program does not have a special priority following exponentiation.

However, operations inside parentheses always have the highest priority and are always evaluated first.

Thus by using parentheses in the right places you can always obtain the operator precedence you need for your purpose.

The following operator precedence is used in the program:

1. parentheses ( )

2. unary operators (Factorials (!) )

3. one argument functions

4. exponentiation (^) (power expressions)

5. multiplication (*) and floating-point division (/)

6. integer division (\)

7. modulo (MOD)

8. addition (+), subtraction (-)

9. relational operators (<, <=, =, >=, >, <> )

10. NOT, ISFALSE and ISTRUE

11. AND

12. OR and XOR (exclusive OR)

13. EQV (equivalence)

14. IMP (implication)

These are the implemented trigonometric functions:

"ARCSINH() - Arc (Inverse) Hyperbolic Sine"

"ARCCOSH() - Arc (Inverse) Hyperbolic Cosine"

"ARCTANH() - Arc (Inverse) Hyperbolic Tangent"

"ARCSECH() - Arc (Inverse) Hyperbolic Secant"

"ARCCSCH() - Arc (Inverse) Hyperbolic Cosecant"

"ARCCOTH() - Arc (Inverse) Hyperbolic Cotangent"

"ARCSIN() - Arc (Inverse) Sine"

"ARCCOS() - Arc (Inverse) Cosine"

"ARCSEC() - Arc (Inverse) Secant"

"ARCCSC() - Arc (Inverse) Cosecant"

"ARCCOT() - Arc (Inverse) Cotangent"

"SINH() - Hyperbolic Sine","TANH() - Hyperbolic Tangent"

"SECH() - Hyperbolic Secant"

"CSCH() - Hyperbolic Cosecant"

"COTH() - Hyperbolic Cotangent"

"SEC() - Secant"

"CSC() - Cosecant"

"COT() - Cotangent"

"SIN() - Sine","COS() - Cosine"

"TAN() - Tangent"

"ATN() - Arc (Inverse) Tangent"

"LN() - Natural Log (base E)"

"EXP2() - Exponentiation of 2 or Antilog 2"

"EXP10() - Exponentiation of 10 or Antilog 10"

"EXP() - Exponentiation of E or Antilog E"

"SQR() - Square Root","LOG10() - Common Log (base 10)"

"ABS() - Absolute Value"

"LOG2() - Log (base 2)"

"LOG() - Natural Log (base E)"

"AND - Logical AND"

"XOR - Logical XOR (Exclusive OR)"

"OR - Logical OR"

"MOD - MOD (Modulo)"

"IMP - Logical IMP (Implication)"

"EQV - Logical EQV (Equivalence)"

"NOT - NOT","ISTRUE - Logical Truth"

"ISFALSE - Logical Falsity"

"CEIL() - Ceiling"

"FRAC() - Fractional Part"

"FIX() - Truncate To Integer"

"SGN() - Sign"

"PI# - Constant (3.14159..)"

"E# - Constant (2.71828..)"

A number of constants and conversions are available, making this math evaluator an advanced scientific calculator.

These "known constants" include:

"Foot_TO_meter" = "*1/ 3.28084"

"Meter_TO_foot" , "* 3.28084"

"Inch_TO_centimeter" , "* 2.54"

"Centimeter_TO_inch" , "*1 / 2.54"

"Kilometer_TO_mile" , "*1 / 1.609344"

"Mile_TO_kilometer" , "* 1.609344"

"Inch_TO_foot" , "*1 / 12"

"Foot_TO_inch" , "* 12"

"Yard_TO_meter" , "*1 / 1.093613"

"Meter_TO_yard" , "* 1.093613"

"Fathom_TO_meter" , "* 1.8288"

"Meter_TO_fathom" , "*1 / 1.8288"

"Mile_TO_light-year" , "*1 / 5880000000000"

"Light-year_TO_mile" , "* 5880000000000"

"Parsec_TO_light-year" , "* 3.261643"

"Light-year_TO_parsec" , "*1 / 3.261643"

"Square_ft_TO_square_m" , "*1 / 10.76391"

"Square_m_TO_square_ft" , "* 10.76391"

"Square_in_TO_square_cm" , "* 6.4516"

"Square_cm_TO_square_in" , "*1 / 6.4516"

"Hectare_TO_acre" , "* 2.471054"

"Acre_TO_hectare" , "*1 / 2.471054"

"Pound_TO_kilogram" , "*1 / 2.204623"

"Kilogram_TO_pound" , "* 2.204623"

"Ton_(metric)_TO_Kilogram" , "* 1000"

"Kilogram_TO_ton_(metric)" , "*1 / 1000"

"Ton_(US)_TO_Kilogram" , "* 907.18474"

"Kilogram_TO_ton_(US)" , "*1 / 907.18474"

"Ton_(UK)_TO_Kilogram" , "* 1016.046909"

"Kilogram_TO_ton_(UK)" , "*1 / 1016.046909"

"Ounce_(avoirdupois)_TO_gram" , "* 28.349551"

"Gram_TO_ounce_(avoirdupois)" , "*1 / 28.349551"

"Ounce_(troy)_TO_gram" , "* 31.103508"

"Gram_TO_ounce_(troy)" , "*1 / 31.103508"

"Fahrenheit_TO_Celsius" , "*1 / 1.8 - 32 / 1.8"

"Celsius_TO_Fahrenheit" , "* 1.8 + 32"

"Celsius_TO_Kelvin" , "*1 + 273.16"

"Kelvin_TO_Celsius" , "*1 - 273.16"

"Gallon_(US_dry)_TO_liter" , "* 4.404884"

"Liter_TO_gallon_(US_dry)" , "*1 / 4.404884"

"Gallon_(US_liquid)_TO_liter" , "* 3.785412"

"Liter_TO_gallon_(US_liquid)" , "*1 / 3.785412"

"Quart_(US_dry)_TO_gallon_(US_dry)" , "*1 / 4"

"Gallon_(US_dry)_TO_quart_(US_dry)" , "* 4"

"Pint_TO_liter_(US_dry)" , "* 0.55061"

"Liter_TO_pint_(US_dry)" , "*1 / 0.55061"

"Pint_TO_liter_(US_liquid)" , "* 0.473176"

"Liter_TO_pint_(US_liquid)" , "*1 / 0.473176"

"Cubic_ft_TO_cubic_m" , "*1 / 35.314667"

"Cubic_m_TO_cubic_ft" , "* 35.314667"

"Horsepower_(elec.)_TO_watt" , "* 745.7"

"Watt_TO_horsepower_(elec.)" , "*1 / 745.7"

"Horsepower_(metric)_TO_watt" , "* 735.499"

"Watt_TO_horsepower_(metric)" , "*1 / 735.499"

"BTU/hour_TO_watt" , "* 0.293071"

"Watt_TO_BTU/hour" , "*1 / 0.293071"

"Kilowatt_TO_watt" , "* 1000"

"Watt_TO_kilowatt" , "*1 / 1000"

"Kph_TO_mph" , "*1 / 1.609344"

"Mph_TO_kph" , "* 1.609344"

"Knot_TO_mph" , "* 1.150778"

"Mph_TO_knot" , "*1 / 1.150778"

"Meter/sec_TO_ft/sec" , "* 3.28084"

"Ft/sec_TO_meter/sec" , "*1 / 3.28084"

"Second_TO_minute" , "*1 / 60"

"Minute_TO_second" , "* 60"

"Minute_TO_hour" , "*1 / 60"

"Hour_TO_minute" , "* 60"

"Minute_TO_day" , "*1 / 1440"

"Day_TO_minute" , "* 1440"

"Day_TO_hour" , "* 24"

"Hour_TO_day" , "*1 / 24"

"Psi_TO_pascal" , "* 6894.757"

"Pascal_TO_psi" , "*1 / 6894.757"

"Psi_TO_atmosphere" , "* 0.068046"

"Atmosphere_TO_psi" , "*1 / 0.068046"

"Psi_TO_kg/sqcm" , "* 0.070307"

"Kg/sqcm_TO_psi" , "*1 / 0.070307"

"Degrees_TO_radians" , "* 1.74532925199432958E-2

"Radians_TO_degrees" , "*1 / 1.74532925199432958E-2

Here are the known conversions:

"Acceleration_of_gravity_(m/sec²)" , "9.80665"

"Dry_air_density_at_STP_(kg/m³)" , "1.293"

"Light_speed_in_a_vacuum_(m/sec)" , "299792458"

"Solar_constant_(watts/m²)" , "1340"

"Sound_speed_at_STP_(m/sec)" , "331.4"

"Standard_atmosphere_(nt/m²)" , "101300"

"Earth_equatorial_radius_(m)" , "6378000"

"Earth_escape_velcity_(m/sec)" , "11186"

"Earth_magnetic_dipole_moment_(amp-m²)" , "6.400E21"

"Earth_mass_(kg)" , "5.983E24"

"Earth_mean_angular_rotational_speed_(rads/sec)" , ".0000729"

"Earth_mean_density_(kg/m³)" , "5522"

"Earth_mean_orbital_speed_(m/sec)" , "29770"

"Earth_polar_radius_(m)" , "6357000"

"Earth_volume_(m³)" , "1.087E21"

"Alpha_particle_mass_(kg)" , "6.64465598E-27"

"Electron_charge-mass_ratio_(coul/kg)" , "175881961000"

"Electron_rest_mass_(kg)" , "9.10938188E-31"

"Muon_rest_mass_(kg)" , "1.88353109E-28"

"Neutron_rest_mass_(kg)" , "1.67492716E-27"

"Proton_rest_mass_(kg)" , "1.67262158E-27"

"Atomic_mass_constant_(kg)" , "1.66053873E-27"

"Avogadro_constant_(1/mole)" , "6.02214199E23"

"Boltzmann_constant_(joule/K)" , "1.3806503E-23"

"Elementary_charge_(coul)" , "1.602176462E-19"

"Faraday_constant_(coul/mole)" , "96485.3415"

"Gravitational_constant_(nt-m²/kg²)" , ".000000000066726"

"Permeability_constant_(henry/m)" , "1.25663706143E-6"

"Permittivity_constant_(farad/m)" , "8.85418781762E-12"

"Planck_constant_(joule-sec)" , "6.62606876E-34"

"Rydberg_constant_(1/m)" , "10973731.568549"

"Stefan-Boltzmann_constant_(watt/m²K4)" , ".000000056704"

"Universal_gas_constant_(joule/K-mole)" , "8.314472"

"Wien_displacement_constant_(m-K)" , ".00290"

Input of angles can be in degrees or radians, depending if you specify the "#" as an additional flag.

However, trigonometric output using the ARC functions will always be in radians.

You can transform angles to radians and vice versa.

Beispiel:

VAR\$$FOR=SIN(1)*Inch_TO_centimeter

' Die Angabe des |# bewirkt Winkelgerechnungen in "Degree" statt "Radian"

UNI.m_eval|$$FOR|#

VAR\$$RES=$v1$

MBX\$$RES

VAR\$$FOR=(5*Inch_TO_centimeter)*Acceleration_of_gravity_(m/sec²)

UNI.m_eval|$$FOR|#>$$RES

MBX\$$RES

****************************

m_is_leapyear

****************************

Die Funktion ermittelt, ob das angegebene Jahr (im Bereich 0 bis 5000) ein Schaltjahr ist oder nicht.

Die Rückgabe ist dementsprechend 1 oder 0.

Fehlt die Jahresangabe, dann wird das aktuell auf dem PC eingestellte Datum zugrunde gelegt.

Beispiel:

UNI.m_is_leapyear|1968>$$RES

UNI.m_is_leapyear|2015

VAR\$$RES=$v1$

' Im Folgenden wird das aktuelle Jahr zugrunde gelegt, da die Jahresangabe fehlt:

UNI.m_is_leapyear>$$RES

****************************

m_get_time

****************************

Die Funktion "m_get_time" ermittelt Zeit und/oder Datum. Darüber hinaus können auch Datumsberechnungen ausgeführt werden.

Da es hierbei wichtig ist, dass man genau das gewünschte Format erhält, unabhängig von den jeweiligen Ländereinstellungen, kann man hier das Format selbst angeben.

Dies geschieht unter Verwendung der folgenden Buchstaben:

y - Jahr

m - Monat

d - Tag

h - Stunde

n - Minute

s - Sekunde

t - Tick (Mikrosekunde)

Ein einfacher Aufruf der Funktion sieht so aus:

UNI.m_get_time|dd>$$RES

Ergebnis: 23 - wenn gerade der 23.te des Monats ist.

UNI.m_get_time|dddd>$$RES

Ergebnis: In diesem Fall 0023 da vier "d" angegeben wurden.

' Ein komplettes Datum erhält man so:

UNI.m_get_time|dd/mm/yyyy>$$RES

Ergebnis in $$RES ist hier zum Beispiel: 03/02/2011

Auf die gleiche Weise kann man die Zeit ermitteln:

UNI.m_get_time|nn>$$RES

Ergebnis wäre zum Beispiel 03 (falls es gerade 7:03 ist).

UNI.m_get_time|nn-ss-tttt>$$RES

' Hier erhält man zum Beispiel Minuten, Sekunden und Ticks.

' Zeitpunkt in 4 Jahren in einem User-definierten Format

UNI.m_get_time|dd/mm/yyyy|AY:4>$$RES

Die Funktion bietet außerdem die Möglichkeit, ausgehend von der jetzigen Zeit Datums-Berechnungen auszuführen.

Dazu kann man als zweiten Parameter angeben, welcher Betrag von Tag, Monat, Jahr etc. abgezogen oder hinzuaddiert werden soll.

Diese Angabe erfolgt durch Buchstabenkombinationen von "A" (Add) oder "S" (Subtract) und dem jeweiligen Zeitbuchstaben wie folgt:

AY:(Zahl) ' Jahre hinzuzählen

SY:(Zahl) ' Jahre abziehen

AM:(Zahl) ' Monate hinzuzählen

SM:(Zahl) ' Monate abziehen

AD:(Zahl) ' Tage hinzuzählen

SD:(Zahl) ' Tage abziehen

AH:(Zahl) ' Stunden hinzuzählen

SH:(Zahl) ' Stunden abziehen

AN:(Zahl) ' Minuten hinzuzählen

SN:(Zahl) ' Minuten abziehen

AS:(Zahl) ' Sekunden hinzuzählen

SS:(Zahl) ' Sekunden abziehen

AT:(Zahl) ' Ticks hinzuzählen

ST:(Zahl) ' Ticks abziehen

Beispiele:

UNI.m_get_time|yy-mm-dd|AH:200,SN:400>$$RES

' Es werden zum aktuellen Datum 200 Stunden hinzugezählt und dann 400 Sekunden abgezogen.

' Das Ergebnis wird im gewünschten Format ausgegeben.

UNI.m_get_time|dd;mm;hh|AD:50,SH:90>$$RES

' Es werden zum aktuellen Datum 50 Tage hinzugezählt und dann 90 Stunden abgezogen.

' Das Ergebnis wird im gewünschten Format ausgegeben in die Variable $$RES.

Der Befehl kann auch für Datumsberechnungen verwendet werden.

Dazu wird die Startzeit mit den folgenden Optionen geändert:

NY: (geänderte Jahreszahl 0 ... 5000)

NM: (Monatszahl: 1 ... 12)

ND: (Tag: 1 ... 31)

NN: (Minute: 0 ... 59)

NS: (Sekunde: 0 ... 59)

NT: (Millisekunde: 0 ... 999)

Beispiel:

UNI.m_get_time|yy-mm-dd|NY:2013,NM:5,ND:5,AH:200,SN:400>$$RES

Man kann so auch einfach ein Datum formatieren (ohne Berechnung):

UNI.m_get_time|yy-mm-dd|NY:2013,NM:5,ND:5>$$RES

****************************

"dtn.","m_date_to_number"

****************************

Der Befehl wandelt ein Datum in eine 32 bit-Zahl um. Dadurch können Datumsvergleiche einfach mittels IVB\ erfolgen.

Beispiel 1:

UNI.dtn.|15-03-2005

VAR\$$DAT=$v1$

UNI.ntd.|$$DAT

MBX\$v1$

Beispiel 2:

UNI.dtn.|15-03-2005

VAR\$$DAA=$v1$

UNI.dtn.|19-04-2005

VAR\$$DAB=$v1$

UNI.dtn.|20-04-2005

VAR\$$DAC=$v1$

IVB\$$DAC|$$DAA|$$DAB

MBX\Datum ist innerhalb des Zeitraumes

ELSE

MBX\Datum ist nicht innerhalb des Zeitraumes

EVB\

Beispiel 3:

' Lässt man das Datum weg, wird das heutige "Local Time" Datum verwendet.

UNI.dtn.|

VAR\$$DAA=$v1$

UNI.dtn.|17-04-2011

VAR\$$DAB=$v1$

CAL\$$DIF=$$DAB-$$DAA

MBX\$$DAA-$$DAB--$$DIF

****************************

"ntd.","m_number_to_date"

****************************

Der 15-03-2011 ergibt zum Beispiel 149823.

Der 16-04-2011 ist 32 Tage später ergibt also 149855.

Auf diese Weise kann man auch leicht DAtumsberechnungen ausführen, auf Tagesbasis.

Mit der "number_to_date" Funktion kann man dann die berechneten Werte wieder in Reale Daten zurückumwandeln.

****************************

"rdi.","m_return_date_info"

****************************

Returns Date-Info (Systemunabhängig). Je nach Angabe eines Zahlenparameters werden unterschiedliche Informationen zum aktuellen Zeitpunkt ermittelt und zurückgegeben:

0 - dayname,

1 - Monthname,

2 - Datenum,

3 - yearnum,

4 - time,

5 - Time + Milliseconds,

6 - DayOfWeek (as number 0-6),

7 - Datum (deutsche Schreibweise),

8 - Wochentag (immer Englisch!),

9 - Wochetag (nur 2 Buchstaben, gross)

10 - Zeit - nur Stunde und Minute

Beispielskript Datumsfunktionen:

' Diese Angabe könnte in einer INI-Datei stehen.

' Sie sagt aus in welchen zeiträumen ein Unterskript ausgeführt werden soll (oder nicht)

VAR\$$INT=Mo*7:00-12:00,Di*9:00-10:00

FEM\1,|$$INT|DoIt|$$INA

MBX\Fertig

:DoIt

' Heutiger Tag als Zahl

UNI.m_return_date_info|6>$$DAN

' Erste Zwei Buchstaben aus Ini-Zeile sind der Tag

GSS\1,2|$$INA>$$DAY

GSB\Daynum

' Wenn nicht heutiger Tag gemeint ist

JIV\$$RES!$$DAN:enz

' Ab hier Uhrzeit prüfen

' Aktuelle Zeit holen

UNI.m_return_date_info|10>$$TIM

' Zeitangaben holen

SBD\|$$INA|*|2>$$TMS

' In von / bis aufspalten

SBD\|$$TMS|-|1

' Von-Zeit

VAR\$$TMA=$v1$

' Bis Zeit

VAR\$$TMB=$v2$

UNI.m_verify_time_format|$$TMA>$$TMA

UNI.m_verify_time_format|$$TMB>$$TMB

UNI.m_verify_time_format|$$TMS>$$TMS

UNI.m_time_to_number|$$TMA>$$TAN

UNI.m_time_to_number|$$TMB>$$TBN

UNI.m_time_to_number|$$TMS>$$TSN

IVB\$$TSN|$$TAN|$$TBN

' Zeit ist innerhalb der genannten Parameter

ELSE

' Zeit ist nicht innerhalb der genannten Parameter

EVB\

:enz

:Daynum

SLC\$$DAY

CSE\MO

VAR\$$RES=1

CSE\DI,TU

VAR\$$RES=2

CSE\MI,WE

VAR\$$RES=3

CSE\DO,TH

VAR\$$RES=4

CSE\FR

VAR\$$RES=5

CSE\SA

VAR\$$RES=6

CEL\

VAR\$$RES=7

ESL\

RET\

****************************

"vdf.","m_verify_date_format"

****************************

Der Befehl stellt sicher, dass ein String das notwendige deutsche Datumsformat DD-MM-YYYY hat.

Es wird auch geprüft ob die Zahlen im erforderlichen Bereich sind.

Der String wird falls erforderlich um führende "0" ergänzt und so zurückgegeben.

Beispiel:

UNI.vdf.|41-2-99

MBX\$v1$

' Da 41 keine gültige Datumsangabe wirde der Wert auf 31 reduziert.

Ausgabe: 31-02-0099

****************************

"vtf.","m_verify_time_format"

****************************

Der Befehl stellt sicher, dass ein String das notwendige deutsche Zeitformat HH:MM:SS hat.

Es wird auch geprüft ob die Zahlen im erforderlichen Bereich sind.

Der String wird falls erforderlich um führende "0" ergänzt und so zurückgegeben.

Beispiel:

UNI.vtf.|24-1-9

MBX\$v1$

Rückgabe: 23:01:09

****************************

"ttn.","m_time_to_number"

****************************

Erzeugt eine Zahl, die die Anzahl der Dekunde nseit Mitternacht angibt.

Dadurch lassen sich Zeitabfragen leicht via IVB\ ausführen.

Ebenso werden Zeitberechnungen mit Sekunden vereinfacht.

Beispiel:

UNI.ttn.|10:09:00

VAR\$$DAT=$v1$

MBX\$$DAT

' Ausgabe: 36540

UNI.ntt.|$$DAT

MBX\$v1$

' Ausgabe: 10:09:00

****************************

"ntt.","m_number_to_time"

****************************

Gegenfunktion zu "m_time_to_number". Nach einer Zeitberechnung läßt sich damit die Anzahl der Sekunden wieder in die Tageszeit umrechnen.

Beispiel:

UNI.ttn.|10:09:00

VAR\$$DAT=$v1$

MBX\$$DAT

' Ausgabe: 36540

UNI.ntt.|$$DAT

MBX\$v1$

' Ausgabe: 10:09:00

#######################################################################################################################

Mit diesen Befehlen können die Robots untereinander kommunizieren.

****************************

"csi.","c_create_alive_signal"

****************************

Erzeugt ein systemweites Signal, das von einem anderen Robot via "c_try_signal" abgefragt werden kann.

Signale werden automatisch entfernt, wenn der Robot, der das Signal gesetzt hat beendet wird.

Die Rückgabe ist der Name des Signals, falls ein Name angegeben wurde, dieser.

Falls kein Signal erstelltw erden konnte, ist die Rückgabe ein Minuszeichen/Bindestrich "-".

****************************

"tsi.","c_try_alive_signal"

****************************

Fragt ob ein systemweites Signal gesetzt wurde. Rückgabe ist 1/0 je nach dem ob das Signal von irgendwoher gesetzt wurde oder nicht.

****************************

"rsi.","c_remove_alive_signal"

****************************

Entfernt ein systemweites Alive-Signal. Rückgbae ist 0/1 je nach dem ob das Signal entfernt werden konnte oder nicht.

ACHTUNG: Ein globales "Alive Signal" kann NUR von der robot-Instanz gelöscht werden, die es erzeugt hat.

Wenn der Robot sich beendet (egal wie) wird automatisch auch das "Alive Signal" gelöscht.

****************************

"wsi.","c_wait_alive_signal"

****************************

Wartet bis das angegebene Signal erzeugt wird oder verschwindet.

Es kann als weiterer Parameter ein Timeout angegeben werden.

Falls das Timeout erreicht wird, wird das ITO\ (Timeout-Flag) gesetzt, ansonsten ist die Rückgabe "1".

Falls auf das Verschwinden eines Signals gewartet wird, muss das Signal beim Aufruf des Befehls bereits vorhanden sein,

sonst ist die Bedingung sofort erfüllt.

Beispiele:

' Signalname "RUN", 10 Sekunden Timeout ob Signal erscheint

UNI.c_wait_alive_signal|RUN|10

ITO\

MBX\Signal nicht erschienen!

ETO\

' Signalname "RUNX", 360 Sekunden Timeout ob Signal verschwindet

UNI.c_wait_alive_signal|!RUNX|360

ITO\

MBX\Signal nicht verschwunden!

ETO\

****************************

"csf.","c_create_signal_flag"

****************************

Erzeugt ein systemweites Flag, das von einem anderen Robot via "c_try_signal_flag" abgefragt werden kann.

Anders als Signale, werden Flags nicht automatisch entfernt, wenn der Robot, der das Flag gesetzt hat beendet wird.

Ausserdem kann ein Flag von jedem Robot gelöscht werden, nicht nur von dem, der es erzeugt hat.

Die Rückgabe ist der Name des Signals, falls ein Name angegeben wurde, dieser.

Falls kein Signal erstellt erden konnte, ist die Rückgabe ein Minuszeichen/Bindestrich "-".

' Robot 1

UNI.csf.|Theo

TDL\500

UNI.rsf.|Theo

CAS\2

' Robot 2

UNI.wsf.|Theo

UNI.wsf.|!Theo

****************************

"tsf.","c_try_signal_flag"

****************************

Fragt ob ein systemweites Flag gesetzt wurde. Rückgabe ist 1/0 je nach dem ob das Flag von irgendwoher gesetzt wurde oder nicht.

****************************

"rsi.","c_remove_alive_signal"

****************************

Entfernt ein systemweites Flag-Signal. Rückgbae ist 0/1 je nach dem ob das Signal entfernt werden konnte oder nicht.

Ein globales "Flag Signal" kann von jeder Robot-Instanz gelöscht werden.

Ein "Flag Signal" ist permanent und besteht auch weiter, wenn der Robot sich beendet, der das "Flag Signal" gesetz hat.

****************************

"wsf.","c_wait_signal_flag"

****************************

Wartet bis das angegebene Flag Signal erzeugt wird oder verschwindet. Es kann als weiterer Parameter ein Timeout angegeben werden.

Falls das Timeout erreicht wird, wird das ITO\ (Timeout-Flag) gesetzt, ansonsten ist die Rückgabe "1".

Falls auf das Verschwinden eines Signals gewartet wird, muss das Signal beim Aufruf des Befehls bereits vorhanden sein, sonst ist die Bedingung sofort erfüllt.

Example

STW.ct|applicationframewindow|fotos

SPC.c|applicationframeinputsinkwindow

UNI.g_analyze|PD:8,FL:12,TL:50

ENR.

Remarks

Limitations:

Mathematical and algorithmic operations

Mathematical and algorithmic operations

UNI. - Universal multi purpose command

Previous Top Next