Tutorial:Erstellen neuer Relaisgruppen - Skripte erstellen

Der Programmablauf von StellSi wird über Scripte gesteuert. Das Scriptsystem von StellSi basiert dabei auf dem C(++)-ähnlichen Angelscript (http://www.angelcode.com/angelscript/).

Hintergrund

Die Logik von StellSi-Stellwerken wird mithilfe von Scripten gesteuert. Das heißt, hinter jedem Stellwerk steht ein kleines Programm, das die Funktionen von StellSi steuert und das man auch bearbeiten kann.

Die Scripte selbst befinden sich in seperaten Dateien, den *.stws-Dateien. Sie liegen zusammen mit den Biblitotheken im Verzeichnis der Bauform. Sie können im Prinzip mit jedem beliebigen Texteditor geöffnet werden, unter Windows zum Beispiel mit Editor/Notepad. Es ist jedoch zu beachten, dass bei Dateien von fremden Betriebssystem möglicherweise eine andere Normierung für den Zeilenumbruch verwendet wurde (Details siehe Wikipedia.). Ist es offensichtlich, dass das Programm die Zeilenumbrüche nicht richtig erkannt hat, hilft es meist einen anderen Editor zu verwenden (unter Windows zum Beispiel WordPad). Für den eigentlichen Code sind die Zeilenumbrüche jedoch nicht relevant.

Im Script stellt Relais- oder Anschaltgruppe eine Klasse dar. Die Schnittstellen werden über Variablen eingefügt und rufen automatisch bestimmte Methoden auf.

Grundlagen

Die Scripte sind im Prinzip wie eine normale Programmiersprache aufgebaut. Daher soll im folgenden eine kurze Einleitung über die Scriptprogrammierung gegeben werden.

Grundlage der Programmierung sind einzelne Klassen: Eine Klasse beginnt mit dem Schlüsselwort class, es folgt der Name der Klasse, dann eine Geschweifte Klammer, innerhalb der sich der Inhalt der Klasse befindet. Die Klasse endet mit einer weiteren geschweiften Klammer.

class Weiche
{
    //Inhalt der Klasse
}

Innerhalb einer Klasse werden allgemeine Variablen deklariert. Variablen speichern Daten oder stellen Verbindungen zu der Programmlogik von StellSi her. Sie beginnt mit dem Datentyp der Variable (z.B. int für eine Zahl) gefolgt von einem Namen der Variable, mit dem man sie später identifizieren kann, und gleich danach einem ; .

class Weiche
{
    Schnittstelle tischfeld;
    int anzahlIrgendetwas;
    bool tasteGedrueckt;
}

Neben den Variablen gibt es innerhalb von Programmen noch Funktionen. Eine Funktion beginnt mit void (oder einem Datentyp) gefolgt von dem Namen der Funktion. Danach folgt eine runde geöffnete Klammer, in der angegeben wird, welche Daten der Funktion mitgegeben werden. Diese Daten werden kommagetrennt in der Form Datentyp Name angegeben. Es folgt eine geschweifte Klammer für den Methodenanfang, der Methodeninhalt und eine geschweifte Klammer für das Methodenende.

class Weiche
{
    Schnittstelle tischfeld;
    int anzahlIrgendetwas;
    bool tasteGedrueckt;
    
    void init()
    {
         //Methodeninhalt
    }
    void on_tischfeld_wht(int wert)
    {
         //Methodeninhalt
    }
    void beliebigeMethode(int wert, bool andererWert)
    {
         //Methodeninhalt
    }
}

Innerhalb der Methoden kann man mit den Variablen rechnen und ihnen Werte zuweisen. + addiert zwei Zahlen, - subtrahiert sie, * multipliziert, / dividiert Sie. Mit == wird überprüft ob Zahlen oder Warheitswerte gleich sind; das Ergebnis ist ein Warheitswert. Mit = werden rechts stehende Zahlen oder Warheitswerte einer links stehenden Variable zugewiesen. Mit ! wird aus einem Warheitswert sein Gegenteil. Mit & oder && wird zurückgegeben, ob der eine und der andere Warheitswert wahr ist, mit | oder || wird zurückgegeben, ob der eine oder der andere Warheitswert wahr ist. Mit <, <=, > und >= wird überprüft, welche Zahl größer ist. Mit Klammern werden, wie in der Mathematik, die Reihenfolgen der Rechnereien festgelegt. Alles was zwischen // und dem Zeilenende oder zwischen /* und */ folgt ist ein Kommentar und wird (im gesamten Programm) ignoriert. Ein Befehl endet mit ; . Das Programm arbeitet die Befehle Schritt für Schritt ab.

class Weiche
{
    Schnittstelle tischfeld;
    int anzahlIrgendetwas;
    bool tasteGedrueckt;
    
    void init()
    {
         anzahlIrgendetwas=0;
         tasteGedrueckt=false;
    }
    void on_tischfeld_wht(int wert)
    {
         tasteGedrueckt=true;
         anzahlIrgendetwas=wert;
    }
    int beliebigeMethode(int wert, bool andererWert)
    {
         tasteGedrueckt = ((wert == 1)||(wert > 15))&&(!andererWert);
         //Rest der Methode.
    }
}

In den Methoden können andere Methoden aufgerufen werden. Eigene Methoden werden aufgerufen, indem man Sie mit ihrem Namen nennt, in einer Klammer kommagetrennt die Parameter übergibt und den Befehl dann wieder mit ; abschließt. Die Kommunikation mit StellSi findet statt, indem man den Namen einer (Schnitstellen-)Variablen gefolgt von einem . und dann dem Namen einer StellSi-Methode wie eine lokale Methode aufruft. Einige Methoden benötigen dafür Zeichenfolgen. Eine Zeichenfolge ist ein Text zwischen zwei Anführungszeichen.

class Weiche
{
    Schnittstelle tischfeld;
    int anzahlIrgendetwas;
    bool tasteGedrueckt;
    
    void init()
    {
         anzahlIrgendetwas=0;
         tasteGedrueckt=false;
         tischfeld.setWert("besetzt",1);
    }
    void on_tischfeld_wht(int wert)
    {
         tasteGedrueckt=true;
         anzahlIrgendetwas=wert;
         beliebigeMethode(27,false);
    }
    int beliebigeMethode(int wert, bool andererWert)
    {
         tasteGedrueckt = ((wert == 1)||(wert > 15))&&(!andererWert);
         tischfeld.setWert("irgendwas",41);
         //Rest der Methode.
    }
}

Der Programmablauf kann mit Bedingungen bedingt fortgesetzt werden. Bedingungen beginnen mit if gefolgt von einem in eine Klammer eingeschlossenen Wahrheitsausdruck. Folgt nur ein Befehl, kann dieser direkt danach folgen; wenn mehrere Befehle bedingt abgearbeitet werden sollen, müssen diese in geschweifte Klammern zusammengefasst werden. Nach dem else-Schlüsselwort können auf die gleiche Art und Weise Befehle folgen, die ausgeführt werden sollen, wenn der Warheitswert false ist.

class Weiche
{
    Schnittstelle tischfeld;
    int anzahlIrgendetwas;
    bool tasteGedrueckt;
    
    void init()
    {
         anzahlIrgendetwas=0;
         tasteGedrueckt=false;
         tischfeld.setWert("besetzt",1);
    }
    void on_tischfeld_wht(int wert)
    {
         tasteGedrueckt=true;
         anzahlIrgendetwas=wert;
         if (wert > 26)
           beliebigeMethode(27,false);
         else
         {
           beliebigeMethode(wert,true);
           tischfeld.setWert("nochetwas",1);
         }
    }
    int beliebigeMethode(int wert, bool andererWert)
    {
         tasteGedrueckt = ((wert == 1)||(wert > 15))&&(!andererWert);
         tischfeld.setWert("irgendwas",41);
         //Rest der Methode.
    }
}

Die Ausführung von (void-)Methoden kann mithilfe von return; abgebrochen werden. Methoden, die nicht void sind, haben einen Rückgabewert und können daher wie Variablen verwendet werden, um etwas zu berechnen. Sie müssen ein return beinhalten, dem der Wert, der zurückgegeben werden soll folgt.

class Weiche
{
    Schnittstelle tischfeld;
    int anzahlIrgendetwas;
    bool tasteGedrueckt;
    
    void init()
    {
         anzahlIrgendetwas=0;
         tasteGedrueckt=false;
         tischfeld.setWert("besetzt",1);
    }
    void on_tischfeld_wht(int wert)
    {
         tasteGedrueckt=true;
         anzahlIrgendetwas=wert;
         if (wert > 26)
           beliebigeMethode(27,false);
         else
         {
           beliebigeMethode(wert,true); //Kommentar
           tischfeld.setWert("nochetwas" /*Kommentar*/,beliebigeMethode(0,false));
           return;
         }
    }
    int beliebigeMethode(int wert, bool andererWert)
    {
         tasteGedrueckt = ((wert == 1)||(wert > 15))&&(!andererWert);
         tischfeld.setWert("irgendwas",41);
         return 32;
    }
}

Bestimmte Methoden (im obigen Fall init und die on-Methode) werden automatisch von StellSi aufgerufen. Werden Variablen innerhalb einer Methode deklariert, gelten Sie nur bis zum Ende des aktuellen Bereiches (schließende }, wenn zwischen der } noch ein paar { aufgemacht wurden zählen die zugehörigen } natürlich nicht dazu).

Hinweis: Gibt es zum Beispiel zwei Weichen, die beide auf der Klasse Weiche aufbauen, so sind diese unhabhängig voneinander. Die beiden Weichen arbeiten mit verschiedenen Instanzen der Klasse.

Für eine ausführlichere Anleitung sei auf die entsprechende Fachliteratur verwiesen.

Datentypen

Siehe Tutorial:Namen von Klassen