Wie man eine Anlage automatisiert und trotzdem - JS

Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
1
Wie man eine Anlage
automatisiert und trotzdem alles
vernünftig fährt und man sogar
selbst fahren kann
Eine kurze Beschreibung der jsTRF Rules und DriverCommands.
© JS 2006
Veröffentlichung nur auf js-home.org und Partnerseiten erlaubt.
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
2
Inhaltsverzeichnis
1.Wie man anfängt und was man braucht.................................................................................... 3
2.Nach dem Bauen....................................................................................................................... 4
3.Wir regeln die Regeln damit sie später alles regeln.................................................................. 5
3.1Fahrstraßen......................................................................................................................... 5
3.2Fahrstraßen wollen geschaltet werden................................................................................6
3.2.1DriverCommand „setpath“......................................................................................... 7
3.2.2Trigger steuern Fahrstraßen........................................................................................ 7
3.3Timetable/Fahrplan-Regel................................................................................................10
3.4Und wie war das mit dem selbst fahren?..........................................................................11
3.5Fahrstraßen im Betrieb ändern......................................................................................... 11
3.6Alle Fahrplan-Befehle...................................................................................................... 12
4.Zusätzliche Signalbilder..........................................................................................................14
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
3
1. Wie man anfängt und was man
braucht
Zuerst sollte man sich die nötigen Rules auf dem Rechner installieren, also am besten gleich
alle jsTRF-Rules (KUID 192081:) und Commands – kurz, alle Script.
Außerdem noch KUID 70791:9001, 206816:99003, 206816:99004 und 178892:80003 –
letztere ist optional und macht (noch) Probleme mit TRS2006.
Dann gehts ans bauen der Anlage, das wird hier mal nicht weiter beschrieben. Man sollte dabei
mit Signalen nicht geizen, kann sich also ruhig am Vorbild orientieren – ebenso mit den
Weichen. Ganz besonders toll sind Bahnsteige mit Passagierfunktion. Die sollte man auch
ruhig nutzen, sieht gut aus. Außerdem brauchen wir Portale, damit Züge entstehen.
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
4
2. Nach dem Bauen
Nach dem Bauen geht es an den Feinschliff – aber diesesmal nicht den optischen: Signale
brauchen Namen und es werden Trackmarks als Ziele benötigt:
•
Alle Signale, die vor Weichen stehen und damit eine Fahrstraße beginnen, brauchen
einen Namen. Über die Art der Namensgebung will ich dabei nichts sagen, das kann
jeder machen, wie er will – bei der DB werden die Signale vom 1. Esig beginnend mit A
durchbuchstabiert und dann vom 2. Esig vom Z rückwärts – das reicht zwar nicht immer,
aber dann muß man eben improvisieren. Für unseren Zweck sind vielleicht sprechendere
Namen sinnvoller, also z.B. alle Signale eines Bahnhofs schonmal mit einem Prefix, z.B.
für B-Stadt den Prefix „BS“. Dann noch eine sinnige Numerierung wie z.B. „E1“ fürs 1.
Esig, „A1a“ fürs Asig von Gleis 1 in die eine Richtung, „A1b“ für die andere.
•
Überhaupt brauchen alle Signale, die Teil einer Fahrstraße werden sollen, einen Namen.
•
Die Bahnsteige, an die Züge fahren sollen, brauchen außerdem Trackmarks als Ziele –
sprechende Namen sind da schon Pflicht, z.B. habe der Bahnhof „B-Stadt“ 3 Gleise: 1,
2, 3. Gleis 1 wird in Richtung C-Stadt nur befahren, 2 in die Gegenrichtung, also AStadt. Gleis 3 in beide Richtungen, da es aber neben 2 liegt sei seine „Hauptrichtung“
wie bei Gleis 2. Wir legen also nun 4 Trackmarks an:
B-Stadt Gleis 1a
am Ende von Gleis 1 Richtung C-Stadt
B-Stadt Gleis 2a
am Ende von Gleis 2 Richtung A-Stadt
B-Stadt Gleis 3a
am Ende von Gleis 3 Richtung A-Stadt
B-Stadt Gleis 3b
am Ende von Gleis 3 Richtung C-Stadt
Wir haben nun 4 Trackmarks, vorbei der Trackmark mit dem A am Ende immer die die
Hauptfahrtrichtung des Gleises liegt. Achja, Zeichen muß der Trackmark natürlich in
Fahrtrichtung, also weg vom Bahnsteig.
•
Wo wird schon Trackmarks legen, legen wir noch ein paar an. Gleis 1 und Gleis 2 sind
sehr lange Bahnsteige und so ein kurzer Regionalzug (Nahverkehrszug) mit 3
Wägelchen soll ja nicht unbedingt immer ganz vorn am Bahnsteigende halten – da ist ja
meist kein Dach mehr. Drum legen wir noch 2 Trackmarks jeweils ins vordere drittel,
also einige Wagenlängen hinter den anderen Trackmark: „B-Stadt Gleis 1a@4" und „BStadt Gleis 2a@4“ - was soll nun? Ein Zug mit 4 Wagen (z.B. 3 Wagen plus Lok) oder
weniger wird nun an diesem Trackmark halten, mit mehr Wagen am anderen - also sollte
der Platz dahinter groß genug für einen 3-Wagen-Lokzug sein.
•
So, dann brauchen die Portale, die Züge verschlucken sollen, noch einen Trackmark vor
der Einfahrt.
Das wars erstmal mit der Anlage, jetzt kommen die Regeln!
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
5
3. Wir regeln die Regeln damit sie
später alles regeln
3.1 Fahrstraßen
Zuerstmal gilt es die Fahrstraßen zu bestimmen. Dazu dient die Fahrweg-Rule („jsTRFFahrwege“), diese also hinzufügen. Fahrwege brauchen viel Platz, deshalb sollte man nicht
zuviele in eine Rule-Instanz packen. Als Orientierung gibt es eine Speicherplatzanzeige im
Fenster. Sollte diese zu 2/3 voll sein, sollte man besser eine neue Rule-Instanz hinzufügen und
dort weitere Fahrstraßen anlegen.
Fahrstraßen werden nach Bahnhöfen geordnet, ein Bahnhof ist nur in einer Rule-Instanz
sichtbar.
Also legen wir zuerst mal einen Bahnhof an.
Dann geht es auch gleich los mit den Fahrwegen. Dazu legen wir davon eine neue an. Der
Name ist erstmal egal, es kann also der Standardname übernommen werden. Diesen neuen
Fahrweg bearbeiten wird nun (EDIT-Knopf). Ein Fahrweg braucht ein Startsignal, ein neuer
Fahrweg hat sowas nicht, also sollte man es setzen (EDIT-Knopf). Aus der Liste wählt man
nun das richtige Signal aus, am besten fängt man ein Einfahrt-Signal eines Bahnhofs an.
Anschließend sieht man die Strecke hinter dem Signal im Fenster kompakt dargestellt.
Vermutlich führt sie nicht zum gewünschten Ziel. Fahrwege sollten immer an einem anderen
Signal enden. Über die Weichen-Knöpfe können Weichen umgestellt werden, so daß man sich
bis zum Ziel vorarbeiten kann. Kommen unterwegs Sperrsignale vor, die man vielleicht auch
als Teil der Fahrstraße haben möchte, drückt man den +-Knopf hinter dem Signal – wichtig:
das Signal muß dazu einen Namen haben, sonst geht das nicht.
Stimmt die Fahrstraße soweit, mal den Knopf mit diesem Pfeil hinter dem Namen des
Fahrwegs am oberen Rand drücken. Dies erzeugt einen automatischen Namen für die
Fahrstraße – bestehend aus Startsignal und dem Weg: entweder das Endsignal oder, wenn da,
einem Trackmark oder was anderem aussagekräftigem auf dem Weg. Wer das nicht mag, kann
den Namen auch selbst vergeben.
Speichern drücken nicht vergessen, sonst passiert nichts!
In der Liste muß man nun noch die Signalbilder einstellen – standardmäßig sind die rot, das
wäre aber nicht so günstig, wenn Züge fahren sollen. Dazu auf die Ampel hinter den
Signalnamen drücken. Hier gibts die erste Besonderheit: Vorsignale sind Teil einer anderen
Fahrstraße, stehen aber in der aktuellen. Diese muß man ebenfalls aufnehmen (müssen deshalb
einen Namen haben!), sonst endet die Fahrstraße zu früh. Aber wir dürfen diese nicht
verstellen. Dazu gibt es das Signalbild „leer“ auf dem Ampel, also alle Lichter aus (moderne
Vorsignale sind nicht als Signale sichtbar und brauchen deshalb nicht diese umständliche
Lösung).
Nun gibts noch eine nette Sache: Rot erzwingen. Dazu dient die Ampel hinter dem
Fahrstraßennamen. Ist die aus, ist diese Funktion aus, ist sie auch Rot, ist die Funktion an. Rot
erzwingen setzt alle Signale des Fahrwegs auf rot wenn keine Fahrstraße anliegt. Das ist ganz
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
6
günstig, da Trainz einem sonst schonmal dazwischenfunkt.
Leider funktionieren die eingestellten Signalbilder nicht bei alle Signalen – zumindest was
Grün und Gelb angeht. Signale, die eigene Setups haben, können sich da schonmal bockig
verhalten und stellen trotzdem ein anderes Bild ein. Dann muß man in deren Setup alles
weitere einstellen, damit das zusammenpaßt. Signale, die sogar das Signalbild ROT
eigenständig abschalten, muß man über unsichtbare Weichen, die standardmäßig eine Zugfahrt
verhindern, zur Kooperation überreden.
Jetzt kommt noch ein etwas kompliziertere Teil: „MX-Weichen“. Trainz kann mit Kreuzungen
nicht umgehen – oder besser, es ist ihm völlig egal. Den Zügen auch, aber dem Auge tuts weh!
Dazu gibts MX-Weichen für Fahrstraßen. Eine MX-Weiche ist eine gesperrte Weiche
außerhalb der Fahrstraße. Durch diese Sperre kann man jedoch andere Fahrstraßen daran
hindern, geschaltet zu werden bzw. können andere Fahrstraßen die aktuelle Fahrstraße darin
hintern:
Eine MX-Weichen zu einer Weiche der Fahrstraße muß ebenfalls frei sein, damit die
Fahrstraße geschaltet werden kann und sie wird dann freigegeben, wenn die Weiche selbst
freigegeben wird, also wenn der Zug drüber weggefahren ist.
Kommt noch die Alias-Gruppe:
Alias-Gruppen braucht man nur bei Ausfahrt-Fahrstraßen – zumindest machen sie da am
meisten Sinn. Diese Gruppen fassen mehrere Fahrstraßen zu einem Namen zusammen. Im
Driver wird dann unter diesem Gruppennamen automatisch die richtige Fahrstraße ausgewählt
– das sehen wir später im Detail. Eine Gruppe existiert nur innerhalb eines Bahnhofs. Zum
setzen einer Gruppe den Gruppen-Alias-Namen bzw. den Text, daß keiner gesetzt ist,
anklicken. Aus der Liste kann nun ein Gruppen-Name gewählt werden, die GruppenZugehörigkeit gelöscht werden („-- keine Gruppe“) oder eine neue Gruppe angelegt werden
(„-- neue Gruppe“), das dürfte bei einem neuen Bahnhof auch nötig sein. Eine neue Gruppe hat
nun einen ziemlich blöden Namen. Um ihn zu ändern den „Edit“-Knopf drücken und einen
Namen eingeben. Ein Gruppenname der dem Namen des Bahnhofs, in die alle Fahrstraßen
diese Gruppe führen, ist am geeignetsten.
Neue Signale-Features:
Einige neuere Signale bieten zusätzliche Signalbilder. Unterstützt ein Signal diese und wurde
für die Zusammenarbeit mit der Fahrweg-Regel ausgelegt, erscheint hinter der „Ampel“ für
das Signalbild ein weiteres Ampel-Symbol mit der Bezeichnung „Xtra“. Damit lassen sich
neben den normalen rot/gelb/grün Bildern die zusätzlichen Signalbilder des Signals für eine
Fahrstraße einstellen (siehe auch Kapitel 4).
Das war schon alles!
Ok, man kann eine Fahrstraße kopieren, sehr hilfreich beim Einfahrtsignal, denn da reicht
manchmal die Änderung einer Weiche und schon hat mal eine neue Fahrstraße fertig oder
wenn man ein anderes Signalbild für die selbe Fahrstraße haben möchte.
3.2 Fahrstraßen wollen geschaltet werden
Fahrstraßen kann man nun auf 2 Arten schalten:
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
7
1. von Hand über den DriverCommand „setpath“
2. per Trigger
3.2.1 DriverCommand „setpath“
Mit diesem Befehl versucht der Fahrer, eine Fahrstraße zu setzen. Dabei kann er warten oder
auch nicht. Die Fahrstraße wird jedenfalls, sobald frei, geschaltet, egal, ob er wartet oder nicht.
Statt direkt einer Fahrstraße kann auch eine Alias-Gruppe ausgewählt werden. Dann wird der
Fahrer die Fahrstraße zu schalten versuchen, die in seiner Fahrtrichtung beim nächsten Signal
vor ihm beginnt.
Coole Sache: gibt es mehrere Fahrstraßen, die dort beginnen und der gleichen Gruppe
angehören, wird er die Fahrstraße nehmen, die frei ist. Führen also 2 Wege zum gleichen Ziel
kann man so einen Zug automatisch auf den freien Weg schicken.
Ob man den Fahrer warten läßt, bis die Fahrstraße da ist oder nicht, ist Geschmackssache.
Während er wartet, kann er nichts andere machen. Wartet er nicht, kann er z.B. die Türen
öffnen oder schließen oder losfahren. Letzeres wäre fatal wenn die Fahrstraße noch gar nicht
da ist – zumindest sieht es blöd aus. Deshalb gibts dazu den „Warte bis nicht mehr Rot“
DriverCommand.
Die Idee dabei ist diese: Ein Zug soll 2 Minuten Aufenthalt haben. Also wäre ein „warte 2
Minuten“ das beste. Was aber, wenn die Fahrstraße nicht sofort geschaltet werden kann? Dann
dauert der Aufenthalt länger. Vielleicht unnötig länger, denn falls die Fahrstraße erst nach 1
Minute frei ist, hat er 3 Minuten Aufenthalt. Hätte aber ruhig nur 2 haben könne. Andererseits,
wenn die Fahrstraße selbst nach 2 Minuten nicht frei ist, soll er ja nicht gleich losfahren.
Die Lösung: Türen auf, setpath ohne Warten, warten 2 Minuten, warten bis nicht mehr rot,
Türen zu, losfahren.
3.2.2 Trigger steuern Fahrstraßen
Nun ist es auch nicht immer so toll, die Fahrstraße selbst schalten zu müssen: Wenn ein Zug
einen Bahnhof anfährt will er noch nicht einige Kilometer vorher erstmal selbst seine
Fahrstraßen schalten.
Dazu hat Auran Trigger erfunden und dazu habe ich sie benutzt:
FahrwegTrigger („jsTRF-FahrwegTrigger“)
Diese Rule nun hinzufügen.
Die Idee dahinter ist denkbar einfach: Ein Zug bekommt den Befehl, zu einem Trackmark zu
fahren. Und wir stellen unterwegs einige Trigger aus und wenn er dort drüber fährt schalten
wir die nötigen Fahrstraßen, damit er zu seinem Ziel kommt.
3.2.2.1 Vorbereitung
Ok, nun haben wir die Rule drin und vielleicht schon geöffnet – aber wir haben ja noch gar
keine Trigger gesetzt. Das holen wir jetzt erstmal nach, also Rule-Editor wieder schließen.
Trigger wollen gut plaziert sein:
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
•
weit genug vor dem Esig eines Bahnhofs
•
nicht zuweit weg, sonst könnte es andere Züge behindern
8
Ein guter Kompromiß bei normalen Zügen ist 1 ½ Blocksignale vor dem Esig – also ein gutes
Stück vor dem Vorsignal des Esig. Dann kommt der Trainz-Fahrer auch nicht durch seinen
Röntgenblick auf die Idee wegen des roten Signals schonmal die Bremsen anzuwärmen.
Trigger brauchen Namen, der FahrwegTrigger braucht Trigger mit guten Namen. Gute Namen
haben ein (einstellbares) Prefix oder Namensmuster.
Außerdem brauchen wir nur Trigger für die Einfahrt in einen Bahnhof, raus benutzen wir den
setpath Befehl – fürs erste.
Also einige Trigger wie beschrieben weit weg von der 1. Fahrstraße eines Bahnhofs. Als
Namesmuster wählen wir „FW Trigger“ und dahinter dann etwas sprechendes wie ein Kürzel
des Bahnhofs, zu dem der Trigger führt und dann noch ein Kürzel des Bahnhofs, von dem das
Gleis kommt, z.B. „FW Trigger BS AS“ für einen Trigger auf dem Gleis vor dem Bahnhof „BStadt“ aus Richtung „A-Stadt“.
Das machen wir dann nun mal für alle Bahnhöfe, ich geh solange eMails lesen, bis das fertig
ist....
3.2.2.2 Trigger verknüpfen
Schon fertig? Naja, war auch nicht viel Mail da, n paar Dinger aus dem Forum, das kommt
später...
Ok, die Trigger sind da, zurück in die FahrwegTrigger Rule.
Direkt auf der erste Seite unten steht was von Namensmuster – klingelts? Das sollten wir nun
so ändern, wie wir das bei den Triggern benutzt haben. Das ist ganz hilfreich, denn Trigger
gibts massig auch ohne Fahrweg-Trigger! Wie der Name Muster schon sagt, reicht es nicht,
nur den Text einzugeben, man muß ein Suchmuster eingeben. Das kennt man doch von
Dateinamen: „*“ als Platzhalter für „alles beliebige“. Es gibts noch mehr als „*“, Details dazu
in der Hilfe in der Rule. Dummerweise geht der Stern bei Trainz nicht einzugeben. Deswegen
muß man ein Ausrufezeichen „!“ eingeben. Das wird dann zu einem Stern umgesetzt. Im
Beispiel geben wir „FW Trigger!“ ein und sehen „FW Trigger*“ nach dem OK.
Dann gehts auch schon los. Die Bahnhöfe wurden bereits von den Fahrstraßen übernommen.
Nun fügen wir einen neuen Trigger hinzu. Dann setzen wir dafür einige Fahrstraßen, die dieser
schalten soll. Schließlich wird für jede Fahrstraße ein oder mehrere Ziele definiert. Ziele
können alle Trackmarks sein, die angefahren werden sollen oder, viel besser, Suchmuster.
Also statt „A-Stadt Gleis 1“ und „A-Stadt Gleis 2“ angeben zu müssen, reicht ein „A-Stadt
Gleis *“.
Kann die Regel später im Driver kein passendes Ziel finden, kann sie eine Default-Fahrstraße
nehmen, dazu dient der kleine runde Schalter. Das ist aber nicht immer günstig, hängt von der
Situation ob, z.B. reagiert der Trigger nicht richtungsabhängig, da kann ein Default schonmal
ungünstig sein. Der Schalter dahinter sollte immer abgehakt sein!
Hier wären wir im einfachen Fall damit fertig...
Aber es geht noch mehr:
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
•
Unter-Fahrstraßen
•
Funktionen
9
Unter-Fahrstraßen sind Fahrstraßen, die geschaltet werden, wenn deren übergeordnete
Fahrstraße erfolgreich geschaltet wurde. Ein Beispiel:
Ein Bahnhof A-Stadt hat 2 Gleise, die auch aus unserer Beispielrichtung beide befahren
werden können, die Fahrstraßen heißen „Esig1 Gleis 1“ und „Esig1 Gleis 2“. Und dahinter
gibt es 2 Fahrstraßen, die den Bahnhof wieder verlassen „A1 weg“ von Gleis 1 aus und „A2
weg“ von Gleise 2 aus.
Dem Trigger für die Einfahrt geben wir nun erstmal 2 Fahrstraßen und die Ziele:
Esig1 Gleis 1
Gleis 1
Esig1 Gleis 2
Gleis 2
Damit kann nun ein Zug einfahren und er selbst muß dann per DriverCommand setpath die
„A1 weg“ oder „A2 weg“ setzen – oder noch besser, wenn beide in einer Alias-Gruppe sind,
muß nur noch „Richtung weg“ setzen.
Aber was ist mit durchfahrenden Zügen? Dazu eine 3. Regel mit Unterpfad, dann haben wir
insgesamt:
Esig1 Gleis 1
Gleis 1
Esig1 Gleis 2
Gleis 2
Esig1 Gleis 1
A1 weg
Für die 3. haben wir hier jetzt kein Ziel, das könnte nun entweder als Default gesetzt werden
oder aber bzw. zusätzlich könnte man die Gleisnamen von anderen Bahnhöfen angeben, zu
dem die durchfahrenden Züge fahren.
Bleiben noch die Funktionen: Funktionen werden so wie Trigger angelegt und mit Fahrstraßen
und Zielen versehen. Funktionen kann man dann von Triggern „aufrufen“ lassen. So kann man
sich in manchen Situationen etwas Arbeit ersparen indem man Dinge nur 1x definieren muß.
Funktionen werden zielabhängig aufgerufen werden, also statt einer Fahrstraße.
Das wars auch schon damit.
Eigentlich könnte man jetzt schon loslegen und fahren lassen. Und bevor es die TimetableRule gab, war das auch so nötig. Und es ist auch durchaus von Vorteil, das mal zu machen, um
dann den Ablauf der Timetable-Rule besser zu verstehen.
Im Prinzip muß man den Fahrern nun diese Befehlsfolge geben: Autodrive zu einem
Trackmark eines Bahnsteigs, dort warten, wenn nötig per setpath die Fahrstraße zum Verlassen
setzen lassen und dann weitefahren zum nächsten Trackmark.
Was hat des noch mit diesem Haken-Schalter auf sich? Damit kann eine Fahrstraße
abgeschaltet werden. Wozu soll das gut sein? Zu einem zum Testen, zum anderen werden wir
das später sehen (Kapitel 3.5).
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
10
3.3 Timetable/Fahrplan-Regel
Genau das, was da drüber so einfach steht, macht die Fahrplan-Regel („jsTRF-Fahrplan“) auch
„nur“. Nur macht sie es etwas eleganter und vereinfacht die Arbeit und Wartung – und sie
ermöglicht die manuelle Steuerung der Lok!
Aber vorher ein paar Vorarbeiten, die nicht zwingend sind, aber den Komfort erhöhen:
•
Die „DestSignTable“ Rule hinzufügen und dort einige Zieltexte eingeben, die später auf
den Zielschildern der Züge erscheinen sollen – sofern die verwendeten Züge das können.
•
Die ScheduleLib („jsTRF-Fahrauftragssammlung“) hinzufügen – dort kann man nämlich
Befehlsfolgen ablegen um sie leicher wiederverwenden zu können. Im Moment brauchen
wir aber noch keine. Aber vielleicht später am Ende des Tutoriums.
So, nun aber die Fahrplan-Regel hinzu und bearbeitet.
Fahrpläne in der Rule sind eine simple Sache und haben ein einfaches Prinzip:
•
„fahre irgendwohin, tu da was“
•
mach nochmal was woanders
Legen wir mal einen neuen Fahrplan an, geben ihm einen guten Namen und dann bearbeiten
wir ihn.
Es gibt zur Zeit 7 mögliche Fahrplan-Befehle (Detaillierte Beschreibung in Kapitel 3.6):
•
Copy Commands (copycommand)
•
Drive and Load (driveload)
•
Use other timetable (nexttimetable)
•
Portal and Exit (portalexit)
•
Restart (restart)
•
Shunting
•
Other timetable by variable value (nextbyvariable)
•
If by variable value (ifbyvariable)
•
If by driver name (ifbydrivername)
Und selbst davon braucht man normalerweise nur 3, davon einen ganz oft.
Aber bauen wir unseren Fahrplan weiter. Dazu einen „driveload“ hinzufügen – das ist nämlich
der wichtigsten.
Dort gibt man nun das Fahrziel des Zugs an, dann die Wartezeit am Ziel, ob er die
Fahrtrichtung ändern soll nach den Ankunft, die Zugzielanzeige, eine Fahrstraße oder
vielleicht sogar Befehle aus der ScheduleLib ausführen soll.
Nungut, erstmal ein Fahrziel, also unser Trackmark für Gleis 1a in B-Stadt. Dort soll der Zug
dann 2 Minuten warten. Zum verlassen braucht er eine Fahrstraße, diese setzen wir anhand der
Gruppe – „B-Stadt C-Stadt“ wäre das richtig hier. Wichtig für die Optik ist noch die Seite an
der der Bahnsteig ist, damit sich die Türen richtig öffnen.
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
11
Das war schon der 1. Eintrag, nun gleich nochmal einen „driveload“ hinzu. Als Fahrziel Gleis
2a in C-Stadt (da führt Gleis 1 ja hin, siehe oben). Als Wartezeit setzen wir dort mal 5
Minuten, außerdem ändern wir die Fahrtrichtung und die Zugzielanzeige und dann brauchen
wir eine Fahrstraßengruppe zum rauskommen, Gruppe „B-Stadt“ (Auswahl „C-Stadt BStadt“). So, jetzt noch einen 3. Eintrag: „portalexit“. Dort wählen wir ein Portal und dann den
Trackmark, der davor liegt.
Was haben wir nun gemacht?
Es wird folgendes passieren: Gar nichts. Es fehlt noch was!
Wir müssen diesen Fahrplan einem Zug bzw. dessen Fahrer geben – entweder direkt oder über
ScheduleLib oder Portal. Jedenfalls muß der Fahrer den DriverCommand „UseTimetable“ mit
diesem Fahrplan ausführen. Das führt dazu, daß der Fahrplan hinten (!) an alle bestehenden
Befehle des Fahrers angehängt wird.
Gut, aber was passiert nun?
Der Fahrer führt den Befehl „UseTimetable“ aus. Dieser hängt nun anhand oben definiertem
Fahrplan einige neue Befehle an: Den Befehl, daß der Zug zu dem 1. Trackmark fährt („BStadt Gleis 1a“, die Türen auf der Seite aufmacht, die eingestellt wurde, dann einige Zeit
wartet, eine Fahrstraße für die Ausfahrt setzt, nochmal etwas wartet bis die Wartezeit 2
Minuten insgesamt rum ist. Dann prüft der Fahrer, ob er grün hat, macht die Türen zu und
fährt zum nächsten Trackmark, „C-Stadt Gleis 2a“. Dort angekommen, wieder Türen auf,
etwas warten, Richtung wechseln (der Fahrer sitzt im Steuerwagen sofern vorhanden), noch
etwas warten, Fahrstraße, warten, auf grün prüfen, Türen zu, losfahren. Kommt er nun am
Trackmark vor dem Portal an, fährt es in das Portal und der Zug ist weg.
3.4 Und wie war das mit dem selbst fahren?
Hat der Fahrer im Driver seinen Fahrplan bekommen, kann man auch selbst fahren. Dazu mal
die Taste „k“ drücken (Tastatur!). Im erscheinenden Fenster die Falte „Manual Drive“ öffnen
(das „+“ davor drücken“. Nun muß man den Zug mit der Kamera ausgewählt haben, den man
fahren will. Dann erscheint hier die Möglichkeit, den Zug selbst zu fahren. Dort kann man das
dann auch wieder beenden. Wenn der Zug nun laut Fahrplan fahren soll, kann man das dann
selbst machen.
3.5 Fahrstraßen im Betrieb ändern
Kommen wir zu diesem Haken-Schalter in der Fahrweg-Trigger (PathTrigger) Rule. Wie
gesagt, sollte der im Normalfall gesetzt sein. Dann schaltet eine Fahrstraße automatisch. Ist der
Haken weg, wird die Fahrstraße nicht beachtet. Das kann man aber im laufenden Betrieb
ändern. Dazu dient ebenfalls das „K“-Fenster. Dort die Falte „PathTrigger“ öffnen. Es
erscheint eine Liste aller definierten Trigger. Diese können nun ebenfalls geöffnet werden und
dann sieht man die Fahrstraßen und Ziele des Triggers und wieder den Haken-Schalter und den
runden Knopf. Der runde Knopf ist, wie vorher, der Default-Schalter und ermöglicht die
Änderung der Default-Fahrstraße im Betrieb (diese Änderungen werden jedoch nicht
gespeichert!). Außerdem kann über den Haken-Schalter (nah, schon eine Vermutung?) eine
Fahrstraße im Betrieb ein- oder ausgeschaltet werden. Wozu das gut ist? Man könnte z.B. so
dynamisch eingreifen um Züge umzuleiten (sofern man die nötigen Fahrstraßen vorder im
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
12
Editor definiert hat und diese dann am besten abgeschaltet hat).
3.6 Alle Fahrplan-Befehle
Hier eine kurze Beschreibung alle verfügbaren Fahrplan-Befehle.
Befehl
Drive and Load
(driveload)
Restart
Verwendung
Fährt einen Zug zu einem Ziel, öffnet
die Türen, ändern auf Wunsch
Zugschilder und Fahrtrichtung, wartet,
erlaubt CopyCommand vor und nach
warten, setzt auf Wunsch Fahrstraße.
Startet Fahrplan vom Anfang.
Fahrplaneinträge danach
werden nicht ausgeführt!
Fährt einen Zug zu einem Trackmark,
dann in ein Portal – der Trackmark
sollte deshalb vor dem Portal sein.
Falls der Zug im Portal für
immer verschindet werden
keine Fahrplaneinträge danach
mehr ausgeführt!
Fährt optional zu einem Trackmark,
führt dann CopyCommand aus.
Nach CopyCommand wird
Fahrplan weiter ausgeführt!
(restart)
Portal and Exit
(portalexit)
Copy Commands
(copycommand)
Use other
timetable
Besonderheiten
Erlaubt den Wechsel zu einem anderen Fahrplaneinträge danach
Fahrplan.
werden nicht ausgeführt!
(nexttimetable)
Shunting
Wie „Drive and Load“ aber ohne Load
– ein Zug fährt zu einem Ziel, öffnet
jedoch keine Türen, ändern aber auf
Wunsch Zugschilder und Fahrtrichtung,
wartet, erlaubt CopyCommand und
setzt eine Fahrstraße
Other timetable by Erlaubt den Wechsel zu einem von bis Fahrplaneinträge danach
zu 5 verschiedenen Fahrplänen anhand werden nicht immer
variable value
des Werts einer Session-Variable (0 für ausgeführt!
(nextbyvariable)
1. Fahrplan, 1 für 2. usw.). Der Wert
kann dabei gleich oder größer-gleich
sein (wählbar). Paßt der Wert nicht (nur
bei Prüfung auf Gleichheit möglich),
wird der Fahrplan dahinter weiter
ausgeführt.
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
Befehl
If by variable
value
(ifbyvariable)
If by driver name
(ifbydrivername)
Dummy
Verwendung
13
Besonderheiten
Wenn-dann-Befehl. Der Vergleich mit
einer Session-Variable (Vergleichart
wählbar) mit einem numerischen Wert
bewirkt die Fortsetzung des Fahrplans
bei Gültigkeit des Vergleichs direkt
hinter dem Befehl, ansonsten hinter
dem Befehl „sonst“, der ebenfalls
hinzugefügt wird. Danach wird der
Fahrplan hinter dem „ende wenn“
Befehl fortgesetzt (wird auch
hinzugefügt).
Fügt gleich 3 Befehle ein:
wenn, sonst, ende wenn (if,
else, endif). Dazwischen
müssen dann die Befehle.
Wenn-dann-Befehl. Der Vergleich mit
dem Namen des Fahrers des Fahrplan
(Vergleich wählbar: gleich oder
ungleich, Muster oder ungleich Muster)
bewirkt die Fortsetzung des Fahrplans
bei Gültigkeit des Vergleichs direkt
hinter dem Befehl, ansonsten hinter
dem Befehl „sonst“, der ebenfalls
hinzugefügt wird. Danach wird der
Fahrplan hinter dem „ende wenn“
Befehl fortgesetzt (wird auch
hinzugefügt).
Fügt gleich 3 Befehle ein:
wenn, sonst, ende wenn (if,
else, endif). Dazwischen
müssen dann die Befehle.
Macht nichts, führt nächsten Fahrplan
aus.
Als (optischer) Separator
geeignet.
If-Befehle dürfen nicht
ineinander verschachtelt
werden!
If-Befehle dürfen nicht
ineinander verschachtelt
werden!
(dummy)
CopyCommand führt Befehle aus der Schedule-Library (Fahrerauftragssammlung) aus, die
Befehle werden dabei eingefügt, nicht hinten angehängt.
© JS 2006
Wie man eine Anlage automatisiert und trotzdem alles vernünftig
fährt und man sogar selbst fahren kann
14
4. Zusätzliche Signalbilder
Die Funktion der zusätzliche Signalbilder über die Fahrweg-Regel erfordert einige
Anpassungen am Signal durch den Ersteller. Eine Beschreibung des Verfahrens ist verfügbar
und wurde so bereits von einigen Signalerbauern umgesetzt. Je mehr Signale dieses Verfahren
unterstützen, desto besser für den Anlagenerbauer.
© JS 2006