Logikgatter (logic gates) in der TMD


Mapping (Zuordnung)

Die Grundlage für jede logische Schaltung im Aerofly5 sind Servo-Outputs zwischen 0 und +1. Das hat neben den zwingenden mathematischen Voraussetzungen unter anderem den Vorteil, dass wir uns jeden Wert einfach vorstellen können z.B. als Prozentzahl.

Voll proportionaler Input

Hier wird der proportionale Input vom Steuergerät auch proportional weitergegeben, d.h. auch Zwischenwerte sind möglich und auch gewünscht um einen Input zu drosseln aber nicht immer ganz abschalten zu müssen.

Input: -1 bis 1 voll proportional

        <[string8][object][servolinear]
            <[string8][Name][Input1Mapping]>
            <[string8][Input][Input1.GetOutput]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][0]>
            <[float64tmarray][InputPosition][  -1 1 ]>
            <[float64tmarray][OutputPosition][  0 1 ]>
        >

Output: Input1Mapping.GetOutput
0 bis 1 voll proportional

An- / Aus Schalter

Mit diesem “Schalter” wird versucht entweder 0 oder 1 auszugeben. Zwischenschritte sind zwar nie ganz auszuschließen, jedoch ist der Bereich, in dem Zwischenwerte auftreten können so gering, dass diese vonn der Auflösung der Steuerung (Bit-Schritte) nicht erreicht werden können.
Das Beispiel zeigt einen Schalter, der oberhalb der Hälfte der Eingabe steht 1 ausgibt und unterhalb immer 0. Die Schwelle lässt sich theoretisch natürlich nach Belieben verschieben, jedoch sollte man an den Randbereichen vorsichtig sein. Es könnte ja sein, dass die Kalibrierung des Steuergerätes nicht immer 100% des Weges nutzt.

Input: -1 bis 1 voll proportional

        <[string8][object][servolinear]
            <[string8][Name][Input1Mapping]>
            <[string8][Input][Input1.GetOutput]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][0]>
            <[float64tmarray][InputPosition][  -1 0.499999 0.5 1 ]>
            <[float64tmarray][OutputPosition][  0 0        1   1 ]>
        >

Output: Input1Mapping.GetOutput
0 oder 1


AND-Gate (Und-Schaltung)

(für ein NOT-AND-Gate werden die Inputs invertiert gemappt also 1 bis 0 statt 0 bis 1)

Unter einer Und-Schaltung a.k.a. And-Gate verstehe ich eine Logik, die zwei Eingangsgrößen zu einer kombiniert.
Nur wenn beide Eingangsgrößen aktiv werden, schaltet die Logik durch. Ist das nicht der Fall wird stehts 0 ausgegeben, der Output ist blockiert.

Ein solches And-Gate kann man z.B. dazu nutzen um eine Steuereingabe des Piloten zu blockieren mit einer anderen Funktion.
Als Beispiele fallen mir dazu ein:
– das Einfahren des Fahrwerks am Boden verhindern,
– beim Klapptiebwerk den Motor erst anlaufen lassen, wenn der Motorträger ausgefahren wurde,
– automatisches Einschalten des Dual-Rates bei höheren Geschwindigkeiten
– automatisch ausfahrende Landeklappen bei Verringerung der Geschwindigkeit (oder bei entsprechenden Anstellwinkeln (automaische Snap-Flap)
– deaktivieren solcher automatischen Funktionen durch einen anderen Input (komplettes Deaktivieren des Auto-Piloten z.B)

Mathematik dahinter:
Die Multiplikation einer Zahl mit 0 ergibt immer 0. Wenn also einer der beiden Inputs 0 ist, dann wird der Output auch 0 sein. Erst wenn beide Eingangsgrößen einen Wert größer 0 haben, dann wird auch ein Wert ausgegeben, der größer als 0 ist.

Informatik:
while ( (input1 > 0) && (input2 > 0) ) (voll-proportional)
while ( input1 && input2 ) (falls als Input-Größen An- / Aus-Schalter genutzt werden)

Inputs:
“0 bis 1 voll proportional” (aus dem Mapping, s.o.)
bzw. “0 oder 1”

        <[string8][object][product]
            <[string8][Name][Input1andInput2]>
            <[string8][Input0][Input1Mapping.GetOutput]>
            <[string8][Input1][Input2Mapping.GetOutput]>
        >

Output:
Input1andInput2.Output: 0 – 1 vollproportional bzw.
0 oder 1, je nach Input-Größen.

Ausgabe

Den Ausgabewert vom And-Gate an sich kann man kaum sinnvoll nutzen. Wir hätten gerne wieder unseren vollen Weg zurück und vielleicht möchten wir auch beim Ausgang noch eine gewisse Zuordnung umsetzen, bevor wir den Wert wieder an unser Modell “zurückgeben”

Mit diesem Linearservo wird ein Input zwischen 0 und 1 wieder auf das Intervall -1 bis +1 aufgespreizt. Wenn man besonders Vorsichtig sein will bei einem An- / Aus-Schalter, sollte man auch hier wieder eine Art “Schwelle” einbauen, damit auch wirklich keine Zwischenschritte möglich werden.

        <[string8][object][servolinear]
            <[string8][Name][ANDGateMapping]>
            <[string8][Input][Input1andInput2.Output]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][-1]>
            <[float64tmarray][InputPosition][   0 1 ]>
            <[float64tmarray][OutputPosition][ -1 1 ]>
        >

Output:
ANDGateMapping.GetOutput: -1 bis 1 voll proportional bzw. andere Steuerbereiche,
0 oder 1 oder ähnliche Outputs.


OR-Gate (Oder-Schaltung)

(für ein NOR-Gate werden die Inputs entsprechend invertiert…)

Mit einem Or-Gate wird eine Funktion aufgerufen, wenn entweder der eine oder der ande Input einen Wert größer 0 annimmt.
Diese Logik-Schaltung kann man z.B. nutzen, wenn man möchte, dass zwei verschiedene Inputs die gleiche Funktion steuern.
Beispiele hierfür:
Butterfly-Mischer (schon von Hause aus implementiert)
– später als wichtiger Bestandteil um User-Eingaben zu überschreiben
– für Abfragen wie “Modell auf dem Boden”, wo der Output ausgelöst wird, sobald auch nur ein Rad den Boden berührt

Mathematik dahinter:
Die Addition wird hier genutzt. Sobald einer der Inputs größer als 0 wird, wird die Summe der beiden Outputs auch größer als 0.
Es könnte hierbei wichtig werden, den Output zu begrenzen mit einem Linear-Servo, weil sonst der Output bis auf 2 wachsen kann…
(so, wie es im Moment noch bei dem Butterfly-Mischer der Fall ist.) Alternativ kann man “Weight0” und “Weight1” nutzen, das die Inputs wie bei einer Multiplikation vorher reduziert, der maximale Output ist dann 1.

Informatik:
while ( input1 || input2 )

Input:
0 – 1 voll proportional bzw.
0 oder 1

        <[string8][object][mixlinear]
            <[string8][Name][Input1orInput2]>
            <[string8][Input0][Input1.GetOutput]>
            <[string8][Input1][Input2.GetOutput]>
            <[float64][Weight0][0.5]>
            <[float64][Weight1][0.5]>
            <[float64][Offset][0]>
        >

Output:
Input1orInput2.Output: 0 bis 1 voll proportional
bzw. 0, 0.5 oder 1 (drei Stellungen)

Ausgabe

Da der Wert ja noch zwischen 0 und 1 (oder auch 2) schwanken kann nutzen wir wieder ein Linear-Servo um den Bereich des Outputs einzudämmen.
Bei dieser Variante des Outputs wird alles, was den Wert 0.5 überschreitet einfach abgeschnitten.

Wenn man lieber einen “Schalter” als Ausgabewert wünscht, kann man hier wieder eine “Stufe” einbauen.

        <[string8][object][servolinear]
            <[string8][Name][ORGateMapping]>
            <[string8][Input][Input1orInput2.Output]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][-1]>
            <[float64tmarray][InputPosition][   0 0.5 1]>
            <[float64tmarray][OutputPosition][ -1 1   1]>
        >

Output:
ORGateMapping.GetOutput: -1 bis 1 voll proportional bzw.
-1 oder 1

XOR Gate (Entweder-Oder)

Wir hätten gerne einen Output, wenn entweder der eine Output aktiv ist, oder der andere. Aber nicht wenn keiner oder beide aktiv sind.
Dazu nehmen wir zunächst ein OR-Gate und ändern beim Output einfach die Zuweisung für den maximal möglichen Wert.
Richtig sinnvoll ist diese Schaltung nur noch als An- / Aus-Schalter.

        <[string8][object][servolinear]
            <[string8][Name][XORGateMapping]>
            <[string8][Input][Input1orInput2.Output]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][-1]>
            <[float64tmarray][InputPosition][   0 0.5  1]>
            <[float64tmarray][OutputPosition][ -1 1   -1]>
        >

Output:
XORGateMapping.GetOutput: -1 bis +1


User-Input überschreiben

Manche Funktionen, wie z.B. einen Auto-Piloten möchte man nicht immer aktiv haben. Es ist zwar schön, wenn das Flugzeug von selbst die Höhe hält, doch was ist, wenn man wieder landen will?
Dann hätte man ganz gerne wieder volle Kontrolle über daas Flugzeug und um diese abschaltbare Funktion des Autopiloten geht es hier. Solange der Autopilot aktiv ist, möchten wir ausschließlich dessen Inputs an die Steuermaschinen des Flugzeugs senden. Wenn wir ihn ausschalten, wollen wir voll Kontrolle, ohne dass der Autopilot gegen uns arbeitet.
Mit den oben aufgeführten Gates kann man eine solche Steuerung schon umsetzen. Das Grundgerüst ist hier ein OR-Gate, dass den Input vom Autopilot und den des Piloten addiert.
Davor setzen wir jeweils eine Multiplikation, die je nach Status des Schalters für den Autopiloten den Input des Autopiloten bzw. Piloten einschränkt. Proportional über einen Schieber könnte man so später im Sim den EInfluss des Autopiloten regeln, wenn man das möchte.
Um eine Fly-by-Wire Steuerung zu bauen muss man dann eine weitere logische Schaltung entwickeln, die den Autopiloten in Grenzfällen automatisch wieder einschaltet. Das Konzept dafür wäre aber exakt das gleiche wie bei dem einfachen Überschreiben des Autopiloten…

Ziel: Überschreiben des einen Inputs mit einem anderen, solange eine weitere Funktion aktiv ist.

Informatik:
while (f1): Output = input1
while (!f1): Output = input2

Switch

Das folgende Servo gibt einen Wert zwischen 0 und 1 aus, z.B. je nach Geberposition.
Es dämpft später den Wert des ersten Inputs.

Input:
SwitchInput.GetOutput: -1 bis +1 proportional

        <[string8][object][servolinear]
            <[string8][Name][SwitchInput1]>
            <[string8][Input][SwitchInput.GetOutput]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][-1]>
            <[float64tmarray][InputPosition][ -1 1 ]>
            <[float64tmarray][OutputPosition][ 0 1 ]>
        >

Für die zweite Funktion wird der Output einfach logisch umgedreht.

        <[string8][object][servolinear]
            <[string8][Name][SwitchInput2]>
            <[string8][Input][SwitchInput.GetOutput]>
            <[float64][OutputSpeed][10]>
            <[float64][Position][-1]>
            <[float64tmarray][InputPosition][ -1 1 ]>
            <[float64tmarray][OutputPosition][ 1 0 ]>
        >

Output:
SwitchInput1.GetOutput: 0 bis 1 und gegenläufig
SwitchInput2.GetOutput: 1 bis 0

Im nächsten Schritt werden die Werte der Inputs mit der Position des Switches multipliziert. So werden die Maximalauschläge des jeweiligen Inputs reduziert:

Input:
Input1.GetOutput, Input2.GetOutput: -1 bis 1 voll proportionale Steuerfunktion
0 bis 1 Drosselfunktion

        <[string8][object][product]
            <[string8][Name][Input1enabled]>
            <[string8][Input0][Input1.GetOutput]>
            <[string8][Input1][SwitchInput1.GetOutput]>
        >
        <[string8][object][product]
            <[string8][Name][Input2enabled]>
            <[string8][Input0][Input2.GetOutput]>
            <[string8][Input1][SwitchInput2.GetOutput]>
        >

Output:
Input1enabled.Output, Input2enabled.Output: -1 bis +1
zwei gedrosselte Funktionen, wenn eine größer wird, wird die andere entsprechend kleiner.

Im letzten Schritt fügen wir die beiden Funktioen mit einem OR-Gate zusammen. Um den maximalen Ausschlag müssen wir uns hier keine Gedanken machen, da die Summe 1 nicht übersteigen und -1 nicht unterschreiten kann.

        <[string8][object][mixlinear]
            <[string8][Name][Input1orInput2]>
            <[string8][Input0][Input1enabled.Output]>
            <[string8][Input1][Input2enabled.Output]>
            <[float64][Weight0][1]>
            <[float64][Weight1][1]>
            <[float64][Offset][0]>
        >

Output:
Input1orInput2.Output: von -1 bis +1

Wir haben somit eine Funktion erschaffen mit der wir proportional zwischen zwei verschiedenen Inputs hin und her wechseln können.
Falls man das Ganze nicht proportional sondern nur als Schalter haben möchte, also definitiv nur einen der beiden Steuereingaben, dann muss man beim Switch eine “Stufe” einbauen, wie oben gezeigt.

Leave a comment

Your email address will not be published. Required fields are marked *