BeneluxSpoor.net forum
Vraag en antwoord => Elektronica en analoog => Topic gestart door: Te 2/2 op 29 oktober 2020, 00:54:30
-
Ik werk graag met relais, maar soms denk je bij jezelf: "waar begin ik aan?"
Dat is het moment om af te wegen: relais-aanpak of arduino-aanpak?
Relais-aanpak
(https://images.beneluxspoor.net/bnls/kopstation-wisselstraat1.png)
Het bijzondere aan deze wisselstraat is spoor B (met uitsluitend getrokken treinen),
met een rijweg met maar 1 rijrichting, en maar 1 doelspoor,
en die niet over het kruiswissel komt. Dat is een bewuste keus.
Getrokken treinen worden bij aankomst apart afgehandeld.
Voor dit baanplan zijn 12 SPNO relais nodig (12 rijwegen, en dan vul ik de rest van kopspoor 6 en de relatie met de loc-depots nog even niet in) om een diodematrix aan te sturen.
De diodematrix zet per rijweg:
-alle te passeren wissel-relais
-rijrichtingrelais op de wisselstraat (2x, en kopspoor of V)
-2/3 rail relais op de wisselstraat (A,B en kopspoor of V)
-kruising relais (indien van toepassing: diagonalen relais, rijrichting relais en 2/3-rail relais)
Bij elkaar verstoken al die relais (aangestuurd door de matrix) 12 VA maximaal per rijweg , bij een maximum van 5 wissels. Er zijn naast de benodigde wisselrelais een stuk of 10 bistabiele hulprelais bij betrokken. Bij twee gelijktijdige rijwegen kost het circa 20 VA, en bij 3 gelijktijdige 24 VA. Er zijn twee bijna identieke stations gepland ....
De schakellogica bevindt zich op een aparte 12 vDc trafo. Een rijrichting relais schakelt tussen twee DC rijspanningtrafo's (Aankomst-trafo, Vertrek-trafo). En 3-rail locs rijden en schakelen hun rijrichting om met DC.
Voor de relais-liefhebbers:
De keus welke rijweg(en) gekozen worden, wordt deels bepaald door de achterkant van de vertrekkende trein bij V. Die trein bepaalt eerst waar hij vandaan kwam, om dat kopspoor vrij te kunnen geven. Pas daarna kan een nieuwe rijweg "gekozen" worden. In geval van een stopknop procedure is herstart/keuze via een stoppen (Ja/Nee) hulprelais geleid.
Ook elke kopspoor-aankomst bepaalt een nieuwe rijwegkeuze. In geval van een stopknop procedure is deze herstart/keuze via een stoppen (Ja/Nee) hulprelais geleid.
Geautomatiseerd werkt het geheel op basis van diefje-met-verlos:
een kopspoor dat vrij komt, wordt zo snel mogelijk opgevuld.
Methode: Als er een kopspoor van een strijdige vertrek-rijweg bezet is,
laat je die eerst vertrekken. Eventueel meerdere achter elkaar. B.v. V4, V5, *V6
Daarmee open je de mogelijkheid om parallelle rijwegen te kiezen: (A4 of A5) AND *B6//(V1 of V2 of V3). Die reeksen sluit je af met een strijdige rijweg reeks: A1,A2,A3 of V4, V5, *V6
Waarna je met de parallelle rijwegen weer gewoon verder kunt. Tot sint juttemis.
Er is maar 1 vertrekspoor, op 2 aankomst-sporen en dat betekent dat er maximaal 3 gelijktijdige treinbewegingen mogelijk zijn, in praktijk 2 treinbewegingen, omdat de loc-wissel op kopspoor 6 wel wat langer duurt, dan het keren van een pendeltrein. Maar bij kopspoor 6 zijn natuurlijk ook treinbewegingen in beide richtingen, t.b.v. loc-wissel.
*Let op: kopspoor6 heeft een hulprelais Procedure-klaar
Niet Klaar? Dan zijn B6 en V6 niet mogelijk.
Arduino
Als je met deze wensen en uitwerking kijkt naar een Arduino toepassing, wat bespaar je dan op de schakelingen?
- Ik kan me voorstellen dat de 12 SPNO relais en de diodematrix vervallen, omdat je de max 5 wisselrelais per rijweg (en de 10 hulprelais) ook op een andere manier kunt aansturen.
- Ik kan me voorstellen dat de twee rijspanningtrafo's vervallen, en vervangen worden door motor drivers. Maar hoeveel je er dan nodig hebt? Geen idee.
- Ik kan me voorstellen dat je minder lichtsluizen nodig hebt, mits je een andere detectie op de kopsporen toepast.
Veel verder kom ik nog niet.
Dus schiet er maar op los.
-
Als je met een arduino een en ander wil gaan aansturen, heb je ook relais nodig, dus daar ontkom je vaak niet aan.
Het is alleen gemakkelijker om een arduino een software update te geven dan een schakelpaneel/kast om te bouwen. ;D
Je hebt 2 keuzes om wissel sturing te kiezen, om zetten via een relais gestuurd wisselspoelen, of servo sturingen om je wissels om te zetten, dan kunnen de relais vervallen.
Heb je wissels met kunststof puntstukken of zijn ze van metaal? bij kunststof puntstukken, heb je geen ompoling nodig, bij metaal wel en dus een relais.
Èn met een arduno kan je wissel voor wissel laten omzetten en dat gaat met relais weer wat lastiger.
Succes met je keuze.
Nog een tip; begin met een ali arduno, en als je klaar bent met testen zet er dan een echte in, die gaan langer mee en kunnen ook meer.
-
[...] en kunnen ook meer.
Kun je dat nader uitleggen?
-
Ik werk graag met relais, maar soms denk je bij jezelf: "waar begin ik aan?"
Een spinneweb aan draad, had ik vroeger ook. Vooral leuk als je je schema niet meer kan vinden en iets moet repareren of aanpassen.
Bij elkaar verstoken al die relais (aangestuurd door de matrix) 12 VA maximaal per rijweg
Help me even. De relais waar ik je laatst op wees, verbruiken iets van 40~50mA per stuk p 5V. Stel dat ik er 10 tegelijk aanzet dan verbruik ik 10 x 0.050 * 5= 2.5VA. Wat voor relais gebruik jij?
Als je met deze wensen en uitwerking kijkt naar een Arduino toepassing, wat bespaar je dan op de schakelingen?
Een aantal dingen, denk ik. Ik begrijp nog slechts de grote lijnen van wat je wilt doen, maar volgens mij kan je een aantal relais weglaten, en je kan er nog meer weglaten door wissels bijvoorbeeld met mosfets aan te sturen. En zoals Richard & ik al vermeldden, kan je ook servo's gebruiken, met servo's bespaar je ook minimaal 15€ per magnetische wisselaandrijving. Je bespaart, denk ik ook tijd en stress. Het lijkt me best een nare nare klus om een schakeling met 20+ relais te bouwen.
Ik kan me voorstellen dat de twee rijspanningtrafo's vervallen, en vervangen worden door motor drivers. Maar hoeveel je er dan nodig hebt? Geen idee.
In een zo'n H-brug driver die ik je opstuurde, kan je 2 treinen onafhankelijk aansturen met PWM in beide richtingen. Dus als je nu maar 2 regel trafo's heb dan zou ik zeggen: je hebt er 1 nodig. En ze zijn ook maar ~€3,50 per stuk, dus schoom vooral niet om een 2e er bij te kopen ;)
..... de diodematrix vervallen,
Ja dat klopt ook. Een diodematrix is iets wat je heel makkelijk kan coderen in software. Ik heb voor een project waarbij ik alle wissels met 2 drukknoppen wilt bedienen, een programma geschreven die bijhoudt waar de trein is zodat de arduino snapt wanneer hij welke wissel moet omzetten. De blinde wissels gaan dan van zelf om wanneer de trein er 1 tegenkomt. En de eerstvolgende niet-blinde wissel kan ik met de knopjes bedienen. Hiervoor heb ik uiteindelijk ook een matrix gemaakt waar mijn hele layout in staat.
Section section[ sectionAmount ] = { // this table is the layout
( NA, NA, NA, NA, NA, NA, NA, NA, NA, NA ), // dummy
( NA, 1, NA, 2, 1|C, NA, NA, NA, 4, 5 ), // 1
( NA, 1, NA, 2, 1|S, NA, NA, NA, 4, 5 ), // 2
( NA, 2, NA, 3, NA, NA, NA, NA, 7, 6 ), // 3
( 1, 3, 1, 3, 2|C, NA, 2, 1, 8, 9 ), // 4
( 1, 4, 1, NA, 2|S, 4|S, 2, 1, 10, 10 ), // 5
( 2, 4, NA, NA, 5|C, 4|C, 3, 3, 10, 10 ), // 6
( 2, NA, NA, NA, NA, NA, 3, 3, NA, NA ), // 7
( 3, NA, 1, NA, NA, NA, 4, 4, NA, NA ), // 8
( 3, 6, NA, 6, 3|C, 7|C, 4, 4, 11, 11 ), // 9
( 4, 5, 4, 6, NA, NA, 5, 6, 11, 12 ), // 10
( 6, NA, 7, NA, NA, NA, 10, 9, NA, NA ), // 11
( 5, NA, 4, NA, 6|C, NA, 10, 10, 13, NA ), // 12
} ;
Zou ik ooit een nieuwe baan maken, kan ik deze code zo recyclen. Zou mijn layout veranderen, hoef ik alleen in deze tabel een paar nummertjes aan te passen.
Ik heb trouwens nog een vraagje over je pendelsysteem, misschien dat ik het gemist heb. Maar hoe regel jij het afremmen en optrekken van je treinen?
En heb je al iets van een relais schema gemaakt? Het klinkt alsof je het al helemaal heb uitgewerkt als ik dit zo lees (y)
Hennik was me voor maar
[...] en kunnen ook meer.
Het zijn dezelfde atmega328 chips die er op zitten?
[..] die gaan langer mee
Hoewel ik dit nog wel 'plausibel' wil achten, ben ik wel erg nieuwsgierig naar de reden hier achter? Volgens mij doen de bedrijven die de klonen bestuken niet echt slecht werk. Ik heb zelfs een keer gelezen dat de afgedrukte teksten op de klonen nog zelfs van betere kwaliteit waren dan de originele.
En je vergeet een belangrijk puntje. Een echte originele arduino kost tussen de 20 en 25 euro. Ik koop nano's in voor €1,70 en ze doen het nog steeds prima. Zelfs al zou er een voortijdig overleden, kan je hem gewoon uitwisselen voor een nieuwe kloon. En na 10x dat gedaan te hebben, ben je nog steeds goedkoper uit, en tegen de tijd dat dat gebeurt, ben je wss boven de 150 jaar ;D
Dus ik deel niet dit advies om een 'originele' arduino te kopen puur om het feit dat die gewoon belachelijk duur zijn.
Bas
-
Ik ben zelf met een soortgelijk projectje bezig, en heb gekozen voor Arduino's.
Eigenlijk om 2 basisredenen:
1 - wissels wilde ik aansturen met servo's
2 - software is makkelijker aan te passen dan hardware, als er onverhoopt toch iets fout zit (en die kans achtte ik voor mezelf vrij hoog)
Maar ook met Arduino's is het toch best nog wel een complex projectje.
Ik heb gekozen om het in delen op te knippen:
1 - Eén Arduino Nano om de servo's voor de wissels aan te sturen. Zoals Richard als idee al opperde, laat ik die sequentieel achter elkaar aansturen, gewoon omdat het kan en omdat dat leuk is. De servo's zijn daardoor ook rechtstreeks op de Arduino aan te sluiten.
2 - Eén Arduino Nano voor de rijregelaars. Jij hebt tenminste 3 rijregelaars nodig omdat er theoretisch 3 treinen tegelijk kunnen rijden. Misschien nog een paar extra om de relaisschakeling op de wisselstraat zo simpel mogelijk te houden. Dat kan één Arduino Nano prima aan. Enige hardware die ik extra gebruik is een Mosfet, diode, condensator, 3 weerstanden en een optocoupler (kan waarschijnlijk ook zonder) per rijregelaar. Er passen 5 van die rijregelaars op één gaatjesprint van 6 bij 4,5 cm.
Ik heb eerst met de bekende H-brugjes geprobeerd, maar ik merkte forse kortsluitingen bij de overgang van de ene sectie naar de andere, daarom gekozen voor PWM met een enkele Mosfet. Nadeeltje is toch een relais nodig voor de rijrichting. Die kan via een weerstand, een transistor en een vrijloopdiode op dezelfde Arduino worden aangesloten.
Overigens maak ik hier dankbaar gebruik van de Weistra Regelaar die Bas (bask185) hier voorgesteld heeft: https://forum.beneluxspoor.net/index.php?topic=92349.msg3222111961#msg3222111961 (maar dan 5x in één sketch).
3 - Eén Arduino Mega voor de sensoren, bedienknoppen en wat relais voor aan/uit en mogelijk toch wat secties schakelen naar de juiste rijregelaar bijv in de wisselstraat.
Het aantal sensoren zal in theorie niet verschillen van wat je voor volledige relais-constructie nodig hebt, Stroomdetectie, IR-sluisje etc. De Mega heeft voldoende aansluitmogelijkheden.
In deze Arduino komt dan ook alle logica om alles op basis van de input-signalen te regelen. Via een simpele I2C verbinding kunnen opdrachten worden doorgegeven aan de beide andere Arduino's. Omdat ze alle 3 naast elkaar zitten, volstaat I2C prima.
Dus ik heb toch nog wat relais nodig, maar de schakeling kan zeer basic blijven, en blijft verstoken van alle logica.
Ik heb voor dit baandeel één 5V= voeding voor de Arduino's, servo's en relais. Mijne kan 2A aan, ik denk eigenlijk dat 1A al wel volstaat.
En ik heb één voeding voor de rijspanning (bij voorkeur een vlakke gelijkspanning die gelijk is aan de maximum snelheid die je je treinen wilt laten rijden, dan werkt de PWM rijregelaar het mooist)
Wellicht heb je hier wat aan.
-
Als ik nog een bijdrage mag leveren..?
Je geeft aan dat je allemaal kopsporen hebt. Als die allemaal recht zijn, dan zou je voor sensoren eens aan deze kunnen denken:
https://nl.aliexpress.com/store/2138141/search?origin=y&SearchText=VL53L0X
Een Time-of-Flight laser afstandssensor.
Die plaats je bij het stootblok, en je schijnt behoorlijk precies te kunnen meten als er een trein op 30cm nadert, en op 1 cm voor het stootblok laten stoppen.
Nadeel (pfff altijd weer een nadeel hè): ze zijn lastig uit het zicht weg te werken.
Zie hier hoe dat kan werken: https://youtu.be/t7dPz7Q2Rig?t=637
-
Misschien een bruikbare (analoge) tip: kijk eens naar Tillig wisselmotoren en de mogelijkheden voor instellingen van wisselstraten.
Normaal gesproken: bij 1 inkomend spoor, alleen de knop van het bestemde eindspoor bedienen. Alle betreffende wissels schakelen na elkaar.
Bij dit railplan heb je meerdere mogelijkheden, dus krijg je dan een 2-knops bediening. Motoren zijn eind-afgeschakeld. Scheelt volgens mij een hoop in de diodematrix en/of relais.
Geen kant en klare oplossing maar misschien brengt je dit op aanvullende ideeën.
-
Hennik geeft me nog een idee. Je kan ook een arduino inzetten om met een enkele mosfet en stroomdetectie (of lichtsluis) een trein te laten remmen tot stilstand. De arduino stuurt het baanvlak aan met een enkele mosfet op 100%, als de trein dan aan komt rijden op de sectie, dan kan de arduino geregeld het pwm verlagen totdat de trein stilstaat. Dan kan je met een potmeter er bij de afstand een beetje finetunen. Dit fungeert dan eigenlijk ook als een diode fuik. Als de spanning dan ompoolt, dan geleidt de mosfet als het goed is. En dan kan je de andere kant op rijden.
Je kan een arduino ook al je sporen tegelijk op dezelfde manier afhandelen, misschien ook interessant voor je?
Bas
-
Bij elkaar verstoken al die relais (aangestuurd door de matrix) 12 VA maximaal per rijweg
Je zou bistabiele relais kunnen gebruiken: die hoef je maar even te bekrachtigen, blijven dan in die stand staan, en gebruiken dus ook geen energie meer.
Nog een tip; begin met een ali arduno, en als je klaar bent met testen zet er dan een echte in, die gaan langer mee en kunnen ook meer.
Dit is niet waar.
arduino geregeld het pwm verlagen
Kijk uit: digitale decoders kunnen slecht tegen PWM-spanning!
-
Kijk uit: digitale decoders kunnen slecht tegen PWM-spanning!
We zitten in de rubriek "Elektronica en analoog" dus hebben het niet over decoders.
In voorkomend geval zet je er een elco over de PWM-uitgang, maar dan mis je de voordelen van PWM
-
We zitten in de rubriek "Elektronica en analoog" dus hebben het niet over decoders.
Een digitale loc kan ook op analoge spanning rijden. Vandaar mijn waarschuwing.
-
Oke.. doorborduren..
Ik heb je plaatje iets ingekleurd met wat ik denk dat je als secties voor rijregelaars zou kunnen zien:
(https://abload.de/img/relaisbesturingpsj66.jpg)
Op V, A en B kan je de vaste voeding laten zoals je zelf al voorgesteld had.
Dan een rijregelaar voor 1, 2 en 3
eentje voor 4 en 5
en eentje voor 6
Deze bedienen tegelijk ieder ook een stukje van de wisselstraten.
Even uitgaande van mijn methode met de enkele Mosfet, schakel je de voeding van de rijregelaar naar V, A, of B afhankelijk van waar de trein vandaan komt of naartoe gaat. Daarmee heb je gelijk de juiste rijrichting of rijspanning als je 3-rail wilt rijden.
Als ik het zo bekijk heb je voor elke rijregelaar maar één relais nodig met 2 aan-aan-contacten (en iets aanvullends voor 3 rail, maar dat zul je zelf wel iets voor uitgedacht hebben)
En dan nog voor ieder kopspoor een relais om dat spoor geheel af te schakelen.
-
Section section[ sectionAmount ] = { // this table is the layout
( NA, NA, NA, NA, NA, NA, NA, NA, NA, NA ), // dummy
( NA, 1, NA, 2, 1|C, NA, NA, NA, 4, 5 ), // 1
( NA, 1, NA, 2, 1|S, NA, etc...
Zou je de betekenis van die codes wat nader willen toelichten? Ik ben nieuwsgierig hoe je dat bedacht hebt...
-
Een digitale loc kan ook op analoge spanning rijden. Vandaar mijn waarschuwing.
Ja, maar als je PWM gaat sturen dan ziet de decoder dat als digitaal signaal maar hij snapt niks van het protocol. Dus hij doet niks. Zelf geprobeerd met het enige digitale model dat ik ooit heb gehad. Is nu echt analoog, weg met die decoder.
-
Ik lees mee. (Gek ;D)
Eerste reactie:
1. Relais, er zijn hier allerlei types uit de oude doos. Ik koos de meest beroerde voor de berekening wat een rijwegkeus maximaal vreet. Al die relais (incl die van de wissels) zijn bistabiel. Ze schakelen dus korte tijd, en het piekverbruik komt weliswaar hoog uit, maar de rijwegkeuzen vallen nooit exact tegelijkertijd (dus effectief kom je veel lager uit). Alleen de rijweg-relaismatrix is monostabiel.
2. Ik heb servo's maar dit eerste station moet een schaduwstation worden, dus dacht ik relais voor wissels in te zetten. De zichtbaarheid van sensors is dus ook geen enkel punt.
3. Kopsporen zijn alle 6 recht en ongeveer 2,40 meter lang. Als ze langer moten worden, dan komen ze in een boog, en aangezien op kopspoor 6 (het voorste spoor) loc-wissel moet plaats vinden, zou die boog zeer ruim moeten worden (waar geen ruimte voor is).
4, Afremmen/optrekken heb ik niet overwogen (schaduwstation), maar door het rijrichting relais te laten schakelen tussen twee trafo's in de aankomstsnelheid altijd lager dan de vertreksnelheid.
Kijk uit: digitale decoders kunnen slecht tegen PWM-spanning!
Is me bekend. Er is 1 loc: een omgebouwde Fleischmann met een Märklin Alzheimer decoder. Die bouw ik terug naar 2-rail. Ik heb toch al niet zo op met decoders. ;D
Die decoder kan ook niet zo goed tegen Kleinbahn trafo's. Kleinbahn was in de jaren '80 een van de eerste leveranciers van een zgn. elektronische DC-trafo. Hoewel ze nooit hebben prijsgegeven wat er in zat, en het ding er hitte-gesealed uit ziet aan de buitenkant (dus bij mij nooit open geweest), rijden treinen erop alsof het PWM is. Nep-PWM zeg maar, oftewel gewoon afgevlakt. De enige locs die er op kruipsnelheid niet mee van hun plaats komen, zijn die van Lima (uit de jaren '80). Afijn dat was al jaren bekend (alleen nog niet toen ik ze kocht).
Alle analoge merk-locs (Fleischmann, HAG, Liliput, Märklin, Metrop, Roco) kunnen kruipen, zowel 2-rail als 3-rail locs.
plaatje iets ingekleurd met wat ik denk dat je als secties voor rijregelaars zou kunnen zien:
Dat is zinvol voor m'n denkproces over wat die Arduino-rijregelaars anders zouden kunnen doen.
Bedankt nog, daarvoor.
Dat youtube filmpje heb ik ook bekeken. Als je toch ook kijkt naar Neil Armstrong, lopend op de maan, waarom dan niet naar dit? Interessant, altijd weer, nieuwe technieken, nieuwe kansen.
-
Zou je de betekenis van die codes wat nader willen toelichten? Ik ben nieuwsgierig hoe je dat bedacht hebt...
Het ging meer om de illustratie hoe je in code een tabel er uit kan zien..
Ik zal het bovenstaande commentaar er bij plakken.
const int C = 0b10000000 ;
const int S = 0b00000000 ;
/*
> leftSensor
| > rightSensor
| |
| | > leftTurnout ; these must jump by the buttons
| | | > rightTurnout
| | | |
| | | | > rightTurnoutBlind ; 1st bit true = curved, false = straight
| | | | | > leftTurnoutBlind ; blind turnouts must jump when train enters new section
| | | | | |
| | | | | | > leftStraightSection ; last 4 bytes contain information about which new section the train is heading for
| | | | | | | > leftCurvedSection
| | | | | | | |
| | | | | | | | > rightStraightSection
| | | | | | | | | > rightCurvedSection
| | | | | | | | | | */
Section section[ sectionAmount ] = { // this table is the layout
( NA, NA, NA, NA, NA, NA, NA, NA, NA, NA ), // dummy
( NA, 1, NA, 2, 1|C, NA, NA, NA, 4, 5 ), // 1
( NA, 1, NA, 2, 1|S, NA, NA, NA, 4, 5 ), // 2
( NA, 2, NA, 3, NA, NA, NA, NA, 7, 6 ), // 3
( 1, 3, 1, 3, 2|C, NA, 2, 1, 8, 9 ), // 4
( 1, 4, 1, NA, 2|S, 4|S, 2, 1, 10, 10 ), // 5
( 2, 4, NA, NA, 5|C, 4|C, 3, 3, 10, 10 ), // 6
( 2, NA, NA, NA, NA, NA, 3, 3, NA, NA ), // 7
( 3, NA, 1, NA, NA, NA, 4, 4, NA, NA ), // 8
( 3, 6, NA, 6, 3|C, 7|C, 4, 4, 11, 11 ), // 9
( 4, 5, 4, 6, NA, NA, 5, 6, 11, 12 ), // 10
( 6, NA, 7, NA, NA, NA, 10, 9, NA, NA ), // 11
( 5, NA, 4, NA, 6|C, NA, 10, 10, 13, NA ), // 12
} ;
Elke regel stelt 1 sectie voor en elke sectie heeft de volgende attributen:
De eerste 2 kolommen zijn de nummers van de des betreffende sensors. Een kopspoor heeft altijd aan 1 kant een sensor, daarom staat er NA (= Not Available) tussen.
Kolom 3 en 4 zijn de wissels die links en rechts van de trein liggen, deze wissels kan ik dan bedienen met 2 drukknopjes.
Kolom 5 en 6 zijn eventuele blinde wissels waar de trein op af koerst. Deze wissels worden door de SW vanzelf omgezet wanneer een trein een nieuwe sectie betreedt. Ik heb puntstuk polarisatie en kan geen wissels open rijden.
De laatste vier kolommen zijn de naburige secties. Als de trein over de linker sensor van een sectie rijdt, dan wordt de nieuwe sectie die van kolom 7 en 8. Rijdt de trein over de rechter sectie dan wordt de nieuwe sectie uit kolom 9 of 10 gehaald. Welk van de twee is dan afhankelijk van de stand van de wissel.
In de laatste 4 kolommen staan wel eens dubbele waardes tussen, dit heeft te maken met de ligging van de wissels. Omdat ik zo gierig als mogelijk aan het denken was, wilde ik zo min mogelijk sensors hebben (LDR's in dit geval). Na uren gedacht te hebben, had ik beredeneerd dat overal waar sporen samen kopen na de wissels een sensor moest komen. Dit resulteert in het feit dat ik een best rare sectie indeling heb. Maar.. ik heb nu slechts 6 terugmelders op 12 sectiess (y)
Tijdens het coderen kwam ik er achter dat ik misschien beter meer sensors had kunnen gebruiken omdat je eigenlijk gewoon 'normale' secties wilt hebben. Hoewel deze versie geheid zal werken, ben ik parallel een versie aan het maken, waarbij de tabel voor je kan worden ingevuld met data die op de EEPROM ligt. Waar ik uiteindelijk naar toe wil, is dat je op een programma, een baan kan tekenen en dat de informatie van de layout op de EEPROM van de arduino kan worden gepropt via de seriele bus.
Dan is het geheel wat makkelijker bruikbaar en voor anderen mensen ook makkelijk te gebruiken. Ik heb zelfs een script gemaakt die het arduino programma voor je kan uploaden zonder verdere dependencies. Je kan dan alles doen vanuit het programma met slechts een paar knopjes. Als klap op de vuurpijl wil ik dan een PCB er voor ontwerpen die je modulair met I2C apparaten en extra handregelaars kan uitbreiden (servo drivers en IO extenders voor de terugmelders). Dit systeem kan in theorie ook werken met meerdere treinen. Om de treinen zelf aan te sturen, gebruik ik of DCC of de weistra pwm regeling.
Bas
-
Na uren gedacht te hebben, had ik beredeneerd dat overal waar sporen samen kopen na de wissels een sensor moest komen.
Zie de wisselstraat als een binaire boom: bij elke knoop een sensor. Zoiets?
Je gebruikt in ieder geval niet zoiets als een graaf-matrix, met sensor-graaf-knopen, zoveel is duidelijk.
Ik denk dat dit sneller werkt, en minder flexibel is, tenzij je er een speelveld-editor bij maakt.
Het doet me ook een beetje denken aan een speelveld-array in een "dungeons" spelletje.
Dat werkte vroeger met word-waarden, waarvan de ene byte de identificatie van een object aangaf, en de andere byte bepaalde eigenschappen gecodeerd bevatte. Door een element uit te lezen , en dan te shiften, kon je die waarden heel erg snel benutten, althans met een 16-bits-processor. Daar werden ook speelveld-editors voor gemaakt (in ansi-C, waar ik, jaren '80, mee werkte).
Om nog eens wat olie op het vuur te werpen: analoog is er een beperking die mee speelt (bloklengte).
Omdat ieder blok voorzien is van een aantal relais, en een of meer sensors, kom je er niet zo snel toe om "super"-blokken te maken/ daarmee bedoel ik blokken die bestaan uit 3 of meer blokken.
Stel de kortste pendeltrein is 60 cm en de langste 2,2 meter, dan zul je omwille van de kosten, eerder geneigd zijn alle blokken dan maar op 2,4 meter te zetten, en dus de kopsporen ook.
Stel, je kunt korte treinen met een magneet (op een bepaalde plek, b.v. zijkant) uitrusten, dan kun je analoog daar wel iets op maken, maar dat kost relatief veel meer. Om daar wel mee rekening te houden op een pendelstation, kan ik me nog net voorstellen. Er zou dan b.v. één kopspoor zijn voor korte treinen, waar ze met drietallen achter elkaar in passen. Er moet dan ook iets aangepast aan de aankomstmethode en aan de vertrekmethode ...
Hoe ligt dat bij een Arduino besturing?
-
code/tabel
Okee, dank je. Je benadering is me duidelijk, en een goed uitgangspunt voor wat ik van plan ben.
-
@Te2/2
Hoe ligt dat bij een Arduino besturing?
Zoals ik al eens zei, jouw fantasie is hier de limiet. Alles wat jij kan bedenken om met treinenbesturing te doen, kan een arduino uitvoeren.
Er schiet mij nu een idee binnen (heb ik veel last van ::)), stel nu dat je 2 lichtsluizen achter elkaar zet op ca 1cm afstand. Dan kan je twee dingen doen, omdat je er twee heb, kan je berekenen hoe snel de trein rijdt. Als je weet hoe snel de trein rijdt en bijhoudt hoelang de trein zich op/tussen een van de lichtsluizen bevindt, kan je ook berekenen hoe lang de trein is. Dit werkt natuurlijk alleen als je trein met een ~ongeveer constante snelheid langs de sensors rijdt.
Je zou waarschijnlijk kunnen afremmen op het moment dat je trein nog halverwege de sensors zit, maar dan moet je het afremmen meenemen in de berekening. Dat is niet heel nauwkeurig, omdat het dutycycle niveau niet 100% evenredig is met de snelheid. Maar het is misschien wel werkbaar/acceptabel.
Om je treinen zo dynamisch te verdelen over je blokken is enigszins een programmeer uitdaging, maar het is zeker mogelijk en ik denk dat het uiteindelijk veel toegevoegde waarde kan hebben.
In other news.
Ik heb mijn eerste PCB's binnen van mijn nieuwe seinmodule. Deze kunnen misschien ook een oplossing bieden. Behalve een sein aan te sturen, kunnen ze ook een blok regelen zowel analoog als digitaal. Je kan natuurlijk het sein weglaten en alleen de blok functionaliteiten gebruiken. De analoge module is echter nog niet af en ik moet nog het een en ander uitwerken.
De werking:
Stel nu dat je een blok voor een sein verdeelt in twee secties, sectie A en sectie B. De trein komt binnenrijden in sectie A en het sein staat achter sectie B. De seinmodule kent een groen, geel en rood seinbeeld. Het sein is rood als het volgende blok bezet is. Het sein wordt geel wanneer het volgende sein op rood springt EN wanneer het volgende blok niet meer bezet is (het kan dus voorkomen dat 2 opvolgende blokken beiden rood zijn, wanneer de trein tussen de secties zit).
Als een sectie groen is, laten de secties A en B de trein op 100% doorrijden, als het sein geel is, dan laat sectie A de trein doorrijden en sectie B laat de trein op 50% (of minder net wat je wilt) rijden. Als het sein op rood springt, dan laat sectie A de trein ook op halve snelheid rijden en sectie B laat hem remmen tot stilstand. Ik doe hier precies hetzelfde als Lenz doet met hun dure BM2 modules, alleen ik kan dat ook met analoge treinen.
Als de blokken opvolgend zijn groen, geel, rood dan zijn de zes secties in deze volgorde: 100%(1A), 100%(1B), 100%(2A), 50%(2B), 50%(3A), 0%(3B). Een trein zal altijd doorrijden tot de allerlaatste sectie (sectie 3B).
Als nu een trein doorrijdt en stopt in sectie 3B, dan is blok 3 officieel bezet en toont het sein van blok 2 ook rood. De nieuwe situatie wordt dan als volgt:
Blok 1 geel, blok 2 rood, blok 3 rood dan zijn de secties: 100%(1A), 50%(1B), 50%(2A), 0%(2B), 50%(3A) en 0%(3B <- hier staat nu al een trein).
De volgende trein zal dus in sectie 2B stoppen en wanneer dat gebeurt dan is blok 2 bezet, en je raadt het al, de eerstvolgende trein zal in 1B stoppen. Als sectie drie de laatse is, dan kan je die permanent op rood zetten. Als je nu de polariteit omdraait, kan je de treinen weer wegsturen de andere kant op.
Om te voorkomen dat alle treinen tegelijk wegrijden, kan je twee dingen doen. Spanningsloos maken van de sectie. Of het bovenstaande proces uitvoeren in de andere richting. Dit bloksysteem wat ik ontworpen werkt in principe in 1 richting. Het is wel zo ingericht dat je hem dubbel kan uitvoeren in beide richtingen. Maar let op je krijgt dan wel 2 arduino's per blok en het is aanzienlijk duurder dan de oplossing die bovenin deze post staat.
Ik maak wel even het verhaaltje af. Stel nu we gaan deze blok modules dubbel uitvoeren, dan werkt het andersom hetzelfde. De trein die staat te wachten in sectie 1B wilt nu de andere kant op. Als dat spoor vrij is, zal hij optrekken en gaan rijden. Het sein van blok 1 (in de andere richting) toont nu rood omdat de trein het spoor er achter bezet houdt. Zodra de trein uit blok 1 weg is en blok 1 niet meer bezet is, dan zal blok 2 op oranje springen en de trein die staat te wachten zal met langzame snelheid rijden naar blok 1, totdat het spoor achter blok 1 weer vrij is.
Ik heb ook 'wisselmodules' in de maak. Dan zijn modules die je parallel op een wissel aansluit (dus de draden waarmee je de wisselspoelen aanstuurt, gaan ook naar deze module toe). Tevens heeft deze wissel ook een aansluiting voor een servomotor, zodat je dus een wissel ook met een servo kan aansturen. Het primaire doel van de wisselmodule is om de signalen en de bezetmelder lijnen van de seinmodules onder de wisselstraten in goede banen te geleiden. Elke wissel moet dan zo'n module krijgen, en je kan deze modules in elkaar steken of makkelijk verbinden met jumperkabels.
Stel nu dat de trein die als eerste wegrijdt vanaf spoor 1 naar spoor V, dan moet de volgende trein wachten todat spoor V vrij is. Gooien we nu de wissels om naar spoor A en spoor A is vrij, dan zal de 2e trein meteen al weg kunnen rijden.
Zou iemand dit hele systeem hebben dan zou je (mits goed aangesloten :P) alleen nog maar wissels en baan polariteit moeten aansturen. Althans tests moeten dit nog uitwijzen of dit ook daadwerkelijk zo is ::) En het is leuk, omdat je dan een systeem heb wat bijna het zelfde werkt als in het grootbedrijf.
Maar goed, 2 sensors achter elkaar zetten is goedkoper en makkelijker uitvoerbaar ;D
Je eist trouwens wel veel met je drie treinen achter elkaar opslaan, klinkt als een leuke uitdaging ook.
Bas
-
trouwens, we kunnen natuurlijk ook 1 arduino speciaal toewijden om 1 volledig kop spoor te voorzien 8).
-
Kun je dat nader uitleggen?
Ja dat kan:
De aliexpress Arduino heeft maar een beperkt aantal mogelijkheden.
Is een cloon.
De echte dure arduino heeft betere componenten en elke heeft een eigen serie nummer.
De echte arduino’s kunnen ook meer.
Voor de hobby is een goedkope arduino vaak prima omdat die maar weinig dingen hoeven te doen.
Met de echte kan je meer complexe schakelingen maken, die kunnen die goedkope niet aan.
Ook dit staat op dit forum beschreven.
(Als ik het gevonden heb, plaats ik hier de link wel).
-
Als je toch (gedeeltelijk) wilt automatiseren, waarom dan niet meteen compleet naar “echte” software? Itrain, traincontrolller, koploper, arduino’s voor servobesturing a la arcomora etc. geeft je veel meer gemak, flexibiliteit en vrijwel onbeperkte mogelijkheden, en een veel generieker groeipad.
-
Hoewel het m.i. veel minder leuk is, er bestaat hardware genaamd Dinamo (https://domburgtrainsupport.com/dinamo-dts) dat zowel digitale als analoge treinen kan aansturen en wat kan werken met iTrain en koploper. Elk blok heeft dan zijn eigen H brug met ingebouwde bezetmelder. En elk blok kan zowel een digitale als een analoge trein aansturen. Ze gebruiken het bij ons op de club bij de alkmaar baan en het werkt heel goed. Er bestaan volgens mij ook modules bij om seinen, wissels en servo's mee aan te sturen. Ik denk ook dat dit de duurste mogelijkheid is, waar het is idd wel waard het te vermelden.
Bas
@Richard
Richard niet kwaad bedoeld, maar probeer me te begrijpen. Je komt met deze bewering:
Nog een tip; begin met een ali arduno, en als je klaar bent met testen zet er dan een echte in, die gaan langer mee en kunnen ook meer.
Dan vragen wij om een uitleg en je antwoordt weer met:
...
De aliexpress Arduino heeft maar een beperkt aantal mogelijkheden.
...
De echte arduino’s kunnen ook meer.
Voor de hobby is een goedkope arduino vaak prima omdat die maar weinig dingen hoeven te doen.
Met de echte kan je meer complexe schakelingen maken, die kunnen die goedkope niet aan.
...
De geciteerde regels zijn geen uitleg, het zijn bijzonder onwaarschijnlijke beweringen, die (nog)niet worden ondersteund door een bron. Ik zeg dat ze gewoonweg niet waar zijn. Met de volgende argumenten: Het is dezelfde microcontroller, je hebt dezelfde IO tot je beschikking en hij draait op dezelfde frequentie en ze zijn beide 5V tollerant. Dus in wel opzicht zou een kloon minder kunnen? Noem twee dingen? Waarom kan een kloon complexe schakelingen niet aan? Waar is dat op gebasseerd? Kun je een voorbeeld geven?
En:
is een cloon
is ook niet echt bepaald een argument
Je hebt wel gelijk dat een originele waarschijnlijk minder snel stuk gaat, maar de kans dat zo'n ding bij normaal gebruik stuk gaat, is al bijzonder klein.
Je spreekt trouwens ook jezelf een beetje tegen. Je raadt namelijk de OP aan om een originele te kopen voor €20,- p.s (met de nog onbewezen beweringen als argumenten). En nu zeg je:
Voor de hobby is een goedkope arduino vaak prima omdat die maar weinig dingen hoeven te doen.
Waarom raad je de OP dan aan om €20,- neer te leggen, als hij zijn 'simpele' taak volgens jou waarschijnlijk afkan met een €2,- kloon?
Het enige wat ik trouwens kan bedenken, wat een kloon misschien niet zou kunnen, is muis functies en toetsenbord functies overnemen van je computer. Het is namelijk bij een originele arduino mogelijk om de usb-ttl converter firmware te hacken en te vervangen door firmare die dat dus kan. Of dat iemand ooit gedaan hebt bij de CH340 en of dat mogelijk is, dat weet ik niet. Maar niemand doet dit in de praktijk, want iedereen die zijn arduino als muis wilt inzetten, koopt gewoon een andere kloon met een atmega32u4 die die functionaliteit heeft ingebouwd.
En nogmaals, ik bedoel dit allemaal niet gemeen maar ik ben nu erg kritisch op de gemaakte beweringen.
-
@Richard
Richard niet kwaad bedoeld, maar probeer me te begrijpen. Je komt met deze bewering:Dan vragen wij om een uitleg en je antwoordt weer met:De geciteerde regels zijn geen uitleg, het zijn bijzonder onwaarschijnlijke beweringen, die (nog)niet worden ondersteund door een bron. Ik zeg dat ze gewoonweg niet waar zijn. Met de volgende argumenten: Het is dezelfde microcontroller, je hebt dezelfde IO tot je beschikking en hij draait op dezelfde frequentie en ze zijn beide 5V tollerant. Dus in wel opzicht zou een kloon minder kunnen? Noem twee dingen? Waarom kan een kloon complexe schakelingen niet aan? Waar is dat op gebasseerd? Kun je een voorbeeld geven?
Ik ben het met Bas eens. Een Chinese Arduino is namelijk geen kloon. Het Arduino platform is open source, dat betekend dat het hele ontwerp zich in het publieke domein bevind en iedereen dat mag gebruiken. Verder ben ik bang dat de z.g echte Arduino's ook gewoon in China geproduceerd worden (de infrastructuur aan fabrieken ontbreekt tegenwoordig vrijwel overal, zeker hier in het westen). Maar het belangrijkste is de software, die wordt niet in China geschreven en onderhouden, dat is de OpenSource gemeenschap die dat doet. Ik heb nu 10+ Chinese Arduino's in gebruik en tot nu toe daar geen enkel probleem mee gehad. Voor mij is het enige verschil, de tijd van leveren, ik kan naar Amersfoort fietsen en daar bij de electronica zaak een Arduino kopen (ongeveer 35-40 euro), dan heb ik hem gelijk en er zit vaak nog wat ander spul bij dat ik niet nodig heb of ik bestel hem in China (3,5-7euro) en moet 1-2 maanden wachten. Ik kies voor de laatste optie.
Overigens dat van de software wordt niet vaak genoemd, maar dat is in mijn ervaring vaak het probleem waarom goedkope Chinese klonen problemen geven. Bijv. Lais DCC decoders. Die hebben bij mij uiteindelijk nooit goed gewerkt, niet omdat de hardware problematisch was, want dat ziet er goed uit, maar omdat de software waarschijnlijkl een gejatte versie van DCCconcepts was, maar zonder ondersteuning en vol met bugs.
Groet Meino
-
De echte arduino’s kunnen ook meer.
Nog maar eens: dat is niet waar.
-
Leuke puzzel! Ik zat ook eerst na te denken over relais, maar het gemakkelijkst lijkt het me (zonder programma’s of digitaal) om alle rijwegen een aparte motordriver te geven en met een Arduino Mega alles aan te sturen (ook de wissels), inclusief 3 ingbouwde weistra regelaars voor VAB. Genoeg IO over voor sensoren en/of NX buttons, status leds,etc.
In ieder geval veel plezier met het ontwerpen en nadenken erover!
-
jouw fantasie is hier de limiet. Alles wat jij kan bedenken om met treinenbesturing te doen, kan een arduino uitvoeren.
Er schiet mij nu een idee binnen (heb ik veel last van ::)), stel nu dat je 2 lichtsluizen achter elkaar zet op ca 1cm afstand.
fantasie->idee
Jij hebt er last van, en ik ook: fantasie stuurt ideeën aan. Dus mind mapping, voorafgaand de uitwerking.
En fijn voor mensen die meelezen, want het scheurt bij hen ook iets open.
Met twee sensoren, een nand-ic en een relais, kun je analoog de rijrichting vast stellen.
Sommige analoog rijders gebruiken 3 sensors en 2 relais om het zelfde te doen (zonder ic).
Met één lichtsluis, een nand-ic, en twee relais, kun je ook de rijrichting vast stellen.
Digitaal zou je die weg met lichtsluis niet moeten gaan, omdat een nand-ic te kort reageert,
en te snel reageert op iedere (onzekere) waarneming door de sensor (trillend of flikkerend signaal).
Of je de snelheid analoog daarmee ook kunt vast stellen, weet ik niet, waarschijnlijk wel.
Die relais zijn, denk ik, niet nodig als je een arduino gebruikt, de rest wel.
Maar voor het idee van 2 sensoren, zou ik eerder reedcontacten, unipolaire hallsensoren, of LDR's nemen, vanwege prijs en aantal.
Een ledje erboven hangen, maakt een LDR stukken betrouwbaarder (kan in m'n schaduwstation makkelijk; er komt een "dak" op, waarin de bovenleiding is gefreesd). ;D
Als je toch (gedeeltelijk) wilt automatiseren, waarom dan niet meteen compleet naar “echte” software?
Dat is een levensbeschouwelijke vraag. Ik ben met pensioen. ik heb altijd gedacht gezond 100 te worden (net als de rest van de familie), tot m'n twee jaar oudere zus ineens eruit stapte (niet de C van Covid, maar de K).
Dan bedenk je dat je misschien nog 10 jaar (in plaats van 30) lol hebt van je hobby. Een groeipad is niet echt meer nodig. Dinamo ken ik, maar heb ik afgewezen. Virtueel koploper rijden op een analoge baan, kan ook, zelfs gemixt 2+3 rail. Maar is overbodig gezien de bescheiden maat.
Er gaan hooguit 16 treinen rijden op een (nog te bouwen) dubbelsporige baan met twee kopstations. Dat is analoog volledig te overzien. Die kopstations zijn ruimtebesparend bedoeld (smal en lang), dat scheelt in tafeldiepte en bereikbaarheid.
De enige reden om blok-gestuurd te willen rijden, is de combinatie 2-rail plus 3-rail. In elk blok past of het ene type of het andere. En dat principe geldt ook voor rijwegen en kopsporen. En dus ook voor wissels en kruisingen.
De relais die dat regelen, zal ik altijd nodig houden, in welk besturingssysteem ook: ze beregelen de concrete aansluiting van spoorstaven, puntstukken en kruisstukken, voor zover aanwezig.
Die (merendeels bistabiele) relais zijn er ook allemaal al: Takamisawa, Hongfa, Nais, e.d. En ik heb ze ook eerder gebruikt. Gelukkig in voetjes, niet vastgesoldeerd. De besturingslogica staat relatief los van de realisatie.
Analoog is dat geheel te overzien. Vooral als het schaduwstation alle handelingen automatisch verricht.
Het kan gewoon. Maar moet nog wel even in elkaar gesoldeerd, liefst voor 2022.
Arduino verlegt het accent wat. Maar vooral qua logica; procedure gericht (analoog met uitsluitend relais en wat ic's) versus object oriented gericht (arduino). En dat kan, zolang je volledig kunt abstraheren van de fysieke aansluitingen aan de rails.
En daarin ligt mijns inziens de uitdaging.
-
Arduino Mega [..] Genoeg IO over voor sensoren en/of NX buttons, status leds,etc.
Als het alleen om het aantal I/O-pinnen gaat hoef je niet per se een Mega te kopen hoor, een Uno of Nano kun je met port-extenders net zoveel in- en outputs geven als je nodig hebt!
* PCF8574: 8-bits I/O, via I2C. Max. 64 poorten.
* PCF8575: Idem, 16-bits.
Met een I2C-multiplexer kun je dan nog 8 reeksen van deze ic's aansluiten.
* 74HC595: 8-bit serial-in, serial or parallel-out shift register, via GPIO pins. Theoretisch geen maximum, maar houd rekening met de tijd die nodig is om de bits stuk voor stuk uit te shiften.
Ook hier kun je weer meerdere reeksen parallel aansluiten.
-
Goed om over hardware te beginnen, zelf ben ik meer een software-mens.
Ik las dat de eerste 32-bits Arduino uit is (draaiend op 3,3 v).
Dus alles waarover jullie het hebben, is 8-bits of 16-bits (draaiend op 5v).
Maakt dat iets uit voor het aantal beschikbare IO-poorten en of -pinnen,
of staat dat volslagen los van processortype en processor voltage?
-
Goed om over hardware te beginnen, zelf ben ik meer een software-mens.
Als ik de keuze heb zal ik altijd voor software kiezen.
Ik las dat de eerste 32-bits Arduino uit is (draaiend op 3,3 v).
Goed nieuws! :-) Kost wel wat meer! https://store.arduino.cc/arduino-due
Maakt dat iets uit voor het aantal beschikbare IO-poorten en of -pinnen
Nee, dat staat er los van. De eerdergenoemde Due is echt weer (net als de Mega) ruim voorzien van oa. I/O, analoge inputs en PWM outputs, maar wellicht zijn of komen er ook kleinere broertjes.
De Due heeft bovendien 4 UARTs, dat kan handig zijn zijn voor de communicatie met andere Arduinos! En 84 MHz clockspeed is natuurlijk ook wel lekker.. ;-) Maar of dat voor de besturing van (een deel van) een modelbaan nou echt wel nodig is, ik weet het niet...
Zelf ben ik van plan een Uno in te zetten voor het hoofdstation, en een paar Nanos voor kleinere taken elders op de baan. Dit omdat je met bv. alleen een Mega wel érg veel bedrading moet aanleggen.
Edit: Zo heel erg nieuw blijkt 'ie nou ook weer niet te zijn! Enfin, wizziknie, jij ook niet... ;-p
-
Zie de wisselstraat als een binaire boom: bij elke knoop een sensor. Zoiets?
Je gebruikt in ieder geval niet zoiets als een graaf-matrix, met sensor-graaf-knopen, zoveel is duidelijk.
Tenzij ik me vergis is een binary tree een specifieke vorm van een directed of undirected graph.
Meestal de vorm van een directed graph maar soms ook als undirected (als je bv van child node terug naar parent node wil).
-
Het is natuurlijk niet helemaal eerlijk om uit een array-representatie af te leiden hoe het object erachter functioneert (als rijweg-matrix of als graaf-matrix). Want uiteindelijk hangt dat af van de methoden die je toepast.
Analoog bedraad ik alles. En een van de eerste dingen die ik deed met rijwegen, was het doorlussen van stroomkringen van de "Unterflur-Antriebe". Dit is een van die jeugdzondes van echt heel lang geleden.
Ik had toen nog van die Roco apparaten (niet de 10030, maar nog ouder, de 4555A (http://www.mpc-modellbahnsteuerung.de/010_Modellbahnthemen/Roco4555A.pdf) ) onder de wissels hangen (echte stroomvreters), en was op zoek naar relais die met wat minder toe konden. Het voordeel was: ze hadden 3 gescheiden stroomkringen, oftewel eigenlijk net eentje te weinig.
In die tijd ontstond dit idee: de doorgeluste rijweg. Er van uitgaande dat je wissels nooit open rijdt, "weet" een trein na het verlaten van een station van welk vertrekspoor hij komt (zolang de wissels nog niet zijn verzet), en bij binnenkomst op dat station, is al bekend op welk aankomstspoor hij zal binnen komen. Dat zijn open deuren, maar wel erg zinvolle open deuren. Het is logica.
(https://images.beneluxspoor.net/bnls/wisselstraat1a.png)
Deze manier van rijwegen door lussen (d.m.v. geregen draadjes) schaf je af als je arduino zou inzetten, omdat je dit software matig "kunt weten". Kan de software er wat mee?
Een programmeur die zich niet bewust is van de mogelijkheid of noodzaak, krijgt het niet mee.
Ik noem deze manier statische logica (bijvoorbeeld de vertrokken trein geeft z'n eigen vertrekspoor vrij), en zet die tegenover dynamische logica (afwezigheidsdetectie op de stationssporen). Allebei analoog toepasbaar.