Formula
Zurück Nach oben Vorwärts

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;

formula.jpg (27886 bytes)
Formulaprogramm:
out[#d] = (in1[#d]>0) && (in2[#d]>0);
b=c;