In dit stukje zal ik uitleggen hoe ongeveer een digitaal systeem werkt, met nadruk op het SLX systeem. Daarna zal ik een voorbeeld geven hoe dit uit te werken in software.
Digitale Aansturing
Bij digitaal rijden via de computer is er sprake van 2 protocollen. Enerzijds het electronische signaal uit de centrale op de rails. Daarnaast de datastroom op de bus. Deze datastroom is feite een adressenbestand met gegevens.
Allereerst is belangrijk te begrijpen hoe de 'bus' is opgebouwd. In een bus wordt gesproken over adressen. Er is een adresbus en een databus.
De adresbus bevat alle mogelijke adressen (zegmaar de huisnummers in een straat) en de databus heeft gegevens die bij de adressen horen. Wat voor gegevens dit zijn is afhankelijk van het apparaat dat naar het adres luistert.
Het aantal adressen op een bus wordt bepaald door de grootte van de adresbus. In SLX is deze 8 bits (1 byte). Dit komt neer op 256 adressen. De databus is ook 8 bits.
Dit kun je afleiden uit het binaire stelsel. Indien je hier niet bekend mee bent, dan is het interessant en aan te raden om hierover eens wat te lezen. Maar om even op te frissen:
Code: Selecteer alles
Decimale waarde 128 64 32 16 8 4 2 1
Positie adresbit 8 7 6 5 4 3 2 1
10000, 5e bit is WAAR, decimale waarde 16. Uitkomst = 16.
10100, 5e bit is WAAR, 3e bit is WAAR, decimale waarde 16 + 4. Uitkomst = 20.
In de windows rekenmachine zit op standje Wetenschappelijk (via Beeld) ook de mogelijkheid om binaire data in te voeren en daarna om te switchen naar decimaal en v.v..
Als je 128+64+32+16+8+4+2+1 optelt komt je uit op 255 adressen, en aangezien 0 ook nog een adres is zit je op 256.Opmerking: In de Rautenhaus handleiding begint men vanaf bit 0. Waarom dit is, is mij ook niet geheel duidelijk, omdat er geen 0 bit is.
ECHTER, nu gebruikt SLX de 7e bit om aan te geven of het om een lees of schrijf actie gaat. Hierdoor mag je 128 aftrekken en kom je uit op 128 adressen (0 - 127).
Maken we een momentopname van een lege SLX bus, met lege databits (waarde), dan ziet deze er als volgt uit:
Code: Selecteer alles
Adres(bin) Adres(dec) Waarde(bin)
00000000 0 00000000
00000001 1 00000000
00000010 2 00000000
00000011 3 00000000
00000100 4 00000000
Bij een SLX lokdecoder is de waarde als volgt opgebouwd:
Code: Selecteer alles
Bit Actie
8 Hoorn/Tyfoon
7 Licht
6 Rijrichting
5 t/m 1 Snelheid. In SLX is deze in 31 stappen. (11111 => 31)
Wisseldecoders en bezetmelders hebben veel minder data nodig. Blok is bezet JA/NEE, wissel is rechtdoor/afbuigend. Hierdoor is voor elk blok/wissel maar 1 bit nodig.
Bij SLX betekend dit dat een wisseldecoder/bezetmelder 8 wissels/blokken kan aansturen. Elke uitgang op het component correspondeert met een bit. Ook combinaties zijn mogelijk, 4 bezetmelders + 4 wissels. Het zal bij SLX bijna altijd 8 zijn, anders verspil je (kostbare) databits. Per 8 is er dus 1 adres nodig.
Bij Rautenhaus is het zo dat er is afgesproken dat adressen 0-111 voor decoders worden gebruikt. De adressen die daarna volgen zijn systeemadressen het systeemstatus opgevraagd kan worden.Opmerking: Er zijn ook bezetmelders die het adres/adressen van loks die op dat blok staan terugmelden.
Opmerking: Snelheid van servoaandrijvingen zijn vaak apart instelbaar.
Daarnaast kan Rautenhaus ook nog de computer gebruiken om te decoders te programmeren. Hiervoor moet je wel een aantal decoderadressen inleveren en houd je 0-104 over. Dit is instelbaar, als je dit uitzet heb je je 0-111 weer terug.
Met de computer
Zodra de computer verbonden is met de interface kan er dataoverdracht plaats vinden. Er kan data in en uit gaan.
Communiceren vind plaats door bits naar de bus te schrijven. Of ervanaf te lezen.
Allereerst zal er een seriële verbinding moeten worden opgebouwd over een COM poort. Bij zo'n verbinding komen een aantal parameters kijken, zoals baudrate. Ik zal straks een voorbeeld geven waarin dit allemaal uitgelegd staat.
Bij Selectrix werkt het daarna als volgt:
Data lezen:
Er worden 2 bytes (2x 8bits) achtereenvolgend naar de bus geschreven. In de eerste byte staat het adres waarvan gelezen moet worden, de waarde van de 2e byte maakt niks uit. Ik heb hem gewoon op 0 gelaten. Het is gewoon een controlebyte.
Hierna volgt direct een antwoord terug in de vorm van een databyte. Het is dan aan jou om dit te interpreteren naar hetgene wat je wilde weten van de decoder.
Data schrijven:
Om data te schrijven worden ook 2 bytes achtereenvolgend geschreven. De eerste byte krijgt nu bit 8 als WAAR mee, om aan te geven dat het om een schrijfactie gaat. Schrijven naar adres 15 zou dus als adresbyte 128 + 15 = 143 krijgen.
In de 2e byte staat de waarde. Zie ook het eerder gegeven schema over de lokdecoder.
Programmeren
Tot zover even het theoretische gedeelte. Tijd voor een voorbeeld in .NET met C#.
Mocht je het willen proberen dan kun je gratis Visual C# 2008 Express Edition downloaden. Ik in veel talen geprogrammeerd, maar de makkelijkheid van het installeren vind ik van Visual Studio toch het beste. Niet handmatig installiepakketjes uitzoeken oid. Als je het eenmaal hebt kun je direct aan de slag.
http://www.microsoft.com/express/download/
(Bij het groene blokje)
Voor nu alleen even een voorbeeldje van hoe een trein te laten rijden. Ik heb hier ook nog een voorbeeld van het uitlezen van de bus en bij de trein een geluidje te laten horen via de computer.
Start via File -> New Project een nieuwe Console Application.
AFBEELDING
Dan zie je het volgende:
AFBEELDING
Dit is de nieuwe void Main code:
Opmerking: Deze code gaat er vanuit dat locadres 1 wordt gebruikt, maar deze is makkelijk aan te passen. Zie daarvoor het commentaar in de code.
Code: Selecteer alles
static void Main(string[] args)
{
System.IO.Ports.SerialPort serialPort = new System.IO.Ports.SerialPort();
/* Baudrate hangt af van de instelling op
* de interface. In mijn geval was het 9600. */
serialPort.BaudRate = 9600;
serialPort.PortName = "COM1"; // compoort.
/* De volgende gegevens zijn specifiek aan het
* protocol dat gebruikt word. Deze heb ik uit
* de handleiding gehaald van Rautenhaus. */
serialPort.Parity = Parity.None;
serialPort.StopBits = StopBits.One;
serialPort.DataBits = 8;
/* verbinden */
serialPort.Open();
/* We moeten 2 bytes schrijven om de trein
* te laten rijden. Dit stoppen we in een array
* Door decimale waardes bij elkaar op te tellen en dmv
* Convert.ToByte te doen, krijgen we de waardes in het juiste
* formaat. Als je 64 weg zou laten zou de loc gaan rijden
* zonder licht. */
byte[] commandoRijden = new byte[]
{
Convert.ToByte(128 + 1), /* 128 schrijfcommando, naar locadres 1 */
Convert.ToByte(64 + 10) /* 64 lichtfunctie, snelheid 10 */
};
/* schrijven naar de bus. de 2e parameter (0) is start
* van de data, maar we willen gewoon het hele commandorijden schrijven,
* dus schrijven we vanaf 0. Anders zou het ook niet werken trouwens.
*
* 3e parameter dito, hoeveel willen we schrijven. Het hele commando graag ;) */
serialPort.Write(commandoRijden, 0, commandoRijden.Length);
/* We wachten 2 sec en stoppen de trein daarna. */
System.Threading.Thread.Sleep(2000);
byte[] commandoStoppen = new byte[]
{
Convert.ToByte(128 + 1), /* 128 schrijfcommando, naar locadres 1 */
Convert.ToByte(0) /* 0, geen snelheid, geen licht */
};
serialPort.Write(commandoStoppen, 0, commandoStoppen.Length);
/* sluiten. is niet perse nodig maar wel netjes. */
serialPort.Close();
}
Download hier het project:
http://www.powerscriptzone.nl/nico/mode ... gitaal.zip
Succes!
