Oktober 2013

AT2652D, Rev. 07

User’s Guide

FORMEL/SCRIPT-EDITOR
AVL CONCERTO™ 2014
v4.6
Copyright 2013 AVL List GmbH, Graz - Austria

Der Inhalt dieser Dokumentation darf ohne vorherige schriftliche Zustimmung von AVL weder ganz noch teilweise
in irgendeiner Form reproduziert oder an dritte Personen weitergegeben werden.
Die Erstellung dieser Dokumentation wurde mit der nötigen Sorgfalt durchgeführt, sodass für verbleibende Fehler
oder Auslassungen sowie für dadurch eventuell entstehende Schäden von AVL keine Haftung übernommen wird.
Alle genannten Warenzeichen oder registrierten Warenzeichen sind Eigentum der jeweiligen Eigentümer.

Alle Rechte vorbehalten.

 Inhaltsverzeichnis 3

Inhaltsverzeichnis

1 Formel/Script-Editor.......................................................................................................... 7
1.1 Benutzeroberfläche .................................................................................................................. 7

1.2 Funktionsfenster ....................................................................................................................... 8

1.3 Arbeitsfenster ........................................................................................................................... 9

1.3.1 Arbeitsweise........................................................................................................................ 9
[Link] Eingabehilfen .................................................................................................... 10
1.4 Kanal-Browser ........................................................................................................................ 12

1.5 Meldungsfenster ..................................................................................................................... 12

1.6 Formeldebugger ..................................................................................................................... 13

1.6.1 Aktivieren des Debuggers................................................................................................. 13
1.6.2 Debug-Fenster .................................................................................................................. 14
1.6.3 Direkte Variablenansicht ................................................................................................... 14

2 Formelsyntax ................................................................................................................... 15
2.1 Anweisung .............................................................................................................................. 15

2.2 Kommentar ............................................................................................................................. 15

2.3 Ausdruck................................................................................................................................. 15

2.4 Datenset ................................................................................................................................. 15

2.5 Variable und Kanal ................................................................................................................. 16

2.6 Datenformate und Konstante.................................................................................................. 17

2.6.1 Zahlen ............................................................................................................................... 17
2.6.2 Strings............................................................................................................................... 17
2.6.3 BOOL-Daten ..................................................................................................................... 17

2.7 User-Variable.......................................................................................................................... 17
2.7.1 User-Variablen über Kommandozeilenparameter setzen ................................................. 18

2.8 Globale Datensets .................................................................................................................. 18

2.9 Return Anweisung .................................................................................................................. 18

2.10 Compiler Switches.................................................................................................................. 19

2.10.1 ContinueIfDataSetNotFound............................................................................................. 19
2.10.2 EnableRangeCheck .......................................................................................................... 19
2.10.3 LoadFullResolution ........................................................................................................... 19
2.10.4 OnComErrorResumeNext................................................................................................. 19
2.10.5 RecalcOnPaint .................................................................................................................. 19
2.10.6 RestrictChannelSearchToCurrentKey............................................................................... 19

2.11 Operatoren ............................................................................................................................. 20

2.11.1 Arithmetische Operatoren ................................................................................................. 20
2.11.2 String Operatoren ............................................................................................................. 20
2.11.3 Vergleichsoperatoren........................................................................................................ 21
2.11.4 Logische Operatoren ........................................................................................................ 21

Formel/Script-Editor — User’s Guide

4 Inhaltsverzeichnis

2.11.5 Methoden/Eigenschaftenoperator .....................................................................................21

[Link] Ansprechen einzelner Punkte ...........................................................................22
[Link] Ansprechen ungültiger Punkte ..........................................................................22
[Link] Ansprechen mehrerer Punkte ...........................................................................22
[Link] PenUp-Flag .......................................................................................................23
2.11.6 Set-Operatoren .................................................................................................................23
2.11.7 Ansprechen von Zyklen/Messungen .................................................................................23

2.12 Strukturanweisungen.............................................................................................................. 24
2.12.1 if...then...else Statement ...................................................................................................24
2.12.2 For-Schleife .......................................................................................................................25
2.12.3 While-Schleife ...................................................................................................................25
2.12.4 Break-Anweisung ..............................................................................................................26
2.12.5 Return-Anweisung.............................................................................................................26

2.13 Funktionsaufrufe..................................................................................................................... 26

2.14 Makros.................................................................................................................................... 27
2.14.1 Makros als Unterprogramme.............................................................................................27
2.14.2 Transformationsmakros ....................................................................................................28

2.15 Formeln/Makros/Scripts verschlüsseln (nur mit Option N[Y]) ................................................. 29

2.16 Beispiele ................................................................................................................................. 29

2.16.1 Einfache Formelbeispiele ..................................................................................................29
2.16.2 Formeln mit mehrfachen Dateien ......................................................................................30

3 Funktionsreferenz ........................................................................................................... 31

4 Klassen............................................................................................................................. 33
4.1 Syntax..................................................................................................................................... 34

4.2 Arbeiten mit Anzeige-Objekten............................................................................................... 35

4.2.1 Fenster ..............................................................................................................................35
4.2.2 Objekte..............................................................................................................................36
4.2.3 Display Items.....................................................................................................................36

4.3 Composer-Skript..................................................................................................................... 38
4.3.1 Aufbau der Composer-Befehle..........................................................................................38
[Link] Benannte Parameter .........................................................................................38
[Link] Adressierung .....................................................................................................39
[Link] Bereiche ............................................................................................................41
4.4 Eigenschaften und Methoden................................................................................................. 42

5 Beispiele ........................................................................................................................... 43
5.1 Transformation Makros........................................................................................................... 43
5.1.1 Transformation zur Verschiebung der X- und Y Achse .....................................................43
5.1.2 Berechnung des Integrals innerhalb zweier vordefinierter Grenzen .................................43

Formel/Script-Editor — User’s Guide

 Inhaltsverzeichnis 5

5.2 Scripts..................................................................................................................................... 45
5.2.1 [Link] .............................................................................................................. 45
5.2.2 [Link]............................................................................................................. 46
5.2.3 Datenset einer Y-Achse finden ......................................................................................... 46
5.2.4 Punktauswahl ................................................................................................................... 47
5.2.5 Log pV Diagram ................................................................................................................ 48
5.2.6 Objektverwaltung .............................................................................................................. 48

6 Zugriff auf DOS-Kommando........................................................................................... 51

Index............................................................................................................................................................. 53

Formel/Script-Editor — User’s Guide

6 Inhaltsverzeichnis

Formel/Script-Editor — User’s Guide

 Formel/Script-Editor 7

1 Formel/Script-Editor
Der Formel/Script-Editor stellt Ihnen eine komplette Entwicklungsumgebung
innerhalb von CONCERTO zur Verfügung. Diese folgende Beschreibung gilt
auch zur Erstellung von Makrofunktionen und Scripts (siehe auch im Exploration
Guide unter Berechnungen).

1.1 Benutzeroberfläche
Der Formel/Script-Editor wird als eigenes Applikationsfenster dargestellt,
welches individuell angepasst (z. B. in der Größe verändert) werden kann.
Sie haben folgende Möglichkeiten, den Formel/Script-Editor aufzurufen:
„ Shortcut-Leiste:

alternativ „ Workflow-Leiste und Wahl des Eintrags Formel/Script-Editor:

„ Funktionstaste Strg+E
„ Menüeintrag Ansicht | Komponenten | Formel/Script-Editor

Formel/Script-Editor — User’s Guide

8 Formel/Script-Editor

Das Formel/Script-Editor-Hauptfenster ist wie folgt unterteilt:

5
6

2
3

1 .... Funktionsfenster
2 .... Arbeitsfenster
3 .... Kanal-Browser
4 .... Meldungsfenster
5 .... Menüleiste
6 .... Symbolleiste
Abb. 1

1.2 Funktionsfenster
Hier haben Sie die Möglichkeit, nach Funktionen unter verschiedenen
Funktionstypen zu suchen. Um sich detaillierte Informationen zu den Funktionen
anzeigen zu lassen, markieren Sie die gewünschte Funktion. Im Meldungs-
fenster wird dann die genaue Syntax sowie eine Kurzbeschreibung angezeigt
(siehe Meldungsfenster auf Seite 12).

Formel/Script-Editor — User’s Guide

 Formel/Script-Editor 9

1.3 Arbeitsfenster
Im Arbeitsfenster können Formeln, Makrofunktionen sowie Scripts erstellt und
bearbeitet werden. Über den Menüeintrag Datei | Neu oder durch Drücken auf
folgendes Symbol wird automatisch ein neues Blatt erstellt:

Sie können gleichzeitig mehrere Formeln, bzw. Makrofunktionen und Scripts

bearbeiten.
Nach dem Erstellen Ihrer Funktionen können Sie diese durch Drücken auf
folgendes Symbol überprüfen:

Es wird hier allerdings nur die Syntax, nicht aber das Vorhandensein von
Kanälen geprüft.

1.3.1 Arbeitsweise
Wenn Sie eine bestimmte Funktion nutzen wollen ist es nicht nötig diese per
Hand zu schreiben. Sie können diese aus der Funktionsliste per Drag and Drop
auf Ihr Arbeitsblatt ziehen. Es erscheint dann ein Dialog, welcher eine Kurzbe-
schreibung der Funktion sowie sämtliche Parameter, welche für die Funktion
benötigt werden, zeigt. Um Datensets in diesen Dialog einzufügen, ziehen Sie
den gewünschten Kanal einfach aus dem Kanal-Browser an die richtige Stelle im
Dialog.

Abb. 2

Formel/Script-Editor — User’s Guide

10 Formel/Script-Editor

Dabei wird der Name des Kanals mit FileAlias und Datenschlüssel dargestellt.
Nach Bestätigen wird die Funktion erstellt und im Arbeitsblatt angezeigt.

[Link] Eingabehilfen
Der Formel/Script-Editor bietet ein Hilfsmittel bei der Bearbeitung von Quell-
codes, ähnlich IntelliSense von Microsoft (z. B. in deren Produkt Microsoft Visual
Studio). Dabei erhalten Sie während der Eingabe einer Formel, eines Makros
oder Scripts über eine Dropdown-Liste Auswahlmöglichkeiten von verfügbaren
Objekttypen und Funktionsnamen, die die Arbeit erleichtert und insbesondere
die Menge des einzugebenden Quellcodes reduzieren.

Beispiel
Das folgende Beispiel soll diese Funktionalität veranschaulichen:

1. Deklarieren Sie zunächst eine Variable mit einer Dim-Anweisung,

z. B "Dim DataExp as".
Der Editor schlägt automatisch alle möglichen Objekttypen vor:

Abb. 3

2. Wählen Sie DataExplorer durch einen Doppelklick oder durch Drücken der
Eingabetaste, um den Member dem Code hinzuzufügen.
Eine Variable vom Typ DataExplorer ist nun deklariert:

Abb. 4

Formel/Script-Editor — User’s Guide

 Formel/Script-Editor 11

3. Setzen Sie nun hinter die Objektvariable einen Punkt, schlägt der Editor
wieder automatisch alle verfügbaren Funktionen, Attribute und Methoden
vor:

Abb. 5

Weitere Vereinfachung bei der Codeeingabe:

Bei der Verwendung einer Funktion, die eine Variable eines bestimmten Typs
zurückliefet (z. B. SelWin - gibt immer ein Fenster zurück) haben Sie folgende
Möglichkeit der vereinfachten Eingabe:
• Machen zu eine Zuweisung von SelWin auf w, z. B. w=SelWin("*").
Bei der Eingabe von "w." interpretiert der Editor, dass "w" vom Typ Fenster
ist und es werden automatisch alle möglichen Funktionen für den Objekttyp
Fenster vorgeschlagen:

Abb. 6

Formel/Script-Editor — User’s Guide

12 Formel/Script-Editor

Diese Funktionalität lässt sich nun beliebig auf alle Klassen anwenden (Fenster,
Objekt, Datenset, ...):

Abb. 7

Wie die Beispiele oben deutlich zeigen, wird durch diese Funktionalität die
Menge des einzugebenden Quellcodes erheblich reduziert.

1.4 Kanal-Browser
Der Kanal-Browser zeigt alle geladenen Dateien/Versuche inklusive ihrer
Kanäle.
Sie können Kanäle mittels Drag & Drop aus dem Kanal-Browser in das Arbeits-
fenster ziehen.
Mehr zu diesem Thema finden Sie im Exploration Guide unter Benutzer-
oberfäche.

1.5 Meldungsfenster

Abb. 8

Zeigt Informationen zu Formeln sowie Fehlermeldungen des Compilers.

Wenn das Formel/Script-Editor-Fenster nicht sichtbar ist, werden Fehlermeldung
in der Meldungsleiste eingeblendet.
Wenn Sie auf die Fehlermeldung doppelklicken, öffnet sich der
Formel/Script-Editor automatisch und zeigt die Zeile an, welche den Fehler
verursachte. Sie können dann entscheiden, ob Sie einen Breakpoint setzen
möchten, um den Code zu debuggen (siehe Abschnitt Formeldebugger auf
Seite 13).

Formel/Script-Editor — User’s Guide

 Formel/Script-Editor 13

1.6 Formeldebugger
Mit dem Formeldebugger können Sie die Abarbeitung von Makrofunktionen,
Formeln und Scipts überwachen. Der Debugger ermöglicht das Setzen von
Breakpoints, die Einzelschrittabarbeitung des Codes und stellt alle Variablen dar.
Der Debugger verfügt über folgende Funktionalitäten:
Go F5
Startet die Abarbeitung des Scripts, welches gerade dargestellt wird.
Debugger abbrechen ESC
Wenn die Abarbeitung einer Makrofunktion, einer Formel oder eines Scripts
mittels Breakpoint angehalten wurde, kann der Debug-Vorgang und die Abar-
beitung mit dieser Schaltfläche gestoppt werden.
Step Into F8
Einzelschritt ("Single Step"): Nur die nächste Zeile wird abgearbeitet. Trifft die
Abarbeitung auf eine selbst geschriebene Makrofunktion, wird diese in einem
weiteren Fenster angezeigt und kann dort weiter schrittweise verfolgt werden.
Step Over Shift+F8
Einzelschritt: Nur die nächste Zeile wird abgearbeitet. Trifft die Abarbeitung auf
eine selbst geschriebene Makrofunktion, wird diese als Ganzes ausgeführt.
Run to Cursor Ctrl+F8
Wenn Sie den Cursor in eine beliebige Position der Makrofunktion, der Formel
oder des Scripts stellen, wird die Abarbeitung an der Cursorposition gestoppt.
Die Zeile, in der sich der Cursor befindet, wird dabei noch nicht berücksichtigt.
Breakpoint einfügen/entfernen F9
Die Abarbeitung der Makrofunktion, der Formel oder des Scripts, wird an dieser
Stelle unterbrochen. Alle bis dahin verwendeten Variablen und deren Wert
werden im Watch-Fenster eingeblendet. Die Zeile, in der sich der Breakpoint
befindet, wird dabei noch nicht berücksichtigt.
Alle Breakpoints entfernen
Alle gesetzten Breakpoints werden entfernt.

1.6.1 Aktivieren des Debuggers

Um den Debugger zu aktivieren, muss zuerst ein Breakpoint im Code gesetzt
werden.
Wenn Sie ein Script debuggen wollen, können Sie dieses anschließend mit dem
Go Button starten. Wenn Sie eine Formel oder ein Makro debuggen wollen,
stellen Sie sicher, das dieses neu berechnet wird, z. B. durch Drücken von
Neurechnen in der Symbolleiste von CONCERTO oder durch
Neuladen/Neueinlesen der Daten.

Formel/Script-Editor — User’s Guide

14 Formel/Script-Editor

1.6.2 Debug-Fenster
Dieses Fenster erscheint nur dann, wenn die Abarbeitung einer Makrofunktion,
einer Formel oder eines Scripts, mittels Breakpoint oder Run to Cursor ange-
halten wurde. Es beinhaltet zwei Seiten:
Alle Alle bereits verwendeten Variablen und deren Wert werden in diesem Fenster
eingeblendet.

Abb. 9

Benutzerdefiniert Zur besseren Übersicht können einzelne Variablen im Text durch einen
Doppelklick markiert und mittels Drag and Drop in die Registerkarte Benutzer-
definiert gezogen werden.

Abb. 10

Durch einen Rechtsklick in das Fenster kann die Darstellung zwischen horizontal
und vertikal umgeschaltet werden.

1.6.3 Direkte Variablenansicht

Während des Debuggens ist es möglich, sich den Wert einer Variablen anzeigen
zu lassen, in dem Sie mit dem Mauscursor auf eine Variable fahren. Kurz
danach wird der Wert in einem kleinen Tipp-Fenster neben der Variable ange-
zeigt.

Formel/Script-Editor — User’s Guide

 Formelsyntax 15

2 Formelsyntax
Die Syntax für Formeln, Makros und Scripts ist identisch. Sie ähnelt Visual
Basic, auch wenn einige wenige Elemente aus C inkludiert sind.
Makros und Scripts, welche ein Argument übernehmen, müssen mit einer
“arg“-Zeile beginnen, um die Argumente Variablen zuzuordnen.
Die Einheit des Ergebnisses wird entweder durch den Funktionsaufruf "setunit"
oder durch das Schlüsselwort "UNIT:" definiert.

2.1 Anweisung
Jede Formel, jede Makro oder Script besteht aus Anweisungen. Alle
Anweisungen werden durch das Zeilenende abgeschlossen. Wenn Sie eine
lange Zeile aufteilen wollen, fügen Sie einen Backslash (\) am Ende der Zeile
ein. Dies zeigt an, dass diese Zeile in der nächsten fortgesetzt wird.

2.2 Kommentar
Sie können Ihren Code Kommentare hinzufügen. Es gibt zwei Arten: Entweder
schließen Sie Ihren Kommentar in /* .......... */ ein, oder Sie verwenden // .......,
woraufhin der Rest der Zeile als Kommentar interpretiert wird.

2.3 Ausdruck
Eine Kombination von Variablen, Konstanten, Funktionen, Makros, Operatoren
und Klammern wird Ausdruck genannt. Jeder Ausdruck erzeugt ein internes
Ergebnis Datenset, das meist einer Variablen zugewiesen wird.

2.4 Datenset
Jede Dateninformation die verarbeitet wird ist als sogenanntes Datenset aufge-
baut. Diese Struktur ist ähnlich der des Visual Basic Variant Datentyps, jedoch
wesentlich leistungsfähiger. Jede Variable in einer Formel, Makro oder Script ist
ein Datenset. Ein Kanal, welcher von einem Versuch geladen wird, wird in ein
Datenset umgewandelt.
Datensets bestehen aus einem oder mehreren Punkten, d.h. Sie können Skalare
oder Vektoren sein. Das Geheimnis des Formelcompilers ist das Bearbeiten von
ganzen Datensets anstelle einzelner Datenwerte. Jede Operation auf Datensets
wird automatisch auf alle Punkte des Datensets angewendet. Dadurch entfällt
die Programmierung von zeitintensiven Schleifen.

Information

Vorsicht ist geboten, wenn Sie zwei Datensets unterschiedlicher Länge

verwenden. Es ist z. B. nicht möglich ein Datenset, welches aus 10 Punkten
besteht, mit einem Datenset bestehend aus 4 Punkten zu addieren. Vektoren
und Skalare hingegen können verknüpft werden. Wenn ein Datenset mit 10
Punkten und ein Datenset mit 1 Punkt (Skalar) addiert werden, wird jeder Wert
des Vektordatensets mit dem Skalarwert addiert.

Formel/Script-Editor — User’s Guide

16 Formelsyntax

Ein Datenset besteht nicht nur aus einem einzelnen Datenvektor, sondern viel-
mehr aus einer X-Spur, einer Y-Spur und einer Markerspur.

X Y I
1 27,46 0
2 30,72 0
3 32,02 0
4 34,85 0
5 36,48 0
6 38,26 0

Tab. 1

X-Spur Die X-Spur ist im einfachsten Fall eine Punktnummer, sie kann aber auch ein
Zeitwert, ein Kurbelwinkelwert oder irgendeine andere Größe (sogar ein Text)
sein.
Y-Spur Die Y-Spur stellt die eigentlichen Datenwerte dar. Auch diese könnten Texte
sein. In diesem Fall kann man dann nicht rechnen, sondern nur spezielle String-
manipulationen anwenden.
Markerspur Die Markerspur enthält diverse Markierungen, wie z. B. ob ein Punkt auf ungültig
gesetzt wurde. Der Interpreter ist in der Lage, mit einzelnen ungültigen Punkten
in Vektoren korrekt zu arbeiten. In den Ergebnissen werden die entsprechenden
Punkte ebenfalls ungültig markiert. Damit wird ihre Anzeige unterdrückt.

2.5 Variable und Kanal

„ Variablen (Lokale Datensets): Eine Variable wird verwendet, um das
Ergebnis eines Ausdrucks oder eines Funktionsaufrufes zwischenzuspei-
chern. Der Name einer Variablen kann aus Buchstaben und Ziffern
bestehen. Namen, die auf der linken Seite einer Zuweisung (des " = ")
erscheinen, werden automatisch als Variable interpretiert, d. h. sie stellen
lokale Datensets dar, die nur während der Ausführung der Formel verfügbar
sind. Eine explizite Deklaration bzw. Definition ist nicht notwendig. Variablen
stellen ein lokales Datenset dar und sind nur innerhalb der Formel, des
Makros oder des Scripts gültig.
„ Kanäle (File Datensets): Ein Kanal referenziert immer auf einen geöff-
neten Versuch des Daten-Explorers. Sobald dieser geladen wird, wird
dieser in ein Datenset umgewandelt. Dieses kann referenziert werden,
indem der Name des Kanals angegeben wird.
„ Formeln: Formeln haben einen Bezug zu einem File (Versuch). Deshalb ist
es ausreichend, wenn der Name eines Kanals angegeben wird
(z. B. SPEED), um diese zu referenzieren. Sollte jedoch dieser Name unter
mehreren Datenschlüssel vorkommen, ist es - um Verwechslungen vorzu-
beugen - notwendig, den Datenschlüssel vor dem Namen anzuführen
(z. B. D’SPEED). Andernfalls wird vom Compiler zuerst unter dem Daten-
schlüssel, in welchem sich die Formel befindet, gesucht. Wird er dort nicht
gefunden, werden alle anderen Datenschlüssel durchsucht.
Wenn Sie einen Kanal aus einem anderen offenen Versuch einbinden
möchten, muss der volle Pfad angegeben werden (Alias:Daten-
schlüssel’Name), z. B. PUMA1:D’SPEED.
„ Scripts: Da ein Script keine Zugehörigkeit zu einem offenen Versuch hat,
muss immer der volle Pfad angegeben werden.
„ Makros: Makros können von Formeln oder Scripts aufgerufen werden.
Somit hängt es vom Aufruf ab, wie eine Referenz zu einem Kanal definiert
werden muss.

Formel/Script-Editor — User’s Guide

 Formelsyntax 17

Information

Wenn ein Normname Leerzeichen oder andere Sonderzeichen beinhaltet, muss

der Name innerhalb der DS() Funktion stehen, z. B. DS(“TEST1:DAT’AIR MASS
FLOW“).

2.6 Datenformate und Konstante

2.6.1 Zahlen
Der Formelcompiler verwendet ein Fließkommaformat mit doppelter Genauigkeit
(double precision). Alle Zahlenkonstanten werden deshalb auch in dieses
Format umgewandelt. Beachten Sie, dass beim Vergleich von zwei
Ergebnis-Werten aus verschiedenen Rechenoperationen die Zahlenwerte auf
Grund der endlichen Stellenanzahl oft nicht exakt gleich sein werden.
Verwenden Sie daher die Round- Funktion, um für beide Werte eine gemein-
same Genauigkeit zu definieren, und führen dann den Vergleich durch.

2.6.2 Strings
Der Compiler kann auch Strings verarbeiten. Strings können sowohl numerische
als auch alphanumerische Zeichen oder Zeichenfolgen sein. Das gilt nicht nur
für Strings in Datensets, sondern auch für Konstanten, die für einige Funktionen
benutzt werden. Stringkonstanten müssen immer in Anführungszeichen einge-
schlossen werden, z. B. "textabc".

2.6.3 BOOL-Daten
Der Compiler unterstützt auch BOOL-Datensets. Das sind spezielle Datensets,
die nur die Werte 0 und 1 annehmen. Alle anderen Werte verhalten sich gleich
wie 1. Sie resultieren aus Vergleichsoperationen oder speziellen Funktionen.
Eine BOOL-Konstante ist identisch zu den Ziffern 0 und 1.

2.7 User-Variable
Normale, lokale Variable existieren nur während der Ausführung der Formel des
Makros oder des Scripts, in welchem sie vorkommen. User-Variable hingegen
sind Variable, die ihren Inhalt während der ganzen Sitzung beibehalten. Beginnt
der Name einer User-Variablen mit einem Prozentzeichen, wird ihr Inhalt in der
Datei [Link] (Verzeichnis MyLib) gespeichert und automatisch bei der
nächsten Sitzung wiederhergestellt. Beim Erzeugen von User-Variablen über
den Menüeintrag Extras | Uservariablen kann festgelegt werden, ob eine Vari-
able eine Text oder eine Zahl speichern soll.
User-Variablen werden oft durch Eingabedialoge gesetzt. Damit ist es möglich,
Benutzerinformationen aus einem laufendem Script abzufragen. Normale
Benutzervariable (die nicht mit einem Prozentzeichen beginnen) können nur
über die Funktionsaufrufe GetUserVar und SetUserVar angesprochen werden.
Persistente Benutzervariabeln können hingegen auch direkt mit ihrem Namen
verwendet werden. Sie können auch auf der linken Seite einer Zuweisung
verwendet werden.

Formel/Script-Editor — User’s Guide

18 Formelsyntax

User-Variablen können mit einer Arbeitsumgebung oder einem Layout gespei-

chert werden. Durch die zusätzliche Benennung der Variable von %CWF_ (für
Arbeitsumgebung) bzw. %CLY_ (für Layout) werden die User-Variablen
entweder mit der aktuellen Arbeitsumgebung bzw. dem Layout gespeichert und
sind beim Laden derselben wieder verfügbar.

2.7.1 User-Variablen über Kommandozeilenparameter setzen

User-Variablen können auch bereits beim CONCERTO-Start über den Komman-
dozeilenparameter gesetzt werden.
„ Syntax:
-var "%Variable=[Description|]Value[|DataTyp|System]"
Mittels dem Parameter -var können beliebig viele User-Variablen übergeben
werden. Dazu stehen folgende Möglichkeiten der User-Variablen-Übergabe zur
Verfügung:
„ Syntax 1:
-var "Variable1=[Description|]Value[DataTyp|System], Variable2=[Descrip-
tion|]Value[|DataTyp|System]"
„ Syntax 2:
-var "Variable1=[Description|]Value[DataTyp|System]" - var
"Variable2=[Description|]Value[|DataTyp|System]"
„ Parameter:
– %Variable: Name der Variable
– Description (optional): Beschreibung zur User-Variable
– Value: Wert der User-Variable
– DataTyp: derzeit nicht benutzt
– System (optional): 0 (Voreinstellung; Variable kann im User-Vari-
ablen-Editor editiert werden) oder 1 (Variable ist gegen Editieren
gesperrt)

2.8 Globale Datensets

Eine weitere Möglichkeit Variablen zwischen Scripts auszutauschen, bieten die
sogenannten Globalen Datensets. Mittels der Applikationsmethode AddGlobal-
DataSet kann jede Variable in ein globales Datenset kopiert werden. Mittels der
Applikationsmethode GetGlobalDataSet kann diese wieder eingelesen werden.
Globale Datensets können aus numerischen Werten oder Strings bestehen. Sie
können Skalare oder Vektoren sein. Sie bleiben bis zum Ende einer Sitzung
erhalten.

2.9 Return Anweisung

Formeln und Makros sollten mit der return-Anweisung enden. Dieses definiert
die Variable welche zurückgegeben werden soll. Fehlt die return-Anweisung,
wird das Datenset zurückgegeben, welches als letztes berechnet wurde, unab-
hängig von seinem Namen.
Die return-Anweisung kann auch einen Ausdruck beinhalten z. B. return A+B.

Formel/Script-Editor — User’s Guide

 Formelsyntax 19

2.10 Compiler Switches

SetCompilerSwitch-Anweisungen dienen dazu, das Default-Verhalten des
Compilers zu ä[Link] wirken immer nur innerhalb der aufgerufenen Formel,
Makros oder Scripts und werden mit folgender Syntax aufgerufen:
„ SetCompilerSwitch("Function", Par)
– Function: Compiler Switch
– Par: 1 (=Ein), 0 (=Aus, Default)

2.10.1 ContinueIfDataSetNotFound
Durch Setzen dieses Switchs werden Berechnungen fortgesetzt, auch wenn das
einer Variablen zugewiesene Datenset nicht gefunden wurde.

2.10.2 EnableRangeCheck
Durch Setzen dieses Switchs können innerhalb der Formel/Makro/Scripts zeitba-
sierende Datensets mit unterschiedlicher Auflösung automatisch miteinander
verrechnet werden.
Zur Berechnung wird der gmeinsame Zeitbereich, sowie die kleinere Auflösung
der beiden Datensets herangezogen.
Unterstützt werden sowohl arithmetische als auch Vergleichsoperationen.

2.10.3 LoadFullResolution
Durch Setzen dieses Compiler-Switches wird sichergestellt, dass die Daten in
voller Auflösung geladen werden.

2.10.4 OnComErrorResumeNext
Durch Setzen dieses Compiler-Switches wird bei COM-Fehlern weitergerechnet
und nur eine Warnmeldung in der Meldungsliste ausgegeben:
SetCompilerSwitch("OnComErrorResumeNext", 1)
Wird der Wert auf 2 gesetzt, wird auch die Warnmeldung unterdrückt.

2.10.5 RecalcOnPaint
Durch Setzen dieses Switchs wird dieses Makro auch dann neu gerechnet,
wenn das Digrammobjekt neu gezeichnet wird.
Per Default wird ein Makro nur dann neu gerechnet, wenn sich die im Objekt
angezeigten Daten ändern.

2.10.6 RestrictChannelSearchToCurrentKey
Durch Setzen dieses Switches in einer Formel beziehen sich Kanalzuweisungen
(z. B.: var = Speed) ausschließlich nur auf jenen Kanal, der sich auch im selben
Datenschlüssel der Formel befindet.
Per Default werden bei dieser Art der Kanalzuweisung alle weiteren Daten-
schlüssel ebenfalls nach dem referenzierten Kanal durchsucht, falls dieser nicht
im selben Datenschlüssel der Formel gefunden werden kann.

Formel/Script-Editor — User’s Guide

20 Formelsyntax

2.11 Operatoren

2.11.1 Arithmetische Operatoren

Arithmetische Operatoren bearbeiten zwei numerische Ausdrücke. Das
Ergebnis ist immer ein numerisches Datenset.

Addition: +
Subtraktion: -
Multiplikation: *
Division: /
Modulo Division: % (gibt den Rest einer Division zurück)

Wenn eines der Argumente ein Vektor ist, und das andere ein einzelner Wert,
werden alle Punkte des Vektors mit dem einzelnen Wert verknüpft.

Beispiel
C = A * 2

A bestehe aus: 30, 36, 37

C wird dann: 60, 72, 74

Wenn beide Argumente Vektoren sind, werden alle Punkte jedes Vektors
berechnet. Sie sollten deshalb gleich lang sein. Andernfalls wird die Berechnung
mit der Meldung "Datenset passen nicht zusammen" abgebrochen.

Beispiel
C = A - B

A bestehe aus: 30, 36, 37

B bestehe aus: 27, 30, 32
C wird dann: 3, 6, 5

2.11.2 String Operatoren

Verkettung von Strings: String1 + String2
Der + Operator hängt String2 an String1 an.

Beispiel
A = "Heute ist"
B = " Freitag"
C = A + B

C besteht dann aus: “Heute ist Freitag“

Formel/Script-Editor — User’s Guide

 Formelsyntax 21

2.11.3 Vergleichsoperatoren
Vergleichsoperatoren vergleichen zwei Ausdrücke. Das Ergebnis ist immer ein
BOOL-Datenset.

Gleich: =
Ungleich: <>
kleiner als: <
größer als: >
kleiner gleich: <=
größer gleich: >=

Wenn die Argumente-Vektoren Datensets sind, wird der Vergleich bei jedem
Punkt durchgeführt. Das resultierende BOOL-Datenset ist ebenso ein Vektor,
der an Stellen mit Gleichheit eine 1 und an ungleichen eine 0 enthält.

Information

Ein BOOL-Vektor Datenset kann nicht für eine if-Bedingung verwendet werden!

2.11.4 Logische Operatoren

Logische Operatoren werden auf Bool-Datensets angewendet. Das Ergebnis ist
wieder ein BOOL-Datenset. Wenn beide Datensets Vektoren sind, werden alle
Punkte ausgewertet.

Logisches UND: and

Logisches ODER: or
Negation: implementiert als Funktion: not(variable)

2.11.5 Methoden/Eigenschaftenoperator
Die Formelsyntax ist auch in der Lage, mit Objekten zu arbeiten und unterstützt
den Aufruf von Methoden eines Objekts oder das Setzen/Auslesen von Eigen-
schaften. Eine Methode ist wie ein Funktionsaufruf. Sie kann Argumente
aufnehmen und liefert ein Ergebnis zurück. Sie muss immer auf der rechten
Seite einer Zuweisung stehen. Eine Eigenschaft kann jedoch ausgelesen oder
gesetzt werden und somit links von der Zuweisung stehen (Eigenschaft wird auf
diesen Wert gesetzt) oder rechts (Eigenschaft wird ausgelesen).
Ein Punkt (.) wird verwendet, um zwischen dem Objektnamen und den
Methoden- bzw. Eigenschaftsnamen zu unterscheiden:
[Link]
[Link]
Somit dürfen Variablennamen keinen Punkt beinhalten. Wenn Kanalnamen
Punkte beinhalten, müssen diese in der DS() Funktion angegeben werden.
Es gibt eine Vielzahl von unterstützten Objekten. Für eine detailierte Auflistung
dieser siehe Abschnitt Klassen auf Seite 33. Hier wird ausschließlich auf einige
spezielle Eigenschaften eines Datensets eingegangen. Ein Datenset ist eben-
falls ein Objekt.
Da Datensets aus mehreren Punkten bestehen können, und der Compiler auto-
matisch alle Punkte referenziert, müssen spezielle Eigenschaften aufgerufen
werden, um nur einen bestimmten Punkt zu adressieren. Eigenschaften werden
auch benötigt, um einen bestimmten Punkt des X-Vektors oder des Markerspur-
vektors zu adressieren.

Formel/Script-Editor — User’s Guide

22 Formelsyntax

[Link] Ansprechen einzelner Punkte

Um einzelne Punkte zu adressieren, muss die x- oder y-Eigenschaft, gefolgt von
eckigen Klammern, welche den Indexpunkt beinhalten, verwendet werden.
A.y[n] und A.x[n]

Beispiel
A = SPEED.y[2]

adressiert den zweiten Punkt des Datensets SPEED

Dieser wird in die Variable A kopiert, welche ein skalares Datenset nur aus
diesem Punkt bestehend darstellt.

Information

Der Zähler in den eckigen Klammern beginnt immer mit 1. Der Index 0 ist daher
nicht erlaubt. Wenn Sie den Index 0 oder einen Index, der größer als die Punk-
tanzahl ist verwenden, wird die Berechnung mit der Fehlermeldung "Index ist
ungültig" abgebrochen.
Bei der Angabe von negative Zahlen wird von hinten zu zählen begonnen. Für
–1 wird somit der letzte Wert zurückgegeben, für –2 der vorletzte usw.

[Link] Ansprechen ungültiger Punkte

Die Eigenschaft i gefolgt von eckigen Klammern, welche den Indexpunkt bein-
halten, wird verwendet, um auf Gültigkeit zu prüfen oder die Gültigkeit festzu-
legen.
A.i[n]

Beispiele
A.i[5] = 1

setzt den fünften Punkt von A auf ungültig

B = A.i[10]

Wenn der zehnte Punkt ungültig ist, nimmt B den Wert 1 an, andernfalls 0.

[Link] Ansprechen mehrerer Punkte

Die y-, x- und i-Eigenschaft kann auch auf mehrere Punkte angewendet werden,
indem ein Indexvektor übergeben wird.
A.y[Indexvektor], A.x[Indexvektor] und A.i[Indexvektor]
Ein Indexvektor ist auch ein Datenset, welches aus Integerwerten innerhalb der
zulässigen Indizes besteht. Diese müssen nicht monoton steigend sein.

Beispiel
Indvec = {5,7,8}
V = A.y[Indvec]

liefert den fünften, siebten und achten Wert von A und speichert diese in V

Formel/Script-Editor — User’s Guide

 Formelsyntax 23

[Link] PenUp-Flag
Die PenUp-Eigenschaft gibt an, ob die Kurvenlinie zwischen zwei Punkten
gezeichnet werden soll oder nicht. Um für einen oder mehrere Punkte eines
Datensets diese Eigenschaft zu setzen oder zu löschen, ist hinter dem Eigen-
schaftsnamen der Index oder Indexvektor des Punktes bzw. der Punkte anzu-
geben. Im Gegensatz zu ungültigen Punkten werden die Punkte vor und nach
den Punkten mit gesetztem PenUp-Flag nicht durchverbunden, sondern die
Kurvenlinie unterbrochen. Sie beginnt wieder mit dem ersten Punkt, bei
welchem die PenUp-Eigenschaft wieder auf 0 ist. Die Messpunkte selbst werden
gezeichnet.
[Link][n] = 1

Beispiele
[Link][4..7]=1

hebt den Zeichstift ab dem dritten Indexpunkt und setzt den Stift am achten
Indexpunkt wieder auf, wobei die Messpunkte gezeichnet werden
[Link][4..7]=1
A.i[4..7]=1

hebt den Zeichstift ab dem dritten Indexpunkt und setzt den Stift am achten
Indexpunkt wieder auf, wobei die Messpunkte zwischen dem dritten und achten
nicht gezeichnet werden

2.11.6 Set-Operatoren
Die folgenden Operatoren können verwendet werden, um ein neues Datenset
durch Angabe seiner Elemente zu erzeugen. Die Werte des Abszissenvektors
sind identisch zu den Punktindizes.

Aufzählung:{w1,w2,w3,w4} Erzeugt ein Datenset aus w1, w2 usw. Das gilt sowohl für Werte, als auch für
Strings, z. B. v = {1,3,10}.
Bereich:w1..w2 Erzeugt ein Datenset, das aus Integerwerten im Bereich w1 bis w2 besteht,
z. B. v=1..100.

2.11.7 Ansprechen von Zyklen/Messungen

[ ] Operator Der [ ] Operator kann angewendet werden, wenn Daten in einzelne Zyklen oder
Messungen aufgesplittet sind.
Zyklen Bei Indizierdaten werden die Messkanäle üblicherweise während mehrerer,
hintereinander folgender Motorarbeitsspiele aufgezeichnet. Der Klammerope-
rator kann benutzt werden, um einen einzelnen dieser Zyklen zu adressieren.

Information

Auf Zyklen kann nur referenziert werden. Zuweisungen auf einen bestimmten
Zyklus eines Datensets sind nicht möglich.

Beispiel
P_ZYL[4]

spricht den 4. Zyklus von P_ZYL an

Verwechseln Sie diesen Klammeroperator nicht mit jenem, der benutzt wird, um
einzelne Punkte hinter einer .y, .x, oder .i Methode anzusprechen. Es ist jedoch
möglich, beide Operatoren zu kombinieren.

Formel/Script-Editor — User’s Guide

24 Formelsyntax

Beispiel
CA’P_ZYL1[10].y[83]

spricht den 83. Punkt des 10. Zyklusses des Kanals P_ZYL1 aus dem Daten-
schlüssel CA an

Messungen Prüfstandsdaten sind ebenfalls oft segmentiert. Wurde ein bestimmter Recorder
mehrfach während eines Versuchs gestartet, entstehen einzelne Recordermes-
sungen, die alle die gleichen Kanäle beinhalten. Diese einzelnen Recordermes-
sungen sind unter dem selben Datenschlüssel (Messungstyp) im Daten-Explorer
sichtbar und können auch einzeln angesprochen werden. Ebenso ist es auch
möglich, Stationärdaten in Pseudomessungen aufzusplitten, wobei jede eine
bestimmte Parametervariation (eine Kurve) repräsentiert.
Der [ ] Operator kann benutzt werden, um Daten aus einer bestimmten Messung
anzusprechen.

Beispiel
D’TORQUE[5]

adressiert die 5. Messung des Datensatzes D’TORQUE aus dem Daten-

schlüssel D

Information

In Formeln ist es normalerweise nicht notwendig, diesen Zyklus/Messungsope-

rator zu verwenden. Eine Formel korreliert durch die Quelldatensets, die in der
Berechnung benutzt werden, automatisch mit dem gleichen Zyklus bzw. der glei-
chen Messung wie das Quelldatenset. Die aktuelle Zyklus/Messungsnummer
kann durch einen Balken in der Statuszeile modifiziert werden. Damit werden
nicht nur die angezeigten Kanäle, sondern auch die in den Formeln benutzten
Datensets automatisch mit dem für das Fenster definierten Zyklus berechnet.

2.12 Strukturanweisungen

2.12.1 if...then...else Statement

„ Syntax 1:
If Bedingung then
Anweisung [else [Anweisung]]
„ Syntax 2:
if Bedingung then
[Anweisungen]
else
[Anweisungen]
endif

Beispiel
Wenn Wert = 20 dann [Anweisung] ansonsten [Anweisung]
if Wert = 20 then
[Anweisung]
else
[Anweisung]
endif

Formel/Script-Editor — User’s Guide

 Formelsyntax 25

Das entspricht einer Standard if...then...else-Verzweigung. Wenn der Aus-

druck "Bedingung" wahr ist (BOOL value >0, od. true), dann wird (werden)
die erste Anweisung(en) ausgeführt, andernfalls die zweiten. Das else und
der zweite Anweisungsblock dürfen auch entfallen.
„ Mehrfachbedingung:
Nach dem else kann ein zweites if-Statement angefügt werden:

Beispiel
elseif Bedingung2 then
[Anweisung]
else [Anweisungen]

2.12.2 For-Schleife
Syntax:
for zähler = start to ende [step int]
[Anweisung]
[if Bedingung then continue
Anweisung]
next [zähler]
Das ist eine for-Schleifenstruktur. Alle Anweisungen zwischen der for und der
next-Zeile werden bei jedem Durchlauf ausgeführt.
Ein continue-Statement kann verwendet werden, um beim Auftreten einer
gültigen Bedingung nachkommende Anweisungen zu überspringen.
zähler ist eine numerische Zählervariable (Datenset mit einem Wert). Am Anfang
der Schleife wird zähler auf start gesetzt. Bei jedem Durchlauf wird zähler um int
erhöht (ohne step wird 1 angenommen).
Wenn step positiv ist, wird die Schleife so lange durchlaufen, solange zähler
kleiner oder gleich ende ist.
Wenn step negativ ist, wird die Schleife so lange durchlaufen, solange zähler
größer oder gleich ende ist.

Beispiel
for i = 1 to 100
[Anweisungen]
next i

Schleifen können auch verschachtelt werden.

2.12.3 While-Schleife
Syntax:
while Bedingung
[Anweisungen]
endwhile
Das entspricht einer while-Schleife. Alle Anweisungen zwischen der while und
der endwhile-Anweisung werden ausgeführt, solange die Bedingung erfüllt ist.
Bedingung ist ein Ausdruck, der ein BOOL-Datenset zurückgibt.

Beispiel
while i < 100
[Anweisungen]
i = i + 1
endwhile

Die Schleife wird beendet, wenn der Wert 100 erreicht worden ist.

Formel/Script-Editor — User’s Guide

26 Formelsyntax

2.12.4 Break-Anweisung
Syntax:
break
Diese Anweisung bricht eine for- oder while-Schleife ab. Sie wird hauptsäch-
lich in Verbindung mit einer if...then-Anweisung verwendet.
In verschachtelten Schleifen ermöglicht break das Zurückkehren zur übergeord-
neten Schleife.

2.12.5 Return-Anweisung
Syntax:
return [Ausdruck]
Diese Anweisung beendet die Formel/Makro-Bearbeitung und liefert den Wert
von Ausdruck. Wenn kein Ausdruck vorhanden ist, wird der Wert der letzten
Zuweisung zurückgegeben. Sie sollten immer die return-Anweisung
verwenden. Sie könnten sonst falsche Ergebnisse erhalten.

Beispiel
A = FL'TORQUE
return A * 0.8

obiges ist äquivalent zu:

A = FL'TORQUE
B = A * 0.8
return B

2.13 Funktionsaufrufe
Es gibt eine große Anzahl interner Funktionen. Sie stellen verschiedene
Rechenalgorithmen und Aktionen in optimierter Form zur Verfügung.
Jede Funktion gibt ein Datenset zurück. Das könnte eine ganze Kurve oder ein
einzelner Wert sein. Eine Funktion benötigt meistens Parameter. Sie können
Datensets, Konstante, andere Funktionen, Makros oder ganze Ausdrücke als
Parameter verwenden.
Syntax:
Funktionsname(parameter1, parameter2,...)

Formel/Script-Editor — User’s Guide

 Formelsyntax 27

2.14 Makros

2.14.1 Makros als Unterprogramme

Makros sind benutzerdefinierbare Funktionen. Sie haben einen Namen und
werden wie Funktionen aufgerufen. Jedes Makro liefert ein Datenset zurück.
Dieses könnte eine ganze Kurve, oder aber auch ein einzelner Wert sein.
Ein Makro benötigt üblicherweise Parameter. Sie können Datensets, Konstante,
andere Funktionen, Makros und ganze Ausdrücke als Parameter verwenden.
Syntax:
MakroName (parameter1, parameter2,...)

Information

Der Makroname darf nicht identisch mit einem Funktionsnamen sein, da es

sonst nie aufgerufen werden würde! Da es in der Syntax keinen Unterschied
zwischen diesen beiden Aufrufen gibt, überprüft der Compiler zunächst seine
internen Funktionen. Wenn die Funktion nicht gefunden wird, durchsucht er alle
definierten Makroverzeichnisse nach einer .MAC-Datei des selben Namens.
Wenn dieses gefunden wird, wird dieses geladen, compiliert und ausgeführt.

Definiert sind die Makroverzeichnisse unter dem Schlüsselwort “GlobalMac-

roDir“ in der [Link] Datei (siehe Extras | Voreinstellungen...). Deswei-
teren wird auch der Pfad, der unter dem Schlüsselwort “Macropath“ in der Datei
[Link] definiert ist, als auch das \macros Unterverzeichnis der aktuellen
Arbeitsumgebung überprüft.
Ein Makro muss eine arg() Anweisung in der ersten Zeile enthalten:
arg(var1, var2, ...)
var1, var2 etc. sind die Namen lokaler Variablen, die im Makro verwendet
werden. Diese werden durch die Parameter des Makroaufrufs, parameter1,
parameter2 etc., ersetzt.
Makros können wie Unterfunktionen verwendet werden. Sie können von
Formeln, Scripts und anderen Makros aufgerufen werden.
Mit Hilfe der ByRef-Anweisung können Variablen aus dem Code in welchem der
Makroaufruf stattfindet manipuliert werden.

Beispiel
Makrocode des Makros [Link]:
arg (ByRef argument1, ByRef argument2)
argument1.y[1]=10 argument2.y[1]=20
return argument2+10

Aufruf im Script:
var1=1
var2=2
var3=Test(var1,var2)

Die Variablen besitzen nun folgende Werte: var1=10, var2=20, var3=30

Formel/Script-Editor — User’s Guide

28 Formelsyntax

2.14.2 Transformationsmakros
Transformationsmakros werden in Darstellungsobjekten verwendet, um die darin
enthaltenen Datensets vor der Anzeige in irgendeiner Form zu bearbeiten. Auf
diese Weise könnte z. B. ein Kurvenverlauf vor der Anzeige geglättet werden.
Ebenso könnte man damit einen Kanal vor der Darstellung umkalibrieren.
Genauso könnte man einen zeitlichen Verlauf z. B. in x-Richtung verschieben.
Eine andere Möglichkeit besteht darin, aus einer Kurve einen Kennwert z. B. das
Maximum oder den Mittelwert zu errechnen und diesen in einer Tabelle darzu-
stellen. Damit würde man zwar einem Tabellenobjekt eine ganze Kurve als
Datenset übergeben, durch das Transformationsmakro wird dieser jedoch zu
einem einzigen Ergebniswert reduziert.
Die Zuweisung eines Transformationsmakros zu einem Objekt erfolgt auf der
Transformationsseite seines Eigenschaftsdialoges. Hier kann aus den Makros
der aktuellen Arbeitsumgebung, der Standardbibliothek oder der persönlichen
Bibliothek ausgewählt werden. Das in dem Anzeigeobjekt enthaltene Datenset
wird als Argument an das Makro übergeben. Zusätzlich können auch noch
weitere Argumente im Eigenschaftsdialog definiert werden und an das Makro
übergeben werden.
Sind dem Darstellungsobjekt mehrere Datensets zugeordnet worden, wird bei
der Darstellung das Transformationsmakros auf jedes einzelne Datenset separat
angewendet. Es besteht aber auch die Möglichkeit, alle Datensets zu einem
Ergebnis zu verarbeiten. In diesem Fall wird das Transformationsmakro nur für
das erste Datenset aufgerufen, die anderen Datensets können im Makro selbst
über die Funktion ObjDS() angesprochen werden.
Weiters muss noch zwischen normalen Transformationen (manchmal auch als
y-Transformationen bezeichnet) und Basistransformationen (manchmal auch als
x-Transformation bezeichnet) unterschieden werden.
Normale Transformationen können bei jedem Anzeigeobjekt separat spezifiziert
werden. Das bedeutet, dass z. B. in einem Diagramm für jede Achse eine eigene
Transformation definiert werden kann. Eine x-Transformation bezieht sich
hingegen nur auf die x-Achse eines Diagramms. Da alle in einem Diagramm
dargestellten Kurven einen gemeinsamen Bezug zur x-Achse haben, wird eine
definierte x-Transformation auch auf alle Kurven angewendet. Sind in den
einzelnen Achsobjekten auch noch normale Transformationen definiert, wird
zuerst das Basistransformationsmakro aufgerufen und dessen Ergebnis
anschließend, wenn vorhanden, der normalen Transformation eines Objekts
unterworfen. Als Besonderheit der Basis (x) Transformation muss dabei
beachtet werden, dass die Datensets dabei mit vertauschter x-, und y-Spur in
das x-Transformationsmakro übergeben werden. Dies den Vorteil, dass auf
diese Art und Weise x-Achsenmanipulationen sehr einfach geschrieben werden
können. Will man beispielsweise alle Kurven in einem Diagramm um den Wert N
in x-Richtung verschieben, so könnte man folgendes einfache Makro schreiben:

Beispiel
arg ch, N
return ch + N

Möchte man hingegen die einzelnen Kurven eines Diagramms um unterschied-

liche Beträge in x-Richtung verschieben, kann dies mit einer Basis oder x-Trans-
formation nicht erledigt werden. Zu diesem Zweck muss eine normale
Transformation erstellt werden, die jedem einzelnen Achsobjekt separat zuge-
ordnet wird. Da in diesem Fall die Datensets normal an das Makro übergeben
werden, ist der Aufbau des Makros etwas komplizierter. Man muss die x-Spur
des übergebenen Datensets extrahieren, anschließend einen Offset dazuzählen
und daraus wieder ein neues Datenset zusammenbauen.

Beispiel
arg ch, n
return Create{Xds{ch}+n,ch}

Formel/Script-Editor — User’s Guide

 Formelsyntax 29

Im obigem Beispiel wird aus dem übergebenen Datenset ch zuerst die x-Spur
mittels Funktion xds extrahiert. Zu dieser wird der Offset n dazugezählt.
Anschließend wird über die Create-Funktion die modifizierte x-Spur und das
Datenset ch (genauer gesagt dessen y-Spur) wiederum zu einem neuen
Datenset zusammengebaut und dieses als Ergebnis des Makros retourniert.
Im Zusammenhang mit Zeitverläufen sei auch noch auf ein anderes Problem
hingewiesen. Wie schon erwähnt, können Datensets mit mehreren Punkten nur
dann miteinander verrechnet werden, wenn die Punkteanzahl bei beiden iden-
tisch ist. Hat man nun Messkanäle zur Verfügung, die mit unterschiedlichen
Abtastraten erfasst wurden, ist dies im allgemeinen nicht der Fall. Es ist daher
notwendig, beide Kanäle auf eine gleiche Punkteanzahl zu interpolieren. Dies
kann mit Hilfe der Range()-Funktion erledigt werden.

2.15 Formeln/Makros/Scripts verschlüsseln (nur mit Option N[Y])

Formeln/Makros/Scripts können unter dem Menüeintrag Datei | Verschlüsselt
exportieren verschlüsselt gespeichert werden.
Danach wird der Inhalt der Formel (Makro/Script) im Formel/Script-Editor nicht
mehr angezeigt. Sie können so Formeln/Makros/Scripts erstellen und weiter-
geben sodass diese auch von anderen Anwendern genützt werden können,
ohne den Berechnungsalgorithmus offenzulegen.

HINWEIS

Die Datei ist danach nicht mehr les- und editierbar.

2.16 Beispiele

2.16.1 Einfache Formelbeispiele

Beispiel
UNIT: KW
PI = 3.14159
K = (PI/30)/1000
POWER = FL’TORQUE * FL’SPEED * K

TORQUE und SPEED im oberen Beispiel werden aus dem Versuch angefordert,
aus dem der virtuelle Kanal POWER geladen wird. Sie werden von dem selben
Datenschlüssel geladen wie POWER. Wenn TORQUE und POWER von einem
anderen Datenschlüssel genommen werden sollen, muss der Datenschlüssel
explizit angegeben werden: z. B. D‘TORQUE und D‘SPEED.
PI und K sind nur lokale Variablen.

Beispiel
In der folgenden Formel werden Messpunkte, die größer als ein Schwellwert
sind, auf ungültig gesetzt:
//Einlesen des FL'TORQUE Kanals und speichern der Werte unter der Variablen A
A = FL'TORQUE
limitVal = 100
//npoints(A) liefert die Anzahl an Messpunkten von Datenset A
//verwendung einer for-next Schleife
for z = 1 to npoints(A)
//Ungültig setzten wenn der nWert von A zu hoch ist
if A.y[z] > limitVal then A.i[z] = 1
next z
return A

Formel/Script-Editor — User’s Guide

30 Formelsyntax

Sehr oft können Schleifen durch Vektoroperationen ersetzt werden. Dies führt zu
einer wesentlich schnelleren Berechnung. Im obrigen Beispiel kann die Schleife
durch folgenden Ausdruck ersetzt werden:
boolds = A > limitVal
A.i[1..[Link]] = boolds

2.16.2 Formeln mit mehrfachen Dateien

Wenn Sie in Ihren Formeln mehr als eine Datei verwenden, muss der Alias
zusätzlich angegeben werden.

Beispiel
Wenn Sie z. B. von Kanal P aus drei Dateien den Durchschnitt rechnen wollen:
PAVG = (ALIAS1:D’P + ALIAS2:D’P + ALIAS3:D’P) / 3

(ALIAS als Beispiel-Alias, D als Beispieldatenschlüssel)

ALIAS1, ALIAS2, ALIAS3 müssen zuvor im Daten-Explorer geöffnet worden
sein.
PAVG erscheint in allen drei Dateien als virtueller Kanal.

Formel/Script-Editor — User’s Guide

 Funktionsreferenz 31

3 Funktionsreferenz
Der Formel/Script-Editor stellt eine große Bibliothek an leistungsstarken Funkti-
onen zur Verfügung. Zur leichteren Handhabung ist die Bibliothek in mehrere
Kategorien unterteilt:
„ Standard:
Einfache mathematische Funktionen und Konstanten
„ Standard 2:
Funktionen für Integral, Ableitung, Ausgleichsrechnung u.ä.
„ Extraction:
Funktionen zur Erstellung neuer Datensets und zum Extrahieren von Teilen
eines Datensets
„ Statistik:
Statistische Ergebnissfunktionen wie Maximum, Minimum usw.
„ Trigonometrie:
trigonometrische Funktionen wie Sinus, Cosinus usw.
„ Logisch:
Funktionen, die Boolsche Datensets liefern; z. B. zur Schwellwertprüfung,
Prüfung des Vorhandensein von Datensets usw.
„ Modal:
Funktionen für die Abgas-Modalanalyse
„ String:
Stringoperationen
„ Hilfsfunktionen:
Mehrere nützliche Funktionen zur Handhabung von Datensets, User Vari-
ablen, Export von Daten usw.
„ Erweitert:
FFT und Klassierungsberechnungen
„ Script:
Funktionen, die Benutzerinteraktionen entsprechen; diese sollten nur in
Scripts verwendet werden.
„ Indizierfunktionen:
Kernfunktionen, welche von CalcGraf-Makros verwendet werden
Eine detaillierte Beschreibung zu den Funktionen finden Sie in der Online Hilfe.
„ Öffnen Sie die Online Hilfe über das Menü Hilfe
„ oder drücken Sie die Funktionstaste F1 für kontext-sensitive Hilfe.

Formel/Script-Editor — User’s Guide

32 Funktionsreferenz

Formel/Script-Editor — User’s Guide

 Klassen 33

4 Klassen
Gleich wie Visual Basic kann auch der CONCERTO-Formel/Script-Editor mit
Objekten arbeiten. Dies ist sehr vorteilhaft, besonders wenn Objekte wie Display
Items hierarchisch geordnet sind. In diesem Fall kann ein Objekt mehrere
andere Objekte beinhalten.
Um ein Objekt zu modifizieren, können dessen Eigenschaften gesetzt werden
oder dessen Methoden aufgerufen werden. Hierfür muss nur die Eigen-
schaft/Methode an die Objektvariable, getrennt durch einen Punkt, angefügt
werden. Dadurch können komplizierte Funktionsaufrufe mit vielen Parametern
verhindert werden.
Es gibt verschiedene Klassen von Objekten. Neben den typischen Klassen wie
Datenset, Files, Fenster, Anzeigeobjekte und Display Items, die diese Objekte
referenzieren, gibt es auch die sogenannte Applikationsklasse. Auf der einen
Seite erlaubt diese allgemeine Eigenschaften der Software zu ändern, anderer-
seits stellt sie nützliche Methoden für die Script-Programmierung zur Verfügung.
Anstelle solche allgemeinen Funktionen in die Funktionsbibliothek Hilfsfunkti-
onen oder Script einzubauen, wird AVL künftig eher Methoden in der Klasse
Applikation implementieren. Dies verhindert, dass ein selbstgeschriebenes
Makro von einer neuen Funktion seitens AVL überdeckt wird.
Bevor Sie ein Objekt ansprechen können, müssen Sie dieses referenzieren, was
geschieht, wenn es erzeugt wird oder wenn es bereits besteht, indem sein Name
referenziert wird. Dies wiederum wird mittels Funktionsaufrufen wie AddWin()
oder SelWin(), welche sich in der Script-Biliothek befinden, erreicht. Die Objekt-
variable, welche von diesen Funktionsaufrufen zurückgegeben wird, dient als
Stellvertreter für das Objekt. Methoden und Eigenschaften werden nur auf sie
angewandt.
Objektvariablen können auch mehrere Objekte (Objektlisten) referenzieren. Die
meisten Objektselektierfunktionen, wie SelWin(), erlauben es, Wildcards zu
verwenden, um einfach nach mehreren Objekten zu filtern. Sie erhalten
weiterhin nur eine Objektvariable, diese referenziert jedoch für alle Eigen-
schaften und Methoden, welche auf sie angewendet werden und alle Objekte,
die selektiert worden sind.

Formel/Script-Editor — User’s Guide

34 Klassen

4.1 Syntax
Wie auch in Visual Basic üblich werden Eigenschaften eines Objekts angespro-
chen, indem man der Objektvariablen den Eigenschaftsnamen durch einen
Punkt getrennt nachstellt.
Das gleiche gilt für Methoden, wobei hier noch runde Klammern () als Zeichen
eines Funktionsaufrufs anzuschließen sind.
[Link]
[Link] oder [Link] (Argumentenliste)
Eine Methode ist wie ein Funktionsaufruf, welcher möglicherweise Argumente
benötigt. Normalerweise liefert sie ein Ergebnis zurück. Der Aufruf muss daher
immer auf der rechten Seite einer Zuweisung stehen. Eine Eigenschaft kann
ausgelesen oder gesetzt werden, und kann daher links der Zuweisung (Eigen-
schaft wird gesetzt) oder auf der rechten Seite (Eigenschaft wird ausgelesen)
stehen.
Wenn eine Objektvariable mehrere Objekte (Objektliste) referenziert, werden die
Methoden und Eigenschaften auf alle Objekte angewandt. Sie können auch indi-
viduelle Objekte einer Objektliste referenzieren, indem Sie eckige Klammern [ ]
verwenden.
Objektvariable[n].Eigenschaft
Objektvariable[n].Eigenschaft oder Objektvariable[n].Methode(Argumen-
tenliste)

Information

Variablen, welche Objekte oder eine Objektliste referenzieren, sind keine Daten-
sets. Daher darf nicht Objektvariable.y[n] geschrieben werden, um ein speziefi-
sches Objekt zu referenzieren. Datensets sind spezielle Objekte, welche mit
Daten arbeiten. Die .y[n] Eigenschaft eines Datensets dient zur Addressierung
des n-ten Datenpunktes eines Datenvektors, welcher sich in einem Datensetob-
jekt befindet.

Beispiel
Der folgende Aufruf selektiert das gerade aktive Fenster durch den GetActi-
veWin() Funktionsaufruf. Dieses Objekt wird durch die Variable Win referenziert:
Win = GetActiveWin()

Der folgende Aufruf selektiert das untergeordnete Objekt TORQUE welches sich
im Fenster befindet. Dies wird durch die Methode SelObj() erreicht. Nehmen wir
an, TORQUE sei ein Kurven- (Y-Achse) Objekt. Es wird durch die Variable Obj
referenziert:
Obj = [Link](“TORQUE“)

Der folgende Aufruf der Methode AutoRangeY löst eine automatische Neuska-
lierung der Achse aus. Da AutoRangeY keine Parameter benötigt, können die
Parameter weggelassen werden:
[Link]

Der folgende Aufruf liest den Startpunkt der Y-Achse aus, welchen die Eigen-
schaft y0 beinhaltet, und weißt ihn der Variablen lower zu:
lower = Obj.y0

Der folgende Aufruf der Eigenschaft y0 setzt den Startpunkt der Y-Achse auf 0:
Obj.y0 = 0

Formel/Script-Editor — User’s Guide

 Klassen 35

4.2 Arbeiten mit Anzeige-Objekten

Es gibt drei verschiedene Klassen, über die Anzeigeobjekte von einem Script
aus zu erzeugt/modifiziert werden können.
„ Die Fensterklasse
„ Die Anzeige-)Objektklasse
„ Die Display Item-Klasse
Objekte dieser Klassen sind verschachtelt, z. B. Anzeigeobjekte sind Unterob-
jekte eines Fensters und Display Items sind Unterobjekte von Anzeigeobjekten.
Es ist wichtig zu verstehen, dass die Methoden und Eigenschaften von Objekten
dieser Klassen nichts weiter als Möglichkeiten sind, um diese von Scripts aus zu
erzeugen/modifizieren, anstelle den interaktiven Objektassistenten bzw. den
interaktiven Eigenschaftsdialog zu verwenden.
Für ein besseres Verständnis der vorhandenen Methoden können Sie in den
zugehörigen Eigenschaftsdialogen nachsehen.
Für ein besseres Verständnis der Objekthierarchie beachten Sie den
Layout-Explorer, welcher die Hierarchie in verständlicher Form visualisiert.

4.2.1 Fenster
Alle Anzeigeobjekte sind in Fenstern enthalten. Es gibt mehrere Fenstertypen
wie Diagrammfenster, Protokollfenster, Vorlagenfenster oder Dialogfenster. Alle
haben das selbe Verhalten.
Bevor Sie mit individuellen Anzeigeobjekten arbeiten können, müssen Sie das
Fenster referenzieren (oder erzeugen), in welchem sich das Anzeigeobjekt
befindet. Das Fenster selbst hat auch viele Eigenschaften, die gesetzt werden
können.
Verwenden Sie die SelWin() Script-Funktion, um ein bereits bestehendes
Fenster zu referenzieren:
Win = SelWin("Fenster1")

Über die Variable Win können Sie nun das Fenster "Fenster1" referenzieren.
Sie können auch mehrere Fenster (Fensterliste) mit einer Variablen ansprechen.
Geben Sie dazu als Argument eine Maske an z. B. "Fenster*". Wenn Sie über-
haupt keinen Fensternamen übergeben, werden durch die Variable alle vorhan-
denen Fenster angesprochen:
AllWins = SelWin()

Die Variable AllWins repräsentiert nun alle Fenster. Aktionen die auf AllWins
angewendet werden, wirken sich daher auf alle Fenster aus.
Verwenden Sie GetActiveWin() um das gerade aktive Fenster zu referenzieren:
GetActiveWin()

Verwenden Sie AddWin() um ein neues Fenster zu erzeugen:

AddWin("Name")

Fügt zum Layout ein Fenster namens "Name" hinzu und liefert eine Variable
dafür zurück.
Wenn Sie eine Objektvariable erzeugt haben, können Sie nun mit dieser die
Fenstereigenschaften auslesen bzw. setzen oder deren Methoden aufrufen.
Um ein Neuzeichnen aller Fenster auszulösen, können Sie z. B. folgende Anwei-
sung schreiben:
[Link]

Formel/Script-Editor — User’s Guide

36 Klassen

Um ein bestimmtes Fenster aus einer Fensterliste anzusprechen, verwenden

Sie den Array-Operator [ ] direkt hinter der Variable:
AllWins[1].Paint ...

Dies zeichnet das erste Fenster neu.

Information

Schreiben Sie nicht AllWins.y[1], da es sich hier um kein Datenset handelt,

sondern um eine Objektvariable.

4.2.2 Objekte
Um mit einem Anzeigeobjekt eines Fensters arbeiten zu können, muss dieses
ebenfalls selektiert werden. Dies geschieht über die Methode SelObj() der Fens-
tervariablen, also jenes Fensters, welches das Anzeigeobjekt beinhaltet, also
z. B.:
Obj1= [Link]("TORQUE")

Dies wählt das Unterobjekt TORQUE aus.

Genauso können Sie wieder über eine Namensmaske mehrere Objekte (Objekt-
liste) oder durch Weglassen des Namens alle Objekte ansprechen:
AllObjs = [Link]()

Nun haben Sie unter der Variablen AllObjs alle Anzeigeobjekte des Fensters
Win (im obigen Beispiel "Diagramm1") angesprochen und können mit der glei-
chen Syntax wie bei Fenstervariablen Eigenschaften und Methoden aufrufen.
Um ein bestimmtes Anzeigeobjekt aus einer Objektliste anzusprechen,
verwenden Sie den Array-Operator also z. B.
AllObjs[3].yUnit

Liefert die Einheit des 3. Anzeigeobjekts der Liste AllObjs zurück.

Anstelle separate Fenster und Anzeigeobjektvariable zu verwalten, ist auch eine
Kaskadierung möglich. So setzen Sie etwa mit
SelWin("Fenster1").SelObj("TORQUE").y0 = 100

den unteren Achswert des Objekts TORQUE im Fenster Diagramm1 auf 100.

4.2.3 Display Items

Abgesehen von reinen Layout gestaltenden Anzeigeobjekten (wie etwa ein Text
oder eine Bitmap) referenzieren die meisten Objekte darzustellende Datensets.
Diese werden im Layout-Explorer auch in der nächsten Hierarchiestufe darge-
stellt. Obwohl sie dort das gleiche Aussehen wie Datensets haben, handelt es
sich genaugenommen um Anzeigeelemente, die auch entsprechende Eigen-
schaften aufweisen. Sie werden daher Display Items genannt (DS).
So ist etwa das Anzeigeobjekt "Kurve" (interne Bezeichnung "LINE") ein Objekt,
welches über eine Achse verfügt und mit dieser mehrere Kanäle als überlagerte
Kurven darstellen kann. Diese einzelnen Kurvenzüge werden als Display Items
bezeichnet. Attribute wie etwa die Kurvenfarbe sind daher nicht beim Kurvenob-
jekt sondern bei den Display Items angesiedelt, Attribute wie die Achsendwerte
beim Anzeigeobjekt.

Formel/Script-Editor — User’s Guide

 Klassen 37

Um mit einem Display Item eines Anzeigeobjekts arbeiten zu können, muss

dieses ebenfalls selektiert werden. Dies geschieht über die Methode SelDS() der
Objektvariablen, also jenes Anzeigeobjekts, welches das Display Item bein-
haltet. Der Name des Display Items ist normalerweise identisch zu dem Namen
des Datensets, welches es darstellt, z. B.:
DS1 = [Link]("ATFFILE1:D'N")

Dies wählt das Display Item des Datensets ATFFILE1:D'N aus.

Genauso können Sie wieder durch Weglassen des Itemnamens alle Items
ansprechen:
AllDSItems = [Link]()

Nun haben Sie unter der Variablen AllDSItems alle Display Items des Objekts
Obj1 angesprochen und können mit der gleichen Syntax wie bei Objektvariablen
Eigenschaften lesen oder setzen.
Um ein bestimmtes Item der Variablen zugeordneten Itemliste anzusprechen
verwenden Sie den Array-Operator also z. B.
AllDSItems[2].Colour ...

liefert die Farbe des 2. Display Items der Itemliste in der Variablen AllDSItems.
Anstelle Fenster, Objekt- und Itemvariable getrennt zu verwalten, ist auch eine
Kaskadierung möglich.

Beispiel
Win=SelWin("X/Y Diagram")
[Link]("N").SelDS("ATFFILE1:D'N").Colour = 0
[Link]

selektiert das Fenster X/Y Diagram und setzt im Objekt (N) die Farbe des Lini-
enzuges des Display Items ATFFILE1:D'N auf rot ( = Farbindex 4 in der Farb-
liste unter Menü-Format - Zählung ab 0)

Einige Objekte besitzen Display Items, zu denen kein Datenset assoziiert ist
(z. B. die Isolinien eines Muscheldiagramms). Diese Items können momentan
noch nicht selektiert werden.

Formel/Script-Editor — User’s Guide

38 Klassen

4.3 Composer-Skript
Mit den Composer-Skript-Befehlen können Daten verändert, umstrukturiert,
extrahiert, neu zusammengesetzt oder überhaupt erzeugt werden.
Mittels Composer-Skript kann jede der folgenden Datenebenen angesprochen
und entsprechend bearbeitet werden:
„ Versuchsebene (Test, ConcertoFile)
„ Datenschlüsselebene (Messungsebene)
„ Kanalebene

4.3.1 Aufbau der Composer-Befehle

Die Composer-Skript-Befehle sind in der Klasse Composer zusammengefasst
(siehe Online-Hilfe).
Der Aufruf der einzelnen Befehle erfolgt immer nach dem gleichen Schema:
„ Das erste Argument gibt an, worauf der Befehl angewendet werden soll,
adressiert also einen Versuch (ConcertoFile), eine Messung oder einen
Kanal.
„ Bei Befehlen, die sich nur auf einen Ausschnitt (Bereich) von Daten
beziehen, spezifiziert das zweite Argument diesen Bereich.
„ Alle weiteren Argumente sind abhängig vom Befehl und werden verwendet,
um weitere Parameter für die Ausführung des Befehls zu spezifizieren.
Viele dieser Parameter sind optional und müssen nur dann explizit ange-
geben werden, wenn ein von der Vorgabe abweichendes Verhalten
gewünscht wird. Die Reihenfolge, in der diese Parameter angegeben
werden, ist beliebig.

Beispiel
Dim cp As Composer
...
[Link](addr, range)
...
[Link](addr, range, "Value:", 2000, "StepWidth:", 100)

[Link] Benannte Parameter

Jeder benannte Parameter wird durch ein Paar von Funktionsargumenten fest-
gelegt:
„ Das erste Argument ist immer der Name des Parameters. Dies ist immer
ein String-Typ und endet mit einem Doppelpunkt.

Beispiele
"Value:"
"Resolution:"
"Description:"

„ Das zweite Argument ist der Parameterwert.

Im Beispiel FillRange oben wurden zwei benannte Parameter angegeben: Value
(mit einem Wert von 2000) und StepWidth (mit einem Wert von 100).

Formel/Script-Editor — User’s Guide

 Klassen 39

[Link] Adressierung
Um festzulegen, worauf sich ein Composer-Befehl bezieht, wird ein Adressie-
rungsobjekt verwendet. Das ist ein Objekt der Klasse Addressing (siehe
Online-Hilfe).
Ein Addressierungsobjekt kann auf flexible Weise jede der am Anfang ange-
führten Datenebenen adressieren. Das erfolgt, indem entsprechend benannte
Parameter über die Methode Set festgelegt werden.
Ein ConcertoFile kann Beispielsweise entweder über seinen Alias-Namen oder
über die Kombination aus Datenquellenname und Versuchsname oder auch mit
Hilfe eines File-Objektes adressiert werden. Im folgenden Beispiel werden alter-
native Möglichkeiten gezeigt, um einen Versuch (ConcertoFile) zu adressieren:

Beispiele
Dim addr As Addressing

1. Adressieren eines Versuchs, der mit dem Alias CPF1 geöffnet ist:
[Link]("Alias:", "CPF1")

2. Adressieren des Versuchs [Link] in der Datenquelle MyCTF Files.

Da die Reihenfolge, in der die benannten Parameter angegeben werden,
beliebig ist, bewirkten beide Zeilen das selbe:
[Link]("GroupName:", "MyCTF Files", "TestName:", "[Link]")
[Link]("TestName:", "[Link]", "GroupName:", "MyCTF Files")

Genauso können die beiden Parameter auch über zwei einzelne Aufrufe ange-
geben werden:
[Link]("GroupName:", "MyCTF Files")
[Link]("TestName:", "[Link]")

3. Adressieren eines Versuchs mittels eines File-Objektes. Existiert im Skript

bereits ein File-Objekt, das einen bestimmten Versuch repräsentiert, dann kann
auch eine Referenz auf dieses File-Objekt zur Adressierung desselben dienen:
file = SelFile("MyCTF Files", "[Link]")
[Link]("ConcertoFileRef:", file)

Sollen ein Datenschlüssel bzw. eine Messung adressiert werden, so ist noch der
Name des Datenschlüssels mittels des Parameters DataKeyName und optional
eine Messungs-Id über den Parameter MeasId anzugeben.
Die Adressierung des Versuchs, in dem sich der Datenschlüssel befindet, kann
dabei auf eine der oben gezeigten Arten erfolgen:

Beispiele
[Link]("Alias:", "CPF1", "DataKeyName:", "D")

[Link]("GroupName:", "MyCTF Files", "TestName:", "[Link]")

[Link]("DataKeyName:", "!P")

[Link]("GroupName:", "MyCTF Files",\

"TestName:", "[Link]",\
"DataKeyName:", "!P",\
"MeasId:", 2)

Formel/Script-Editor — User’s Guide

40 Klassen

Um einen Kanal innerhalb eines Datenschlüssels bzw. innerhalb einer Messung

zu adressieren, wird der Name des Kanals mittels des Parameters ChannelName
angegeben:

Beispiele
[Link]("GroupName:", "MyCTF Files",\
"TestName:", "[Link]",\
"DataKeyName:", "!P",\
"MeasId:", 2,\
"ChannelName:", "n_dyn")

Solche Adressierungsobjekte können jetzt in den Composer-Methoden

verwendet werden, um bestimmt Aktionen auf die adressierten Daten auszu-
führen.
Das folgende Beispiel erzeugt einen neuen Datenschlüssel mit dem Namen
MyData in einem bereits existierenden Composer-File, das mit dem Alias CPF1
geöffnet ist und erzeugt dann darin weiters einen Kanal Drehzahl mit Platz für
100 Werte.

Beispiel
Dim cp As Composer
Dim myAddr As Addressing

[Link]("Alias:", "CPF1", "DataKeyName:", "MyData")

[Link](myAddr)

[Link]("ChannelName:", "Drehzahl")
[Link](myAddr, "Unit:", "U/min", "ValueCount:", 100)

Zunächst wird der Datenschlüssel adressiert, der erzeugt werden soll, und dann
mit der Composer-Methode AddNewDataKey angelegt. Danach wird die Adres-
sierung um den zu erzeugenden Kanal erweitert, indem der Parameter Chan-
nelName gesetzt wird. Damit wird dann die Composer-Methode AddNewChannel
aufgerufen, um den Kanal zu erzeugen.

Übersicht über die verwendeten Parameter des Addressing-Objektes:

Name Typ Beschreibung

Alias String Alias-Name eines geöffneten Versuchs
GroupName String Datenquellenname
TestName String Name eines Versuchs
ConcertoFileRef File-Objekt Referenziert ein File-Objekt
DataKeyName String Name eine Datenschlüssels
MeasId Zahl Messungs-Id
ChannelName String Kanalname
DataSetRef Dataset-Objekt Referenziert ein Dataset-Objekt

Tab. 2

Eine genaue Spezifikation mit allen Möglichkeiten der Klasse Addressing finden
Sie in der Online-Hilfe.
Das folgende Beispiel erzeugt ein neues ComposerFile mit dem Namen MyNew-
File und dem Alias My1, welches in das Layout eingebettet ist. In diesem File
wird ein zeitbasierter Datenschlüssel mit dem Namen D und der Beschreibung
Created Data angelegt, in dem zwei Numerische Kanäle a und b angelegt
werden, wobei der erste 100 Punkte mit einer Auflösung von 0,5 Sekunden und
der zweite 50 Punkte bei halber Auflösung hat. Beide Kanäle sind danach mit
ungültigen Werten gefüllt, da noch keine expliziten Daten in die Kanäle
geschrieben wurden.

Formel/Script-Editor — User’s Guide

 Klassen 41

Beispiel
Dim cmp As Composer
Dim newFileAddr As Addressing

[Link]("TestName:", "MyNewFile", "Alias:", "My1")

[Link](newFileAddr, "LayoutEmbedded:", 1)

[Link]("DataKeyName:", "D")
[Link](newFileAddr,\
"Description:", "Created Data",\
"BaseType:", "TIMEBASED")
[Link]("ChannelName:", "a")
[Link](newFileAddr,\
"Unit:", "s",\
"Resolution:", 0.5,\
"ValueCount:", 100)

[Link]("ChannelName:", "b")
[Link](newFileAddr,\
"Unit:", "s",\
"Resolution:", 1.0,\
"ValueCount:", 50)

[Link] Bereiche
Wenn mit Hilfe der Composer-Befehle Daten in einen Kanal geschrieben oder
bestimmte Daten extrahiert werden sollen, dann muss festgelegt werden,
welche Daten davon betroffen sein sollen. Dies erfolgt über ein Bereichsobjekt,
ein Objekt der Klasse Range.
Ein Bereichsobjekt wird, wie schon beim Adressierungsobjekt gezeigt, mit Hilfe
benannter Parameter über die Methode Set beschrieben.
Es gibt mehrere Möglichkeiten, Bereiche mittels eines Bereichsobjektes zu
spezifizieren. Ein Bereich kann beispielsweise über den DataSet-Startindex und
die Anzahl der Werte beschrieben werden:
Dim r As Range

[Link]("DSIndex:", 3, "Count:", 7)

Oftmals ist es jedoch sinnvoller, anstelle des Index den Basiswert (Wert der
x-Spur) zu verwenden:
[Link]("BaseStartValue:", 20.5, "Count:", 10)

Wird als Count der Wert -1 angegeben, so wird damit ein nach hinten offener
Bereich spezifiziert, also alle Werte beginnend bei der angegebenen Startposi-
tion bis zum Ende des DataSet.
Mit einem Bereichsobjekt können auch mehrere, nicht zusammenhängende
Bereiche, definiert werden. Dazu wird ein DataSet mit Wertepaaren übergeben,
wobei der erste Wert den Start und der zweite das Ende eines Bereiches
beschreibt.
rangeDS = new(6, 0)
rangeDS.y[1] = 3.5// 1. Bereich von 3.5 bis 8
rangeDS.y[2] = 8.0
rangeDS.y[3] = 12.5// 2. Bereich von 12.5 bis 14.0
rangeDS.y[4] = 14.0
rangeDS.y[5] = 14.5 // 3. Bereich von 14.5 bis 16
rangeDS.y[6] = 16.0
[Link]("RangesDSRef:", rangeDS, AddressingMode: "BaseStartValue")

In diesem Fall wird über den Parameter AddressingMode festgelegt, wie die
Werte im DataSet das als RangesDSRef angegeben wurde, zu interpretieren
sind: DSIndex, wenn die Werte Indizes darstellen oder BaseStartValue, wenn
die Werte Basiswerte (Werte der x-Spur) darstellen.

Formel/Script-Editor — User’s Guide

42 Klassen

Übersicht über die verwendeten Parameter des Range-Objektes:

Name Typ Beschreibung

DSIndex Ganzzahl DataSet-Index, bei dem der Bereich beginnt
BaseStartValue Zahl Basiswert, bei dem der Bereich beginnt
Count Ganzzahl Anzahl der Werte, die der Bereich umfasst
RangesDSRef DataSet-Objekt DataSet, welches die Start- und Endwerte von Bereichen definiert
AddressingMode String Wie die Werte, die mittels RangesDSRef angegeben wurden, zu inter-
pretieren sind: DSIndex oder BaseStartValue

Tab. 3

Zur Beschreibung von Bereichen sollten die Parameter DSIndex, Base-

StartValue und RangesDSRef nur alternativ verwendet werden.

Beispiel
rangeDS = new(6, 0)
rangeDS.y[1] = 3.5// 1. Bereich von 3.5s bis 8s
rangeDS.y[2] = 8.0
rangeDS.y[3] = 14.5 // 2. Bereich von 14.5s bis 16s
rangeDS.y[4] = 16.0
Dim r As Range
[Link]("RangesDSRef:", rangeDS,\
"AddressingMode:", "BaseStartValue")

[Link]("ChannelName:", "a")
[Link](newFileAddr, r, "Value:", 100)

4.4 Eigenschaften und Methoden

Eine detaillierte Beschreibung zu den Methoden und Eigenschaften finden Sie in
der Online Hilfe.
„ Öffnen Sie die Online Hilfe über das Menü Hilfe
„ oder drücken Sie die Funktionstaste F1 für kontext-sensitive Hilfe.

Formel/Script-Editor — User’s Guide

 Beispiele 43

5 Beispiele

5.1 Transformation Makros

5.1.1 Transformation zur Verschiebung der X- und Y Achse

Beispiel
arg kanal,verx,very
DS = Create(Xds(kanal) + verx,kanal + very)
return DS

„ arg kanal,verx,very
Das Datenset unter der Variablen kanal speichern, sowie die beiden Para-
meter unter den Variablen verx für den Wert der X-Verschiebung bezie-
hungsweise very für den Wert der Y-Verschiebung speichern.
„ DS = Create(Xds(kanal) + verx,kanal + very)
Unter der Variablen b wird durch den Befehl Create() ein neues Datenset
erzeugt. Da wir die X-Achse von kanal übernehmen wollen, können wir
diese mit Xds(kanal) übernehmen. Um nun die Achse mit unserem
gewünschten Wert zu verschieben, addieren wir die Achse von kanal mit
unserem Wert welcher unter der Variablen verx gespeichert ist:
Xds(kanal)+verx. Für die Y-Achse funktioniert es auf die gleiche Weise, nur
brauchen wir nicht explizit die Y-Achse ansprechen, da diese immer default-
mäßig verwendet wird, wenn nur die Variable eingegeben wird.
„ return DS
Hiermit wird unser neu erzeugtes Datenset DS ausgegeben.

5.1.2 Berechnung des Integrals innerhalb zweier vordefinierter Grenzen

Beispiel
arg kanal,start,stop
points = nPoints(kanal)
c = New(points,0)
for j = 1 to points
if kanal.x[j] > start and kanal.x[j] < stop then c.y[j] = 1
next j
d = Reduce(kanal,c)
b = Integral(d)
return b

„ arg a,start,stop
Speichern des Datensets unter der Variablen kanal, sowie das festlegen der
Grenzen durch die Parameter start und stop.
„ points = nPoints(kanal)
Unter der Variablen points wird die Anzahl an Messpunkten abgespeichert.
„ c = New(points,0)
Unter der Variablen c wird ein neues BoolDatenset erzeugt, welches genau
so viele Messpunkte hat wie das Datenset kanal, und dessen Wert immer
"0" ist.

Formel/Script-Editor — User’s Guide

44 Beispiele

„ Datenset c:
1 0
2 0
3 0
... 0
... 0
points 0

Tab. 4

„ for j = 1 to points
Beginn der For-Schleife um alle Punkte des Datensets a durchzusehen, um
herauszufinden, welche Punkte von a sich innerhalb der Grenzen befinden.
„ if kanal.x[j] > start and kanal.x[j] < stop then c.y[j] = 1
If-Bedingung um zu sehen, ob der j-te Punkt von c X-Achse innerhalb der
Grenzen liegt, wenn ja, wird der entsprechende Punkt des Datensets c auf
1 gesetzt. Für c erhalten wir zum Beispiel nun folgendes:
1 0
2 0
3 0
4 1
5 1
... 1
... 1
19 1
20 0
21 0
... 0
points 0

Tab. 5

„ next j
Beendet die For-Schleife und erhöht j um eins.
„ d = Reduce(kanal,c)
Nun reduzieren wir das Datenset kanal auf die für uns wichtigen Punkte und
speichern dies unter der Variablen d.
„ b = Integral(d)
Nun wird d integriert und unter der Variablen b gespeichert.
„ return b
Hiermit wird unser neu erzeugtes Datenset b ausgegeben.

Formel/Script-Editor — User’s Guide

 Beispiele 45

5.2 Scripts

5.2.1 [Link]
Script, durch das mehrere Versuche aus einer ausgewählten Datenquelle mit
einem ausgewählten Layout automatisch geöffnet, ausgedruckt und anschlie-
ßend wieder geschlossen werden.

Beispiel
LoadLayoutDialog()
SelectFileGroup()
a = SelectFileBrowser(globalvar("$CURRENT_GROUP"))
zaehler = nPoints(a)
for i = 1 to zaehler
LoadFile(globalvar("$CURRENT_GROUP"),a.y[i])
PrintWindow()
RemoveFile(globalvar("$CURRENT_GROUP"),a.y[i])
next i

„ LoadLayoutDialog()
Öffnet den Layoutdialog. Hier können Sie das Layout auswählen mit dem
die Versuche ausgewertet werden sollen.
„ SelectFileGroup()
Öffnet das Datenquellenfenster. Hier können Sie auswählen, in welcher
Datenquelle sich die auszuwertenden Versuche befinden.
„ a = SelectFileBrowser(globalvar("$CURRENT_GROUP"))
Mit SelectFileBrowser() wird das Fenster zur Auswahl der Versuche
geöffnet. Unter der globalen Variable $CURRENT_GROUP ist die zuvor
ausgewählte Datenquelle automatisch gespeichert. Unter der Variablen a
werden die von Ihnen ausgewählten Versuche gespeichert.
„ zaehler = nPoints(a)
Unter zaehler wird nun die Anzahl der Versuche gespeichert.
„ for i = 1 to zaehler
For-Schleife, die nacheinander alle Versuche öffnet, ausdruckt und
anschließend wieder schließt.
„ LoadFile(globalvar("$CURRENT_GROUP"),a.y[i])
Dieser Befehl öffnet den jeweiligen Versuch. Die Syntax dieses Befehls
lautet: LoadFile(DataSource, FileName). Der Name der verwendeten
Datenquelle ist unter CURRENT_GROUP, der Name des Versuchs unter
dem jeweiligen y-Wert von a gespeichert.
„ PrintWindow("All")
Druckt alle Fenster aus.
„ RemoveFile(globalvar("$CURRENT_GROUP"),a.y[i])
Schließt den jeweils geöffneten Versuch wieder.
„ next i
Beendet die For-Schleife und erhöht i um eins.

Formel/Script-Editor — User’s Guide

46 Beispiele

5.2.2 [Link]
Beispiel
//show all cycles of curves in a diagram window
Win = GetActiveWin() //select active window
Obj = [Link]() //select (all) objects: there should be only one curve object
FirstDS = [Link]() //select (all) data sets
for i = 1 to [Link]
[Link]([Link]+"["+i+"]")
next i
[Link]().Colour = [Link] //same colour

„ Win = GetActiveWin()
Unter der Variablen Win wird das aktive Fenster gespeichert.
„ Obj = [Link]()
Unter der Variablen Obj werden alle Objekte des aktiven Fensters gespei-
chert.
„ FirstDS = [Link]()
Unter der Variablen FirstDS werden alle Datensets aller Objekte gespei-
chert.
„ for i = 1 to [Link]
For-Schleife die von 1 beginnend bis zur höchsten Zyklusnummer durch-
zählt.
„ [Link]([Link]+"["+i+"]")
Da unter der Variablen Obj alle Objekte gespeichert sind, wird nun mit dem
Befehl [Link]() bei allen Objekten das erste Datenset um die Daten-
sets aus allen Zyklen erweitert.
„ next i
Beendet die For-Schleife und erhöht i um eins.
„ [Link]().Colour = [Link]
Alle Kurven bekommen die Farbe der ersten Kurve.

5.2.3 Datenset einer Y-Achse finden

Beispiel
Win = GetActiveWin()
ObjDiagram = [Link]("*","DIAGRAM")
ObjScale = [Link]()
ObjItem = [Link]("*","Y")

yDataset = DS([Link])
xDataset = xds(yDataset)

return 0

„ Win = GetActiveWin()
Unter der Variablen Win wird das aktive Fenster gespeichert.
„ ObjDiagram = [Link]("*","DIAGRAM")
Unter der Variablen ObjDiagram werden alle aktiven Objekte des aktiven
Fensters gespeichert, die vom Objekttyp DIAGRAM sind.
„ ObjScale = [Link]()
Unter der Variablen ObjScale werden alle Objekte gespeichert, welche mit
dem Objekt ObjDiagram verbunden sind.

Formel/Script-Editor — User’s Guide

 Beispiele 47

„ ObjItem = [Link]("*","Y")
Unter der Variablen ObjItem werden alle DatenSets aus ObjScale gespei-
chert.
„ yDataset = DS([Link])
Unter der Variablen yDataset wird das erstgereihte Datenset aus ObjItem
gespeichert.
„ xDataset = xds(yDataset)
Unter xDataset wird das zu yDataset zugehörige Abszissendatenset
gespeichert.

5.2.4 Punktauswahl
Beispiel
Input("Punktauswahl","%pktliste","Punkte (z. B. 1..5,7,9,12..15):")
Win = GetActiveWin()
Obj = [Link]()
for i = 1 to [Link]
CurObj = Obj[i]
CurObj.yTrafoName1 = "SelPoints"
CurObj.yTrafoArg1 = "{" + %pktliste +"}"
next i

„ Input("Punktauswahl","%pktliste","Punkte (z. B.
1..5,7,9,12..15):")
Ruft den InputDialog auf.
„ Win = GetActiveWin()
Speichert das aktuelle Fenster unter der Variablen Win.
„ Obj = [Link]()
Speichert die Objekte unter der Variablen Obj.
„ for i = 1 to [Link]
For-Schleife von 1 beginnend bis zur maximalen Anzahl der Objekte.
„ CurObj = Obj[i]
Unter der Variablen CurObj wird das i-te Objekt gespeichert.
„ CurObj.yTrafoName1 = "SelPoints"
Über das Objekt das unter CurObj gespeichert ist, wird die Transformation
"SelPoints" gelegt.
„ CurObj.yTrafoArg1 = "{" + %pktliste +"}"
Als Parameter für die Transformation wird "{" + %pktliste +"}" übergeben.
„ next i
Beendet die For-Schleife und erhöht i um eins.

Formel/Script-Editor — User’s Guide

48 Beispiele

5.2.5 Log pV Diagram

Beispiel
// Create logarithmic pV Diagram
Win = ActiveWin()
[Link] = "logpVdiag"
[Link] = "Vol log"
[Link]

„ Win = ActiveWin()
Speichern des aktiven Diagrammes unter der Variablen Win.
„ [Link] = "logpVdiag"
Über die X-Achse wird die Transformation "logpVdiag" gelegt.
„ [Link] = "Vol log"
Die Bezeichnung der X-Achse wird auf "Vol log" umbenannt.
„ [Link]
Es wird ein Autoskalieren für das Fenster, das unter der Variablen Win
gespeichert ist, ausgeführt.

5.2.6 Objektverwaltung
Das folgende Beispiel stellt eine umfangreiche Anwendung der Objektbehand-
lung in CONCERTO-Scripts dar. Zielsetzung ist es ein Layout zu dokumentieren.
Zu diesem Zweck werden für jedes CONCERTO-Fenster alle Objekte und die
darin enthaltenen Datensets in einer Textdatei aufgelistet. Für die Display-Items
werden weiters noch Farbe und Linienstil ausgegeben:

Formel/Script-Editor — User’s Guide

 Beispiele 49

Beispiel
//LayoutDocumentation Example
//This script prints all window names together with the contained display objects
//and the contained dataset items into a text file.
//For every dataset item the fullname of the associated dataset as well as colour
and style are given in addition.
input("Select Path for Layout Documentation ", "%docpath", "File Path e.g.
C:\layoutdoc\")
layoutname =globalvar("$LAYOUT")
%docname = %docpath + layoutname + ".txt"
WriteLn(%docname,"Layout: " + layoutname ,0)
WriteLn(%docname,"====================================",1) //1 to append to file
AllWin=SelWin()
//Select all windows and assign the returned list of handles to the windows to
variable AllWin
//alternativly:SelWin("*")
//To select certain windows via a name maske: SelWin("ABC*") - using * als wildcard
//create an auxiliary dataset with all object type identifierstrings
objtypes = {"ANNOLINE","BITMAP","RECTANGLE","WINDOW","LINE","BAR","SCATTER", \
"BAND","FORM","MAP","LEGEND","TEXT","LIST","TABLE","COMPBAR","STACKBAR","BOX","SU
RFACE" }
for i =1 to [Link]
CurWin = AllWin[i] //Select one window out of AllWin
// Note: Don't use .y for selecting an element out of a window list, use just
[] .
// To select the n-th window in AllWin therefore write just AllWin[i] and
not AllWin.y[i]
writeln(%docname," ",1)
writeln(%docname,"Window: " + [Link],1)
for t = 1 to [Link]
AllObj = [Link]("*",objtypes.y[t]) //get handles to all objects
//Select all display items off CurWin and assign this list to variable
AllDSNames
for j= 1 to [Link]
CurObj=AllObj[j]// select one object
writeln(%docname," " + objtypes.y[t] + " " + [Link],1)
AllDSItems = [Link]()
//Select all dataset items in CurObj and assign this list to variable AllDSItems
//Note: These are no datasets but just handles to the data set items defining,
//which data sets are used within a display object
for k = 1 to [Link]
CurDS= AllDSItems[k]
writeln(%docname," DatasetItem: "+ [Link] + " DS: " + [Link] + "
Col: " +[Link] + " Style: "+ [Link] ,1)
next k
next j
next t
next i

Formel/Script-Editor — User’s Guide

50 Beispiele

Formel/Script-Editor — User’s Guide

 Zugriff auf DOS-Kommando 51

6 Zugriff auf DOS-Kommando

CONCERTO-Scripts können den vollen Umfang der DOS-Kommandos nutzen.
Um in CONCERTO-Scripts auf DOS-Kommandos zugreifen zu können, gibt es
die Makrofunktion RunCmd().
Syntax:
RunCmd(DOS-Kommando)

Beispiel
RunCmd("Copy C:\[Link] E:\")
Obiges CONCERTO-Script kopiert die Datei [Link] von Laufwerk C auf das
Laufwerk E.
Um mehrere Befehle nacheinander abarbeiten zu lassen, muss man ein
ASCII-Datenset mit mehreren Punkten erzeugen, wobei jeder eine Kommando-
zeile enthält. Das Beispiel-Script würde dann wie folgt aussehen:
Kommandos={"md d:\Test","copy C:\temp\[Link] d:\Test\[Link]"}
RunCmd(Kommandos)

richtet auf dem Laufwerk D das Verzeichnis "Test" ein

Anschließend wird die Datei [Link] von "C:\temp nach D:\Test" kopiert.

Formel/Script-Editor — User’s Guide

52 Zugriff auf DOS-Kommando

Formel/Script-Editor — User’s Guide

 Index 53

Index
A F
Adressierungsobjekt …39 Go …13
Anweisung …15 Step Into …13
Anzeige-Objekte …35 Fehlermeldung …12
Applikation Fenster …35
Fenster …8 Fensterliste …35
Klasse …33 Fließkommaformat …17
Arbeitsfenster …9 Formel …16
Auflösung verschlüsseln …29
Daten …19 For-Schleife …25
Ausdruck …15 Funktionen …31
automatisch Funktions-
Code vervollständigen …10 aufrufe …26
fenster …8
B liste …9
Beispiele …29 typen …8
Bereichsobjekt …41
BOOL G
Daten …17 globales Datenset …18
Datenset …21
Break-Anweisung …26 I
Breakpoint …13 if, then, else - Statement …24
ByRef-Anweisung …27 if-Bedingung …24
interne Funktionen …26
C
Compiler Switches …19 K
Composer Kanal …16
Klasse …38 adressieren …40
Skript-Befehl …38 Kanal-Browser …12
ConcertoFile Klasse
adressieren …39 Composer …38
continue …25 Range …41
ContinueIfDataSetNotFound …19 Klassen …33
Run to Cursor …13 DisplayItem-Klasse …35
Fensterklasse …35
D Objektklasse …35
DataSet-Startindex …41 Syntax …34
Daten Kommentar …15
Auflösung …19 Konstante …17
Format …17
splitten …23 L
Daten-Explorer Layout-Explorer …35
öffnen …42 LoadFullResolution …19
Datenschlüssel
adressieren …39 M
Datenset …15
Makro
einer Y-Achse finden …46
als Unterprogramm …27
erstellen …23
Name …27
global …18
verschlüsseln …29
Debug-Fenster …14
Marker
Debugger …13
Spur …16
Dim-Anweisung …10
Display Item …36 Meldungsfenster …12
DOS-Kommando …51 Methode …34, 42

E N
Eigenschaften …42 Neurechnen …13
Eingabehilfe …10
EnableRangeCheck …19

Formel/Script-Editor — User’s Guide

54 Index

O X
Oberfläche …7 X-Spur …16
Objekt …33, 36
ansprechen …33-34 Y
Eigenschaften …33 Y-Achse
Klassen …33 Datenset finden …46
Selektierfunktion …33 Y-Spur …16
Variable …33
OnComErrorResumeNext …19 Z
Operatoren …20 Zahlen …17
arithmetische …20 Zeile
logische …21 aufteilen …15
Methoden, Eigenschaften …21 Zyklen/Messungen
String …20 ansprechen …23
Vergleichsoperatoren …21

P
PenUp-Flag …23
Programmierhilfe …10
Punkt
ansprechen …22

R
RecalcOnPaint …19
RestrictChannelSearchToCurrentKey …19
Return …18
Return-Anweisung …26
Round …17

S
Script
verschlüsseln …29
Set-Operatoren …23
Step Over …13
Statement if, then, else …24
String …17
Strukturanweisungen …24
Syntax …15
Klassen …34

T
Transformation …28

U
User-Variable …17
im Layout …18
in Arbeitsumgebung …18
über Kommandozeilenparameter setzen …18
[Link] …17

V
Variable …14, 16
anzeigen …14
einfache Eingabe …10
zwischen Skripts auszutauschen …18
verschlüsseln …29

W
Warnung
bei COM-Fehler …19
While-Schleife …25

Formel/Script-Editor — User’s Guide

FOR FURTHER INFORMATION PLEASE CONTACT:

AVL List GmbH, Hans-List-Platz 1, 8020 Graz, Austria

Phone: +43 316 787-0, Fax: +43 316 787-400, info@[Link], [Link]