H0 Modelspoor Forum
Modelbaanbouw voor de liefhebber => Eigen bouwprojecten => Topic gestart door: Theo op 13 oktober 2020, 17:02:29
-
Ik ben aan een nieuw project begonnen, het aansturen van een analoge baan via je laptop.
(http://www.mupload.nl/img/1rbi8wp2e0ac.jpg)
Vanuit de laptop wordt de I/O-kaart aangesproken die vervolgens de baan bedient via relais.
Ik probeer het programma zo eenvoudig mogelijk te houden.
In de eerste versie kun je met het programma nog maximaal 32 wissels, blokken en/of seinen bedienen.
De tekening in het programma maak je gewoon met een tekenprogramma zoals paint.
(http://www.mupload.nl/img/8t8yey8ya.jpg)
Gr Theo
-
Je gebruikt deze kaart (https://www.amazon.com/Velleman-K8055N-Experiment-Interface-Board/dp/B0088I0OEI), en ik lees daarover bij farnell (https://cpc.farnell.com/velleman-kit/k8055n/interface-board-usb-experiment/dp/HK01126), die de datasheet (http://www.farnell.com/datasheets/1564584.pdf) beschikbaar stelt, dat je er in windows voor kunt programmeren. Visual Studio, of moet ik toch meer richting assembler denken?
Dit verkoop praatje maakt me niet wijzer:
Het lijkt me iets duurder in de aanschaf dan een Arduino board, maar als je met Visual Studio iets kan, ligt dat anders (maak van je werk je hobby).
Succes.
-
Beste Theo,
Ik denk dat je het leuk vindt om te doen, maar je weet dat zo'n systeem al bestaat, Dinamo http://www.vpeb.nl/oplossingen/treinen/ (http://www.vpeb.nl/oplossingen/treinen/) ?
Groet, Anne W
-
Ja, het is vooral leuk om het te maken. Ik heb ook gekeken naar de arduino, maar een arduino is niet echt geschikt om vanuit je pc aan te sturen, dus toch maar de k8055. Met alleen een k8055 heb je te weinig uitgangen, 8 stuks en daarmee zou je maar b.v. 4 wissels mee kunnen bedienen. Als je gebruik maak van multiplexers kan je maximaal 64 wissels, blokken en/of seinen aansturen.
Bij tante Ali heb ik er nu 4 besteld, dus even wachten totdat ze binnen zijn. (een muliplexer heb je daar al voor 50 cent, toch geen geld meer)
In de versie waar ik nu mee ben begonnen is nog beperkt tot 32 wissels en zo, maar als deze goed werkt kan je als nog naar 64 gaan.
Je kunt het programma zo als het er nu uitziet downloaden via http://www.modelspoorpic.nl/stoomspoor.html (http://www.modelspoorpic.nl/stoomspoor.html)
In eerste instantie kun je met het programma alleen aansturen, maar daarna wil ik ook sensoren plaatsen zodat je kan zien af de trein ook daadwerkelijk is aangekomen. De laatste stap zal dan zijn het maken van een spoorboekje.
Maar eerst even afwachten tot de elektronica binnen is.
Gr Theo
-
Het idee is om de relais op de volgende manier aan te sturen.
De klok staat uit, dus er wordt geen signaal naar de relais gestuurd, zeg maar de "uit" stand in rust.
Dan worden adres-1 en adres-2 gemaakt, hiermee wordt een specifiek relais gekozen, maar nog niet aangezet.
Daarna gaat de klok naar 5V, de "muliplexer 1=>4" heeft een "1=>16 muliplexer" geselecteerd en deze wordt nu aangezet.
Het geselecteerde relais wordt nu 0,5 seconde bekrachtigd.
(http://www.mupload.nl/img/4fc3xpe50g86.jpg)
-
Met de uitgangen kan ik nu even niet verder omdat de multiplexer nog uit China moeten binnen komen.
Maar ik kan wel alvast gaan nadenken over de ingangen, de sensors op de baan.
Ik wil 10 sensoren kunnen plaatsen die om beurten worden afgetast. Iedere seconde worden deze 10 een keer afgetast (en ook moet ik hier een multiplexer inzetten, de kaart heeft van zichzelf maar 5 ingangen.)
Maar het kan zijn dat als z'n sensor wordt afgetast de trein net niet meer over de sensor rijdt en de sensor geen trein ziet op het moment dat ik de sensor uitlees, kort om er moet hier een tijdsvertrager worden gemaakt. Ik denk eraan om hiervoor twee arduino's in te zetten. Je kunt met een programma (een schets) een tijdvertrager maken.
Wie weet een simpele schets om dit te programmeren in arduino-nano??
Deze schets moet aan de volgende eisen voldoen:
- de input moet laag getrokken worden als er een trein over de sensor rijdt
- de uitgang moet 1,2 seconde actief blijven
- de uitgang moet laag getrokken worden bij detectie
- de arduino moet continu blijven detecteren, je kan geen delay of zoiets gebruiken
Wie heeft er een simpele oplossing?
Gr Theo
-
Van arduino weet ik zo goed als niets, dus daarbij kan ik je niet helpen, maar van sensors juist heel veel.
Uit je woordkeus maak ik op dat je een bepaald type sensor voor ogen hebt, namelijk eentje die soms uit is als die aan had moeten zijn. Dat betekent dat je een bipolaire optocoupler niet in overweging hebt genomen, maar bijvoorbeeld denkt aan LDR, IR-beam of IR-reflexie, of zelfs reedcontact of unipolaire hallsensor.
Als je met reedcontacten (unipolaire hallsensoren) werkt, kun je denken aan twee reedcontacten (begin en eind van een traject, of aan twee magneten op de trein (voor- en achterkant). De sensor is uit op het moment dat jij 'm wil pollen, maar je pollt de sensors dan niet zelf, maar het relais (of D-flipflop) dat door die twee sensors per blok of twee magneten per trein wordt bediend. Het voordeel van 2 sensors t.o.v. 2 magneten op de trein is de plaatsingsmogelijkheid, en daarmee de volle lengte van de sectie die je ermee bestrijkt. De andere optie (twee magneten op een trein) is juist handiger voor de positiebepaling van die trein binnen een blok (b.v. gemeten vanuit het midden van een perron), en dan zul je inderdaad soms geen signaal ontvangen als je dat juist wel wilt.
Als je met LDR of IR werkt, dan werkt dat alleen zolang de trein wordt waargenomen, maar ook niet verder dan dat. Dus dat is alleen geschikt voor blokbewaking als de trein even lang is als een blok, en dat is zelden zo. Daarom worden die sensors meestal alleen gebruikt voor puntbewaking (b.v. de achterkant van een trein, de positie van de koppeling).
Een optocoupler heeft als voordeel dat je met stroom- of massadetectie kunt werken, binnen een bepaald tracee (b.v. een blok). Dat faalt nooit, is altijd aan als er een trein is, en altijd uit als hij er niet is. En bij elke poll heb je zekerheid.
LDR en IR zijn wel geschikt om vast te stellen of een deel van een blok vrij is, maar niet om vast te stellen of een heel blok bezet is. Daar komt het verschil met een optocoupler eigenlijk op neer. De optocoupler kan van een heel blok beide statussen vast stellen.
-
Nee, mijn gedachten gaan niet uit naar een specifieke sensor. Het programma dat ik maak moet algemeen en voor iedereen te vrij gebruiken zijn. Wel heeft het de voorkeur dat de sensor de spanning naar beneden trekt, maar dit is niet perse nodig. Bovendien er zijn diverse trucs om een signaal om te keren. Wel de moet de uitgang van de timer omlaag gaan bij een detectie, dit is nodig voor de I/O-kaart (k8055) naar de laptop. Bij het programma wil ik ook een handleiding maken waarin je keuze hebt om een arduino of een PIC te gebruiken als timer.
Gr Theo
-
Bij het programma wil ik ook een handleiding maken waarin je keuze hebt om een arduino of een PIC te gebruiken als timer.
Timer: je wil dus een externe timer hebben vanwege arduino en k8055, en er niet een bestaande timer-chip tegen aan gooien, omdat je dan klokconflicten kunt verwachten.
Ik zit even te denken aan een oud draadje van iemand, Paul Smits, van de Delftse modelbouwclub (op een ander forum (https://forum.beneluxspoor.net/index.php?topic=57884.0)).
Die was bezig aan een eigen besturingssysteem (arduino) op basis van bezetmelding met 1 LDR per blok, en een IC ULN2803A voor het multiplexen.
Hij kreeg het advies over te stappen naar 8x BD679A, omdat deze IC in praktijk ongeschikt was gebleken.
Hij komt dan uit op een derde mogelijkheid, een MOSFET (dat zegt mij al niets meer).
Hij krijgt van alle kanten advies. En moet halverwege z'n project stoppen om privéredenen.
Hij is dan al 3 keer geswitcht van arduino-types omdat oudere types niet voldeden.
Erg interessante lectuur, vooral alle goedbedoelde commentaar van kenners.
Lees het door want jij begrijpt er meer van dan ik.
Wel de moet de uitgang van de timer omlaag gaan bij een detectie, dit is nodig voor de I/O-kaart (k8055) naar de laptop.
Dat heet, als ik het goed begrijp, "input moet laag getrokken worden", dus naar GND?
In het algemeen doet men dat pull down gebeuren met een stevige weerstand van 1K.
Dat begrip is meer dan eens uitgelegd op een ander forum. Vakjargon. Maar wel nuttig om te weten.
Even 5 willekeurige draadjes waarin ik de term tegen kwam in verband met arduino:
url1 (https://forum.beneluxspoor.net/index.php?topic=57884.msg3221648470#msg3221648470),url2 (https://forum.beneluxspoor.net/index.php?topic=70147.msg3221675785#msg3221675785),url3 (https://forum.beneluxspoor.net/index.php?topic=64725.msg3221573102#msg3221573102),url3 (https://forum.beneluxspoor.net/index.php?topic=61692.msg3221524857#msg3221524857),url5 (https://forum.beneluxspoor.net/index.php?topic=87397.msg3222003279#msg3222003279)
Ik maak uit die draadjes iets anders op dan een elektronicus of een Arduino gebruiker.
Analoog als ik ben, denk ik dan dat het gaat om het aloude principe van iets schakelen tegen + of -.
Ik heb er geen moment aan gedacht dat het daarbij om een timer zou kunnen gaan die je omlaag wilt kunnen trekken.
Laat staan dat ik me voor kan stellen wat er dan fysiek gebeurt: oorzaak-gevolg, ingreep-effect?
Het Beneluxspoor forum is overigens niet het enige treintjesforum met een actieve Arduino gebruikers groep.
Het 3-rail forum heeft ook zo'n groep, maar die zie je alleen als je bent ingelogd op die site. Buitenstaanders zien daar niets van. En het stummiforum.de heeft ook een actieve groep Arduino gebruikers. Gelegenheid tot buurten is er dus genoeg.
-
Nee, het is de bedoeling dat de arduino als timer wordt gebruikt, hij is dus de timer.
De arduino trekt op zijn beurt (als er een trein passeert) de K8055-pin leeg.
De timer moet het signaal van de sensor even oprekken, zodat deze zeker wordt gezien.
Je zou een analoge timer kunnen maken met een 555-ic, maar dat is een verleden tijd.
Gr Theo
-
Je zou een analoge timer kunnen maken met een 555-ic, maar dat is een verleden tijd.
In die verleden tijd leef ik nog. Dus als ik een 556 of 557 tegen kom, denk ik, leuk, zij bestaan ook nog, net als ik.
Een timer rekt dus een signaal wat op, maakt het langer, opdat het signaal door de PC gezien kan worden.
De PC snuffelt dus mee aan de Arduino, maar kan er niet rechtstreeks mee communiceren, op het eenmalig moment na dat je de code oplaadt naar de Arduino.
De Arduino kan wel de PC-insteekkaart (K8055) leeg trekken, maar de PC-insteekkaart kan de Arduino niet leegtrekken.
Dat wordt allemaal anders als je Arduino met wifi uit rust, want dan kan de PC (via wifi) wel actiever meesnuffelen?
(en heb je de insteekkaart- K8055 niet meer nodig, en dus de pull down op de timer ook niet?)
-
Ja, de arduino moet alleen maar het signaaltje iets oprekken meer niet. Ik wil daarvoor de arduino-nano inzetten.
Deze is goedkoop, simpel en direct klaar voor gebruik. Volgens mij kan de arduino-nano niets met wifi, daarvoor moet je het broertje hebben van de nano. (denk ik, want zo thuis in arduino ben ik ook weer niet). Zonder wifi heeft ook zijn voordelen, geen hackers of andere stoorzenders. Bij de metrolijn naar Hoek van Holland kunnen daar over meepraten. Toen alles nog van de NS was reedt de lijn 80 jaar zonder problemen, Maar de lijn moest gemoderniseerd worden en om gebouwd worden naar metro, ze hebben 2 jaar lang storing gehad, in die tijd kan de lijn niet worden gebruikt.
Inderdaad ardiuno trekt de PC-steekkaart leeg, maar de PC-steekkaart kan op zijn beurt ook de arduino leeg trekken als je dat wil, maar daar ga ik hem niet voor gebruiken.
Nee, ik ben alleen opzoek of iemand de code als timer voor een arduino kan schrijven, ik heb de code wel in een andere gelijk soortige taal, maar deze moet omgezet worden zodat een arduino die kan lezen.
Gr Theo
-
Hoi Theo,
Ik kan wel een sketch in elkaar draaien. Ben al bezig....
Rob
-
Hoi Theo,
Hier de "Signaalverlenger" sketch voor de Arduino.
Je kunt op de computer (seriele monitor in de Arduino IDE) volgen welke pinnen 'laag' worden. Dit kun je na het soldeerwerk en testen ook uitzetten door de foutzoeker definitie op 'false' te zetten.
De pinnen die je wilt gebruiken kun je zelf definiëren, ook het aantal is instelbaar (al zul je dan ook de reeksen -Arrays- moeten uitbreiden).
Onder het motto: de beste documentatie is de code zelf, zie de toelichting in de sketch.
/*
SIGNAALVERLENGER
versie 1, 17 okt 2020, Rob van Deursen
De signaalverlenger meet input van sensoren en geeft het signaal langer door op overeenkomstige uitvoer pinnen.
Hiervoor gebruikt het programma 3 reeksen (Arrays):
- Een reeks voor het meten van de invoersignalen ("laag") op een of meer invoer pinnen (sensor pinnen)
- Een reeks met overeenkomstige uitvoer pinnen (signaal pinnen), die het invoer signaal langer doorgeven (ook als "laag").
- Een reeks voor het timen van de lengte van het signaal op elke signaal pin.
Het aantal pinnen, de gebruikte pinnen en de tijdsduur van de signaalverlenging worden in de definities vastgesteld.
Ook is er een foutzoeker, die met seriele print aangeeft welke sensoren actief zijn. Deze kan worden uitgezet.
*/
//*** DECLARATIES ***
//--- Definities ---
#define aantalSensoren 5 // aantal sensoren en signalen
#define verlengTijd 1200 // verlengtijd van het signaal, in milliseconden.
#define foutzoeker true // de foutzoker geeft sensor waarden door op de seriele monitor.
// zet de foutzoeker op 'false' als er geen fouten zijn te zoeken.
#define Sensor_1 2 // invoer pinnen (waar de sensoren op zijn aangesloten)
#define Sensor_2 3
#define Sensor_3 4
#define Sensor_4 5
#define Sensor_5 6
#define Signaal_1 9 // uitvoer pinnen (waar het verlengde signaal op wordt gegeven)
#define Signaal_2 10
#define Signaal_3 11
#define Signaal_4 12
#define Signaal_5 13
//--- Variabelen ---
int index = 0;
int SensorPin[] {Sensor_1 , Sensor_2 , Sensor_3 , Sensor_4 , Sensor_5 };
int SignaalPin[] {Signaal_1, Signaal_2, Signaal_3, Signaal_4, Signaal_5};
long Alarmtijd [aantalSensoren];
//*** INITIALISATIE ***
// Zet de invoer en uitvoer pinnen in de juiste configuratie en initialiseer variabelen
void setup() {
for (index = 0; index < aantalSensoren ; index++) {
pinMode (SensorPin[index], INPUT_PULLUP); // sensor pinnen in 'invoer' modus met interne pullup actief.
pinMode (SignaalPin[index], OUTPUT); // signaal pinnen in 'uitvoer' modus
digitalWrite (SignaalPin[index], HIGH); // geen signaal = 'hoog'
Alarmtijd[index] = 0; // initialiseer alarmtijd
}
#if foutzoeker
Serial.begin(9600);
Serial.println("Foutzoeker actief");
#endif
}
//*** HOOFDPROGRAMMA ***
// Elke invoerpin wordt gelezen. Bij "laag" op de invoerpin (sensor) wordt de overeenkomstige uitvoerpin
// ook "laag". Daarnaast wordt de Alarmtijd gezet. Bij het aflopen van de alarmtijd wordt het signaal op
// de uitvoerpin weer 'hoog'.
void loop() {
for (index = 0; index < aantalSensoren ; index++) {
if ( digitalRead(SensorPin[index]) == LOW) { // sensor is actief
digitalWrite (SignaalPin[index], LOW); // signaalpin naar "laag"
Alarmtijd[index] = millis() + verlengTijd; // zet de alarmtijd
#if foutzoeker
Serial.print("'laag' signaal op pin: ");
Serial.println(SensorPin[index]);
#endif
}
if (Alarmtijd[index] < millis()) { // alarmtijdstip is gepasseerd.
digitalWrite (SignaalPin[index], HIGH); // Signaalpin naar (of blijft) "hoog"
}
}
}
Je kunt, zoals gezegd, een en ander volgen inde seriële monitor, maar met deze definities zet digitale pin D06 ook de onboard LED op pin D13 voor 1,2 seconde uit. Dus dat kun je testen door pin 6 even met de GND te verbinden.
Overigens is een en ander nu zo geprogrammeerd dat de signaalpin 1,2 seconde 'laag' blijft nadat de sensor pin weer hoog is geworden.
Als je nog vragen hebt, hoor ik het wel.
Rob
-
Bedankt Rob,
Deze had ik zelf niet zo bedacht, hij is best ingewikkeld.
Ik heb zelf ook een arduino gekregen, maar nog nooit iets mee gedaan.
Deze ga ik mee nemen in het project.
Gr Theo
-
Graag gedaan, Theo.
Succes er mee!
Rob
-
Zonder wifi heeft ook zijn voordelen, geen hackers of andere stoorzenders. Bij de metrolijn naar Hoek van Holland kunnen daar over meepraten.
Als ouderwets netwerker: ik zweer bij vaste lijnen.
Ik heb ooit een wifi-muis gehad die op hol sloeg als de buurman van TV-kanaal switchte.
Toen ik het wifi modem bij de wisselwoning aansloot, bleek de hele woonwijk op wifi te zitten, sommigen met de deur uitnodigend open voor gasten. Op een stand alone PC kwamen de nieuwste Microsoft updates binnen, en 100x zo snel als via de eigen verbinding, zonder aansluiting of toestemming (straalverbinding van een van de buren). Paar van dat soort geintjes, en je trekt alle wifi zooi uit je hardware. Ik zweer bij kabeltjes trekken (LAN of USB).
Volgens mij kan de arduino-nano niets met wifi, daarvoor moet je het broertje hebben van de nano.
Fijn dat Rob je direct kon helpen.
Over die nano had ik heen gelezen, maar je hebt gelijk, althans ik trof een citaat van een kenner (https://forum.beneluxspoor.net/index.php?topic=67739.msg3221629311#msg3221629311):
als hij Wifi wil toevoegen (neem aan met een ESP8266) kan hij het net zo goed gelijk
poorten naar de ESP. Wat betreft snelheid en geheugen is deze veel sneller /
beter geschikt dan een ATmega (Nano/Pro Mini/Uno)
En zo blijkt:
De ESP8266 heeft wifi onboard (https://forum.beneluxspoor.net/index.php?topic=67699.msg3221628995#msg3221628995), en de andere Arduino's niet. De jouwe dus ook niet. (Dat maak ik eruit op).
Tegelijkertijd hou ik twijfels want: De wemos d1 (https://forum.beneluxspoor.net/index.php?topic=84035.msg3222064192#msg3222064192), een arduino board voor wifi.
Leuk, maar is dat dan een shield die je ergens op kunt gebruiken of is dat feitelijk zelf een arduino-variant?
Uit de contekst maak ik op dat het een van de vele Arduino klonen is.
En deze: Met de Arduino Mega met Wifi, of Mega2560 met losse wifi modules (https://forum.beneluxspoor.net/index.php?topic=87657.msg3222068067#msg3222068067) maken wifi mogelijk; maar die wifi is aan te passen naar ethernet-gebruik (via een library).
De Nano zit daar inderdaad niet bij. Dus jouw Arduino kan het niet, ook niet met losse modules ...
Goh, weer wat geleerd door even wat beter op te letten op zijsprongen in draadjes.
-
Nou Jan,
Als je het toch over verbindingen hebt met draden: de Arduino's kunnen altijd nog serieel praten en luisteren. Niet de snelste manier, maar als er alleen maar wat statussen over de lijn hoeven, is dat ook nog te overzien.
Dus @Theo , misschien is dat seriële gebeuren ook nog een idee naast, of in plaats van, de multiplexers?
Rob
-
Tja, ik zat even in een ander draadje verdiept (https://www.themt.de/el-0100-logc-49.html#aand), iemand die op een simpele manier probeert uit te leggen waarom je pullUp en pullDown weerstanden nodig hebt, zodra je met transistors werkt (en dat speelt vast ook met arduino's en zo).
Bij een NPN–Transistor wordt de Basis via een 330 k–weerstand naar de min–pool „omlaag getrokken” (pull down),
bij een PNP–Transistor omhoog naar de plusppol (pull up).
Omdat transistors anders onbetrouwbaar werken, vanwege hun gevoeligheid voor inductiviteit en dat soort zaken.
Dat is geen uitleg, meer een definitie, maar ik kan ermee leven, en inzien dat het om een vergelijkbaar iets moet gaan.
Draadjes, draadjes, draadjes. Ze zijn niet snel, en hoe lomper de elektronica hoe beter mijn ogen ze nog zien, inclusief draadjes. Bij zo'n SMD bordje (zoals die Arduino's) mogen ze van mij een loep met ledlamp bijleveren.
-
Nu je het hebt over pulldown weerstanden, ook ik moet gebruik maken van deze weerstanden, het is de simpelste manier om een signaal om te keren. Maar ook bekende bussystemen zoals I2C en SPI gebruiken een pulldown weerstand.
Gr Theo
-
Weer een stukje verder met het programma, er kunnen nu de eerste 5 sensoren worden ingelezen.
Ook het eerste beginnetje van de dienstregeling is er. Je bouwt de dienstregeling op met het invullen van het blokdiagram.
Je start de dienstregeling door op de knop "Dienst" te drukken.
(http://www.mupload.nl/img/edxq34vpg4u4q.jpg)
Gr Theo
-
Weer een stukje verder. Als voorbeeld een dienstregeling van "een rondje rond de kerk".
Bij de start wordt eerst wissel-3 om gezet.
- dan wordt het railblok onder spanning gezet zodat de trein vertrekt.
- hierna 4 seconde wachten, even de trein de tijd geven om te vertrekken.
- het railblok komt weer zonder spanning te staan.
- wachten totdat de trein over sensor-1 weer binnen komt.
- 60 seconde wachten bij het perron
- terug naar 2 voor de volgende ronde.
(http://www.mupload.nl/img/g2l9mcwb.jpg)
Het programma begint al een klein beetje te werken.
Gr Theo
-
Een klein foutje ontdekt in het programma waardoor het programma vast kon lopen, maar dat is inmiddels verholpen.
(http://www.mupload.nl/img/c9ikoxk6w.jpg)
De aansluitpinnen hebben in het programma een bijnaam gekregen. Als b.v. een wissel op pin-9 zit om "om" te gaan, is pinnummer-9 niet makkelijk om te onthouden. Hij heeft nu een bijnaam gekregen, hier kun je hem W13Om noemen (Wissel-13 gaat om).
Gr Theo
-
De eerste versie is klaar, het programma en de gebruikshandleiding.
Misschien zijn er nog verbeteringen?????
De handleiding en programma kun je vinden op de site http://www.modelspoorpic.nl/stoomspoor.html (http://www.modelspoorpic.nl/stoomspoor.html)
Gr Theo
-
De multiplexers uit China zijn binnen gekomen, dus tijd om een testversie te maken.
(http://www.mupload.nl/img/ne4ik8trolz.jpg)
Het relaisblok heb ik nog even vervangen door test LED's, omdat ik nog geen goede relaisblok heb, die ik heb is 12V en geen 5V.
Maar de testopstelling werkt, wel is het even uitzoeken waar wie is terecht is gekomen.
De wissels krijgen 0,5 seconde om over te gaan, lijkt mij voldoende.
Inmiddels ben ik ook bezig met een uitgebreide versie te maken, ik heb hem maar StoomspoorXL genoemd.
Deze versie staat als alles goed gaat in december op de site zodat dat iedereen hem kan gebruiken als hij/zij dat wil.
Deze versie heeft 63 aansluitingen voor wissels, blokken enz. 10 sensor ingangen, en hiermee kun je vier dienstlijnen gelijktijdig en onafhankelijk van elkaar laten rijden.
Theo
-
Al hoewel ik nog met het programma bezig ben (het schiet al aardig op), ben ik alvast aan het brainstormen voor de volgende stap.
Daarbij denk ik aan het uitbreiden van het aantal lijnen van 4 naar 6 en het maken van een echte dienstregeling met spoorboekje.
Ook moet er een stations bord komen zoiets als
(http://www.mupload.nl/img/7fsmymemwvl.jpg)
waarbij de treinen dan ook daadwerkelijk zo gaan rijden volgens de klok.
Het zal wel een dienstregeling worden die elk uur herhaald of zoiets.
Het bord komt op een aparte pagina zichtbaar.
Ik zie wel wat het gaat worden.
-
Wow! Dat ziet er interessant en inspirerend uit.
Ook wel verbazend om te zien hoeveel verschillende aspecten de modelspoorhobby heeft en is elk aspect een hobby op zich.
(http://www.mupload.nl/img/7fsmymemwvl.jpg)
Ik begrijp dat dit niet een klein LCD-scherm wordt dat op je perron komt te staan? :o
-
Nee, niet op een kleine LCD-scherm, gewoon op je laptop.
Ik heb inmiddels de eerste versie op het web gezet.
Je kunt 5 diensten draaien,
(https://www.mupload.nl/img/wfeopxk2s1a.jpg)
De treinen rijden nu volgens je ingestelde spoorboekje.
Het spoorboekje maak je met
(https://www.mupload.nl/img/ejohgeif4sy.jpg)
Met de frequentie bepaal je het aantal ritten per uur.
Met minuut geef je aan wanneer de eerste trein moet vertrekken.
"Via", "Naar" en "Spoor" komen op het perronbord te staan.
Gr Theo
-
Nu ik toch bezig ben, vraag me af hoe de digitale code naar de treinen en wissels is opgebouwd?
Ik krijg de indruk dat het via het I2C protocol gaat, maar helemaal zeker ben ik er niet van.
I2C is een bussysteem waarbij alle signalen over een draadje verlopen.
Weet iemand hoe het protocol gaat in deze digitale besturing?
Op internet kun je eigenlijk daarover niets vinden.
-
Weet iemand hoe het protocol gaat in deze digitale besturing?
Op internet kun je eigenlijk daarover niets vinden.
Dat hangt ervan af op welk level je die info zoekt. Als je C-source zoekt, die is er.
Als je bij Arduino zoekt, er zijn al library functies.
Als je op protocol zoekt, zijn er meerdere draadjes, zoals deze
understanding-the-i2c-protocol (https://www.engineersgarage.com/tutorials/understanding-the-i2c-protocol/)
Met dit voorbeeldstukje:
Steps involve for writing the data from Master to Slave:
Address- 1011010, Register Address – 11001010
1. To start communication, Master first sends a START command to the bus.
2. Then sends the 7-bit unique address of the desired slave with the write operation command set to 0.
3. Wait for the acknowledgement (ACK) from the slave/receiver.
4. All connected slaves listen to the address and matched slave responses with ACK byte set.
5. For successful acknowledgement, it sends the required internal 8-bit register address of the slave to which data needs to be written.
6. The selected slave matches the register address, If matches, sends the ACK bit to set otherwise, it sends NACK byte (Non-Acknowledgement byte, describe later.)
7. Master again waits for the acknowledgement.
8. For successful acknowledgement, write the 8-bit data to the slave. When complete data is written on the slave, Slave sends an acknowledgement bit ACK to the Master to notify that it is the end of the writing process.
9. The Master then sends a STOP command as a termination signal to the bus.
And this process goes on until Master writes the complete data to the slave.
Dat is nog steeds vrij abstract, tot je in de C-code of arduino code duikt, die je elders vindt.
Maar je vraag duikt dieper dan de oppervlakte: digitale besturing ....
Ik denk dan simpel: dit protocol is toch al digitaal?
Waarschijnlijk bedoel je dus iets anders: b.v. hoe werkt het digitale protocolt.a.v. wissels en treinen nu al/nog?
Want de bestaande digitale protocollen in de treintjeswereld zijn online ook (min of meer, iets lastiger in verband met copyrights) te vinden. Alleen: van oudere herkomstdatum dan deze "I kwadraat C" technologie. Dus gegarandeerd daar nog niet op gebaseerd, en dus ook nog niet op de "I kwadraat C"-bus. Want de datering van bus en protocol hangen wel samen, natuurlijk.
Kortom: leef je uit in dit draadje, en vertel ons iets meer over je ideeën hierover.
Deze technologie is jonger dan ik 8)
En begin b.v. eens met het DCC-protocol (https://de.wikipedia.org/wiki/Digital_Command_Control), dat is open source, b.v. Schaltdecoder (https://www.opendcc.de/elektronik/opendecoder/opendecoder_sw_schalt.html), en dus behoorlijk goed gedocumenteerd.
Het Märklin systeem, daar krijg je lastiger info over, al lukt dat ook, als je je zinnen erop zet.
-
Na veel zoeken op internet heb ik wel wat kunnen vinden.
Ieder merk heeft zijn eigen manier (protocol) om de signalen op te bouwen en door te geven.
kijk op==> https://people.zeelandnet.nl/zondervan/digispan.html
Het is geen I2C dat ze gebruiken, maar ieder merk lijkt wel zijn eigen protocol te gebruiken, marklin heeft er 2, MM en MFX.
De meeste gebruiken tijds-pulsen met verschillende puls-lengte.
Maar kan ik er wat mee om het te gebruiken binnen het programma van mij?
-
Die pagina van Klaas Zondervan ken ik. Het enige wat je daarbij kunt bedenken is een object georiënteerde codering die voor alle bestaande protocollen een gemeenschappelijke (abstracte) class heeft, en ook I2C dekt.
Die code kan dan gebruikt worden om standaard met alle servers, slaves, memories en randapparatuur I2C te communiceren, en toch alle bestaande protocollen te ondervangen, bijvoorbeeld in een arduino omgeving.
Maar dat moet je willen. Als jij het niet wil, komt er wel een ander die het wel wil, maar dat kan nog even duren voor die code toepasbaar komt, schat ik zo in. En als dat open source moet zijn, dan wordt het tijd voor een github of sourceforge project.
Als er niet al zo'n project is ...., want dat heb ik nog niet gecheckt.
-
Maar dan komt de vraag wat wil je aansturen?
Wissels en seinen aansturen heeft geen meer waarde op deze manier, die worden al aangestuurd.
Wat over blijft zijn de treinen op de baan, deze zou je alleen kunnen aansturen door zelfs pic's te programmeren. maar moet je zover gaan? Ik denk het niet, het is een gigantische puzzel en werk en bovendien moet je ook over testmateriaal beschikken.
Nee, ik ben wat aan het maken voor de analoge baan, daarvoor is er niet veel. Op deze manier heb je toch een PC-besturing waarmee je alle oude en analoge locomotiefjes kunt aansturen en bovendien voor weinig geld.
-
Weer een stukje aan spoomspoor toegevoegd.
Je kunt delen van de baan inkleuren, b.v. hier een blok dat nu even zonder spanning staat.
(http://www.mupload.nl/img/36vhcb0wwh.jpg)
Geef de coördinaten en de kleur op.
-
Nee, ik ben wat aan het maken voor de analoge baan, daarvoor is er niet veel. Op deze manier heb je toch een PC-besturing waarmee je alle oude en analoge locomotiefjes kunt aansturen en bovendien voor weinig geld.
Dat je daarover/-aan begint .. Je zou Gerard van der Sel moeten benaderen. Die hield jarenlang de HCC website (en de hardware) bij van de HCC modeltrein automatiseerders (https://home.hccnet.nl/gerard.vd.sel/hccmsysteem/). Die reden analoog met een PC (toen nog dos-gestuurd).
Volgens mij hebben ze de stekker eruit getrokken wegens gebrek aan belangstelling. Maar dat zou je hem kunnen vragen.
Hij heeft vast nog wel wat verbeter-ideeën o.a. over I/O-kaarten (https://home.hccnet.nl/gerard.vd.sel/hccmsysteem/io_kaarten.html).
Een andere manier bestaat er ook, maar is niet gedocumenteerd, uiteraard (gebruik van deze weg wordt niet gestimuleerd).
Gratis met Koploper (in virtuele mode), of betaald met iTrain. Beide software pakketten zijn bruikbaar met het dinamo systeem, en dat systeem staat toe om gemixt te rijden met digitale en analoge locs (mits DC-gestuurd).
Die software pakketten kunnen (dus) ook overweg met analoge locs. De handleidingen geven dit dan ook aan.
De enige twee zaken die je analoog dan moet willen, zijn S88-dectectie en aansturing van wissels en seinen middels door de PC aangestuurde relais.
Want beide software pakketten moeten weten waar treinen zich bevinden, en beide moeten wissels en seinen (en daarmee de treinenloop) kunnen bedienen.
Alleen dan kun je analoog spreken van een PC-bestuurde treinbaan. En de vraag is: wil iemand die analoog rijdt dat wel?
-
Ik rij zelf ook op deze manier, analoge treinbesturing vanuit je pc. Je maakt allemaal blokken op je baan en je rijdt van blok naar blok.
Lekker op deze manier rommelen aan je eigen besturing is vooral leuk om te doen.
Op de I/O-kaart zitten ook nog twee analoge ingangen op, deze heb ik nu in het programma meegenomen met 2 voltmeters.
Kan je ook gelijk de rijspanning zien op de baan.
Een nadeel van de I/O-kaart is wel het beperkte aan terugmeldingen, hiervoor zou je eigenlijk iets moeten verzinnen om dit uit te breiden.
-
Zo zien de beide voltmeters er uit, een beetje ouderwets.
(http://www.mupload.nl/img/duq5u6qa.jpg)
De tekst kun je aanpassen.
-
Op de I/O-kaart zitten ook nog twee analoge ingangen
HCCM-I/O kaarten of andere I/O-kaarten?
Op zich lijkt me op dit niveau niet veel uitmaken of een ingang analoog is of digitaal, maar misschien vergis ik me.
Belangrijker lijkt me dat een ingang in staat is om dword-waarden of qword-te verwerken. Want dan kun je er iets mee in een zelf te schrijven software programma.
-
Een ingang is een booleaan, een twee standen getal. Er is wel een trein of er is geen trein in het blok.
Maar er is misschien toch een oplossing voor het probleem, op de kaart zitten ook twee PWM uitgangen die totaal niet worden gebruikt.
Deze zijn beide wel 8 bits. Maar deze kun je ook gebruiken voor een hoog/laag signaal en dan heb je 4 standen in totaal er bij.
Ze zijn daar eigenlijk niet voor bedoeld, maar het werkt wel.
Je hebt: Beide laag, 1e hoog 2e laag, 1e laag 2e hoog, beide hoog.
Op deze manier kom je met 5 kaart-ingangen x 4 mogelijkheden = 20 ingangen om sensoren in te lezen.
Totaal kom je dus dan uit op:
63 te bedienen wissels, blokken, seinen enzo,
20 in te lezen terugmelders.
Er is ook nog een truc te bedenken dat je de ingangen verdubbeld naar 128-1= 127 wissels enzo, maar zou je wel zo ver willen gaan??
Theo
-
63 te bedienen wissels, blokken, seinen enzo,
20 in te lezen terugmelders.
Dat geeft aan wat er fout gaat in deze opzet. Een beetje baan heeft veel meer terugmelders dan wissels.
Blokken zijn spoorstukken tussen wissels en spoorstukken tussen spoorstukken. Stel elk blok (spoorstuk) heeft minimaal 1, mogelijk 2 of 3 melders nodig, dan zit je al gauw aan een verhouding van wissels (blokken, seinen enz):terugmelders= 1:3
in plaats van 3:1.
M.a.w. het vergt een totale omslag van denken (en aanleg) als je uit moet gaan van een verhouding van 3:1.
wissels
Een zo'n denkomslag zit bij de wissels. Eén wissel heeft minimaal 2 uitgangen nodig (recht en afbuigend), maar levert mogelijk ook 2 melders (terugmelders wisselstand: recht en afbuigend). Dat kun je analoog anders bedraden, maar dan weet het PC-programma dat niet. Je kunt zelfs analoog doorlussen via wisselrelais dat wisselstanden benut worden om enerzijds vooruitblikkend (inrijwisselstraat) anderzijds terugblikkend (uitrijwisselstraat) blokken vrij te geven of te zetten.
Digitale PC-rijders maken onderscheid tussen rijweg en wisselstraat. Een rijweg is een opeenvolging van blokken en wissels (met wisselstanden). Analoogrijders doen dat soms ook, met name bij complexe wisselstraten (b.v. bij stations).
Analoogrijders maken daarbij gebruik van terugmelders, digitale PC-rijders van terugmeld-detectoren. Het grote verschil zit tot dusverre is de rol van de spanning van het terugmeldsignaal (analoog: kun je iets schakelen met het signaal, versus digitaal: kun je het signaal verwerken?). Als je analoog met een PC rijdt, valt je in die 2e categorie (kun je het signaal verwerken?)
Wat bij veel software pakketten opvalt is dat blokken melders hebben, maar rijwegen (in principe) niet. Analoog spreekt dat laatste niet vanzelf.
seinen
Een andere denkomslag zit bij seinen. Stel je neemt blokseinen, omdat blokken doorgaans in een vaste rijrichting opeenvolgend zijn. In het analoge Märklin systeem is er 1 melder per bloksein (pal na dat sein, en die bewaakt de treinvoorkant); een stopplaats pal voor dat sein, de rest van het blok heeft rijspanning van de ringleiding, en bevat geen melders, maar wel een condensator unit om te voorkomen dat meerdere slepers in een trein ook leidt tot meerdere pulsen. En ja, dan volstaat 1 melder per blok.
In een 2+3-rail systeem kan dat niet op die manier, omdat het hele blok 2-rail of 3-rail is (maar niet beide). Het blok staat bij binnenkomst dus al op 2-rail of op 3-rail. De stopplaats is zo lang als het hele blok, de remweg (afhankelijk van het seinbeeld) wordt vanaf hoger niveau geregeld, en de melder bevindt zich achterin het blok (de treinachterkant is bepalend voor het eventuele stoppen) ; het blokseinbeeld (=uitrij-seinbeeld=volgend blok bezet/vrij) en het inrijrecht (tot een blok met sein rood) zijn gesplitst: de stopplaats (vergroot tot een heel blok) staat toe dat een trein de stopplaats berijdt, ook als die trein in dat blok (en dus in die stopplaats) moet gaan stoppen.
Bij 2-rail systemen zijn er 2 manieren: trein-voorkant melding of trein-achterkant melding; beide hebben hun eigen afhandelingslogica.
Daarvan afgeleid is een 3-rail variant met monostabiele relais (in zelfhoud schakeling): de treinvoorkant zet het relais aan (voor de rit tot aan de stopplaats), de treinachterkant schakelt het relais uit (als het volgende blok bezet is), en bepaalt daarmee de stopplaats (die dus treinlengte-variabel is). Uiteraard komt die variant ook voor bij 2-rail rijders.
Wat je kunt zien aan die verschillende visies (en oplossingen) is dat er minimaal 1 of 2 bezetmelders nodig zijn per blok (bij eenrichtingsverkeer), dat de stopplaats vast of variabel van lengte kan zijn, en dat dit niet afhankelijk is van de vraag of er een wissel volgt. Seinen zijn in veel analoge denksystemen niet bepalend voor de treinafhandeling. Ze geven slechts een beeld van de situatie in het volgende blok (of de volgende blokken): mag de trein in het huidige blok 1 blok verder of mag hij dat niet?
Die kwestie wordt interessanter als je naar blokken gaat kijken die in twee richtingen bereden mogen worden.
Je hebt dan meer terugmelders nodig, ongeacht welk analoge systeem je nastreeft.
En daarom zeg ik: je verhouding is verkeerd om, en daar ga je op vast lopen, tenzij je dat weet om te draaien.
-
Dat valt wel mee denk ik, voor de wissels, blokken en seinen heb je geen terugmelders nodig.
Alles wordt vanuit een systeem geregeld, dus de stand van de wissels, de seinen en de blokken zijn al bekend binnen het systeem.
Neem als voorbeeld deze opstelling:
(http://www.mupload.nl/img/c8pt5gmppl.jpg)
Er zijn 3 sporen bij het station en 2 treinen op de baan. Een trein rijdt tegen de klok in en de andere met de klok mee.
Beide moeten over het enkelspoor rijden.
In deze opstelling heb je 4 wissels, 6 blokken en 2 seinen, totaal heb je dus 12 aansturingen.
Je hebt aan 2 sensoren genoeg in deze opstelling. Hoeft namelijk helemaal niet te weten waar de trein is.
Je moet alleen weten dat hij binnen is gekomen na zijn rit, als je dat weet, weet je ook dat hij vertrokken is.
Als hij vertrekt zet je het sein eerst op groen, dan zet je zijn blok op spanning zodat de trein vertrekt.
Hij rijdt dan over een sensor heen, maar ook die hoeft je niet perse te weten. Als het blok op spanning gezet wordt mag je aannemen dat de trein vertrekt, het is dan logisch dat het sein na b.v. 2 seconde op rood gaat en dat het blok weer zonder spanning komt.
Als je in deze opstelling kijkt naar de verhouding sensoren : uitgangen krijg je de verhouding 2 : 12.
Je kan zo een dienstregeling maken die die van spoor naar spoor loopt, een trein die vertrekt kan tekens kiezen uit 2 sporen om aan te komen.
-
b.v. 2 seconde
Tijdslogica! Ik vat 'm, geloof ik.
Maar dat betekent dat je afziet van een check op koppelingsbreuk (achter gebleven wagons), en dat risico is kleiner met de getekende pendeltreinen dan met getrokken materieel. Want daarvoor gebruiken al die digitaalrijders hun sensors.
-
Ja, als je een wagonnetje verliest blijft hij op het spoor staan en dat kan een botsing met de volgende trein betekenen.
Dat moet je niet hebben.
Om dit te voorkomen had ik in mijn eerste opzet een magneetje onder de laatste wagon gebracht.
Hierdoor ben je zeker dat alles van de trein binnen is gekomen alvorens je verder kan gaan.
Het programma moet je zo opbouwen dat de volgende trein pas mag vertrekken als de voorgaande trein (volledig) is binnen gekomen.
Maar helaas dit bleek in de praktijk, bij mij al thans, niet betrouwbaar genoeg te zijn.
Ik heb daarom de magneetjes (met de reedcontacten) vervangen door IR sensors.
Deze passen precies tussen twee bielzen in van de k-rails.
Dat werkte prima totdat de zon ging schijnen, zonlicht geeft ook IR-straling met als gevolg dat de sensoren afgingen.
Dat laatste heb ik kunnen verhelpen door de IR-sensoren niet meer gevoelig te maken voor de hoeveelheid IR-licht maar voor de plotselinge verandering van de hoeveelheid IR-licht.
Dit werkt nu prima en heb ik geen storingen meer.
(http://www.mupload.nl/img/5o072vv9.jpg)
-
Ik ben zelf handmatig rijder, maar volg dit draadje toch.
Digitaal of analoog: de mate van beveiliging is natuurlijk ook een keuze. Met andere woorden: in hoeverre ga je voor alle mogelijke (en onmogelijke) situaties tijdens het rijden een veiligheid inbouwen?
Ja, als je een wagonnetje verliest blijft hij op het spoor staan en dat kan een botsing met de volgende trein betekenen.
Dat moet je niet hebben.
Ik zou hier bijvoorbeeld zelf eerder onderzoeken waarom de wagon achterblijft: ligt de rails niet goed, zit de koppeling niet lekker? Als je "nooit" wagons verliest, hoef je ook geen sensoren in te bouwen voor eventueel achtergebleven wagons.
Toch?
Rob
-
Het schema voor de aansluiting voor de 20 sensoren.
(http://www.mupload.nl/img/lt03pb610i.jpg)
Ik moet deze schakeling nog wel uittesten.
De 12F675 PIC heb ik vervangen door een 16F628a, deze werkt zowel als tijdverlenger en als multiplexer.
Een z'n PIC kan 4 sensoren afhandelen en met 5 van deze PIC's kun je 20 sensoren inlezen.
Gr Theo
-
De sensoren-meting op de testbank.
(http://www.mupload.nl/img/vl3hle.jpg)
Stond nog wel een adres-cijfer verkeerd, maar ook deze werkt nu zo als het moet.
Er kunnen nu 20 baansensoren worden ingelezen.
Gr Theo
-
Helaas, ik had de plaatjes via www.mupload.nl (http://www.mupload.nl) geüpload, maar helaas deze site is er met ingang van 1 januari mee gestopt.
Jammer, kijken of er ook een andere bruikbare site is.
-
Even een andere site proberen
(https://i.postimg.cc/4dWQWhMw/Foto1.jpg)
Deze werkt, via Postimg.cc en na het Uploaden kiezen voor directe link kiezen voor de code.
Verder ben ik bezig verder uit te breiden van het programma, er zijn nu 8 treinlijnen beschikbaar en heb je de keuze uit twee spoorboekjes.
Ook de opbouw van de lijn zoals je kunt zien op de foto heeft 25 blokken.
-
Als je volgens het spoorboekje gaat rijden, dan gaat dat op tijd.
Maar het kan wel voorkomen dat de trein nog niet op tijd is gearriveerd op het vertrekkende spoor.
Het programma kan dit (nog) zien en zet zodoende wel alles in werking om deze spooktrein te laten vertrekken.
(https://i.postimg.cc/50sk8vSD/Lijn44.jpg)
Om dit te voorkomen heb ik nu een blokje "Green" gemaakt.
Wanneer er nu een trein vertrekt vanaf het spoor wordt het cirkeltje links rood gezet, dit cirkeltje wordt door het blokje Green weer groen gezet als dit blokje aan de beurt is.
Wanneer het cirkeltje rood is wordt deze vertrek-tijd overgeslagen, immers deze trein is nog niet op tijd binnen gekomen en er mag geen spooktrein vertrekken.
Zodra het cirkeltje groen wordt de normale dienstregeling weer hervat.
Dit cirkeltje kun je ook met de hand bedienen door er o te klikken.
-
Inmiddels heb ik ook een gebruikshandleiding gemaakt.
http://modelspoorpic.nl/StoomspoorExpress.pdf (http://modelspoorpic.nl/StoomspoorExpress.pdf)
Gr Theo
-
Al hoewel ik mijn baan heb afgebroken (i.v.m de plaatsing van een nieuw dakkapel) is het programma stoomspoorexpress nog steeds in ontwikkeling. In het computerblad Computeridee is nu een artikel geschreven over het programma Stoomspoorexpress.
In het najaar ga ik weer een baan opbouwen als de binnenkant van het dakkapel klaar is. (eerst vakantie!)
Gr Theo
-
Het dakkapel zit er op, dus langzaam begonnen met de baan.
Bij het afbreken van de oude baan zijn wel enkele rails verloren gegaan, dus dat wordt rondstruinen op de beurzen als ze weer open zijn.
Ben wel begonnen met de tafel en de elektronica, daarvoor hoef je niet naar de beurs.
Op de foto het allereerste begin, 2 relaisblokken die via een multiplexer wordt aangestuurd. Hiermee kunnen (eerste) 8 wissels worden bedient.
(https://i.postimg.cc/63ZNvgt6/DSC-0058.jpg)
Het relaisblok is van tante Ali net als de multiplxer.
Het verdeelstation die moet je zelf solderen.
-
Weer een stukje verder, de aansluiting van de rijblokken (een stukje baan zonder stroom zetten zodat de trein daar kan wachten).
Omdat je met de I/O-kaart tekens maar een kort signaaltje kan afgeven
zit er tussen de multiplexer en het relaisbord een geheugenschakeling.
Deze wordt gemaakt met 4 keer de PIC 12F675.
Per PIC 12F675 kun je 2 relais van het relaisblok aansturen.
Ik gebruik hiervoor de code in de PIC:
Include Eigen12F675 (<== eerst de eigenschappen van de PIC laden)
pin_A0_direction = Output Alias Uit1 is pin_A0 (<== pin-0 als uitgang zetten en zijn naam veranderen in Uit1)
pin_A5_direction = Output Alias Uit2 is pin_A5
pin_A1_direction = Input Alias laag1 is pin_A1
pin_A2_direction = Input Alias hoog1 is pin_A2
pin_A3_direction = Input Alias laag2 is pin_A3
pin_A4_direction = Input Alias hoog2 is pin_A4
Uit1=high Uit2=high (<== bij de start-up de uitgang hoog zetten, het relais blijf afstaan)
Forever loop
If laag1==low then Uit1=high end if (<== uitgang-1 hoog zetten als er een commande van de multiplexer komt)
If hoog1==low then Uit1=low end if
If laag2==low then Uit2=high end if
If hoog2==low then Uit2=low end if
Delay_1ms(50) (<== 50 ms wachten)
end loop (<== terug naar "Forever loop", voor de volgende ronde)
Als de uitgang High is, staat deze hoog en kan het relais zijn stroom niet afvloeien en staat het relais dus af.
De multiplexer heb ik op de printplaat gesoldeerd, schilt weer wat draadjes.
(https://i.postimg.cc/8c7gjfSQ/DSC-0063-Photographic.jpg)
Veder heb ik het programma StoomspoorExpress aangepast, je kunt nu zelf de adressen aanpassen, hierdoor is het wat minder star geworden.
(https://i.postimg.cc/TwHZM2Wk/DSC66.jpg)
-
(https://i.postimg.cc/63ZNvgt6/DSC-0058.jpg)
Het relaisblok is van tante Ali net als de multiplxer.
Gefeliciteerd met deze mijlpaal. En natuurlijk alvast de beste wensen voor 2022 ...
Als ik je goed begrijp gebruik je de multiplexer om een array van 2x8 relais aan te spreken.
Dat zou je in plaats daarvan kunnen doen door 16-bits codering (1 word = 2 bytes) of zie ik iets over het hoofd?
-
Hoi Jan.
Eerst de beste natuurlijk jij en iedereen de beste wensen voor kerst.
Nee, de multiplexer wordt met de vier oranje draadjes aangestuurd, een 4 bits signaal.
4 bits => 2 x 2 x 2 x 2 = 16 uitgangen.
Als je deze voor de wissels gebruikt heb je 8 wissels, elke wissel gebruikt 2 signalen (2 bits) een voor recht zetten en een voor om te zetten.
Hetzelfde geldt voor de blokken, 1 signaal (1 bit) om aan te zetten en een signaal (1 bit) om uit te zetten.
Een Byte bestaat uit 8 bits, dus 8 nullen en/of enen.
Ik heb voor de multiplexers gekozen omdat ze lekker goedkoop zijn en ze zijn kant en klaar te bestellen bij tante Ali. (50 cent/stuk)
Op het hele systeem kun je 63 van die wissels en/of blokken zetten, ik denk dat dat voor de meeste banen voldoende is.
Het is mogelijk om dit te verdubbelen naar 127 wissels en/of blokken.
Een andere vraag is wat zou ik nog meer in het programma kunnen zetten?
Gr Theo
-
De volgende stap in het project is een maken van de rijspanning.
Omdat ik met Marklin rij, ik heb ik gekozen om ook maar wisselstroom op de rails te zetten.
(https://i.postimg.cc/gcM8Wq4X/Rijspanning.jpg)
Links is de trafo die 2 maal een 12 Volt wisselspanning afgeeft.
Via de spanningsregelaar M 063N kan ik de rijpanning regelen.
Met de twee schakelaars kan ik kiezen aan/uit en een 24 Volts signaal geven voor het veranderen van de rijspanning.