Pendel module

[Bert55]

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.

[saskia]

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 .

wat ik al beschreef in # 18 

[saskia]

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

[Bert55]

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.

[Tom Z.]

Zou het op prijs stellen als het nadenken over leidt tot het doen. Wacht met spanning op pendelen met Arduino!

[bask185]

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.



Mvg,

Bas

[Bert55]

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

[bask185]

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 

[Bert55]

Zoals je weet Bas ben ik voor het gemak fan van AI

Code: [Selecteer]

// 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

[Klaas Zondervan]

Denk dat ik ipv een transistor een mosfet zou gebruiken.

Een mosfet is ook een transistor.

[tothebeach]

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.

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

[Klaas Zondervan]

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.

[Bert55]

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.

[spoorijzer]

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

[Bert55]

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