Fahrstrassenschaltung_FS2 - ein Modul und ein kleines Lua-Tutorial

ACHTUNG: Dieses Modul benötigt EEP17.1 UND das Plug-in 1 dazu, EEP18 oder höher.

Im Unterschied zu den bisherigen Fahrstraßenschaltungen benutzt diese keine Datenslots. Dadurch entfällt die Limitierung von 1.000 Speicherplätzen und damit evtl. die Nutzung der gleichen ID für FS-Signal und Datenslot. Außerdem werden nicht alle Fahrstraßen zyklisch abgefragt, ob sie geschaltet werden sollen, sondern nur die zur Schaltung "angeforderten". Dazu geschieht dies in der Reihenfolge der zeitlichen Anmeldung. Dadurch werden nicht die Fahrstraßen bevorzugt, die in der Liste der Fahrstraßen-Signale vorne stehen. Weiterhin wird nur 1 Kontaktpunkt zur Anmeldung der Fahrstraße benötigt. Das Modul löst die Anmeldung (NICHT die Fahrstraße!) sofort nach der Schaltung selbständig auf. Bei mehr als 1 Fahrstraßenziel erfolgt die Auswahl über Routen. Um das zu erreichen, sind aber keine Lua-Kenntnisse nötig. D.h., Sie müssen dafür keine Funktion(en) schreiben.

Allerdings benötigt das Modul eine (1) beliebige Immobile oder beliebiges Landschaftselement.

File

Fahrstrassenschaltung_FS2

Dieses Modul benötigt EEP17.1 UND das Plug-in 1 dazu, EEP18 oder höher.

Fried

Aug 8th 2023

Installieren Sie "Fahrstrassenschaltung_FS2.zip" über den internen EEP-Installer.

Öffnen Sie danach in dem FS2-Ordner im LUA-Verzeichnis ihrer genutzten EEP-Installation die Datei "FS_Basisskript.lua. Kopieren sie den kompletten Inhalt in die Zwischenablage. Öffnen Sie die Lua-Datei Ihrer Anlage, z.B. "MeineAnlage.lua", und fügen Sie dort das kopierte Skript unterhalb der Zeile clearlog() und oberhalb der Funktion EEPMain() ein.

clearlog()

-- Liste aller Fahrstraßensignale
FS_Signale = {}
-- Routenzuordnung für Fahrstraßen mit mehreren Zielen, in der
   Ziel-Reihenfolge 1, 2, ...
FS_Routenziele = {
}
-- ID der Immobilie bzw. des Landschaftselementtes zur 
   TagText-Speicherung der angemeldeten Fahrstraßen
FS_Speicher = "#1"
-- Einbindung desFahrstraßenmoduls
require("FS2\\Fahrstrassenschaltung_FS2")

Fügen Sie nun zwischen die geschweiften Klammern {} hinter FS_Signale = die Signal-IDs ALLER Fahrstraßensignale jeweils gefolgt von einem Komma "," ein.

Haben Sie Fahrstraßen mit mehreren Zielen, fügen Sie zwischen den Zeilen FS_Routenziele = { und } jeweils eine Leerzeile ein. In die Zeile schreiben Sie [] = {}. Zwischen das eckige Klammerpaar [] schreiben Sie nun die Signal-ID des entsprechenden Fahrstraßensignals. Dann schreiben Sie zwischen die geschweiften Klammern {} in der Reihenfolge der Zielnummern 1,2,3,.. jeweils in Anführungszeichen gefolgt von einem Komma ',' die entsprechenden Routen, z.B. "Personenzug","Eilzug",.

Sollen mehrere Routen zu 1 Ziel führen, so setzen Sie an der Stelle zunächst ein geschweiftes Klammerpaar {}. In dieses Klammerpaar schreiben Sie nun – wie vorgehend beschrieben – die Routen für dieses Ziel.

Da sich in der Anlage ja mindestens eine Immobilie oder ein Landschaftselement befinden muss, ist dieses bzw. das erste als Speicher für die angemeldeten Fahrstraßen vordefiniert. Es empfiehlt sich jedoch, hierfür nicht irgendein Modell auszuwählen, sondern eines mit Wiedererkennungswert für diese Aufgabe. Das könnte z.B. das Gebäude des Hauptbahnhofs oder des Bahnhofes mit den meisten Fahrstraßen sein. Die ID entnehmen Sie den Objekteigenschaften des Modells und tragen sie anstatt #1 innerhalb der Anführungszeichen hinter FS_Speicher = ein. Achtung, diese ID beginnt immer mit dem #-Zeichen.

ACHTUNG: Die Anweisung require("FS2\\Fahrstrassenschaltung_FS2") muss unterhalb der Zeile mit FS_Speicher = stehen.

Scrollen Sie nun runter zur Zeile function EEPMain(). Fügen Sie darunter die Zeile FSschalten() ein.

Damit sollte Ihr "MeineAnlage.lua"-Datei mindestens so aussehen:

clearlog()

-- Liste aller Fahrstraßensignale
FS_Signale = {84,86,101,113,121,125} 
-- Routenzuordnung für Fahrstraßen mit mehreren Zielen, in der Reihenfolge 1, 2, ...
FS_Routenziele = {
    [86]  = {"Schnellzug","Personenzug","Güterzug",}
    [121] = {"Schnellzug",{"Eilzug","Personenzug"},"Güterzug",
} 
-- ID der Immobilie bzw. des Landschaftselementtes zur TagText-Speicherung der angemeldeten Fahrstraßen
FS_Speicher = "#1"
-- Einbindung des Fahrstraßenmoduls
require("FS2\\Fahrstrassenschaltung_FS2")

function EEPMain()
    FSschalten()
    return 1
end

Setzen Sie nun in einiger Entfernung vor das Fahrstraßensignal einen Sound-Kontaktpunkt und tragen darin unter Lua-Funktion FSanmelden_000 (ohne Klammern dahinter) ein, wobei Sie anstatt 000 die ID des Fahrstraßensignals eintragen.

Das war es auch schon.

Sollten Sie die Fahrstraße z.B. hinter einem großen Weichenfeld vorzeitig auflösen wollen, stellt Ihnen dafür das Modul die Funktion FSaufloesen_000 zur Verfügung. Diese können Sie ebenfalls an geeigneter Stelle in einen Sound-Kontakt eintragen, natürlich auch hier ohne Klammern dahinter und mit der ID des Fahrstraßensignals anstatt 000.

Sollten Sie eine bestehende Anlage mit diesem Skript ergänzen oder austauschen wollen, so machen Sie das unbedingt in einer ruhenden Anlage ohne Verkehr. Achten Sie außerdem darauf, dass kein Fahrzeug zwischen dem Anforderungskontaktpunkt und dem Fahrstraßensignal steht.

Ich wünsche euch viel Spaß mit dem Modul.

Für die, die nicht nur das Modul blind nutzen möchten, sondern damit auch ihre ersten Lua-Kenntnisse erwerben oder sie eventuell erweitern möchten.

Das Skript beginnt zunächst mit einer Beschreibung. Die sind als sogenannte Kommentare ausgeführt. Ein einzeiliger Kommentar beginnt mit 2 Minuszeichen --, egal wo er beginnt, am Zeilen Anfang oder hinter Lua-Code.

Für mehrzeilige Kommentare schreibt man in der 1. Kommentarzeile hinter die beiden Minuszeichen zweimal die öffnende eckige Klammer --[[ und am Ende des mehrzeiligen Kommentars 2 Minuszeichen mit 2 schließenden eckigen Klammer --]].

In Lua sind alles Variablen. Je nach ihrem zugewiesenen Wert gehören sie einem bestimmten Typ an. Einer Variablen weist man mit einem Gleichheitszeichen einen Wert zu.

Variablenname = Wert

Lua-Variablen können sogar im Laufe eines Skriptes ihren Typ ändern. Auf die einzelnen Typen gehe ich während der Abhandlung des Codes genauer ein.

Das Modul prüft nach den Kommentaren zunächst, ob benötigte Voraussetzungen vorhanden sind. Hier zu wird zunächst eine Variable fsFehler definiert, die festhalten soll, ob ein Fehler aufgetreten ist oder nicht. Optimistisch denkend, wird sie zunächst auf false (unwahr/falsch) gesetzt.

local fsFehler = false

In Lua ist boolean ein Datentyp, der 2 Werte annehmen kann: true und false. Boolesche Werte werden verwendet, um den Wahrheitswert einer Aussage oder eines Ausdrucks in einem Programm darzustellen.

Nebenbei erwähnt: Es gibt in Lua – im Gegensatz zu anderen Computersprachen - nur 2 Werte die Lua als false interpretiert. Das ist false selbst und nil. nil steht in der Regel für das Fehlen eines nützlichen Wertes.

Achtung: In einigen Computersprachen wird die Zahl 0 (Null) als false intepretiert, in Lua ist 0 true.

Nun steht vor der Variablen fsFehler noch das Wort local. Das beschränkt die Gültigkeit der Variablen auf einen bestimmten Bereich und zwar den Bereich in dem sie definiert wurde. In diesem Fall hier, ist das die gesamte Datei Fahrstrassenschaltung_FS2. D.h. in der Lua-Anlagendatei ist sie nicht mehr gültig. Wird sie z.B. in einer Funktion deklariert, so ist sie nur in der Funktion gültig. Wird sie in einer for-Schleife oder einer if-Anweisung definiert, so ist sie nur in der for-Schleife bzw. der if-Anweisung gültig (hierzu komme ich später).

Neben lokalen Variablen gibt es noch globale Variablen, auf die von überall aus einem Programm (einer Anlage) zugegriffen werden kann. Globale Variablen sind alle Variablen vor denen bei der ersten Deklaration kein local steht.

Es empfiehlt sich JEDE Variable, auf die man nicht unbedingt global zugreifen muss, als local zu deklarieren., denn lokale Variablen geben nach dem Verlassen ihres Gültigkeitsbereichs ihren Speicherplatz frei. Das kann in EEP insbesondere bei großen Anlagen sehr nützlich sein.

Weiterhin empfiehlt es sich, schon in der Schreibweise einer Variablen kenntlich zu machen, ob sie global oder lokal ist.

In dem vorliegenden Modul beginnen alle globalen Variablen mit einem Großbuchstaben. Alle lokalen Variablen beginnen mit einem Kleinbuchstaben. Variablen, die einer Funktion als Parameter übergeben werden (siehe unten) sind per Definition lokale Variablen. Um sie von den lokalen Variablen, die innerhalb der Funktion definiert werden, unterscheiden zu können, habe ich ihnen einen Unterstrich _ vorangestellt.

Zunächst wird überprüft, ob die Funktionen aus dem Plug-in 1 zu EEP 17.1 vorhanden sind. Da die EEP-spezifische Funktion EEPSignalSetTagText erst mit dem Plug-in 1 zu EEP 17.1 zur Verfügung steht, kann man dies mit der Frage überprüfen, ob EEPSignalSetTagText gleich oder ungleich nil ist. nil steht ja für das Fehlen eines nützlichen Wertes. Da eine Fehlermeldung ausgegeben werden soll, erfolgt hier die Abfrage mit == auf gleich.

Andere Vergleichsoperatoren sind: ~= ungleich, < kleiner als, > größer als, <= kleiner gleich als und >= größer gleich als.

if EEPSignalSetTagText == nil then

Die Überprüfung selbst erfolgt über eine if (wenn) – then (dann)-Anweisung. Das kennt jeder EEPler aus den Objekteigenschaften eines Kontaktpunktes, eines Signal oder einer Weiche, nur das dort die deutschen Begriffe (wenn (wahr) dann) verwendet werden und in Lua die englischen ( if (wahr/true) then). Lua überprüft nun ob der Begriff, der zwischen if und then steht wahr ist. WENN dem so ist, DANN führt Lua den Code bis zu einem die if-Anweisung beendenden end-Befehl aus.

WENN nun EEPSignalSetTagText nicht vorhanden also nil ist, DANN soll eine Fehlermeldung ausgegeben und zwar in den derzeit gängigen EEP-Sprachen, also in Englisch, Französich oder Deutsch. Nun könnte man untereinander für jede Sprachen ein if-Abfrage machen. Das ist aber nicht nötig, denn es gibt Erweiterungsanweisungen, die es ermöglichen Alternativ-Codeblöcke auszuführen:

if (wenn)

elseif (sonst wenn)

else (sonst)

end (Ende)

Hierbei könnten sogar mehrere elseif-Anweisungen nacheinander erfolgen. Sowohl elseif als auch else sind nicht aber zwingend nötig. Aber jede if-Anweisung MUSS mit einer end-Anweisung abgeschlossen werden.

Um nicht den Überblick bei geschachtelten if-Blöcken zu verlieren, insbesondere dass jeder mit end abgeschlossen wird, empfiehlt es sich, die einzelnen Blöcke einzurücken:

if ..... then
    if .... then
        Code hierfür
    elseif .... then
        Code hierfür
    else                                      
        Code hierfür
    end
    Code für alle Blöcke
end

Die installierte Sprachversion von EEP wird über die von EEP vordefinierte Variable EEPLng ermittelt. Alle von EEP vordefinierten Variablen und Funktionen beginnen mit EEP. Was sie machen, welche Parameter übergeben werden und welche Rückgabewerte sie haben, steht in den EEP-Lua-Handbüchern - sowohl online im Forum als auch in den mitgelieferten PDF-Versionen.

Die Ausgabe der Meldungen erfolgt über die Lua-Funktion print(). Innerhalb der runden Klammern kann man verschieden durch Kommata getrennte Parameter unterschiedlichen Typs eingeben.

Text ist eine Zeichenkette (Typ: string) und muss innerhalb von Anführungszeichen " " stehen. Texte kann man mit 2 Punkten verbinden: "Hugo ist "..Alter.." Jahre alt.". Die Variable Alter kann nun ihren Wert sowohl als Text als auch als Zahl beinhalten. Wenn ein numerischer Wert in einem Kontext verwendet wird, der eine Zeichenkette erwartet, wird der numerische Wert automatisch umgewandelt. Wenn man aber sicher gehen will, kann man auch die entsprechende Variable mit der Lua-Funktion tostring() in eine Zeichenkette umwandeln, wie später benutzt.

WENN nun EEPSignalSetTagText nicht vorhanden ist, DANN sollte nicht nur eine Fehlermeldung ausgegeben werden, sondern auch die Variable fsFehler auf true (wahr) gesetzt werden. Da das unabhängig von den Sprachen ist, kann das entweder vor dem if der Sprachausgaben als auch nach dem end der Sprachausgaben, aber auf jeden Fall vor dem end der Fehlerabfrage erfolgen. Letzteres habe ich im vorliegenden Code gemacht.

Da das Fehlen der Funktionen aus dem Plug-in 1 zu EEP 17.1 so gravierend ist, dass in dem Fall alles weitere überflüssig ist, wird auch die weitere Fehlerüberprüfung nur dann ausgeführt, wenn fsFehler NICHT WAHR ist. Das englische Wort für NICHT ist not und negiert den folgenden Ausdruck. Somit lautet die if-Abfrage:

if not fsFehler then

Da - wie schon geschrieben – eine if-Anweisung prüft, ob der Ausdruck zwischen if und then wahr ist oder nicht und fsFehler als boolean nur die beiden Zustände true/wahr oder false/unwahr haben kann, wäre eine Schreibweise

if fsFehler == false then

zwar möglich, zeugt aber von Lua-Unkenntnis. Sie würden ja auch nicht "Wenn eine Leiche tot ist, dann ..." schreiben.

Wenn also kein Fehler vorliegt, wird zunächst überprüft, ob die Tabelle FS_Signale angelegt wurde. Wenn nicht, wird eine leere Tabelle angelegt.

FS_Signale = FS_Signale or {}

Wenn bei einem "or" (oder) Vergleich der 1. Wert wahr ist, d.h. einen Wert besitzt, wird immer dieser 1. Wert benutzt. Hier also die in der Anlagen-Lua-Datei definierte Tabelle FS_Signale.

Nebenbei erwähnt: Neben "not" und "or" gibt es noch den logischen Operator "and" (und). Bei einem "and" Vergleich wird immer der 1. Wert benutzt, wenn dieser unwahr ist.

Eine Tabelle (Typ "table") besteht immer aus 2 geschweiften Klammern { }, zwischen denen dann die Tabellenwerte eingetragen werden können/müssen. Die Erzeugung der leeren Tabelle ist nötig, da sonst die Variable FS_Signale keinen Wert hat und bei der folgenden Abfrage eine Lua-Fehlermeldung verursachen würde.

if #FS_Signale == 0 then

Ist eine Variable wie hier FS_Signale eine Tabelle, dann gibt die gleichlautende Variable mit einem vorangestellten # (also #FS_Signale) an, wieviel Elemente in der Tabelle vorhanden sind.

Nebenbei erwähnt: ist eine Variable eine Zeichenkette (string), dann gibt die Variable mit dem # davor die Länge der Zeichenkette an, d.h. die Anzahl der Zeichen:

Name = "Hugo"

#Name = 4

Wenn also in der Tabelle FS_Signale keine Einträge stehen, werden auch hier entsprechende Fehlermeldungen ausgegeben und fsFehler auf true gesetzt.

Ob die Tabelle FS_Routenziele angelegt wurde, wird auf die gleiche Art und Weise überprüft wie bei der Tabelle FS_Signale. Auch FS_Routenziele wird gegebenenfalls angelegt.

FS_Routenziele = FS_Routenziele or {}

Eine Fehlermeldung ist nicht notwendig, da Routenziele nicht zwingend notwendig sind. Deswegen muss auch fsFehler nicht auf true gesetzt werden.

Falls die Variable FS_Speicher nicht zugewiesen wurde, wird ihr wie oben bei FS_Signale die Immobilie bzw. das Landschaftselement mit der ID "#1" zugewiesen.

FS_Speicher = FS_Speicher or "#1"

Ob die Immobilie oder das Landschaftselement überhaupt existiert, wird mit der EEP-spezifischen Funktion EEPStructureGetTagText() überprüft:

local ok, _ = EEPStructureGetTagText(FS_Speicher)

Wenn der Speicher, d.h. die Immobilie oder das Landschaftsmodell, existiert gibt die Funktion als 1. Rückgabewert true (wahr) zurück, wenn nicht false (unwahr), unabhängig davon, ob darin ein TagText gespeichert ist oder nicht. Der TagText würde als 2. Wert zurückgegeben. Da der aber hier nicht von Interesse ist, habe ich ihr als Variablennamen einen Unterstrich _ gegeben, was sich in solchen Fällen eingebürgert hat.

Wenn nun die Abfrage, ob der "Speicher" existiert, nicht (not) ok ist, wird wieder eine Fehlermeldung ausgegeben. Diese erfolgte hier jeweils zweizeilig. Für mehrzeilige Textausgaben nimmt man anstatt der Anführungszeichen die doppelten eckigen Klammern [[ ]], die ja schon von den oben beschriebenen Kommentaren bekannt sind, aber ohne die Minuszeichen.

Und natürlich wird fsFehler auf true gesetzt.

Damit ist die Fehlerprüfung beendet und wir kommen zu den eigentlichen Funktionen. Die sind natürlich nur notwendig, wenn bislang fsFehler not true ist.

Fahrstraßen kann man per Hand zu schalten und man sieht sofort, ob der Versuch erfolgreich war. Wenn nicht, muss man den Vorgang entsprechend lange wiederholen. Ebenso ist das bei der automatischen Fahrstraßenschaltung. Über einen Kontaktpunkt in ausreichendem Abstand vor dem Fahrstraßensignal sollte bei Auslösung des Kontaktpunktes eine Funktion die Fahrstraße zur Schaltung "anmelden". Eine weitere Funktion sollte dann zyklisch versuchen, die "angemeldete" Fahrstraße zu schalten und zwar solange bis sie geschaltet wurde. Damit das nicht bis in alle Ewigkeit geschieht, muss diese "Anmeldung" nach der Schaltung wieder rückgängig gemacht werden. Das gilt es nun zu programmieren.

Gibt es mehrere zu schaltende Fahrstraßen müsste die Anmeldefunktion entweder für alle Fahrstraßen gültig sein oder es müsste für jede Fahrstraße eine eigene Funktion geben. Soll eine (1) Funktion für alle Fahrstraßen gültig sein, müsste man ihr die jeweilige ID des Fahrstraßensignals als Parameter übergeben. Das sieht EEP von sich aus nicht vor. Zwar gibt es dazu ein fantastisches Fremdtool, das dieses ermöglicht, jedoch wollte ich den Nutzern dieses Moduls nicht zumuten, zur Nutzung sich noch zwingend ein weiteres Tool aus dem Web downloaden zu müssen.

Die Konsequenz ist, wie gesagt, für jedes Fahrstraßensignal muss eine eigene Funktion her. Gott sei Dank muss man das nicht selber machen. Das kann Lua für einen erledigen.

Alle IDs der Fahrstraßensignale stehen in der Tabelle FS_Signale. Dies muss man nun einzeln abfragen, um für sie dann ihre Funktion erstellen zu lassen. Eine Tabelle durchläuft man recht einfach mit einer sog. for-Schleife (for zu Deutsch: für). Diese wiederholt einen Code-Block, während eine Laufvariable eine arithmetische Folge durchläuft. Sie hat folgende Syntax:

for(für) Laufvariable, Startwert, Endwert, Schrittwert do(tu,mache) Code-Block end

Von Hause aus sind Laufvariable, Startwert, Endwert und Schrittwert lokale Variablen. Sie müssen also nicht vorher als local deklariert werden. Sie sind Zahlen also vom Typ: "number". Für den Variablennamen der Laufvariablen werden häufig die Buchstaben von i bis n verwendet. Jeder andere Name ist aber auch möglich. Startwert, Endwert und Schrittwert können auch vorher definierte Variablen mit einem Zahlenwert sein. Für den Schrittwert (also der Wert, um den die Laufvariable schrittweise erhöht oder erniedrigt wird) ist der Wert 1 voreingestellt. Er muss daher nur dann eingegeben werden, wenn er ungleich 1 sein soll.

Hier soll die Tabelle FS_Signale natürlich gänzlich durchlaufen werden. Der Startwert ist also 1 und der letzte Wert entspricht der Anzahl der Werte in der Tabelle, also #FS_Signale.

for n = 1, #FS_Signale do

In Lua werden Tabellen (Typ: "table") zum Speichern von Wertesammlungen verwendet. Tabellen können entweder durch Zahlen oder Zeichenfolgen indiziert werden, und jeder Index (jede Laufvariable) kann verwendet werden, um einen Wert in der Tabelle zu speichern oder Auszulesen. Die Tabelle FS_Signale in der Lua-Anlagendatei besteht aus einer Reihe durch Kommata getrennter Zahlen (den IDs der Fahrstraßensignale). Auf die Werte kann mit einer Laufvariablen in eckigen Klammen [ ] zugegriffen werden. Z.B. auf den 1. Wert mit FS_Signale[1] und auf den 3. Wert mit FS_Signale[3] u.s.w. In der for-Schleife wird auf die einzelnen Werte mit der Laufvariablen n zugegriffen. Der Übersichtlichkeitshalber wird der Wert von FS_Signale[n] erstmal in einer aussagekräftigen Variablen fsSignal gespeichert und natürlich als local deklarieret. Sie ist damit "nur" im Block der for-Schleife gültig.

local fsSignal = FS_Signale[n]

Eine Funktion ist eine Gruppe von Anweisungen, die zusammen eine Aufgabe erfüllen. Im Laufe dieses Tutorials wurden schon einige Funktionen erwähnt, z.B. die Lua-Funktion print() oder die EEP-Funktion EEPStructureGetTagText(). Um selbst eine Funktion zu definieren gibt es im Prinzip zwei Möglichkeiten.

function Name (Parameter, ...)

Name = function (Parameter, ...)

Beide Möglichkeiten sind gleichwertig und werden auch im Laufe dieses Tutorials genutzt. Um aber Lua x-mal die gleiche Funktion, die sich nur die Fahrstraßen-ID unterscheidet, schreiben zu lassen, bietet sich die 2. Methode an, denn der Funktionsname muss ja aus einem Stammstring und der Fahrstraßen-ID zusammengesetzt werden. Wie das geht, ist ja schon oben beschrieben:

"FSanmelden_"..fsSignal

Nun kommt ein Griff in die Lua-Fortgeschrittenen-Kiste. Alle Variablen (und damit auch alle Funktionen; denn die Funktionsnamen sind ja auch Variablen) stehen bei Lua in einer einzigen, großen Tabelle mit dem Namen _ENV (Abkürzung für ENVIRONMENT, du deutsch "Umgebung"). In diese Umgebungstabelle schreiben wir nun über die Schleife alle unseren Funktionensnamen, weisen ihnen den Typ function zu und legen fest, dass der Funktion der Zugname als Parameter _zugname übergeben wird.

_ENV["FSanmelden_"..fsSignal] = function(_zugname)

Danach schreibt man den Code, als ob man ihn für 1 Funktion schreibt, wobei für die Fahrstraßen_ID immer die Variable fsSignal genutzt wird.

In den meisten bisherigen Fahrstraßenmodulen wurden für die angemeldeten Fahrstraßen Datenslots genutzt. In diesem Modul werden die angemeldeten Fahrstraßen ja alle im TagText eines Immo-/LS-Elementes gespeichert. Dem muss nun die neue Fahrstraße hinzugefügt werden. Dazu wird zuerst mit der EEP-spezifischen Funktion EEPStructureGetTagText der Text mit allen bislang angemeldeten Fahrstraßen aus dem Speicher FS_Speicher ausgelesen und der Variablen angemeldeteFSFS zugewiesen.

local ok, angemeldeteFSFS = EEPStructureGetTagText(FS_Speicher)

Anmerkung: Die Verdoppelung der Abkürzung FS zu FSFS wurde von mir gewählt, um sichtbar zu machen, dass es sich um die Mehrzahl (Fahrstraßen) handelt.

Anmerkung 2: Hier wird im Folgenden auf die Überprüfung, ob ok true ist, verzichtet, da die Auslesung des TagTextes aus FS_Speicher ja schon oben überprüft wurde.

An diesen ausgelesenen Text wird nun die anzumeldende Fahrstraßen-ID angehängt, indem die als Zahl vorliegende ID mit der Lua-Funktion tostring() in eine Zeichenkette umgewandelt wird und mit der ".."-Verknüpfung (siehe oben) an den bestehenden Text hinten angehängt wird, ebenso wie das Komma als Trennzeichen. Abschließend wird der gesamte Text wieder der Variablen angemeldeteFSFS zugewiesen.

angemeldeteFSFS = angemeldeteFSFS..tostring(fsSignal)..","

Dieser wird dann wieder mit der EEP-spezifischen Lua-Funktion EEPStructureSetTagText in den Speicher FS_Speicher zurückgeschrieben.

EEPStructureSetTagText(FS_Speicher, angemeldeteFSFS)

Der folgende print-Befehl

-- print("FS ",fsSignal," angemeldet.")

wurde mit Kommentarzeichen versehen, so dass er im Normalfall nicht ausgeführt wird.

Anmerkung: Mit print-Befehlen sollte man sehr sparsam umgehen, da sie sehr auf die Anlagenperformance (Frame-Rate) gehen. Für eine Fehlersuche sind sie sehr nützlich. Ansonsten sollte man sie aber in EEP nur nutzen, wenn sie unumgänglich sind, z.B. für die Ausgabe einer anschließend händisch vorzunehmenden Anweisung.

Bislang wurde die Fahrstraße "nur" angemeldet. Was ist aber, wenn von dem Fahrstraßenstartsignal mehrere Fahrstraßen zu unterschiedlichen Zielen führen können? Dann steht in der Anleitung, dass in der Tabelle FS_Routenziele das Fahrstraßensignal als Laufvariable – also in eckigen Klammern [ ] – eingetragen werden muss und ihr mit dem Gleichheitszeichen = eine Tabelle – also in geschweiften Klammern { } – mit den einzelnen Ziel-Routen zugeordnet werden muss. Zunächst interessiert natürlich nur, ob in derTabelle FS_Routenziele ein Eintrag mit dem Fahrstraßensignal fsSignal existiert.

if FS_Routenziele[fsSignal] then

Wenn dem so ist, muss man natürlich die Route des aktuellen Zuges kennen. Die Route eines Zuges ermittelt man mit der EEP-spezifischen Funktion EEPGetTrainRoute.

local ok, route = EEPGetTrainRoute(_zugname)

Wenn diese Funktion erfolgreich ausgeführt wurde, also

if ok then

muss die Route gespeichert werden, um sie dann später vergleichen zu können. Hierzu bietet sich der TagText-Speicher des Fahrstraßensignals an. Dies erfolgt mit der EEP-spezifischen Funktion EEPSignalSetTagText.

EEPSignalSetTagText(fsSignal, route)

Wenn nun die Routenabfrage nicht ok war, werden mit if – elseif – else – end abhängig von EEPLng Fehlermeldungen ausgegeben.

Danach muss die if FS_Routenziele[fsSignal]-Abfrage mit end beendet werden und danach abermals mit end die die Eintragung der Funktion FSanmelden_X in die _ENV-Tabelle.

Damit hätten wir die Funktion "nur 1 x geschrieben" und Lua produziert sie mit allen Fahrstraßensignalen für uns direkt beim Einbinden des Fahrstraßenmoduls.

Wenn dann irgendwann mal die Fahrstraße geschaltet ist, sollte man die "Anmeldung" schnellstmöglich löschen (die Anmeldung, nicht die Fahrstraße!), denn sonst wird unnötigerweise weiter versucht, die Fahrstraße zu schalten. Viele nutzen dazu einen Kontaktpunkt hinter dem Fahrstraßensignal. Aber auch bis dahin vergeht unnötige Zeit. Viel eleganter und schneller macht das Lua für uns. Die EEP-spezifische Funktion EEPOnSignal_X wird jedes Mal von EEP aufgerufen, wenn sich die Stellung eines Signals ändert.

An dem X im Funktionsnamen erkennt man, dass auch diese Funktion für alle Fahrstraßen benötigt wird. Wie man dazu Lua für sich arbeiten lässt, wissen wir ja nun. Wir schreiben auch diese Funktion mit dem Fahrstraßensignal fsSignal in die Umgebungsvariable _ENV und übergeben dabei die Signalstellung als Parameter und zwar direkt im Anschluss innerhalb der for n = 1, #FS_Signale do-Schleife.

_ENV["EEPOnSignal_"..fsSignal] = function(_stellung)

Bei Fahrstraßensignalen entspricht die Stellung 1 "Auflösen", die Stellung 2 "Fahrt" für die 1. Fahrstraße sowie entsprechend die Stellung n für die Fahrstraße n-1. Da EEPOnSignal_X natürlich die Fahrstraße nur abmelden soll, wenn sie geschaltet wurde, d.h. die Stellung größer 1 ist, fragen wir das ab.

if _stellung > 1 then

Damit man die Fahrstraße aus dem Speicher löschen kann, benötigt man zunächst wieder die gesamte Zeichenkette mit allen Fahrstraßensignalen.

local ok, angemeldeteFSFS = EEPStructureGetTagText(FS_Speicher)

Dabei muss angemeldeteFSFS natürlich neu als local deklariert werden, da die oben benutzte Funktion mit gleichem Namen ja hier nicht mehr gültig ist.

Als nächstes definieren wir eine Zeichenkette fsGeschaltet, die der geschalteten Fahrstraße entspricht. Hierzu formen wir die Zahl der Fahrstraße fsSignal mit der Lua-Funktion tostring() in eine Zeichenkette um und fügen ihr dann das Komma als Trennzeichen hinten an.

local fsGeschaltet = tostring(fsSignal)..","

Anmerkung: Um umgekehrt eine Zeichenkette (String) in eine Zahl (number) umzuwandeln, gibt es die Lua-Funktion tonumber().

In Lua gibt es eine komplette Bibliothek an Funktionen, die Zeichenketten bearbeiten und alle mit string. beginnen. An dieser Stelle auf alle einzugehen, würde den Rahmen dieses "kleinen" Lua-Tutorials sprengen. Daher beschränke ich mich hier zunächst auf die gsub-Funktion, die in einer Zeichenkette eine Teilzeichenkette durch eine andere Teilzeichenkette ersetzt.

string.gsub = (Zeichenkette, zu_ersetzende_Kette, ersetzende_Kette)

Die Zeichenkette in der wir etwas austauschen wollen ist angemeldeteFSFS. Die Teilzeichenkette, die ersetzt werden soll, ist natürlich fsGeschaltet. Da fsGeschaltet gelöscht werden soll, ersetzen wir sie einfach durch eine Leerzeichenkette "".

angemeldeteFSFS = string.gsub(angemeldeteFSFS, fsGeschaltet, "")

Der Rückgabewert ist die geänderte Zeichenkette. Diese tragen wir abschließend wieder in den TagTextSpeicher ein.

EEPStructureSetTagText(FS_Speicher, angemeldeteFSFS)

Wir schließen die if _stellung > 1 mit end und die _ENV["EEPOnSignal_"..fsSignal] ebenfalls mit end. Damit schreibt uns Lua auch diese Funktion für alle Fahrstraßensignale.

Damit die Fahrstraßensignale bei jeder Stellungsänderung EEPOnSignal_X aufrufen, müssen alle Fahrstraßensignale registriert werden. Da EEPRegisterSignal() aber eine bereits existierende EEP-spezifische Funktion ist, muss sie nur mit allen Fahrstraßensignalen als Parameter aufgerufen werden.

EEPRegisterSignal(fsSignal)

Fahrstraßen werden am Fahrstraßenzielsignal automatisch aufgelöst. Dennoch ist es z.B. bei Weichenfeldern manchmal sinnvoll, dies vorzeitig zu tun, um den Weg für querende Fahrstraßen freizugeben. Dies kann zwar mit nur einer EEP-spezifischen Lua-Funktion erfolgen, dennoch war ich der Meinung, dass in einem Fahrstraßenmodul auch hierfür der Syntax folgenden Funktionen zur Verfügung gestellt werden sollten. Da für jede Fahrstraße eine eigene erstellt werden muss, erfolgt auch das wieder über eine Eintragung in die _ENV-Tabelle.

_ENV["FSaufloesen_"..fsSignal] = function()

Die Auflösung der Fahrstraße erfolgt dann über die Signalstellung 1.

EEPSetSignal(fsSignal, 1, 1)

Mit end wird auch dies _ENV-Eintragung beendet.

Um das Kapitel abzuschließen wird auch die for n = 1, #FS_Signale do-Schleife mit end geschlossen und zuletzt ebenso die if not fsFehler then-Anweisung.

Nun benötigen wir nur noch eine Funktion, die periodisch abfragt, ob eine Fahrstraße angemeldet wurde und diese dann gegebenenfalls versucht zu schalten. Sinnigerweise habe ich sie FSschalten genannt. Wie bereits oben erwähnt, gibt es 2 gleichwertige Methoden eine Funktion zu deklarieren. Für die Funktionen, die in die _ENV-Tabelle geschrieben wurden, hatte ich die Schreibweise Name = function (Parameter) gewählt. Zur Verdeutlichung der Gleichwertigkeit nehme ich hier function Name (Parameter), wobei an FSschalten allerdings keine Parameter übergeben werden müssen.

function FSschalten()

Da es wenig Sinn macht, die Funktion immer wieder zu durchlaufen, wenn wichtige Voraussetzungen fehlen, d.h. fsFehler wahr ist, führen wir den folgenden Code nur aus, wenn das nicht der Fall ist.

if not fsFehler then

Als Erstes lesen wir wieder den TagText mit allen angemeldeten Fahrstraßen aus dem Speicher aus.

local ok, angemeldeteFSFS = EEPStructureGetTagText(FS_Speicher)

Nun müssen aus dieser eventuell langen Zeichenkette die einzelnen Fahrstraßensignale extrahiert werden. Hierzu lernen wir eine zweite string-Funktion kennen.

Die Funktion string.gmatch(Zeichenkette, Muster) liefert einen Iterator, welcher bei jedem Aufruf das nächste Vorkommen des Musters in der Zeichenkette als Teilzeichenfolge zurückgibt.

Bei string.gsub oben, war das "Muster" eine bekannte Zeichenkette. Hier ist das nicht der Fall. Um aber ein Muster für unbekannte Zeichen bilden zu können, gibt es in Lua sogenannte Zeichenklassen:

• . (ein Punkt) repräsentiert z.B. alle Zeichen,
• %a alle Buchstaben,
• %l alle Kleinbuchstaben,
• %u alle Großbuchstaben,
• %d alle Ziffern,
• %w alle alphanumerischen Zeichen,
• %s alle Leerzeichen,

um die wichtigsten zu nennen. Soll/kann das Muster mehrere gleiche Zeichen hintereinander enthalten, so setzt man hinter die Zeichenklasse ein + Zeichen.

Wir wissen nun aber, dass es sich bei der ID eines Fahrstraßensignals um eine oder mehrere Ziffern handelt, die von der nächsten durch ein Komma (also eine Nicht-Ziffer) getrennt ist. Damit suchen wir mit dem Muster "%d+", also nach jeweils allen hintereinanderstehenden Ziffern. Und da string.gmatch einen Iterator zurückgibt, macht man das in einer for-Schleife.

for fsSignal in string.gmatch(angemeldeteFSFS, "%d+") do

Wir erinnern uns, dass Laufvariablen – hier der Iterator fsSignal – immer local sind. Daher ist diese Variable fsSignal auch nur in dieser for-Schleife gültig. Allerdings ist sie eine Zeichenkette, also vom Typ "string". Wir benötigen sie aber als Zahl, also als Typ "number", denn so ist sie die Laufvariable der Tabelle FS_Routenziele. Eine Zahl mit tostring() in eine Zeichenkette umzuwandeln haben wir ja oben schon gemacht. Jetzt benutzen wir die Gegenfunktion tonumber() für den umgekehrten Weg. Und da Variablen in Lua ihren Typ wechseln können, nutzen wir für das Ergebnis weiter den Variablennamen fsSignal.

fsSignal = tonumber(fsSignal)

Als nächstes muss abgeklärt werden, ob es mehrere Fahrstraßenziele gibt oder nur eins. Wenn es mehrere Ziele gibt, muss es einen Eintrag mit der Fahrstraßen-ID in der Tabelle FS_Routenziele geben.

if FS_Routenziele[fsSignal] then

Wenn das zutrifft, muss die Route des angemeldeten Zuges aus dem TagText des Fahrstraßensignals ausgelesen werden.

local ok, zugRoute = EEPSignalGetTagText(fsSignal)

Wenn das erfolgreich war

if ok then

werden der Reihe nach alle in FS_Routenziele für das Fahrstraßensignal fsSignal gespeicherten Routen in einer for-Schleife mit der Laufvariablen zielNr durchlaufen.

for zielNr = 1, #FS_Routenziele[fsSignal] do

Nun kann es ja sein, dass eine Fahrstraße sowohl nur 1 Ziel hat als auch mehrere. Sind es mehrere müssten diese in einer (Unter-)Tabelle stehen (siehe Doku). Das fragen wir in einer if – else – end ab, in dem wir prüfen, ob der Eintrag mit der zielNr des fsSignal-Eintrags der Tabelle FS_Routenziele vom Typ (type) "table" ist.

if type(FS_Routenziele[fsSignal][zielNr]) == "table" then

Wenn dem so ist, muss überprüft werden, ob eine dieser Routen mit der Route des Zuges übereinstimmt. Bevor wir damit starten, benötigen wir aber noch einen Merker für den Fall, dass die Route gefunden wurde. Warum erkläre ich später. Diesen setzt man aber erstmal auf den Wert false (unwahr).

local routeGefunden = false

for routeNr = 1, #FS_Routenziele[fsSignal][zielNr] do

Über die Laufvariable routeNr lesen wir nun die einzelnen Routen aus. Stimmt diese Route mit der Route des Zuges überein, setzen wir den Merker routeGefunden auf true und schalten fsSignal auf die Stellung zielNr + 1.

if zugRoute == route then

routeGefunden = true

EEPSetSignal(fsSignal, zielNr + 1, 1)

Unabhängig davon, ob die Fahrstraße geschaltet wird oder nicht (weil besetzt), kann für diesen Zyklus die Suche abgebrochen werden. Das geschieht mit dem Lua-Befehl

break

Die break -Anweisung beendet sofort die Schleife und setzt die Codeausführung hinter dem end der Schleife fort. Befindet man sich nun aber innerhalb mehrerer Schleifen, so wird nur die innere Schleife beendet, d.h. hier die for routeNr -Schleife. Wenn nun die Route gefunden wurde, muss auch die äußere Schleife for zielNr = beendet werden und das geht nur, wenn man sich gemerkt hat, dass die Route gefunden wurde.

if routeGefunden then break end

Kehren wir zurück zu if type(FS_Routenziele[fsSignal][zielNr]) == "table". Wenn diese Bedingung nun nicht erfüllt wird, gibt es nur 1 Alternative, nämlich dass es unter der zielNr nur 1 Route gibt. Daher benötigen wir keine elseif, sondern können den Fall gleich nach

else

abhandeln. Zuerst muss auch hier die Route aus FS_Routenziele für fsSignal mit der zielNr ausgelesen werden und dann mit der Route des Zuges verglichen werden.

local route = FS_Routenziele[fsSignal][zielNr]

if zugRoute == route then

Wenn dem so ist, schalten wir wie vorher das Fahrstraßensignal und brechen die for zielNr = Schleife ab, denn wir haben ja die Route.

EEPSetSignal(fsSignal, zielNr + 1, 1)

break

Wenn dem aber nicht so ist, überspringt der Code die if zugRoute == und da danach kein Code mehr kommt, wird mit end die if type(FS_Routenziele ... beendet. Mit dem nächsten end wird das Ende der for zielNr = Schleife erreicht. Ist die letztmögliche Laufvariable dieser Schleife noch nicht erreicht, wird mit der nächsten zielNr weitergesucht.

Bevor wir die for zielNr = Schleife begonnen haben, haben wir mit if ok überprüft, ob das Auslesen der Route des angemeldeten Zuges erfolgreich war. Wenn nicht, werden zwischen else und end wieder Fehlermeldungen ausgegeben.

Damit sind alle Fälle abgehakt, bei denen von einem Fahrstraßensignal mehrere Ziele möglich sind.

Bleibt noch die Möglichkeit, dass vom Fahrstraßensignal nur 1 Ziel möglich ist, also dass in FS_Routenziele kein Eintrag für fsSignal besteht. Dazu schaltet man nach dem entsprechenden else-Befehl das Signal fsSignal auf Fahrt bzw. auf Stellung 2.

else

EEPSetSignal(fsSignal, 2, 1)

Auch diese if beendet man mit end, danach die for fsSignal in Schleife, die if not fsFehler-Anweisung und zum Schluss die ganze Funktion.

Noch ein Hinweis. Wenn ich "schreibe schaltet man das Fahrstraßensignal auf Fahrt", so heißt das nicht, dass es auch auf Fahrt geschaltet wurde. Es ist jeweils ein Versuch. Ist die Fahrstraße frei, so schaltet EEP die Straße. Wenn sie besetzt ist, wird sie nicht geschaltet und bleibt solange angemeldet, bis sie dann mal geschaltet wird. Damit die Schaltversuche immer wieder zyklisch durchgeführt werden können, muss die Funktion FSschalten in der EEPMain() aufgerufen werden.

In so einem Tutorial können nicht alle Möglichkeiten von Lua erschöpfend dargestellt werden. Ich hoffe aber, dem ein oder anderen hiermit etwas Lust auf Lua gemacht zu haben oder seine Lua-Kenntnisse eventuell etwas erweitert zu haben.

PS: Dieses Tutorial befindet sich sowohl in der Filebase bei dem Modul als auch nach der Installation im Resourcen\Doc-Verzeichnis als PDF.

Moin Lothar DB54 (LW2) ,

das Skript im mittleren Bild sieht mir in Ordnung aus. Wenn du nun nach dem Laden der Anlage den Lua-Skript-Editor öffnest, müsste genau dieser Text darin stehen. Darin ist schon in Zeile 12 die Einbindung des Moduls aus dem FS2-Ordner des LUA-Ordners enthalten. Wenn dein Skript aber aussieht wie in #14, dann hast du alle anderen Angaben gelöscht und es kann damit auch nicht funktionieren.

Hast du die zip-Datei mit dem internen Installer installiert? Dann müsste im FS-Ordner unter dem LUA-Ordner die Datei Fahrstrassenschaltung_FS2.lua sein.

Steht auf der Anlage ein Baum, ein Busch, ein Haus - also irgendeine Immobilie oder ein LS-Element? Das wird benötigt. Siehe Doku.

Hast du deinem Testfahrzeug eine der Routen "1", "2", "3", "4" oder "5" zugewiesen. Auf dem 3. Bild sehe ich kein Fahrzeug. Ebenso sehe ich keinen KP vor der der 1. Weiche.
Wenn er existiert, hast du dort unter Lua-Funktion FSanmelden_9 eingetragen?

Ich schicke dir per PN meine Kontaktdaten. Dann kannst du mir gerne deine Anlage zuschicken.