Ali-lichtsluisjes en overwegaansturing met arduino

[nighttrain1]

En als Edsko besluit voor een keer mee te doen met de BMB, waar men links rijdt?!? werkt het dan ook nog zo goed?

[gvandersel]

Richard,

Het geheel is door Edsko "gespecificeerd" op twee richtingen per spoor. Dus IEDER spoor kan zowel van links naar rechts als van rechts naar links bereden worden met een werkende AKI.
Dus mocht Edsko ooit met BMB mee willen doen, dan zal de AKI geen spelbreker zijn.

Ik denk dat het grootste probleem het uitschakelen van de AKI wordt. Aan beide kanten rijdt de trein volledig van de module af voordat de AKI open gaat en de bel stopt.

Groet,

Gerard van der Sel.

[Edsko Hekman]

Tenzij je in de rechter BB van je linker buurman/vouw een uitschuifbare set lichtsensoren monteert zodat de in/uitrij tijd iets verlengt kan worden...

Leuk idee, maar dat ga ik niet doen. Lekker simpel houden. Het ding komt zo veel als mogelijk tegen de BB van de buurman aan.

[Edsko Hekman]

Ik denk dat het grootste probleem het uitschakelen van de AKI wordt.

Oplossing: hamer (niet erg vriendelijk) of stekker eruit (wel vriendelijk)

[72sonett]

Wat gebeurt er als een (korte) trein helemaal tussen twee lichtsluizen past? Op dat moment melden beide 'laag' en dan zou de aki open gaan, terwijl er een trein overheen rijdt.

[meino]

Waarom INPUT_PULLUP in plaats van INPUT. Edsko gaat werken met straal breking. Dit betekend dat de pen van de uitgang altijd laag is, tenzij er een trein de straal onderbreekt. Als extra beveiliging gebruik ik de INPUT_PULLUP, zodat bij draadbreuk tussen sensor en Arduino de Ardiono een bezette sensor ziet. Dit heeft bij reflectie geen zin en kan zelfs tot misvattingen leiden.

@Meino: Er is nog een verschil. Ik heb 30 jaar bij de NS (waaronder Movares) gewerkt. Je krijgt dan tussen je oren gestampt dat een fout in de software mensenlevens kan kosten. Dus veel code en hardware ontwerpen hebben dit nog steeds als achtergrond. Ik ben onbewust altijd opzoek naar passieve beveiligingen.

Dat wist ik niet Gerard, dat maakt wel een verschil. Overigens ik heb geen electronica achtergrond maar ik weet ondertussen wel waarvoor een pullup weerstand dient. Maar omdat hierdoor er twee bronnen zijn die 5v leveren op de input pin, vertrouwde ik dat niet. Maar dat kan dus zonder problemen, weer wat geleerd.

Voordat ik morgen ook vertrek heb ik nog even mijn code uitgeprobeerd op een test opstelling met twee sensors (mijn snelheids meter voor het ijken van locomotieven), daar kwam nog een klein foutje in de code uit, vandaar nog even een nieuwe versie.

Code: [Selecteer]

#define DEBUG 0

enum SpoorState {leeg,
                 sensor1komend,
                 sensor2komend,
                 sensor1gaand,
                 sensor2gaand
                };
//
//  Class for a single (white) led which flickers 50 times per
//  minute when on
//
class SingleLed
{
  private:
    int ledPin;
    bool ledOn = true;
    int interval = 600;      // *** 50 keer per minuut
    bool lightOn = false;
    unsigned long lastTime;

  public:
    //
    //  Create a new instance of a (white) led, connect it to the specified
    //  digital pin and put it in the specified state (true = on, false = off)
    //
    SingleLed(int aPin, bool state)
    {
      ledPin = aPin;
      ledOn = state;
      lightOn = false;
      pinMode(ledPin, OUTPUT);

      lastTime = millis();
    }

    //
    //  Set the state of the led (true = on, false = off)
    //
    void setOn(bool state)
    {
#if (DEBUG)
      if (ledOn != state)
      {
        Serial.print("[SingleLed::setOn]");
        if (state)
          Serial.println(" aan");
        else
          Serial.println(" uit");
      }
#endif
      ledOn = state;
    }

    //
    //  If the state is on, put power on the pin of the led, using timers
    //  to make the flicker work.
    //  If the led is off, remove the power from the pin of the led.
    //
    void heartBeat()
    {
      if (ledOn)                               // Do we need to light the led?
      {
        unsigned long currTime = millis();
        if ((currTime - lastTime) >= interval) // Has the interval time passed?
        {
          lastTime = currTime;                 // Start new interval
          if (!lightOn)                        // Was the led lighted?
          {
#if (DEBUG)
            Serial.println("[SingleLed::heartBeat] led aan");
#endif
            digitalWrite(ledPin, HIGH);        // No, so switch it on
            lightOn = true;
          }
          else
          {
#if (DEBUG)
            Serial.println("[SingleLed::heartBeat] led uit");
#endif
            digitalWrite(ledPin, LOW);         // Yes, so switch it off
            lightOn = false;
          }
        }
      }
      else if (lightOn)                        // No light, but is the led still on?
      {
#if (DEBUG)
        Serial.println("[SingleLed::heartBeat] led uit");
#endif
        digitalWrite(ledPin, LOW);             // Switch ir off
        lightOn = false;
      }
    }
};

//
//  Class for a set of two (red) leds which alternate(flicker) 50 times per
//  minute when on
//
class DuoLed
{
  private:
    int led1Pin;
    int led2Pin;
    bool ledOn = true;
    int interval = 600;      // *** 50 keer per minuut
    bool lightOn = false;
    bool phase = false;
    unsigned long lastTime;

  public:
    //
    //  Create a new instance, connect it to the specified
    //  digital pins and put it in the specified state (true = on, false = off)
    //
    DuoLed(int aPin1, int aPin2, bool state)
    {
      led1Pin = aPin1;
      led2Pin = aPin2;
      ledOn = state;
      lightOn = false;
      phase = false;
      pinMode(led1Pin, OUTPUT);
      pinMode(led2Pin, OUTPUT);

      lastTime = millis();
    }

    //
    //  Set the state of the leds (true = on, false = off)
    //
    void setOn(bool state)
    {
#if (DEBUG)
      if (ledOn != state)
      {
        Serial.print("[DuoLed::setOn]");
        if (state)
          Serial.println(" aan");
        else
          Serial.println(" uit");
      }
#endif
      ledOn = state;
    }

    //
    //  If the state is on, put power on the pins of the leds, using timers
    //  to make the alternating flicker work.
    //  If the led is off, remove the power from the pins of the leds.
    //
    void heartBeat()
    {
      if (ledOn)                                  // Are the leds activated
      {
        lightOn = true;
       
        unsigned long currTime = millis();
        if ((currTime - lastTime) >= interval)    // Has the interval passed?
        {
          lastTime = currTime;                    // Yes, start new interval
          if (!phase)                           // The leds alternate, are we in phase1 (led1 on, led2 off)
          {
#if (DEBUG)
            Serial.println("[DuoLed::heartBeat] led1 aan, led2 uit");
#endif
            digitalWrite(led1Pin, HIGH);          // Yes, led1 on
            digitalWrite(led2Pin, LOW);           // led2 off
            phase = true;                       // When the interval expires, switch the leds
          }
          else                                    // We are in phase2 (led1 off, led2 on)
          {
#if (DEBUG)
            Serial.println("[DuoLed::heartBeat] led1 uit, led2 aan");
#endif
            digitalWrite(led1Pin, LOW);           // Led1 off
            digitalWrite(led2Pin, HIGH);          // Led2 on
            phase = false;                      // When the interval expires, switc the leds
          }
        }
      }
      else                                        // The leds are not active, switch of both leds
      {
        if (lightOn)
        {
#if (DEBUG)
          Serial.println("[DuoLed::heartBeat] led1 uit, led2 uit");
#endif
          digitalWrite(led1Pin, LOW);
          digitalWrite(led2Pin, LOW);
          lightOn = false;
        }
      }
    }
};

enum AkiStaat {aan, uit};

//
//  A simple class that represents a complet AKI with all its leds
//
//  TBD, the sound of the bells
//
class AKI
{
  private:
    SingleLed *whiteLight;
    DuoLed    *redLights;
    AkiStaat state = uit;

  public:
    //
    //  Create an instance of the AKI, using the specified Led objects
    //
    AKI(SingleLed *aWhiteLed, DuoLed *aRedLed)
    {
      whiteLight = aWhiteLed;
      redLights = aRedLed;
      state = uit;
    }

    //
    //  Activate the connected leds. TBD: the sound
    //
    void heartBeat()
    {
      redLights->heartBeat();
      whiteLight->heartBeat();
    }

    void set(AkiStaat aState)
    {
#if (DEBUG)
      if (state != aState)
      {
        Serial.print("[AKI::set]");
        if (aState == uit)
          Serial.println(" uit");
        else
          Serial.println(" aan");
      }
#endif
      state = aState;

      if (state == uit)
      {
        redLights->setOn(false);
        whiteLight->setOn(true);
      }
      else
      {
        redLights->setOn(true);
        whiteLight->setOn(false);
      }
    }
};

//
//  Some sensors use a digital signal and keep it high when not active and drop the signal
//  when the sensor trips, use in that case the "laag" setting. Others use a digital signal
//  and are low when not active and make the signal high when the sensor trips, use in that case
//  the "hoog" setting.
//  if the sensor doesn't generate a digital signal, you have to use a pullup resistor (or INPUT_PULLUP)
//  and in that case specify hoog.
//
//  The Flying Fish proximity detectors, when used in reflective mode, need the "laag" setting,
//  when their sensors are removed and positioned opposit each other, they need the "hoog" setting
//
enum SensorTrigger {laag, hoog};

//
//  A simple class which represents the state of a single sensor
//
class Sensor
{
  private:
    int sensorPin;
    SensorTrigger type = hoog;
    bool state = false;           // true = on, false = off

    unsigned long lastTime = 0;   // Timer to ignore short interrupts
#define JITTER_TIME   1000    // wait a second before the sensor goes off

  public:
    //
    //  Create a new instance
    //
    Sensor(int aPin)
    {
      sensorPin = aPin;
      pinMode(sensorPin, INPUT);
    }

    //
    //  Create a new instance
    //
    Sensor(int aPin, SensorTrigger aType)
    {
      sensorPin = aPin;
      type = aType;
      pinMode(sensorPin, INPUT);
    }

    //
    //  Return the current logical state of the sensor
    //
    bool getState()
    {
      return state;
    }

    //
    //  Monitor the physical sensor and update the state accordingly
    //
    void heartBeat()
    {
      if (digitalRead(sensorPin) == HIGH)
      {
        if (type == laag)       // For sensors type laag an high signal means they are in the off state
        {
          if (state != false)   // Process this signal only when the current state is ON
          {
            if (lastTime == 0)
            {
              lastTime = millis();  // start Interval
            }
            else
            {
              unsigned long currTime = millis();
              if ((currTime - lastTime) >= JITTER_TIME)
              {
#if (DEBUG)
                Serial.println("[Sensor::heartBeat] sensor(laag) goes off");
#endif
                state = false;       // sensor goes OFF
                lastTime = 0;        // Reset interval timer
              }
            }
          }
        }
        else
        {
#if (DEBUG)
          if (state != true)
          {
            Serial.println("[Sensor::heartBeat] sensor(hoog) goes on");
          }
#endif
          state = true;        // Sensor goes ON
          lastTime = 0;        // Reset interval timer
        }
      }
      else          // sensorPin  = LOW
      {
        if (type == laag)
        {
#if (DEBUG)
          if (state != true)
          {
            Serial.println("[Sensor::heartBeat] sensor(laag) goes on");
          }
#endif
          state = true;       // Sensor goes ON
          lastTime = 0;        // Reset interval timer;
        }
        else
        {
          if (state != false)   // Process this signal only when the current state is ON
          {
            if (lastTime == 0)
            {
              lastTime = millis();  // start Interval
            }
            else
            {
              unsigned long currTime = millis();
              if ((currTime - lastTime) >= JITTER_TIME)
              {
#if (DEBUG)
                Serial.println("[Sensor::heartBeat] sensor(hoog) goes off");
#endif
                state = false;       // sensor goes OFF
                lastTime = 0;        // Reset interval timer
              }
            }
          }
        }
      }
    }
};

//
//  A finite state machine that guards a occupance of a single track
//
class SpoorControl
{
  private:
    Sensor *sensor1;
    Sensor *sensor2;

    SpoorState  state = leeg;

    //
    //  Based on the state of sensor 1 and the current state of the FSM, a new state
    //  is calculated.
    //
    void handleSensor1(bool trigger)
    {
      if (trigger)                      // Sensor 1 is ON
      {
        if (state == leeg)              // If the state is "leeg" it means that a train enters the section
        {
#if (DEBUG)
          Serial.println("[SpoorControl::handleSensor1] state is sensor1komend");
#endif
          state = sensor1komend;        // so set it to state komend
        }
        else if (state == sensor2komend) // if the other sensor tripped first
        {
#if (DEBUG)
          Serial.println("[SpoorControl::handleSensor1] state is sensor1gaand");
#endif
          state = sensor1gaand;          // The train is starting to leave the section
        }
      }
      else
      { // Sensor went OFF
        if (state == sensor1gaand)       // If the train started to leave via sensor 1
        {
#if (DEBUG)
          Serial.println("[SpoorControl::handleSensor1] state is leeg");
#endif
          state = leeg;                  // the section is "leeg"
        }
      }
    }

    //
    //  Based on the state of sensor 2 and the current state of the FSM, a new state
    //  is calculated.
    //
    void handleSensor2(bool trigger)
    {
      if (trigger)                          // Sensor 2 is ON
      {
        if (state == leeg)                  // Is the section "leeg"?
        {
#if (DEBUG)
          Serial.println("[SpoorControl::handleSensor2] state is sensor2komend");
#endif
          state = sensor2komend;            // A Train entered the section via sensor 2
        }
        else if (state == sensor1komend)    // No a train entered the section via the other sensor
        {
#if (DEBUG)
          Serial.println("[SpoorControl::handleSensor2] state is sensor2gaand");
#endif
          state = sensor2gaand;             // Start the leaving process
        }
      }
      else
      {
        if (state == sensor2gaand)          // A train is in the process of leaving
        {
#if (DEBUG)
          Serial.println("[SpoorControl::handleSensor2] state is leeg");
#endif
          state = leeg;                     // Section is empty again
        }
      }
    }

  public:
    //
    // Create an instance with two sensors
    //
    SpoorControl(Sensor *aSensor1, Sensor *aSensor2)
    {
      sensor1 = aSensor1;
      sensor2 = aSensor2;
    }

    //
    //  Get give the sensors a kick and check their state so we can update our own
    //  state.
    //
    void heartBeat()
    {
      sensor1->heartBeat();
      sensor2->heartBeat();

      handleSensor1(sensor1->getState());
      handleSensor2(sensor2->getState());
    }

    //
    // Return the current state of the section
    //
    SpoorState getState()
    {
      return state;
    }
};

//
//  Create 2 FSM controling two track sections
//
SpoorControl spoor1(new Sensor(A0, laag), new Sensor(A1, laag)); // Sensor works reflective
SpoorControl spoor2(new Sensor(A2, laag), new Sensor(A3, laag));

//
// Create an instance of the AKI
//
AKI aki(new SingleLed(A4, true), new DuoLed(A5, A6, false));

void setup()
{
#if (DEBUG)
  //Serial.begin(9600);
  Serial.begin(115200);
  while (!Serial);
  Serial.println("Starting");
  Serial.flush();
#endif //DEBUG


}

void loop()
{
  spoor1.heartBeat();     // These object must monitor their sensors
  spoor2.heartBeat();     // so they can update their states


  if ((spoor1.getState() == leeg) && (spoor2.getState() == leeg))
  {
    aki.set(uit);         // Stop sound and flashing red lights
  }
  else
  {
    aki.set(aan);         // Start flashing red lights and sound
  }

  aki.heartBeat();        // Let the AKI update it's connected bells and leds
}

Uit het testen bleek wel dat deze Flyijng Fish sensors erg gevoelig zijn voor omgevings licht. Ik deed de test even in mijn serre, maar daar werkte het voor geen meter. Totdat ik me realiseerde (aan de hand van de ledjes op de sensor) dat ze altijd aan waren. Pas toen ik weer in de kelder met de treinbaan was, werkte het naar behoren. Dus let op voor omgevings licht.

Groet Meino

[meino]

Wat gebeurt er als een (korte) trein helemaal tussen twee lichtsluizen past? Op dat moment melden beide 'laag' en dan zou de aki open gaan, terwijl er een trein overheen rijdt.

dat is geen probleem, omdat zowel bij mijn code als de code van Gerard het treinvak pas weer vrijgegeven wordt op het moment dat de trein de tweede sensor activeert en vervolgens de tweede sensor in zijn geheel gepasseerd is. Het feit dat de eerste sensor gepasseerd is heeft geen invloed op de status van het treinvak. Het gaat dus niet om de status van een enkele sensor, maar de volgorde van de statussen van de sensors die bepalen of een treinvak bezet of vrij is.
Overigens zijn er wel scenario's dat het niet goed gaat. Bijv. als een trein de module binnen komt, stopt en dan terug rijdt, kan niet correct afgehandeld worden met de informatie die beschikbaar komt van de lichtsluisjes.

Groet Meino

[gvandersel]

@Meino,

Kijk even in mijn code. De situatie die ontstaat is niet correct,maar wel veilig. De AKI blijft gewoon gesloten. Pas een volgende trein uit de richting waar de eerdere trein kwam zal de boel herstellen, naast opnieuw starten.

Groet,

Gerard van der Sel.

PS. Goede reis en tot over een week dan maar.

[meino]

Dag Gerard

ik had je code bekeken en wat ik zag leek voor betreffende de states erg op mijn code (ook 3 states)
Ik hanteer voor een spoor de volgende states, leeg, komend en gaand. Alleen bij status leeg zal de AKI uit zijn. De volgorde van de gebeurtenissen is bij mij:

• een trein arriveert bij sensor 1, state gaat van leeg naar komend. Vanaf nu worden alle events die van sensor 1 komen weggegooid.
• De trein ariveert bij sensor 2, state gaat van komend naar gaand.
• De trein verlaat de BB en sensor 2 gaat weer naar af, state gaat van gaand naar leeg. Om te voorkomen dat dit te snel getriggered wordt (door korte onderbrekingen) zit er een timer op het naar af gaan van een sensor. Hij moet minimaal 1 seconde af zijn voordat het als een gebeurtenis wordt opgepikt.

Als de trein van de andere kant komt, vindt in principe de zelfde volgorde van state wisselingen plaats. Ik heb je code niet al te diep bekeken, maar ik had het idee dat je de zelfde volgorde van soortgelijke state wisseling hebt geimplementeerd.

Bedankt en jij ook nog een goede reis.

Groet Meino

[72sonett]

Is het niet veel handiger om met een bezetmelder op basis van stroomdetectie te werken - aangenomen dat  behalve de loc ook iedere wagon stroom trekt en voor zover dat niet in strijd is met de eis dat er niets aan de trein veranderd mag worden?

Dat betekent dan dat het met een eenvoudige elektronische schakeltrap (zonder processor) kan worden gerealiseer: bezet = dicht, vrij = open (en je hebt ook geen last van omgevingslicht).

[Edsko Hekman]

Hi,

dat zou in principe kunnen. Echter, dan moet ik van alle deelnemers aan de baan gaan vragen of ze al hun rijdend materieel dat op de baan gaat rijden, stroom moeten afnemen op ale wielen. Dat kan ik niet vragen, vandaar de lichtsluis.

[gvandersel]

NS264 (Koen),

Gebruik jij een servo of een stappenmotor voor je overgenomen. Een servo is gemakkelijker.
Ik kan in de linken die jij gegeven hebt niet echt het stuiteren van de boom terugvinden, wel mooie lineaire bewegingen. Is het de bedoeling dat de bomen ook na stuiteren? Beneden en boven neem ik aan.

Groet,

Gerard van der Sel.

[Edsko Hekman]

Hte is hier nog een beetje rustig. Te warm om nu te gaan knutselen en ook mijn tuin vraagt wel wat aandacht momenteel.
Ik heb echter wel goede hoop dat ik er deze week nog ergens aan toe ga komen.

[NS264]

Ook laatste restje vakantie aan het vieren.

Ik kom er later vandaag op terug.

Een stuiterende boom is leuk maar niet perse noodzakelijk, slechts detail.
De link nr de Duitse forum laat ook vertraging zien met behulp van tandwielen, leuk, maar als je al een mooie beweging hebt met en servo is dat genoeg.

BTW ik heb een steppen controller voor de arduino om of 2 servo te bedienen of een motor.

Ik open een eigen draadje straks omdat het afwijkt van Edsko's plan.

Gr Koen.

Ow, en fotocellen voor detectie.

[gvandersel]

Servo's  kun je direct aan de Arduino aansluiten. Daar heb je geen versterker bij nodig. Stuiteren vergt een patroon ipv een lineaire beweging. Die komt uit een formule of een tabel. Is het wel goed dat we een versie van de software maken?

Groet,

Gerard van der Sel.