Kurzbeschreibung
Parameter Funktionsweise Ein/Ausgänge Limitierungen Querverweise Beispiele
 | Kurzbeschreibung
Formula ist ein mathematischer Formeleditor. Mit Formula werden die an den Moduleingängen anliegenden
Daten durch Formeln verknüpft und die Ergebnisse an beliebigen Ausgängen bereitgestellt.
|
 | Parameter
 | ASCII-Text definiert Formeln, generiert
Ein-/Ausgänge und spezifiziert die Datentypen
|
|
 | Funktionsweise
Die Formeln können im Rahmen der syntaktischen Regeln unter
Verwendung der implementierten Funktionen, Operatoren und Konstanten frei erstellt werden.
Bei den Operatoren werden die üblichen Prioritäten berücksichtigt.
Die Typen von Ein- und Ausgängen werden im Formeltext angegeben.
Syntax
Formel: Ausgangsbezeichner = Formelrumpf;
Es können beliebig viele Formeln angegeben werden. Für jede Formel wird ein Ausgangsbezeichner erzeugt. Der Formelrumpf ist eine mathematische
Formel, die aus vorgegebenen, Operatoren und Funktionen sowie
Eingangsbezeichnern aufgebaut ist.
Operatoren |
|
Symbol |
Operator |
Priorität |
() |
|
|
1=höchste Stufe |
Funktion |
|
|
2 |
unär |
|
- |
unäres minus (Negation) |
3 |
~ |
logisch invertieren (NEG) |
3 |
binär |
arithmetisch |
+ |
Addition |
5 |
- |
Subtraktion |
5 |
* |
Multiplikation |
4 |
/ |
Division |
4 |
% |
Modulo (Divisionsrest) |
4 |
Vergleichs-
operatoren |
< |
kleiner als |
6 |
<= |
kleiner oder gleich |
6 |
> |
größer |
6 |
>= |
größer oder gleich |
6 |
== |
Test auf Gleichheit |
6 |
!= |
Test auf Ungleichheit |
6 |
logische
Operatoren |
&& |
logisch UND |
7 |
|| |
logisch ODER |
8 |
|
mathematische Funktionen |
|
|
Beispiel |
unär
fkt(par) |
allgemein |
exp |
Exponentialfunktion |
|
log |
natürlicher Logarithmus |
|
log10 |
Logarithmus mit Basis 10 |
|
sqrt |
Quadratwurzel |
|
abs |
Betrag |
|
trigonometrisch |
sin |
Sinus |
|
cos |
Cosinus |
|
tan |
Tangens |
|
asin |
Arcussinus |
|
acos |
Arcuscosinus |
|
atan |
Arcustangens |
|
sinh |
Sinus hyperbolicus |
|
cosh |
Cosinus hyperbolicus |
|
tanh |
Tangens hyperbolicus |
|
Rundung |
floor |
nächstkleinere ganze Zahl |
|
ceil |
nächstgrößere ganze Zahl |
|
round |
Ganzzahlwert (Runden) |
|
logische Funktionen |
not |
logisch Invertieren |
|
binär
fkt(par1,par2) |
allgemein |
pow |
Potenzieren |
pow(x,2) =x*x |
Rundung |
fix |
Rundung auf feste Anzahl gültiger Ziffern |
fix(1234.56,3) = 1230 |
logische Funktionen |
and |
UND |
|
or |
ODER |
|
xor |
EXCLUSIV - ODER |
|
equiv |
Äquivalenz |
|
nand |
NOT - AND |
|
nor |
NOT - OR |
|
Logische und reelle Funktionen können beliebig vermischt
werden. Sinnvolle logische Werte entstehen jedoch nur dann, wenn logische Operatoren auf
logische Werte und Ausdrücke angewendet werden.
Z. B. (a>0) && ((c-d) == 3), aber nicht (3*d) && c. |
|
Konstanten |
|
|
|
logische |
TRUE, FALSE, true, false |
1, 0, 1, 0 |
|
numerische |
PI |
3.1415926535 |
Kreiszahl |
E |
2.718281828 |
Euler - Zahl |
Ein- und Ausgänge
Jeder Bezeichner (Folge von alphanumerischen Zeichen, die mit einem Buchstaben
beginnt) auf der linken bzw. rechten Seite einer Formel, der nicht durch eine Konstante
oder Funktion vorbelegt ist, referenziert einen Eingang bzw. Ausgang. Die Namensmengen von
Ein- und Ausgängen dürfen sich überschneiden, d. h. es ist beispielsweise zulässig,
einen Eingang und einen Ausgang a zu nennen.
Gleiche Namen auf der linken bzw. rechten Seite einer Formel referenzieren dieselben Ein-
bzw. Ausgänge. Die Mehrfachverwendung von Namen von Ausgängen ist allerdings nicht
sinnvoll, da durch das Angeben einer zweiten Formel für einen Ausgang die erste überschrieben
wird.
Der Typ eines Ein- oder Ausgangs kann gemäß folgender Syntax spezifiziert werden:
Bezeichner [ vektor-typ ] oder Bezeichner [ vektor-typ,
type-info ]
Datentypen |
Elemente |
Scalar |
Vektor |
Präfix |
& |
% |
# |
|
Bezeichner |
&d |
&f |
%d |
%f |
#d |
#f |
d |
f |
Datentyp |
SWORD |
DOUBLE |
SWORD |
DOUBLE |
SWORD[1] |
DOUBLE[1] |
SWORD[] |
DOUBLE[] |
Trigger |
x |
x |
- |
- |
- |
- |
x |
x |
|
|
|
|
|
|
|
|
Default |
Liegen an allen Triggereingängen Daten an, so wird eine
Bearbeitung der Formeln auf den aktuellen Daten ausgelöst. Neue Daten an
Nicht-Trigger-Eingängen werden zwar übernommen, ziehen aber kein Bearbeitung der Formeln
mit sich.
Falls nicht der Default Datentyp verwendet werden soll, ist für jede Variablen in der
Formel (= Ein/-Ausgänge des Moduls) ein Datentypen anzugeben.
Der Typ enthält die Trigger Information und entscheidet, ob eine Berechnung durchführt
und neue Daten auf die Ausgänge gelegt werden. Liegen Daten nur an Eingängen, welche die
Berechnung nicht auslösen, so werden die Daten zwar in das Modul eingelesen, es erfolgt
jedoch keine Berechnung.
Der Typbezeichner, setzt sich dabei aus d (=ganze Zahl) oder f (=Fließkommazahl) und
einem Präfix (Skalar oder Vektor und Triggereigenschaft) zusammen.
Der Typbezeichner befindt sich in
eckigen Klammern hinter dem Variablennamen:
Eingang, Typ SWORD[1] (Vektor, Länge 1, ganzen Zahlen) |
...=I1[#d] |
Eingang, Typ DOUBLE (Skalar, Fließkommazahl, kein Trigger) |
...=I2[%f] |
Typinformationen (TypeInfo)
Typinformation |
Schlüsselwort |
Beispiel |
Signalname |
name |
name = "Weg" (Anführungszeichen erforderlich!) |
kleinster Wert |
min |
min = -10.0 |
größter Wert |
max |
max = 10.0 |
Einheit |
unit |
unit = "kg m s^-2" (Anführungszeichen!) |
Skalierungsfaktor |
scale |
scale = 0.001 |
Beispiele |
a[f,
name="Weg"] = x/65536;
b[d, min=0; max=1000] = c;
s[#f, name="Dicke", min=0, max=10, unit="m", scale=0.001] = d; |
Sollen Typinformationen gesetzt werden, ist die Angabe des
Datentypes - erstes Element in den eckigen Klammern - notwendig. Die Typinformationen
können in beliebiger Reihenfolge angegeben werden und sind durch Komma zu trennen. Es
müssen nicht alle Parameter spezifiziert werden.
Typkonflikte
Ein neuer Bezeichner definiert einen Ein-
oder Ausgang unter Verwendung des angegebenen oder Default Datentyps.
Weitere Vorkommen des Bezeichners brauchen nicht spezifiziert werden. Wird der Datentyp
wiederholt spezifiziert, so muß er mit dem Datentyp des ersten Auftretens
übereinstimmen. Andernfalls liegt ein Typkonflikt vor und es wird eine Fehlermeldung
ausgegeben.
Beispiele |
a = b + c[f]; |
b und c Typ DOUBLE[] |
st[f] = pow(x, floor(ex[%d]); |
Typen: st=DOUBLE[], x=Default=DOUBLE[], ex=SWORD |
e = sin(b[f]); |
OK |
f = c[#d] * (b
> 0); |
Typkonflikt: c besitzt Typ DOUBLE[] (vgl 1. Zeile) |
o = p + p[d]; |
Typkonflikt: p hat defaultmäßig Typ DOUBLE[] |
Kommentare
Im Editierfeld können Kommentare
eingefügt werden. Sie werden mit "//" eingeleitet und enden mit dem Zeilenende,
z. B.: a = 10 * b; // Skalierung
Fehlermeldungen
Jede Fehlermeldung enthält die Zeilennummer und das zuletzt
gelesene Zeichen. Die Fehlerursache kann jedoch schon vor diesem Zeichen liegen. So wird
zum Beispiel ein vergessener ';' am Ende einer Formel erst erkannt, wenn der gesamte
Formeltext beendet ist (Fehler bei 'EOF') oder wenn die Spezifikation der nächsten Formel
beginnt.
Fehlermeldung |
Ursache |
Fehler in Zeile x bei Token y |
Syntaxfehler (z. B. falsche Klammerung, vergessener Operator, ';' fehlt) |
Typkonflikt
bei Ausgang a |
Typ von Port a mehrfach und verschieden spezifiziert. |
Unbekannter Parameter
an Ausgang z |
Typinformation für Ausgang z ist fehlerhaft. |
Unbekannter Typ |
Variable mit ungültigem Datentyp spezifiziert |
|
 | Ein-/Ausgänge
Eingänge |
Z.B. I0 |
TYPEINFO{TypeInfo}
SWORD[1]{BIN} |
Anzahl und Datentypen der Eingänge werden auf der rechten Seite der Formeln
festgelegt |
Ausgänge |
Z.B.
O0 |
TYPEINFO{TypeInfo}
DOUBLE[]{TIME_DOMAIN} |
Anzahl und Datentypen der Ausgänge werden auf der linken Seite der Formeln
festgelegt |
|
 | Limitierungen
Triggereingänge sind obligatorisch, es muß
immer mindestens ein Trigger-Eingang existieren.
Skalareingänge müssen nicht verdrahtet sein. Sie liefern in diesem Fall 0 oder
den zuletzt anliegenden Wert (falls der Eingang schon einmal verdrahtet war).
An allen Vektoreingängen müssen gleich viele Blöcke mit jeweils gleicher
Blocklänge und gleichem Paketstatus anliegen.
Ausgänge mit Typspezifikation [#x] oder [%x] liefern für jeden Block, der an den
Vektoreingängen anliegt genau einen Wert.
|
 | Querverweise
Interpret
|
 | Beispiele
y1=x*x-3;
// quadrat. Gleichung mit einstellbaren Koeffizienten
y2=a[#f]*x*x+b[#f]*x+c[#f];
// Umwandlung vom Typ DOUBLE[] in Typ SWORD
Weg[d]=round(d);
// Umwandlung von Typ SWORD[] in Typ DOUBLE[]
z = in[d];
O1[f,min=0;max=100;unit="kg",scale=0.001,name="Signal1"]=
pow(x,10)*sin(exp(z))-2;

Formulaprogramm:
out[#d] = (in1[#d]>0) && (in2[#d]>0);
b=c;
|
|