API Standard

Baustelle

Interne Kommunikation mit dem Interface in Railware

Diese Beschreibung richtet sich an erfahrene Softwareentwickler, die mit eigenen Applikationen auf das Railware Interface zugreifen möchten.

Wir können keinen Support für die hier beschriebenen Funktionen leisten und keine Anfragen über deren richtige Verwendung beantworten. Einzelne Angaben der Spezifikation können ohne Angabe von Gründen geändert werden.

In Railware kommunizieren alle Gleisbilder, Fahrpulte und andere Programme mit den Digitalsystemen über das Programm 'Inter.exe'.

In Inter.exe befinden sich Protokollimplementationen der unterstützten Digitalsysteme, das Prioritätensystem 'RAILstack', die Funktionen zur Lok- und Zugsteuerung sowie ein Logbuch.
Es wickelt selbsttätig alle Beschleunigungs- oder Bremsoperationen der Züge ab.

Im folgenden wird 'Inter.exe' als Interface bezeichnet.

Alle Programme senden und empfangen Informationen zum und vom Interface über das Windows Nachrichtensystem.

Die Arbeitsweise des Windows Nachrichtensystems sowie der Funktionen 'SendMessage', 'PostMessage', 'RegisterWindowsMessage' und 'WndProc# oder 'Wnd_Proc' werden als bekannt vorausgesetzt.

Wegen der einfachen Struktur der Kommunikation haben wir auf die Bereitstellung eines Tools zur Ansteuerung des Interface verzichtet.

Die dargestellten Beispiele sind in Delphi kodiert, lassen sich aber leicht in andere Sprachen umsetzen, da nur wenige Funktionen der WinAPI verwendet werden. Lesen Sie dazu in den entsprechenden Infos im Windows Platform SDK'.

Die selbsterstellte Applikation kann sich in einem eigenen Ordner befinden.

Eigene Nachrichten in Windows anmelden

Zu Verwendung eigener Nachrichten müssen diese mit einem eindeutigen Namen spezifiziert und ein Handle angefordert werden.

wmdhEinNachrichtenHandle := RegisterWindowMessage ('MessageName');

Es können folgende Nachrichten von Ihrer Applikation angemeldet werden:

wmInterface := RegisterWindowMessage ('dhInterface');
wmInsMelder := RegisterWindowMessage ('dhInsMelder');
wmSetBelegt := RegisterWindowMessage ('dhSetBelegt');
wmSignal := RegisterWindowMessage ('dhSignal');
wmWeiche := RegisterWindowMessage ('dhWeiche');
wmKuppler := RegisterWindowMessage ('dhKuppler');
wmDelMelder := RegisterWindowMessage ('dhDelMelder');
wmGetAllMelder := RegisterWindowMessage ('dhGetAllMelder');
wmLok := RegisterWindowMessage ('dhLok');
wmLokUpdate := RegisterWindowMessage ('dhLokUpdate');
wmQuitInter := RegisterWindowMessage ('dhQuitInter');
wmGetFahrNum := RegisterWindowMessage ('dhGetFahrNum');
wmGetGleisNum := RegisterWindowMessage ('dhGetGleisNum');
wmGetDrehNum := RegisterWindowMessage ('dhGetDrehNum');
wmReReadParam := RegisterWindowMessage ('dhReReadParam');
wmDrehkranFunktion := RegisterWindowMessage ('dhDrehkranFunktion');
wmDrehkran := RegisterWindowMessage ('dhDrehkran');
wmFunktion := RegisterWindowMessage ('dhFunktion');
wmSetDecoder := RegisterWindowMessage ('dhSetDecoder');
wmSetLok := RegisterWindowMessage ('dhSetLok');
wmZugHelmoPos := RegisterWindowMessage ('dhZugHelmoPos');
wmUhrMinute := RegisterWindowMessage ('dhUhrMinute');
wmZugSetLokDaten := RegisterWindowMessage ('dhZugSetLokDaten');
wmZugOpen := RegisterWindowMessage ('dhZugOpen');
wmZugClose := RegisterWindowMessage ('dhZugSetZugClose');
wmZugLokSet := RegisterWindowMessage ('dhZugLokSet');
wmZugLokAdd := RegisterWindowMessage ('dhZugLokAdd');
wmZugLokDel := RegisterWindowMessage ('dhZugLokDel');
wmZugSpeed := RegisterWindowMessage ('dhZugZugSpeed');
wmdhZugFunktion := RegisterWindowMessage ('dhZugZugFunktion');
wmdhZugHalt := RegisterWindowMessage ('dhZugHalt');
wmdhZugNothalt := RegisterWindowMessage ('dhZugNothalt');

Jedes Programm sollte nur benötigte Meldungen registrieren.

Falls Ihr Programm selbst Nachrichten definiert, sollten keine Bezeichner verwendet werden, die mit ‚wmdh’ beginnen, da Railware weitere hier nicht dokumentierte Nachrichten verwendet.

Nachricht an Interface senden

Senden von Informationen an das Interface erfolgt mit ‚SendMessageÂ’, in bestimmten Fällen auch mit ‚PostMessageÂ’.
Je nach Informationsumfang werden Informationen in TMessage oder in selbstdefinierten Records übertragen. In vielen Fällen reicht die Verwendung von wParam und lParam bzw. wParamHi, wParamLo, lParamHi und lParamLo.

Ein Beispiel:

VAR
  Msg : TMessage;
BEGIN
  wParam := EineZahl;
  lParam := EineAndereZahl;
  SendMessage (ZielWnd,wmEineMessage,wParam,lParam);
END;

Nachricht von Interface empfangen

Hierzu muss die Applikation sich in das Nachrichtensystem der Applikation oder eines Fensters (in der Regel das Hauptfenster) einklinken.

In Delphi geschieht dies im Formular durch überschreiben der vorhandenen WndProc::

procedure WndProc (var Msg : TMessage); override;

Neuer Nachrichtenhandler:

PROCEDURE TUserForm.WndProc (var Msg : TMessage);
BEGIN
  ...
  //Abfangen einer Nachricht
  If Msg.Msg = wmSignal then
    SignalNachrichtVerarbeiten (Msg);  //Eigene Behandlungsroutine starten
...
  //weitere Nachrichten abfangen
...
  // Nachrichten an alten Handler weiterleiten, sonst Hangup.......
  Inherited WndProc (Msg);
END;

Die Verarbeitung von eigenen Nachrichten sollte so schnell wie möglich geschehen, um Windows nicht unnötig zu verlangsamen. Beachten Sie die Windows Dokumentation.

Interfaceprogramm starten

Starten des Interface 'Inter.exe' erfolgt über die folgende Funktion:

VAR
  InterfaceWnd : HWnd; //Wird für alle Aufrufe von SendMessage benötigt

procedure StarteInterface;
begin
  //Interface Window finden
  InterfaceWnd := FindWindow ('TInterfaceForm','Interface');
  //Interface starten, falls nicht gefunden
  if (InterfaceWnd = 0) and 
     (WinExec ('Inter.exe',sw_Normal) <> Error_File_Not_Found) then
    InterfaceWnd := FindWindow ('TInterfaceForm','Interface');
end;

Falls sich Ihre Applikation in einen anderen Ordner befindet, muss der Pfad zu Inter.exe zusätzlich angegeben werden. Später ist die Angabe von Pfaden nicht erforderlich.

Beachten Sie, dass das Starten eines Digitalsystems evtl. etwas länger dauert. In diesem Fall liefert FindWindow? bereits das FensterHandle?, aber das System ist zu diesem Zeitpunkt noch nicht betriebsbereit. Hier muss evtl. eine Zeitverzögerung eingebaut werden.

Interfaceprogramm beenden

Beendet die Kommunikation mit den Digitalsystemen, schließt die Schnittstellen und beendet das Interfaceprogramm. Alle verwendeten Speicherstrukturen werden aufgelöst. Die Zug- und Lokdaten werden im Datenbanksystem gespeichert.

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
Handle ist das Fensterhandle des aufrufenden Programms.

PostMessage (InterfaceWnd,wmQuitInter,Handle,0);

Belegtmelder anmelden

Das Interface meldet Belegtmeldungen immer nur an Programme und Fenster, die dies explizit angefordert haben. Darüber wird bei bestimmten Digitalsystemen automatisch die maximal zu lesenden Bausteine ermittelt.

Jeder Melderanschluss muss einzeln angemeldet werden:

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
Handle ist das Fensterhandle des aufrufenden Programms.

VAR
  Msg : TMessage;
BEGIN
  lParamHi := Baustein;  //Die Nummer (Adresse) des Meldebausteins
  lParamLo := Port;      //Der Anschluss am Baustein
  SendMessage (InterfaceWnd,wmInsMelder,Handle,lParam);
END;

Belegtmeldung empfangen

Es erfolgt einmalig die Übertragung einer Änderung eines Belegtmelders; unabhängig vom Typ des Digitalsystems. Eventuell müssen beim Start eines Programmes alle Belegtmeldungen explizit angefordert werden (siehe: Alle Belegtmeldungen anfordern).

Empfangene Nachricht: wmSetBelegt

Der Aufbau der Nachricht ist:

Msg.lParamHi = Melder    //Nummer des Belegtmeldebausteins
Msg.lParamLo = Kontakt   //Anschluss des Bausteins
Msg.wParamHi = Besetzt   //Belegtmeldung 1=Besetzt, 0=Frei

Alle Belegtmeldungen anfordern

Das Interface wird aufgefordert, alle angemeldeten Belegtmelder neu zu übertragen. Dies kann nur ausgeführt werden, wenn es vom Digitalsystem unterstützt wird. Andernfalls werden alle gespeicherten Belegtzustände übertragen.
Die aktuellen Werte werden an alle geöffneten Fenster gesendet.
Da die Abarbeitung längere Zeit in Anspruch nehmen kann, empfiehlt sich die Verwendung von ‚PostMessageÂ’.

Beispiel:

PostMessage (InterfaceWnd,wmGetAllMelder,0,0);

Schaltdecoder stellen (Weichen/Signale etc.)

Stellt einen Decoder in die definierte Stellung. Es erfolgt keine Prüfung der momentanen Stellung. Doppelkommandos müssen vom aufrufenden Programm abgefangen werden.

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
Handle ist das Fensterhandle des aufrufenden Programms.

aDauer bezeichnet die Schaltdauer: 0=kurz, 1=mittel, 2=lang. Die Werte dafür sind in den Interfaceoptionen hinterlegt.
aAdresse ist die zu schaltende Digitaladresse
aParam ist die Stellung. Sie wird aus einem Array ermittelt. Zulässig sind sWn1,sWn2, sHp0, sHp1,sHp2,sVr0,sVr1,sVr2,sSh0,sSh1 sowie sEin und sAus. Der Aufbau von TSignal wird im Anhang beschrieben.

PROCEDURE ifSendDecoder (aDauer : Integer; aAdresse : Word; aParam : TSignal);
VAR
  Msg : TMessage;
BEGIN
  Msg.lParamLo := Ord (aParam);
  Msg.lParamHi := aDauer;
  SendMessage (InterfaceWnd,wmWeiche,aAdresse,Msg.lParam);
end;

Decoderstellung empfangen

Falls vom Digitalsystem unterstützt, erfolgt die Rückmeldung einer Digitaladresse, die am System geändert wurden, durch diese Nachricht.

Empfangene Nachricht: wmSetDecoder

Msg.wParam = Adresse    //Adresse des Decoders
Msg.lParam = Stellung   //Neue Stellung: 0=Gerade oder Halt, 1=Abzweig oder Fahrt

Lok steuern

Senden von Lokinformationen an das Interface. Dazu wird ein Record verwendet.

Definition von TLokMessage:

TLokMessage = packed record
              Msg      : Cardinal;
              case Integer of
              0 : (Speed    : Byte; //Fahrstufe
                   Direct   : Byte; //Richtung: 1=Vorwärts, 0=Rückwärts
                   Funktion : Byte; //Funktion: 0=Aus, 1=Ein
                   F1F8     : Byte; //Funktionen F0 bis F8
                   Addr     : Word; //Digitaladresse
                   Reserve  : Byte; //F1F4 senden: = 1
                                    //IB: NoForce for Functions = 2
                                    //Priorität: Bremsvorgang = 4
                                    //Lenz3: Funktionen senden = 8
                   ManufTyp : Byte; //Hersteller: 0=Mot,1=DCC,2=Zimo
                                    //Fahrstufen: Bit0-3 =
                                    //      0=14,1=27,2=28,3=31,4=127}
                   ResultAL : Word;
                   ResultAH : Word);
              1 : (wParam   : LongInt;
                   lParam   : Longint;
                   Result   : Longint);
              2 : (WParamLo : Word;
                   WParamHi : Word;
                   LParamLo : Word;
                   LParamHi : Word;
                   ResultLo : Word;
                   ResultHi : Word);
            end;

Beispiel:

procedure SendLokCommand (aLok, aSpeed : Word; aVorwaerts, aFunktion : Boolean; aF1F8 : Byte; aFahrstufen : Integer; aHigh : Boolean);
var
  LokMsg      : TLokMessage;
Begin
  //Adresse und Geschwindigkeit
  LokMsg.Speed := aSpeed;
  LokMsg.Addr := aLok;
  //Richtung
  if aVorwaerts then
    LokMsg.Direct := 1
  else
    LokMsg.Direct := 0;
  //Funktion 0
  if aFunktion then
    LokMsg.Funktion := $01
  else
    LokMsg.Funktion := 0;
  //Andere Funktionen
  LokMsg.F1F8 := aF1F8;
  //Priorität nur 1 setzen, wenn Lok abgebremst werden soll !!!!
  if aHigh then
    LokMsg.Reserve := LokMsg.Reserve or $04;
  case aFahrStufen of
    14,15 : LokMsg.ManufTyp := 0;
    27    : LokMsg.ManufTyp := 1;
    28    : LokMsg.ManufTyp := 2;
    31    : LokMsg.ManufTyp := 3;
    128   : LokMsg.ManufTyp := 4;
  end;
  SendMessage (InterfaceWnd,wmLok,LokMsg.wParam,LokMsg.lParam);
end;

Lokinformation empfangen

Falls vom Digitalsystem unterstützt, erfolgt die Rückmeldung von Lokinformationen, die am System geändert wurden, durch diese Nachricht.

Empfangene Nachricht: wmSetLok

Zur Auswertung der in Msg empfangenen Informationen muss ein Typecast von Msg in LokMsg? erfolgen. Die Strukur von LokMsg? ist bei ‚Lok steuern’ beschrieben.

VAR
  LokMsg absolute Msg;

Zugidentifikation anmelden

Meldet ein Lesegerät eines beliebigen Herstellers am Interface an.
Jeder Empfänger muss einzeln angemeldet werden, unabhängig davon, ob es sich um ein externes System oder ein im Digitalsystem integriertes handelt.

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
Handle ist das Fensterhandle des aufrufenden Programms.
LeseAdresse? ist die Adresse des Transponding Empfängers.

VAR
  Msg : Tmessage;
BEGIN
  lParamHi := Baustein;  //Die Nummer des Meldebausteins
  lParamLo := Port;      //Der Anschluss des Bausteins
  SendMessage (InterfaceWnd,wmInsMelder,Handle,LeseAdresse);
END;

Zugidentifikation empfangen

Falls ein Transpondingsystem konfiguriert wurde, erfolgt die Rückmeldung von Lok- oder Zugpositionen über diese Nachricht. Derzeit ist nur ‚wParamLoÂ’ spezifiziert; andere Werte sind nicht zu verwenden und müssen zwingend 0 sein.

Empfangene Nachricht: wmZugHelmoPos

Lo (Msg.wParamLo) = Adresse //Adresse des Empfängers
Hi (Msg.lParamLo) = Transponder //Nummer des empfangenen Transponder

Hinweis: Diese Spezifikation ist vorläufig und wird in kürze geändert, da verschiedene Hersteller neue Techniken vorbereiten, deren Unterstützung in Vorbereitung ist.

Kommandos zur Zugsteuerung

Die folgenden Funktionen sind implementiert.

Es ist ein Handle für Züge und/oder Lokomotiven erforderlich. Diese Handles müssen aus der Datenbank entnommen werden. Da kein direkter Zugriff auf die Datenbank besteht, wird eine DLL zur Verfügung gestellt.

Ermitteln von Zug- und Loknamen und deren Handles

Die folgenden Funktionen befinden sich in der ‚rwAPI.dll’. Diese DLL muss sich im gleichen Ordner befinden, in dem auch die Datenbanken (*.dat,*.idx,*.blb) sind. Beim starten der DLL muss evtl. der Pfad angegeben werden.

Function GetFirstLoco : ShortString;
Function GetNextLoco : ShortString;
Function GetFirstTrain : ShortString;
Function GetNextTrain : ShortString;

Function GetLocoHandle (Loco : ShortString) : Integer;
Function GetTrainHandle (Loco : ShortString) : Integer;

Die DLL und ein Demoprogramm ‘TestAPI.exe’ mit Source befindet sich in LINKLINKLINK ‚RailwareAPI.zip’.

Zug anmelden

Erzeugt die benötigten Daten und Tabellen für einen Zug und startet einen Thread, der die Kontrolle übernimmt. Es wird die gespeicherte Lok verwendet.
Das Programm muss sicherstellen, das die Funktion nur einmal für die zu steuernden Züge aufgerufen wird.

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
ZugNummer? ist die Referenznummer des neuen Zuges.

SendMessage (InterfaceWnd,wmZugOpen,ZugNummer,0);

Zug löschen

Speichert alle Daten des angegebenen Zuges und entfernt alle Strukturen aus dem Speicher.

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
ZugNummer? ist die Referenznummer des zu löschenden Zuges.

SendMessage (InterfaceWnd,wmZugClose,ZugNummer,0);

Zug Geschwindigkeit setzen

Beschleunigt oder bremst einen Zug auf eine neue Geschwindigkeit.

Verwendet einen eigenen Nachrichtentyp:

VAR
  TZugMessage    = packed record
                     Msg      : Cardinal;
                     case Integer of
                     0 : (Zug      : Word;  //Zugnummer aus Datenbank
                          Speed    : Word;  //Neue Speed in KmH 
                          Typ      : Byte;  //0=km/h 1=Stufe
                          Reserve  : Byte;  //muss 0 sein
                          Pause    : Word;  //Verzögerung um x Millisekunden
                          ResultAL : Word;
                          ResultAH : Word);
                     1 : (wParam   : LongInt;
                          lParam   : Longint;
                          Result   : Longint);
                     2 : (WParamLo : Word;
                          WParamHi : Word;
                          LParamLo : Word;
                          LParamHi : Word;
                          ResultLo : Word;
                          ResultHi : Word);
                   end;

Beispiel:

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.

VAR
  ZugMsg : TZugMessage;

BEGIN
  ...
  ZugMsg.Zug := ZugNummer;   //Setzen der Zugnummer
  ZugMsg.Typ := 0;           //Angabe in KmH
  ZugMsg.Speed := KmH;       //Neue Geschwindigkeit
  ZugMsg.Pause := 0;         //Normal: sofort ausführen
  SendMessage (InterfaceWnd,wmZugSpeed,ZugMsg.wParam,ZugMsg.lParam);
  ...
END;

Zug Anhalten

Der angegebene Zug wird automatisch angehalten. Das Interface berechnet den Bremsweg und steuert den Zug in Abhängigkeit der Lokparameter selbsttätig.

var
  TZugHaltMessage = packed record
                     Msg      : Cardinal;
                     case Integer of
                     0 : (Zug      : Word;  //Zugnummer aus Datenbank
                          Bremsweg : Word;  //Bremsweg (Ausrollweg) in cm
                          Melder   : Byte;  //unbenutzt
                          Port     : Byte;  //unbenutzt
                          Back     : Byte;  //muss 0 sein
                          Reserve  : Byte;  //muss 0 sein
                          ResultAL : Word;
                          ResultAH : Word);
                     1 : (wParam   : LongInt;
                          lParam   : Longint;
                          Result   : Longint);
                     2 : (WParamLo : Word;
                          WParamHi : Word;
                          LParamLo : Word;
                          LParamHi : Word;
                          ResultLo : Word;
                          ResultHi : Word);
                    end;

Dazu ein Beispiel:

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.

VAR
  ZugMsg : TZugHaltMessage;

BEGIN
  ...
  ZugMsg.Zug := ZugNummer;    //Setzen der Zugnummer
  ZugMsg.Bremsweg := Bemsweg; //Gewünschter Bremsweg in cm
  ZugMsg.Melder := 0;         //Wird nicht benötigt
  ZugMsg.Port := 0;           // ...
  ZugMsg.Back := 0;           // ...
  ZugMsg.Reserve := 0;        //Muss 0 sein
  SendMessage (InterfaceWnd,wmZugHalt,ZugMsg.wParam,ZugMsg.lParam);
  ...
END;

Zug Nothalt

Es wird ein sofortiger Nothalt für den Zug ausgelöst. Alle älteren Kommandos im RAILstack werden abgebrochen. Unter Nothalt wird der in den Lokparametern festgelegte Typ verwendet.

Dazu ein Beispiel:

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.
ZugNummer? ist die Referenznummer des anzuhaltenden Zuges.

BEGIN
  ...
  //Zug sofort durch anhalten
  SendMessage (InterfaceWnd,wmZugNothalt,ZugNummer,0);
  ...
END;

Zug Lok einsetzen oder entfernen

Verwendet eine neue Lokomotive für den Zug oder entfernt sie aus Mehrfachtraktion
Es können bis zu 3 Lokomotiven gekoppelt sein, die in echter Mehrfachtraktion gefahren werden. Dazu werden Lokgeschwindigkeiten individuell aus den Tabellen ermittelt. Bremsvorgänge erfolgen nach einem in Railware beschriebenen Verfahren, falls die Bremswege oder Decodertypen unterschiedlich sind.

TZugLoksMessage = packed record
                     Msg      : Cardinal;
                     case Integer of
                     0 : (Zug      : Word;  //Zugnummer
                          Lok      : Word;  //Loknummer der neuen Lok
                          LokPos   : Byte;  //Lok 1..3
                          Mode     : Byte;  //1=Neu/Wechsel 2=Entfernen
                          Reserve1 : Byte;  //muss 0 sein !!
                          Reserve2 : Byte;  //muss 0 sein !!
                          ResultAL : Word;
                          ResultAH : Word);
                     1 : (wParam   : LongInt;
                          lParam   : Longint;
                          Result   : Longint);
                     2 : (WParamLo : Word;
                          WParamHi : Word;
                          LParamLo : Word;
                          LParamHi : Word;
                          ResultLo : Word;
                          ResultHi : Word);
                    end;

__Zug Lokfunktionen setzen_

Setzt Decoderfunktionen oder Fahrtrichtung für alle an den Zug gekuppelten Lokomotiven.

Definiert und verwendet eine eigene Nachricht:

var
  TZugFunktionMessage = packed record
                       Msg      : Cardinal;
                       0 : (Zug      : Word;  //Zugnummer aus Datenbank
                            Direct   : Byte;  //1-0 = Direction 1=Vorwärts
                            Funktion : Byte;  //1-0 = Funktion
                            F1F8     : Byte;  //7-0 = Funktionen F0 bis F8
                            Pause    : Byte;  //Bewirkt Verzögerung um x Sekunden
                            IgnoreF  : Byte;  //muss 0 sein, 1=Nur Rtg Wechsel
                            Reserve2 : Byte;  //muss 0 sein
                            ResultAL : Word;
                            ResultAH : Word);
                       1 : (wParam   : LongInt;
                            lParam   : Longint;
                            Result   : Longint);
                       2 : (WParamLo : Word;
                            WParamHi : Word;
                            LParamLo : Word;
                            LParamHi : Word;
                            ResultLo : Word;
                            ResultHi : Word);
                      end;

Alle Informationen des Records werden ausgewertet.

Dazu ein Beispiel:

InterfaceWnd? ist das beim Start ermittelte FensterHandle? des Interfaces.

VAR
  ZugMsg : TZugFunktionMessage;

BEGIN
  ...
  ZugMsg.Zug := ZugNummer;  //Setzen der Zugnummer
  ZugMsg.Direct := 1;       //Fahre vorwärts
  ZugMsg.Funktion := 0;     //Funktion 0 ausschalten
  ZugMsg.F1F8 := 8;         //Funktion F4 einschalten
  ZugMsg.Pause := 0;        //Normalerweise 0
  ZugMsg.IgnoreF := 0;     //Muss 0 sein !!
  ZugMsg.Reserve2 := 0;     //Muss 0 sein !!
  SendMessage (InterfaceWnd,wmZugFunktion,ZugMsg.wParam,ZugMsg.lParam);
  ...
END;

Kommunikation zwischen Gleisbildern und eigenen Applikationen

Beschreibung zu einem späteren Zeitpunkt.

Anhang

Zur Steuerung von Schaltdecodern ist diese Definition erforderlich, deren Einträge zwingend in dieser Reihenfolge erfolgen müssen.
Davon dürfen nur die folgenden verwendet werden:

sHp0,sHp1,sHp2,sVr0,sVr1,sVr2,sSh0,sSh1,sWn1,sWn2,sEin,sAus

Senden der nicht freigegebenen Werte kann unabsehbare Folgen haben, da sie lediglich für interne Railware Kommunikation IN Gleisbildern verwendet werden.

TYPE
  TSignal    = (sNichts,sHp0,sHp1,sHp2,sVr0,sVr1,sVr2,sSh0,sSh1,sSh00,sWn1,sWn2,sWn3,sVr00,
                iLok,iKupplerRot,iKupplerGruen,iMelder,iDrehkran,iFunktion,
                iDrehL,iDrehR,iDrehOn,iDrehOff,iDrehRt,iDrehGn,iDrehX,sEin,sAus,
                sDkw1,sDkw2,sDkw3,sDkw4,sDkw5,sDkw6);

---