Stack??
Bitte beachte, dass OMSI nicht mehr weiterentwickelt wird. Ein Teil der Entwickler widmet sich inzwischen der Entwicklung eines neuen Simulators. Weitere Informationen zum LOTUS-Simulator findest Du hier.
-
-
Der Stack ist der Speicher, in dem deine Werte sind. Stack (Stapel) deshalb, weil du immer nur auf das oberste Element zugreifen kannst (LIFO-Prinzip). Jeder Ausdruck führt eine Operation auf dem Stack aus. Z.B. packt der Ausdruck '3' die 3 oben auf den Stack. Der Ausdruck '(L.L.var)' packt den Wert der Variable var oben auf den Stack. Der Ausdruck '+' addiert die 2 obersten Stackwerte und packt das Ergebnis oben auf den Stack usw. Daher wird auch die Postfix-Notation verwendet. Jeder Ausdruck hat einen unmittelbaren Einfluss auf die Werte im Stack. Hilfreich ist vielleicht, sich den Stack am Anfang einmal anhand von Beispielen aufzuzeichnen:
-
Hallo. Danke für deine Antwort.
Kannst du mir ein Beispiel nennen, wo man so einen Stack benutzt?
LG
Jonny03HD -
Du nutzt den Stack IMMER. Das ist keine Sache, die du einsetzt, weil es gerade nützlich ist. Ein Beispiel ist schon in meinem letzten Post. Ein weiteres wäre z.B.
Der Stack dazu würde folgendermaßen genutzt werden:Code- Leerer Stack am Anfang:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- / | / | / | / | / | / | / | /
- Die 5 wird auf den Stack geschoben:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 5 | / | / | / | / | / | / | /
- Speichern der 5 in var1 ändert den Stack nicht:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 5 | / | / | / | / | / | / | /
- Die 8 wird auf den Stack geschoben:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 8 | 5 | / | / | / | / | / | /
- Speichern der 8 in var2 ändert den Stack nicht:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 8 | 5 | / | / | / | / | / | /
- Der Wert von var1 wird auf den Stack geschoben:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 5 | 8 | 5 | / | / | / | / | /
- Der Wert von var2 wird auf den Stack geschoben:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 8 | 5 | 8 | 5 | / | / | / | /
- + nimmt die beiden obersten Werte und schiebt ihre Summe auf den Stack:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 13| 8 | 5 | / | / | / | / | /
- Die 4 wird auf den Stack geschoben:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 4 | 13| 8 | 5 | / | / | / | /
- * nimmt die beiden obersten Werte und schiebt ihr Produkt auf den Stack:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 52| 8 | 5 | / | / | / | / | /
- Speichern der 52 in var3 ändert den Stack nicht:
- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
- ---+---+---+---+---+---+---+---
- 52| 8 | 5 | / | / | / | / | /
-
Ich versuche die Sache mal ganz einfach mit einem Beispiel zu erklären.
Als Beispiel nehme ich die Abfahrtskontrolle aus einem Bus. Diese soll leuchten wenn mehrere Gegebenheiten auch vorhanden sind. Es gibt zwei Schreibweisen, was es etwas unklar macht. Aber im Grunde ist es immer das selbe. Der Einfachheit arbeite ich nur mit zwei Ergebnissen (Null [unwahr] oder [Eins Wahr]).
(L.L.Haltestellenbremse) !
(L.L.Feststellbremse) ! &&
(L.L.Tür_0) 0.2 < &&
(L.L.Tür_1) 0.2 < &&
(L.L.Motordrehzahl) 100 > &&
(L.L.Geschwindigkeit) 20 < &&
(L.L.Batteriestrom) &&
(L.L.Türentriegelung) ! &&
(L.L.Gangvorwahl) 0 > &&
(S.L.Abfahrlicht)Hier habe ich nun 9 Variablen die von Omsi berechnet werden sollen. Da man aber nur 8 Stackplätze hat, ist das ist einzigste Schreibweise, die man nutzen kann. Hier wird immer wieder Ein Wert eingetragen und dann berechnet. Das Ergebniss bleibt dann immer auf Stack 0.Die Rechnung sieht dann wie folgt aus:
Variable_A UND Variable_B = Ergebniss_X UND Variable_C = Ergebniss_X UND Variable_D = Ergebniss_X .... usw
Solange alle eingelesenen Variablen (L.L.Var) eine Eins haben, wird auch das Ergebniss immer Eins sein. Ist eine Null drin, bleibt das Ergebniss eine Null.
Jede Variable wird auf Stack 0 eingetragen. Kommt eine neue Variable dazu, geht der Eintrag von Stack 0 auf Stack 1 und dann wird gerechnet. Ergebniss kommt auf Stack 0. Kommt wieder eine Variable dazu, wird das Ergebniss auf Stack 1 gestellt, die neue Variable auf Stack 0 und wieder gerechnet.
(L.L.Haltestellenbremse) !
(L.L.Feststellbremse) !
(L.L.Tür_0) 0.2 <
(L.L.Tür_1) 0.2 <
(L.L.Motordrehzahl) 100 >
(L.L.Geschwindigkeit) 20 <
(L.L.Batteriestrom)
(L.L.Türentriegelung) ! && && && && && && &&
(S.L.Abfahrlicht)
Hier sind nur maximal 8 Variablen möglich. Hier wird anders gerechnet. Jeder eingelesener Wert wird immer auf Stack 0 eingetragen. Mit jedem neuen Wert, fallen die bereits eingetragenen Werte auf den nächst höheren Stack. Am Ende wird zusammen grechnet:
Stack 0 UND Stack 1 UND Stack 2 UND Stack 3 UND usw. UND Stack 7 = Ergebniss_X. Das Ergebniss kommt dann auf Stack 0.Sollte soweit klar sein, oder? Stellst du in der zweiten Möglichkeit mehr Variablen rein, ist das nicht schlimm, aber du bekommst ein falsches Ergebniss, weil die oberen Variablen, mit jeder neuen Variable unter rausfallen. Es können immer nur maximal 8 Stacks beschrieben werden. Kommt oben noch eine 9. oder 10. Variable dazu, dann fliegt zu erst der Wert der Haltestellenbremse raus und dann der Wert der Feststellbremse. Diese werden nicht mitberechnet, weil sie nichtmehr da sind.
In der ersten Möglichkeit kann ich sehr viele Variablen eintragen, in der zweitem maximal 8. Willst du in der zweiten Möglichkeit (was hier keinen Sinn macht) weitere Variablen einrechnen, mußt du mit "sogenannten" Schattenvariablen weitere Ergebnisse eintragen:
(L.L.Haltestellenbremse) !
(L.L.Feststellbremse) !
(L.L.Tür_0) 0.2 <
(L.L.Tür_1) 0.2 <
(L.L.Motordrehzahl) 100 >
(L.L.Geschwindigkeit) 20 <
(L.L.Batteriestrom)
(L.L.Türentriegelung) ! && && && && && && &&
(S.L.Abfahrlicht_0)Dann erstellst du einen weiteren Stackkontainer.
(L.L.Zuendschluesselstellung) 0 >
(L.L.Fehlerleuchte) !
(L.L.Aussenklappe) !
(L.L.Fahrergurt)
(L.L.Testbutton) && && &&
(S.L.Abfahrlicht_1)Nun kannst du beide "sogenannte" Schattenvariablen zusammen rechnen lassen:
(L.L.Abfahrtlicht_0)
(L.L.Abfahrtlicht_1) &&
(S.L.Abfahrtlicht)Jede einzelne Variable (S.L.Variable) wird in einem neuen Stackkontainer berechnet. Die Ergebnisse jedes einzelnen Stackkontainers kannst du in der Datei "laststn.osc" in der Mapdatei einsehen. Du kannst dir das Zusammenrechnen des letzten Stackkontainers hier sparen, weil du den ersten Stackkontainer (Abfahrtlicht_0) bereits mit einrechnen kannst.
(L.L.Abfahrtlicht_0)
(L.L.Zuendschluesselstellung) 0 >
(L.L.Fehlerleuchte) !
(L.L.Aussenklappe) !
(L.L.Fahrergurt)
(L.L.Testbutton) && && &&
(S.L.Abfahrlicht)Wie schon gesagt, macht das bei diesem Beispiel keinen Sinn. Es ist nur ein Beispiel. Solche Schattenbefehle habe ich im MB O 307 V2 und MB O 407 genutzt, weil ich bei der Notlichtschaltung einfach andere Werte des Batteriestroms benötigt habe.
Es sollte die Stacknutzung aber recht gut verdeutlichen.
-
Man kann sich den Stack wie einen Bücherstapel von oben vorstellen. Du tust auf den Bücherstapel immer ein Buch drauf und siehst nur das oberste Buch.
-
Danke für deine Antwort, Tatra.
Hat sehr geholfen.
LG
Jonny03HD