BeneluxSpoor.net forum
Vraag en antwoord => Elektronica en analoog => Topic gestart door: Henry Stelling op 20 September 2025, 19:43:45
-
Vandaag geprobeerd nieuwe pendel module te installeren, helaas tot frustratie geen succes 🤬😤
Waarschijnlijk een Chinees pruts apparaat.
Hij hoeft allen van links naar rechts.
Wie heeft hier een idee bij en wat zijn de beste en simpelste.
Mvrgr
Henry
-
Het is wat handiger meer context te geven. Over welke pendelmodule heb je het?
-
gelijkstroom pendel module, trein rijdt wel maar van het spoor af.
Instellen lukt mij niet.
-
Verdere info over de module?
Een alternatieve oplossing is bijvoorbeeld een arduino met 2 relais erachter. Ben je 100% flexibel.
Edit:
En waarom geen antwoord op de vraag welke module je hebt, zie reactie Klaas ook.
-
Oké zegt mij niet zo veel, moet wel simpel zijn .
-
Vertel nou eerst eens over welke module het gaat. Een link naar de website waar je hem hebt gekocht.
-
Automatisch (timer) toggelend relais met diode fuiken op het einde. Crude but effective. Je hebt alleen geen optrek-remvertraging. Is dat een must?
Oké zegt mij niet zo veel, moet wel simpel zijn .
Beetje Pippi lankous vibes hier :P
Ik heb het nog nooit gedaan, dus ik denk dat ik het wel kan
Arduino oplossing is leuk, maar je moet er wel ff voor zitten. Programmeren en schema's en onderdelenlijsten maken, kunnen we hier altijd bij helpen. Maar de kabeltjes aansluiten en de computer aanzetten, moet je zelf doen.
https://train-science.com/arduinos-wat-kan-je-ermee/ (https://train-science.com/arduinos-wat-kan-je-ermee/)
Mvg,
Bas
-
Gekocht op de treinenbeurs in Joure volgens mij chinees
-
Je moet er toch echt iets meer over vertellen. Als we niet weten wat voor ding het is, kunnen we ook geen zinnige antwoorden geven. Fotootje?
-
Gekocht op de treinenbeurs in Joure volgens mij chinees
Fries? :)
-
Ja klopt, goed verstaan , spreek het niet.
Hier de foto’s.
(https://images.beneluxspoor.net/bnls_2025/9127EE27-EFE5-4418-88F7-29B0E01A878C-68cfa8fd626b6.jpg) (https://images.beneluxspoor.net/bnls_2025/9127EE27-EFE5-4418-88F7-29B0E01A878C-68cfa8fd626b6.jpg)
(https://images.beneluxspoor.net/bnls_2025/2B171094-B649-422F-B188-534D9F842775-68cfa8fd5bf4c.jpg) (https://images.beneluxspoor.net/bnls_2025/2B171094-B649-422F-B188-534D9F842775-68cfa8fd5bf4c.jpg)
(https://images.beneluxspoor.net/bnls_2025/67AD8485-5F3F-447B-8D62-9B04586B4DA3-68cfa90028eb3.jpg) (https://images.beneluxspoor.net/bnls_2025/67AD8485-5F3F-447B-8D62-9B04586B4DA3-68cfa90028eb3.jpg)
-
Doe nou eens de moeite om de foto op een normale leesbare manier hier te plaatsen. Heb geen zin om een handstand voor mijn beeldscherm te moeten maken:
(https://images.beneluxspoor.net/bnls_2025/9127EE27-EFE5-4418-88F7-29B0E01A878C-68cfa8fd626b6-68cfac7cbb257.jpg) (https://images.beneluxspoor.net/bnls_2025/9127EE27-EFE5-4418-88F7-29B0E01A878C-68cfa8fd626b6-68cfac7cbb257.jpg)
Een erg duidelijke handleiding dus wat is nu precies het probleem?
-
Bedrading juist aangesloten en de diodes goed om gezet??
Deze module is de simpelheid zelf. Trein rijdt door tot over de door de diode onderbroken rail en stopt. Stopt die niet, is de diode verkeerdom aangesloten. De ingestelde wachttijd schakelt de polarisatie op het spoor om dmv een relais en de diode staat daardoor in geleiding en de trein rijdt terug tot de andere kant. Daarna herhaald het geheel zich. Dus gewoon de diode omdraaien. Het stuk rail achter de diode moet uiteraard wel de juiste lengte voor die trein hebben. Dwz de stroomafnemende wielen moeten er in zijn geheel op kunnen staan.
Uiteraard de print voeden met +5V.
-
Ja, denk ook dat er iets met de diodes niet goed is.
-
Je schrijft:
Instellen lukt mij niet.
De handleiding heeft het over LED’s (D1, D2) die gaan branden als je het knopje gebruikt. Gebeurt dat wel?
-
Wat gebruik ja als voeding voor de module ?
-
Heb je de rail wel twee maal onderbroken?
Ja, ik zie het nu inderdaad.
Maar is de lengte niet wat krap?
De lok moet met al zijn assen op het met de diode verbonden railstuk staan. Na enige - ingestelde ... - tijd gaat de lok weer terug rijden :)
Ipv usb kontakten verbinden met de wisselspanningcontacten vd trafo!
-
Een erg duidelijke handleiding dus wat is nu precies het probleem?
Daar heb ik toch bedenkingen bij.
Voor het instellen is het inderdaad duidelijk. Maar voor het aansluiten hadden ze nog wat tekst kunnen toevoegen. De print wordt kennelijk gevoed uit de railuitgang van de trafo. Maar er staat nergens wat de polariteit moet zijn. Misschien doet dat er niet toe, maar dat hadden ze wel kunnen vermelden.
De aanduiding USB is ook wat misleidend. Het is geen USB connector maar een klemmenblokje. En waar is dat voor nodig? Hadden ze die 5V niet uit de trafospanning kunnen maken?
-
1° het stuk voorbij de diode ( hier op de foto, links ) moet langer zijn dan de trein die er aankomt, zo ook langs het andere uiteinde.
2° die pendelautomaat is gewoon een automatische polariteitsomschakeling met tijdsvertraging.
Als de polariteit omgeschakeld wordt, zal de trein terug uit het onderbroken deel ( met diode ) vertrekken in de andere richting.
Als die pcb 5 V nodig heeft zal dat uit een appart voedinkje moeten komen.
Een treintransfo heeft gewoonlijk een vaste 14.... 16 Vac uitgang en de andere aansluiting voor de rails is dan een variabele DC spanning ( 0 -> 12....16V ) zodus die kan niet gebruikt worden voor die apparte 5 Vdc
grtjs,
Saskia
-
ja de module ligt op de rails , dat gaat mis 😄
-
Het d1 lampje is defect werkt niet.
Dus als ik de diodes om draai , moet de trein stoppen achter de diode.
-
Henry, denk even na over wat door anderen allemaal is geschreven:
- Heb je een aparte voeding aangesloten op het groene blokje met de twee aansluitingen? Je hebt er wel iets op aangesloten, maar wij kunnen niet zien wat. Moet het 5V zijn, zoals wij denken? Wat zegt de handleiding daarover? Staat er nog iets op de achterkant?
- Wij zien nu maar een stukje van vier bielsen lang dat gescheiden is met een diode. Zijn de stukken aan de uiteinden lang genoeg voor je trein?
- Voordat je allebei de diodes gaat omdraaien, kijk even goed naar de tekening in de handleiding.
-
Ik ga even kijken naar de handleiding en alle adviezen even goed door nemen.
🙏 allemaal.
-
De pendel-module werkt (y) , iedereen bedankt voor zijn hulp .
Rails was te kort en een diode zat dus verkeerd om.
Nu kijken of dit zo ook bij mijn baantje kan integreren.
Nu opzoek naar een iets degelijker versie net zo simpel, welke bevelen jullie mij aan?
Mvrgr
Henry
-
Als dit nu goed werkt, waarom dan op zoek gaan naar een andere " degelijkere "versie, dat is toch nutteloos ? ???
Ik vermoed dat andere versies zeker niet simpeler zijn.
-
Nu kijken of dit zo ook bij mijn baantje kan integreren
Hoe bedoel je? De pendelmodule is een apart baanstuk. De polariteit tussen de beide eind stukken wordt nl omgedraaid na de wachttijd. Elke andere trein die in het tussenstuk zit staat stil gedurende de wachttijd en zal dan ook de andere kant op gaan rijden ;D.
-
;)
Met beide laatste sprekers eens.
Denk je dat je een module van Conrad wel zelfstandig kan aansluiten? ;D
-
Nu opzoek naar een iets degelijker versie net zo simpel, welke bevelen jullie mij aan?
Mvrgr
Henry
Zelf ben ik geen voorstander dit soort printen gezien prijs en beperking.
Met een simpele Arduino nano van €3 en wat randcomponenten van dubbeltjes ben je er ook. Je kunt meerdere stops bedenken, langzaam optrekken en remmen, vaste of random wachttijd, detectie toevoegen.
Maar als de print werkt…
En zoals Bas ook zei, hulp is hier genoeg.
-
Op het gebied van technologie ben ik zeker niet sterk, twijfel 🤔 zelf ook .
Dus graag simpel houden ;.
-
Zelf ben ik geen voorstander dit soort printen gezien prijs en beperking.
Met een simpele Arduino nano van €3 en wat randcomponenten van dubbeltjes ben je er ook. Je kunt meerdere stops bedenken, langzaam optrekken en remmen, vaste of random wachttijd, detectie toevoegen.
Maar als de print werkt…
En zoals Bas ook zei, hulp is hier genoeg.
Heb je een adresje waar je die dingen voor 3 euro kunt kopen ?
-
Zelfs €1,82 wanneer je de connectoren er zelf op soldeert
Ik heb dit zojuist gevonden op AliExpress: €1,15 | Mini / Type-C / Micro USB Nano 3.0 Met de bootloader-compatibele Nano-controller voor Arduino CH340 USB-driver 16Mhz ATMEGA328P
https://a.aliexpress.com/_EyxEskq
Wel wat verzendkosten.
Meestal neem ik “choice”, boven €10 geen verzendkosten en snelle levering.
Ik heb dit zojuist gevonden op AliExpress: €2,89 | Mini / Type-C / Micro USB Nano 3.0 Met de bootloader-compatibele Nano-controller voor Arduino CH340 USB-driver 16Mhz ATMEGA328P
https://a.aliexpress.com/_Eutm72I
Ik heb er een best aantal, nooit problemen gehad.
-
Hoe bedoel je? De pendelmodule is een apart baanstuk. De polariteit tussen de beide eind stukken wordt nl omgedraaid na de wachttijd. Elke andere trein die in het tussenstuk zit staat stil gedurende de wachttijd en zal dan ook de andere kant op gaan rijden ;D.
wat ik al beschreef in # 18 ;D
-
Zelf ben ik geen voorstander dit soort printen gezien prijs en beperking.
Met een simpele Arduino nano van €3 en wat randcomponenten van dubbeltjes ben je er ook. Je kunt meerdere stops bedenken, langzaam optrekken en remmen, vaste of random wachttijd, detectie toevoegen.
Maar als de print werkt…
En zoals Bas ook zei, hulp is hier genoeg.
Ik vermoed dat topicstarter dan nog meer in de knoei geraakt :-X
-
Dat zou best kunnen Saskia al is het tegenop zien erger dan de realiteit. Mijn gedachte is ook wat breder bedoeld dan alleen de TS.
Wellicht is het beter een topic te starten <pendelen met Arduino>
Zal er over nadenken.
-
Zou het op prijs stellen als het nadenken over leidt tot het doen. Wacht met spanning op pendelen met Arduino!
-
Wat ik persoonlijk zou doen, is gebruik maken van een lichtsluis voor het kopspoor. De sluis steekt wel uit je spoor. Je kan ook aan een LDR denken, die is makkelijker weg te werken in het spoor.
De werking:
Als de trein in de sluis rijdt, begint hij met afremmen (PWM) (de afremvertraging kan je met potmeter instellen).
Als de trein de sluis uitrijdt remt hij sneller af (factor 3).
Als de pauze tijd voorbij is (instelbaar met potmeter), toggelt het relais om en met PWM doet de trein langzaam optrekken (instelbaar met potmeter)
Dit lost 3 problemen op:
1). Omdat de detectie is gebasseerd op een lichtlsluis wordt zowel de voor als achterkant van de trein gedetecteerd. Een push-pull trein zal zowel duwend als trekkend dezelfde remweg hebben.
2). Doordat treinen versneld afremmen na het verlaten van de sluis, worden onderlinge snelheidsverschillen tussen je materieel grotendeels opgevangen. Als je nog een te groot verschil heb, kan je per trein natuurlijk de remvertraging aanpassen met de potmeter.
3) aanvullend op 2. Als treinen warm zijn gereden en ze sneller gaan, zorgt punt 2 er ook voor dat dit probleem opgelost wordt.
(https://images.beneluxspoor.net/bnls_2025/image-68d1125e88b9f.png) (https://images.beneluxspoor.net/bnls_2025/image-68d1125e88b9f.png)
Mvg,
Bas
-
Je bent me voor Bas ;) prima concept. Ben zelf op vakantie dus wat beperkt, zeker om iets te testen.
Denk dat ik ipv een transistor een mosfet zou gebruiken.
En slim met de externe potmeters, dan werkt het ook simpel voor de <ik wil niets in een sketch aanpassen > lezers. Dit is net zo eenvoudig aan te sluiten als de print van TS.
Dit kan niet meer dan €10 kosten. €3 voor de nano, €3 voor een dubbel relais, rest voor een paar potmeters,en een mosfet module
-
En een 3 Watt Shunt weerstand van 0.1R, die hang je tussen de emitter van de tranistor en de massa. Dan kan je stroommeten en detecteren wanneer er kortsluiting is. Dat werkt heel goed weet ik uit ervaring ;D
-
Zoals je weet Bas ben ik voor het gemak fan van AI :D
// Constants voor pinnen
const int lightSensorPin1 = 2; // Lichtsluis station 1 (digital)
const int lightSensorPin2 = 3; // Lichtsluis station 2 (digital)
const int relayPin = 4; // Relais uitgang (digital)
const int pwmPin = 5; // PWM uitgang (analog)
const int accelPotPin = A0; // Aanloopvertraging potentiometer
const int decelPotPin = A1; // Remvertraging potentiometer
const int waitPotPin = A2; // Wachttijd potentiometer
// Variabelen
int currentSpeed = 0;
int targetSpeed = 0;
bool movingForward = true;
unsigned long lastUpdateTime = 0;
unsigned long waitStartTime = 0;
bool waiting = false;
// Trein toestanden
enum TrainState {
MOVING_TO_STATION2,
WAITING_AT_STATION2,
MOVING_TO_STATION1,
WAITING_AT_STATION1
};
TrainState currentState = MOVING_TO_STATION2;
void setup() {
// Pin modes instellen
pinMode(lightSensorPin1, INPUT_PULLUP);
pinMode(lightSensorPin2, INPUT_PULLUP);
pinMode(relayPin, OUTPUT);
pinMode(pwmPin, OUTPUT);
// Seriële communicatie voor debugging
Serial.begin(9600);
// Start richting station 2
digitalWrite(relayPin, HIGH); // Richting station 2
movingForward = true;
}
void loop() {
unsigned long currentTime = millis();
// Lees potentiometers
int acceleration = map(analogRead(accelPotPin), 0, 1023, 50, 500);
int deceleration = map(analogRead(decelPotPin), 0, 1023, 50, 500);
int waitTime = map(analogRead(waitPotPin), 0, 1023, 5, 60) * 1000; // seconden naar milliseconds
// Lichtsluis detectie
bool atStation1 = digitalRead(lightSensorPin1) == LOW;
bool atStation2 = digitalRead(lightSensorPin2) == LOW;
// State machine
switch (currentState) {
case MOVING_TO_STATION2:
targetSpeed = 255; // Volle snelheid vooruit
if (atStation2) {
currentState = WAITING_AT_STATION2;
waitStartTime = currentTime;
waiting = true;
targetSpeed = 0;
Serial.println("Aangekomen bij station 2");
}
break;
case WAITING_AT_STATION2:
targetSpeed = 0;
if (currentTime - waitStartTime >= waitTime && !waiting) {
currentState = MOVING_TO_STATION1;
digitalWrite(relayPin, LOW); // Richting station 1
movingForward = false;
Serial.println("Vertrek van station 2");
}
if (waiting && currentTime - waitStartTime >= 1000) {
waiting = false; // Wacht tot trein volledig stil staat
}
break;
case MOVING_TO_STATION1:
targetSpeed = 255; // Volle snelheid achteruit
if (atStation1) {
currentState = WAITING_AT_STATION1;
waitStartTime = currentTime;
waiting = true;
targetSpeed = 0;
Serial.println("Aangekomen bij station 1");
}
break;
case WAITING_AT_STATION1:
targetSpeed = 0;
if (currentTime - waitStartTime >= waitTime && !waiting) {
currentState = MOVING_TO_STATION2;
digitalWrite(relayPin, HIGH); // Richting station 2
movingForward = true;
Serial.println("Vertrek van station 1");
}
if (waiting && currentTime - waitStartTime >= 1000) {
waiting = false; // Wacht tot trein volledig stil staat
}
break;
}
// Snelheid geleidelijk aanpassen
if (currentTime - lastUpdateTime >= 50) { // Update elke 50ms
lastUpdateTime = currentTime;
if (currentSpeed < targetSpeed) {
// Versnellen
currentSpeed += min(acceleration / 20, targetSpeed - currentSpeed);
} else if (currentSpeed > targetSpeed) {
// Vertragen
currentSpeed -= min(deceleration / 20, currentSpeed - targetSpeed);
}
// PWM signaal schrijven
analogWrite(pwmPin, currentSpeed);
// Debug informatie
Serial.print("State: ");
Serial.print(currentState);
Serial.print(" | Speed: ");
Serial.print(currentSpeed);
Serial.print(" | Wait: ");
Serial.print(waitTime / 1000);
Serial.println("s");
}
delay(10); // Kleine vertraging voor stabiliteit
}
Kom zo met aanvulling
-
Denk dat ik ipv een transistor een mosfet zou gebruiken.
Een mosfet is ook een transistor. ;D
-
Zo'n lichtsluis is leuk, maar maakt je modelbaanplanning wel beperkt. Een modelbaan die in de modulebak eindigt op straat, zou dan niet kunnen. Of je moet heel gekunsteld iets plaatsen, waardoor je juist dat open karakter kwijt bent.
zoals bijvoorbeeld bij La Fabrique (https://forum.beneluxspoor.net/index.php?topic=108364.0).
Overigens werkt de pendelautomaat van de TS prima, ook met PWM. Deze was ingebouwd bij La Fabrique en heeft het zeker twee beurzen prima gedaan. Bij Ontraxs heb ik gewoon de hele dag staan spelen :)
En een tip voor jullie techneuten, besef wel, dat als je het eenvoudig wilt houden voor a-techneuten, zoals ik, dat ook de rails en het materieel niet optimaal is. Hoe precies ik ook ben, rail- en rijtechnisch ben ik gewoon niet goed. Dit heeft ook invloed op dat wat jullie ontwikkelen.
Dit geen kritiek, maar dit is gewoon uit ervaring van mijn bestaan als modelbouwer :)
Groet,
michel
-
Ben ook geen fan van lichtsluizen. Ze zijn vaak prominent zichtbaar.
Stroomdetectie is eenvoudiger en onzichtbaar in te bouwen. Het probleem dat een trein getrokken en geduwd verschillend reageert is eenvoudig op te lossen. Zorg dat de geduwde voorkant ook stroom afneemt, al was het maar voor de frontseinen.
-
Jaja Klaas, dat weet ik ook wel >:( ;)
Bas had een NPN tor getekend, vandaar mijn opmerking.
Wat betreft de sketch, voor de niet Arduino liefhebbers, zie het als een black box. Het hoeft er maar 1 keer ingezet worden, kun je zelf of laten doen.
Deze simpele vraag had ik aan AI gesteld:
Kun je me een sketch schrijven voor een analoge modeltrein. De locomotief moet pendelen tussen 2 stations. Station detectie door een lichtsluis. 1 uitgang die eenrelais omschakelt. 1 uitgang met een pwm signaal. 3 ingangen waarop potentiometers zijn aangesloten. 1 voor aanloopvertraging, 1 voor remvertraging, de laatste om de wachttijd in te stellen
Aanvullende info:
Benodigde componenten:
· Arduino (Uno, Nano, etc.)
· 2x LDR of infrarood sensor (lichtsluis) uiteraard kan het ook met andere detectie, stroom, massa, reedrelais, whatever.
· 3x potentiometer (10kΩ)
· Relais module
· Transistor/Mosfet voor PWM sturing
· Voeding voor trein
Aansluitingen:
Sensoren:
· Lichtsluis station 1 → Pin 2
· Lichtsluis station 2 → Pin 3
Potentiometers:
· Aanloopvertraging → A0
· Remvertraging → A1
· Wachttijd → A2
Uitgangen:
· Relais → Pin 4
· PWM → Pin 5
Werking:
1. De trein pendelt tussen 2 stations
2. Lichtsleuven detecteren aankomst
3. Potentiometers regelen:
· Hoe langzaam de trein optrekt
· Hoe langzaam de trein remt
· Hoe lang hij wacht bij elk station
4. Relais schakelt de richting om
5. PWM regelt de snelheid
Je kunt de waarden aanpassen door de map() functie parameters te wijzigen naar je voorkeur!
Voor de helderheid, ik wil niemand iets opdringen. Werkt er iets niet, altijd op te lossen.
-
Lang geleden was ik lid van de modelbaanvereninging in Arnhem, daar hadden we wel een soort lichtsluis, die was echter onder het spoor weggewerkt en keek dan of de 2cm erboven iets stond, of niet. Na het instrooien met ballast zag je er helemaal niets meer van, alleen een miniem oogje. Zou dat een goede toevoeging kunnen zijn?
De echte benaming ben ik natuurlijk kwijt......
Groeten,
Rogier
-
Zoiets zou goed weg te werken zijn:
Ik heb dit zojuist gevonden op AliExpress: €2,16 | 5/10pcs IR Infrarood Obstakel vermijden Sensor Module voor Arduino Diy Smart Car Robot Reflecterende Optische 3PIN
https://a.aliexpress.com/_Ey3LTdU
Paar dubbeltjes per stuk
-
Ik heb een LDR gebruikt, daar heb ik een printje voor gemaak met potmeter voor de gevoeligheid, maar die kan je volgens mij ook inkopen. Die LDR kan je ook makkelijk wegwerken. Alleen omgeving licht kan een ding zijn, als de verlichting erg inconsistent is, zou dat een probleem kunnen vormen. Echter.. als je software heb kan je met met 1 LDR en 1 enkel weerstandje dat probleem ook tackelen. Dan kan je mooi gemiddele brekeningen laten doen en varierende drempelwaardes intodruceren enzo.
Anders een reflectie sensor met IR, Die kan je ook onder je baan wegwerken.
(https://i.imgur.com/D02jKgm.jpg)
Joz heeft een time of flight sensor gebruikt met succes voor een keerlus module. Naar het schijnt deed die al schakelen op de eerste beste koppelhaak die voorbij kwam. Maar daar komt SMD assemblage bij kijken, denk ik. Hij had hem verwerkt tot een biels die je makkelijk kwijt kon. Die kan je echt 99.9% onzichtbaar wegwerken
-
Ach bij al die kunsten kan mijn systeempje er ook nog wel bij.
4 draadjes benodigd voor het rijdend gedeelte.
Geen sluisjes, lichtsensors, stroomdetectie, magneetjes of anderszins. Dus een schone baan met alleen scenery.
Schakeld bij lokomotief of wagon voorop.
(https://images.beneluxspoor.net/bnls_2025/Schermafbeelding-2025-09-22-140256-68d14462dddb3.png) (https://images.beneluxspoor.net/bnls_2025/Schermafbeelding-2025-09-22-140256-68d14462dddb3.png)
Pendelbaan 3,5 meter lang, voorzien van connector en
hierop kan worden aangesloten, direct of middels adapterbox,
1 Pendelunit PWM gestuurd met,
2 schakelaars links/rechts gaand
Schakelaar Handmatig / automatisch pendelen
3potmeters (snelheid, optrek & afrem vertraging en random wachtijd)
Door analoge en digitale lokomotieven bereidbaar
2 ESU Lokprogrammer voor testen en inregelen parameters van ABC
breaking en motorsetting enz
3 Z21 Rijden en treintje spelen.(incl ABC breaking)
-
Welke simpele degelijke pendel module zou ik het beste kunnen aanschaffen?
-
Als het werkt en je tevreden bent met wat je nu hebt, laat je het zo ;).
-
Welke simpele degelijke pendel module zou ik het beste kunnen aanschaffen?
Viessmann 5214
-
Welke simpele degelijke pendel module zou ik het beste kunnen aanschaffen?
Het werkt toch? Jammer geld als je nu wat anders zou kopen.
-
Als je zoekt op pendelzugsteuerung, vind je allerlei mogelijkheden.
De viessmann 5214 lijkt mij een goede keuze. Het aansluiten is supereenvoudig en de instellingen doe je met potmetertjes. Het is wel een module in het duurdere segment.
Tams heeft een module die goedkoper is. Heeft ook de mogelijkheid voor een stop bij een tussenstation.
De keuze is reuze. Maar als de huidige module doet wat je wil, waarom dan nog extra geld uitgeven?
-
Als bezigheid tijdens de vakantie wat nagedacht over de kant en klare oplossingen, prima, wat prijzig en wellicht wat beperkt.
Of ik het zelf ga bouwen, geen idee, maar hier een impressie hoe het kan worden.
het schema:
(https://thumbs-eu-west-1.myalbum.io/photo/1k0/4918b96a-ce2e-4a84-899c-5f28aae1baa4.jpg)
Het printje:
(https://thumbs-eu-west-1.myalbum.io/photo/1k0/07e87b95-ea98-4d87-8d69-25e139a63b8a.jpg)
Zoals het nu getekend is de afmeting 5 * 10cm.
Ik heb er instel potmeters op gezet, dat kunnen net zo goed draai potmeters zijn, helemaal weglaten kan uiteraard ook, de instellingen kun je ook in de sketch aanpassen. (dat zou denk ik ook niet vaak nodig zijn, wel bij het afregelen denk ik.
De 3 leds geven het volgende aan: spanning aangesloten / loc gaat van A naar B, loc gaat van B naar A.
De gedachte is om de laatste 2 leds te laten knipperen tijden optrekken en vertraging, dat zou ook snel knipperen bij optrekken en langzaam bij afremmen kunnen zijn.
2 spare in/outputs zitten erop, bijvoorbeeld voor een tussenstop of zo, meer dan 2 kan ook.
Kosten van zo'n print met alle componenten, denk dan € 10-15
Ik heb het schema en de print vlot getekend, geen fouten controle nog.
Ach, leuk om te doen, of er iemand wat aan heeft ??? ::)
-
Ik geloof zelf in een meer modulaire opzet in plaats van '1 ding'. Ik heb ooit een ding gemaakt, wat ik een 'train-catcher' noemde. Het is eigenlijk niks meer dan een veredelde diode fuik met rem en optrek vertraging. Het enige wat die print deed, was een trein 'catchen' geleidelijk afremmen en stoppen. Hij kon detecteren wanneer er werd omgepoold en adhv daarvan kon hij de trein weer langzaam laten optrekken. Je zou je baan dan een constante spanning moeten geven. (dus je fleischmann trafo op een mooie kruissnelheid instellen).
De train catcher stuurt een pulsje uit als hij een trein heeft 'gevangen'. Dat pulsje kon je aansluiten op een timer relais die dan een instelbare tijd later het spoor deed ompolen. Je had dus 2 catchers en 1 timer relais nodig om een volwaardige automaat mee te maken.
Verder zaten er kleine handigheidjes in:
een buffer sectie waardoor je met push-pull treinen kon werken met dezelfde remwegen.
Een stop sectie om versneld af te remmen.
Je had ook een ingang om een trein vast te blijven houden. Als je bijvoorbeeld meerdere kopspoortjes hebt, kan je kiezen welke trein mag pendelen.
Als je de puls uitgang door loop't naar zijn vast hou lijn, last hij simpelweg een pauze in van 30s. Zo kan je een halte maken halverwege de route.
Je kon er zelfs meer passeerstukken mee realiseren.
Elke catcher heeft zijn eigen potmeter om remvertraging in te stellen, zo kan je met kortere en langere sporen overweg.
Ik had zelfs een werkende protope gemaakt. Het leuk is, dat je kan kiezen tussen handmatige bediening en automatische bediening. Vervang de timer relais door een schakelaar en je kan pendelen door zelf een schakelaar om te gooien. De catchers regelen voor jou het optrekken en afremmen.
Maar het heeft nooit de productie bereikt ::).
Ik heb nog oude documentatie (https://train-science.com/train-catcher/)voor als iemand het boeit
Ik wil het idee nog wel een keer oppakken. Wat ik wil toevoegen, is een centrale print die je dan op een x aantal catchers kan aansluiten. De centrale moet kunnen ompolen, snelheid instellen en automatiseren. Automatiseren wil ik oplossen door programma's in te leren door het voor te doen. Dan moet je zelf dus ompolen en bij train catchers op knopjes drukken om treinen heen en weer te sturen. De centrale neemt die handelingen op, en kan dat later tot op een ms nauwkeurig naspelen.
(https://images.beneluxspoor.net/bnls_2025/image-68d62c836ed88.png) (https://images.beneluxspoor.net/bnls_2025/image-68d62c836ed88.png)
De catchers moeten ook elke een dikke transistor krijgen om wissels te kunnen schakelen dmv een diode matrix. Elke catcher kan dan een volledige wisselstraat schakelen naar/van zijn spoor.
En ik wil optische detectie dmv een LDR toepassen. Dan hoef je geen rail isolaties te maken tussen buffer, brake en stop secties. Als een trein over de sensor rijdt, is hij al in de rem sectie en dan kan de catcher direct beginnen met werken. En als de trein de sensor uit rijdt, kan hij versneld afremmen. (of je moet een aparte stop sensor maken, wat ansich ook prima oplossing is).
Mvg,
Bas
-
Prima Bas, jij hebt ook meer ervaring in het ontwikkelen.
Even buiten het feit dat 3 rail meer mijn ding is ;D
-
Alles begint bij een idee, pas als dat goed is, volgen schema's en printplaten. I like to think dat ik goed in ideeën ben, maar wie ben ik. Ik ben ook altijd benieuwd naar andermans ideeën. Soms PB ik iemand wel eens om een idee te pitchen, iemand waarvan ik weet dat hij daar zelf ook ideeën over bedacht heeft.
Ik denk dat hamvraag is wat is 'beter': 1 pendelautomaat vs meerdere blokjes?
'Beter' is omslachtig maar dat kan je kwantificeren
Wat bedient makkelijker? / hoe wil je het bedienen?
Wat bekabelt makkelijer?
Wat is betrouwbaarder?
Wat is goedkoper?
Is het makkelijk genoeg voor mensen om het te begrijpen?
Met deze eisen kan je al aan de slag gaan met ontwerpen. Je kan beginnen met een schema, maar je kan ook dingen gaan neeretten op papier. Ik was gisteren bijvoorbeeld iets van cab control aan het uitwerken. Daar heb ik inmiddels een print concept voor, maar hier begon het mee
(https://i.imgur.com/1avkY7O.jpeg)
Wat 3-rail betreft... Als de detectie al optisch is opgelost. Dan hoef je eigenlijk alleen maar het ompool relais te wisselen voor een 'hoog pulse' relais. Gewoon een relais wat een korte 24V puls op het spoor. Dat kan volgens mij met een setje jumpers. Ik had wel eens een pwm regelaar in elkaar gehackt met een arduino en een boost-converter. Die marklins rijden namelijk prima 2 kanten op gelijkspanning met minder geluid ;D.
Mvg,
Bas
-
Ah, ompuls relais, zo simpel had ik het nog niet bedacht.
Kan ook nog mooi een oled display toevoegen om de wachttijd en indicatie optrek- en remvertraging weer te geven, kost ook geen drol.
-
Idd, die ene euro. Hoef je hem niet aan de computer te hangen. Kan je eerste een programma opnemen en dan later wachttijden ed finetunen.
Wellicht Bert dat een H-brug ook niet zo slecht is ipv een relais. Want dan kan je evt ook DCC in de mix gooien. Als je digitale treinen behandelt alsof ze analoog zijn en dus spanningsloos zet. Dan kan je onder DCC adres 0, het broadcast adres, ook digitale treinen in de mix gooien. De pendel apparatus hoeft alleen maar te weten dat het een digitale trein betreft. Het adres van de trein maakt dan niet.
Als ik die traincatcher daarop aanpas, kan die ook gewoon de spanning uitzetten met zijn transistor wanneer de trein is ontvangen. Met zijn signaal lijn kan hij tevens doorgeven dat de trein moet remmen en ook moet stoppen.
Mvg,
Bas
-
Dat van DCC snap ik nog niet, maar dat hoeft nu ook nog niet. Je vind het vast niet erg dat we wat parallel bezig zijn, met ideeën spuiten wordt het steed leuker en krijgen we gemak en een functionaliteit die je niet kan kopen. En ook nog eens simpel voor niet techneuten.
Ik heb AI gevraagd naar een aanpassing van de sketch:
1. OLED Display
2. Voor 3rail (ongetwijfeld nog met een brug te kiezen tussen = en ~)
3. Led richting indicatie, A->B en B->A. Knippert langzaam bij optrekken, constant bij op snelheid, snel bij afremmen.
4. 2 extra stopplekken.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
// OLED display instellingen
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
// Constants voor pinnen - Märklin wisselstroom versie
const int lightSensorPin1 = 2; // Lichtsluis station 1 (digital)
const int lightSensorPin2 = 3; // Lichtsluis station 2 (digital)
const int lightSensorPin3 = 10; // Lichtsluis stopplaats 3 (digital)
const int lightSensorPin4 = 11; // Lichtsluis stopplaats 4 (digital)
const int relayPin = 4; // Relais voor richting (digital)
const int pwmPin = 9; // PWM voor snelheid (moet PWM pin zijn)
const int accelPotPin = A0; // Aanloopvertraging potentiometer
const int decelPotPin = A1; // Remvertraging potentiometer
const int waitPotPin = A2; // Wachttijd potentiometer
const int manualControlPin = 6; // Handbediening schakelaar (digital)
const int ledPin1 = 7; // LED 1: Station 1 -> Station 2
const int ledPin2 = 8; // LED 2: Station 2 -> Station 1
const int statusLedPin = 13; // Status LED (built-in)
// Märklin specifieke instellingen
const int MIN_PWM = 30; // Minimale PWM voor Märklin (i.v.m. startspanning)
const int MAX_PWM = 255; // Maximale PWM
const int DIRECTION_DELAY = 500; // Vertraging bij richtingsverandering (ms)
// LED knipper instellingen
const unsigned long SLOW_BLINK_INTERVAL = 800; // Langzaam knipperen (800ms)
const unsigned long FAST_BLINK_INTERVAL = 200; // Snel knipperen (200ms)
const unsigned long VERY_FAST_BLINK_INTERVAL = 100; // Zeer snel knipperen (100ms)
// Stopplaats instellingen
const int STOP_TIME = 3000; // Wachttijd stopplaatsen (3 seconden)
// Variabelen
int currentSpeed = 0;
int targetSpeed = 0;
int previousSpeed = 0;
bool movingForward = true;
unsigned long lastUpdateTime = 0;
unsigned long waitStartTime = 0;
unsigned long directionChangeTime = 0;
unsigned long lastSensorTime = 0;
unsigned long manualOverrideTime = 0;
unsigned long lastDisplayUpdate = 0;
unsigned long lastLEDUpdate = 0;
bool waiting = false;
bool changingDirection = false;
bool manualControl = false;
bool emergencyStopActive = false;
bool sensorError = false;
bool ledState = false;
int cycleCount = 0;
unsigned long totalRunTime = 0;
unsigned long programStartTime = millis();
// Trein toestanden
enum TrainState {
MOVING_TO_STATION2,
WAITING_AT_STATION2,
MOVING_TO_STATION1,
WAITING_AT_STATION1,
STOPPING_AT_POINT3,
STOPPING_AT_POINT4,
MANUAL_CONTROL,
EMERGENCY_STOP
};
TrainState currentState = MOVING_TO_STATION2;
TrainState previousState = MOVING_TO_STATION2;
void setup() {
// Pin modes instellen
pinMode(lightSensorPin1, INPUT_PULLUP);
pinMode(lightSensorPin2, INPUT_PULLUP);
pinMode(lightSensorPin3, INPUT_PULLUP);
pinMode(lightSensorPin4, INPUT_PULLUP);
pinMode(relayPin, OUTPUT);
pinMode(pwmPin, OUTPUT);
pinMode(manualControlPin, INPUT_PULLUP);
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(statusLedPin, OUTPUT);
// OLED display initialiseren
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
for(;;);
}
display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
display.setTextSize(1);
display.setCursor(0,0);
display.println("Märklin Pendeltrein");
display.println("4 Stopplaatsen");
display.display();
delay(2000);
// Seriële communicatie voor debugging
Serial.begin(9600);
Serial.println("Märklin Pendeltrein met 4 Stopplaatsen Gestart");
Serial.println("=============================================");
// Start richting station 2
digitalWrite(relayPin, HIGH);
movingForward = true;
updateLEDs(false);
// Start met minimale snelheid
analogWrite(pwmPin, MIN_PWM);
delay(1000);
programStartTime = millis();
displayStartScreen();
}
void loop() {
unsigned long currentTime = millis();
// Lees bedieningselementen
bool manualControlRequest = digitalRead(manualControlPin) == LOW;
// Handmatige overname detectie
if (manualControlRequest && !manualControl) {
enableManualControl();
} else if (!manualControlRequest && manualControl) {
disableManualControl();
}
if (manualControl) {
handleManualControl();
updateDisplay(currentTime);
updateLEDControl(currentTime);
return;
}
if (emergencyStopActive) {
handleEmergencyStop();
updateDisplay(currentTime);
updateLEDControl(currentTime);
return;
}
// Lees potentiometers
int acceleration = map(analogRead(accelPotPin), 0, 1023, 20, 200);
int deceleration = map(analogRead(decelPotPin), 0, 1023, 20, 200);
int waitTime = map(analogRead(waitPotPin), 0, 1023, 5, 120) * 1000;
// Lichtsluis detectie met debouncing
bool atStation1 = readSensorWithDebounce(lightSensorPin1, currentTime);
bool atStation2 = readSensorWithDebounce(lightSensorPin2, currentTime);
bool atPoint3 = readSensorWithDebounce(lightSensorPin3, currentTime);
bool atPoint4 = readSensorWithDebounce(lightSensorPin4, currentTime);
// Sensor status monitoring
checkSensorStatus(currentTime);
// Update totale looptijd
if (currentState == MOVING_TO_STATION1 || currentState == MOVING_TO_STATION2 ||
currentState == STOPPING_AT_POINT3 || currentState == STOPPING_AT_POINT4) {
totalRunTime += (currentTime - lastUpdateTime);
}
// Uitgebreide State machine met 4 stopplaatsen
switch (currentState) {
case MOVING_TO_STATION2:
targetSpeed = MAX_PWM;
digitalWrite(statusLedPin, HIGH);
if (atPoint3 && movingForward) {
currentState = STOPPING_AT_POINT3;
waitStartTime = currentTime;
waiting = true;
targetSpeed = 0;
logEvent("Aangekomen bij stopplaats 3");
}
else if (atStation2) {
previousState = currentState;
currentState = WAITING_AT_STATION2;
waitStartTime = currentTime;
waiting = true;
targetSpeed = 0;
cycleCount++;
updateLEDs(false);
logEvent("Aangekomen bij station 2");
}
break;
case STOPPING_AT_POINT3:
targetSpeed = 0;
digitalWrite(statusLedPin, (millis() % 1000 < 500));
if (currentTime - waitStartTime >= STOP_TIME && !waiting) {
currentState = MOVING_TO_STATION2;
targetSpeed = MAX_PWM;
logEvent("Vertrokken van stopplaats 3");
}
if (waiting && currentTime - waitStartTime >= 1000) {
waiting = false;
}
break;
case WAITING_AT_STATION2:
targetSpeed = 0;
digitalWrite(statusLedPin, (millis() % 1000 < 500));
if (currentTime - waitStartTime >= waitTime && !waiting && !changingDirection) {
changingDirection = true;
directionChangeTime = currentTime;
digitalWrite(relayPin, LOW);
movingForward = false;
logEvent("Richting veranderd naar station 1");
}
if (changingDirection && currentTime - directionChangeTime >= DIRECTION_DELAY) {
changingDirection = false;
previousState = currentState;
currentState = MOVING_TO_STATION1;
targetSpeed = MIN_PWM;
updateLEDs(true);
logEvent("Vertrek van station 2");
}
if (waiting && currentTime - waitStartTime >= 1000) {
waiting = false;
}
break;
case MOVING_TO_STATION1:
targetSpeed = MAX_PWM;
digitalWrite(statusLedPin, HIGH);
if (atPoint4 && !movingForward) {
currentState = STOPPING_AT_POINT4;
waitStartTime = currentTime;
waiting = true;
targetSpeed = 0;
logEvent("Aangekomen bij stopplaats 4");
}
else if (atStation1) {
previousState = currentState;
currentState = WAITING_AT_STATION1;
waitStartTime = currentTime;
waiting = true;
targetSpeed = 0;
cycleCount++;
updateLEDs(false);
logEvent("Aangekomen bij station 1");
}
break;
case STOPPING_AT_POINT4:
targetSpeed = 0;
digitalWrite(statusLedPin, (millis() % 1000 < 500));
if (currentTime - waitStartTime >= STOP_TIME && !waiting) {
currentState = MOVING_TO_STATION1;
targetSpeed = MAX_PWM;
logEvent("Vertrokken van stopplaats 4");
}
if (waiting && currentTime - waitStartTime >= 1000) {
waiting = false;
}
break;
case WAITING_AT_STATION1:
targetSpeed = 0;
digitalWrite(statusLedPin, (millis() % 1000 < 500));
if (currentTime - waitStartTime >= waitTime && !waiting && !changingDirection) {
changingDirection = true;
directionChangeTime = currentTime;
digitalWrite(relayPin, HIGH);
movingForward = true;
logEvent("Richting veranderd naar station 2");
}
if (changingDirection && currentTime - directionChangeTime >= DIRECTION_DELAY) {
changingDirection = false;
previousState = currentState;
currentState = MOVING_TO_STATION2;
targetSpeed = MIN_PWM;
updateLEDs(true);
logEvent("Vertrek van station 1");
}
if (waiting && currentTime - waitStartTime >= 1000) {
waiting = false;
}
break;
}
// Snelheidsregeling
if (currentTime - lastUpdateTime >= 50) {
previousSpeed = currentSpeed;
updateSpeedControl(acceleration, deceleration, currentTime);
lastUpdateTime = currentTime;
}
// LED aansturing updaten
updateLEDControl(currentTime);
// Display updaten (elke 500ms)
if (currentTime - lastDisplayUpdate >= 500) {
updateDisplay(currentTime);
lastDisplayUpdate = currentTime;
}
// Status rapportage elk uur
static unsigned long lastReportTime = 0;
if (currentTime - lastReportTime >= 3600000) {
generateStatusReport();
lastReportTime = currentTime;
}
delay(10);
}
// LED aansturing functies (zelfde als voorheen)
void updateLEDControl(unsigned long currentTime) {
static unsigned long lastBlinkTime = 0;
unsigned long blinkInterval = 0;
bool shouldBlink = false;
if (emergencyStopActive) {
blinkInterval = VERY_FAST_BLINK_INTERVAL;
shouldBlink = true;
}
else if (currentState == MOVING_TO_STATION1 || currentState == MOVING_TO_STATION2 ||
currentState == STOPPING_AT_POINT3 || currentState == STOPPING_AT_POINT4) {
if (currentSpeed > previousSpeed) {
blinkInterval = SLOW_BLINK_INTERVAL;
shouldBlink = true;
}
else if (currentSpeed < previousSpeed && currentSpeed > MIN_PWM + 10) {
blinkInterval = FAST_BLINK_INTERVAL;
shouldBlink = true;
}
else {
shouldBlink = false;
}
}
else if (currentState == WAITING_AT_STATION1 || currentState == WAITING_AT_STATION2) {
blinkInterval = SLOW_BLINK_INTERVAL;
shouldBlink = true;
}
if (shouldBlink && blinkInterval > 0) {
if (currentTime - lastBlinkTime >= blinkInterval) {
ledState = !ledState;
updateLEDs(ledState);
lastBlinkTime = currentTime;
}
} else {
updateLEDs(!shouldBlink);
}
}
void updateLEDs(bool enable) {
if (emergencyStopActive) {
digitalWrite(ledPin1, enable);
digitalWrite(ledPin2, enable);
}
else if (manualControl) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
else if (currentState == MOVING_TO_STATION2 || currentState == STOPPING_AT_POINT3) {
digitalWrite(ledPin1, enable);
digitalWrite(ledPin2, LOW);
}
else if (currentState == MOVING_TO_STATION1 || currentState == STOPPING_AT_POINT4) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, enable);
}
else {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
}
// Display functies met extra stopplaatsen
void displayStartScreen() {
display.clearDisplay();
display.setTextSize(2);
display.setCursor(0,0);
display.println(" MARKLIN");
display.println(" 4 STOP");
display.println(" PLAATSEN");
display.setTextSize(1);
display.setCursor(0,50);
display.println("Route: 1-3-2-4-1");
display.display();
delay(3000);
}
void updateDisplay(unsigned long currentTime) {
display.clearDisplay();
// Header met status en locatie
display.setTextSize(1);
display.setCursor(0,0);
display.print("Status: ");
display.println(getStateName(currentState));
// Huidige locatie
display.setCursor(70,0);
display.print("Loc: ");
display.println(getLocationName(currentState));
// Horizontale lijn
display.drawLine(0, 10, 128, 10, SSD1306_WHITE);
// Potentiometer waarden
int accelValue = map(analogRead(accelPotPin), 0, 1023, 1, 10);
int decelValue = map(analogRead(decelPotPin), 0, 1023, 1, 10);
int waitValue = map(analogRead(waitPotPin), 0, 1023, 5, 120);
display.setCursor(0,15);
display.print("Optrek: ");
display.print(accelValue);
display.println(" sec");
display.setCursor(0,25);
display.print("Afrem: ");
display.print(decelValue);
display.println(" sec");
display.setCursor(0,35);
display.print("Wachten: ");
display.print(waitValue);
display.println(" sec");
// Stopplaats wachttijd
display.setCursor(0,45);
display.print("Stop: ");
display.print(STOP_TIME / 1000);
display.println(" sec");
// Snelheidsbalk
int speedPercent = map(currentSpeed, 0, 255, 0, 100);
display.setCursor(0,55);
display.print("Snelh: ");
display.print(speedPercent);
display.print("% ");
display.print(currentSpeed > previousSpeed ? "▲" : (currentSpeed < previousSpeed ? "▼" : "■"));
// Snelheidsbalk tekenen
int barWidth = map(currentSpeed, 0, 255, 0, 100);
display.drawRect(50, 55, 70, 8, SSD1306_WHITE);
display.fillRect(50, 55, barWidth * 70 / 100, 8, SSD1306_WHITE);
display.display();
}
String getStateName(TrainState state) {
switch(state) {
case MOVING_TO_STATION1: return "Naar Stat 1";
case MOVING_TO_STATION2: return "Naar Stat 2";
case WAITING_AT_STATION1: return "Wacht Stat 1";
case WAITING_AT_STATION2: return "Wacht Stat 2";
case STOPPING_AT_POINT3: return "Stop Plaats 3";
case STOPPING_AT_POINT4: return "Stop Plaats 4";
case MANUAL_CONTROL: return "Handmatig";
case EMERGENCY_STOP: return "NOODSTOP";
default: return "Onbekend";
}
}
String getLocationName(TrainState state) {
switch(state) {
case MOVING_TO_STATION1: return "1->2";
case MOVING_TO_STATION2: return "2->1";
case WAITING_AT_STATION1: return "Stat 1";
case WAITING_AT_STATION2: return "Stat 2";
case STOPPING_AT_POINT3: return "Stop 3";
case STOPPING_AT_POINT4: return "Stop 4";
case MANUAL_CONTROL: return "Hand";
case EMERGENCY_STOP: return "STOP";
default: return "Onbekend";
}
}
// Overige functies blijven hetzelfde
bool readSensorWithDebounce(int sensorPin, unsigned long currentTime) {
static unsigned long lastSensorTime1 = 0, lastSensorTime2 = 0, lastSensorTime3 = 0, lastSensorTime4 = 0;
static bool lastState1 = HIGH, lastState2 = HIGH, lastState3 = HIGH, lastState4 = HIGH;
bool currentState = digitalRead(sensorPin) == LOW;
unsigned long* lastTime;
bool* lastState;
switch(sensorPin) {
case lightSensorPin1: lastTime = &lastSensorTime1; lastState = &lastState1; break;
case lightSensorPin2: lastTime = &lastSensorTime2; lastState = &lastState2; break;
case lightSensorPin3: lastTime = &lastSensorTime3; lastState = &lastState3; break;
case lightSensorPin4: lastTime = &lastSensorTime4; lastState = &lastState4; break;
default: return false;
}
if (currentState != *lastState) {
*lastTime = currentTime;
*lastState = currentState;
}
return (currentTime - *lastTime > 100) && currentState;
}
void checkSensorStatus(unsigned long currentTime) {
static unsigned long lastSensorCheck = 0;
if (currentTime - lastSensorCheck > 5000) {
// Eenvoudige conflict detectie
int activeSensors = 0;
if (digitalRead(lightSensorPin1) == LOW) activeSensors++;
if (digitalRead(lightSensorPin2) == LOW) activeSensors++;
if (digitalRead(lightSensorPin3) == LOW) activeSensors++;
if (digitalRead(lightSensorPin4) == LOW) activeSensors++;
if (activeSensors > 1) {
sensorError = true;
triggerEmergencyStop("Sensor conflict");
} else {
sensorError = false;
}
lastSensorCheck = currentTime;
}
}
void updateSpeedControl(int acceleration, int deceleration, unsigned long currentTime) {
if (!changingDirection && !emergencyStopActive) {
if (currentSpeed < targetSpeed) {
int speedIncrease = min(acceleration / 20, targetSpeed - currentSpeed);
currentSpeed += speedIncrease;
if (currentSpeed > 0 && currentSpeed < MIN_PWM) currentSpeed = MIN_PWM;
} else if (currentSpeed > targetSpeed) {
int speedDecrease = min(deceleration / 20, currentSpeed - targetSpeed);
currentSpeed -= speedDecrease;
if (currentSpeed < MIN_PWM && targetSpeed == 0) currentSpeed = 0;
}
} else {
currentSpeed = 0;
}
analogWrite(pwmPin, max(currentSpeed, MIN_PWM));
}
void enableManualControl() {
previousState = currentState;
currentState = MANUAL_CONTROL;
manualControl = true;
manualOverrideTime = millis();
updateLEDs(false);
logEvent("Handmatige bediening");
}
void disableManualControl() {
manualControl = false;
currentState = previousState;
updateLEDs(true);
logEvent("Automatisch hervat");
}
void handleManualControl() {
digitalWrite(statusLedPin, (millis() % 500 < 250));
updateLEDs(false);
if (millis() - manualOverrideTime > 300000) disableManualControl();
}
void triggerEmergencyStop(String reason) {
emergencyStopActive = true;
currentState = EMERGENCY_STOP;
targetSpeed = 0;
currentSpeed = 0;
analogWrite(pwmPin, 0);
logEvent("NOODSTOP: " + reason);
}
void handleEmergencyStop() {
digitalWrite(statusLedPin, (millis() % 200 < 100));
}
void logEvent(String message) {
Serial.print("[");
Serial.print(millis() / 1000);
Serial.print("s] ");
Serial.println(message);
}
void generateStatusReport() {
Serial.println("\n=== STATUS RAPPORT ===");
Serial.print("Totale bedrijfstijd: ");
Serial.print((millis() - programStartTime) / 3600000);
Serial.println(" uur");
Serial.print("Aantal cycli: ");
Serial.println(cycleCount);
Serial.print("Huidige staat: ");
Serial.println(getStateName(currentState));
Serial.println("====================\n");
}
void serialEvent() {
while (Serial.available()) {
char command = Serial.read();
switch(command) {
case 's': triggerEmergencyStop("Serieel commando"); break;
case 'r': emergencyStopActive = false; currentState = MOVING_TO_STATION2; break;
case 'm': enableManualControl(); break;
case 'a': disableManualControl(); break;
case '?': generateStatusReport(); break;
}
}
}
Ga thuis eerst op termijn een (Marklin) loc van richting laten veranderen, dan verder testen, leuk dit.
Edit: inmiddels de delays vervangen door millis, denk niet nodig dat nu hier nog neer te zetten
-
Dan hoef je eigenlijk alleen maar het ompool relais te wisselen voor een 'hoog pulse' relais.
Gewoon een relais wat een korte 24V puls op het spoor
Bedoel je dat dit digitaal ook nog steeds werkt? Die pulse geven?
Ik rij analoog , dus vraag ik me, normaal gesproken, nooit af hoe dat digitaal zou gaan.
Bovendien heb ik bij veel locs diodes ingebouwd opdat de pulse helemaal niet meer hoeft ...
En heb je het dan over 24 vDC of 24 vAC, want de meningen waren er vroeger over verdeeld of 24 vDC
altijd correct werkte. Niet dat k er ooit zelf iets van heb gemerkt, overigens.
-
Dag Henry,
Ik heb een uitstekende pendelmodule te koop staan op 2dehands en is niet duur.
je kan zelf de stoptijden ingeven van tussenstops en eindstops.
Het handelt ook meerdere treinen af, leuk ding.
Het werkt prima, maar ik stop met treinen, interesse ?
Groeten,
Robert de Jonge (GoldenOldie)