Doel:€250.00
Donaties:€65.00

Per saldo:€-185.00

Steun ons nu!

Laatst bijgewerkt
op 17-03-2020
Algemeen

De stichting

Recente berichten

Kellerstein; een nieuwe baan in H0 door tijgernootje
Vandaag om 10:46:06
Ultrasone reiniger voor het schoonmaken van een airbrush? door Bjor
Vandaag om 10:44:44
Heuvelland, een tentoonstellingsbaantje in H0 door St00mboy
Vandaag om 10:42:06
DCC++ probleempje door Waterman
Vandaag om 10:37:13
Mijn eerste H0-modeltreinbaan in aanbouw door tijgernootje
Vandaag om 10:37:05
Driemaster in ‘t veen - NS 2900 in h0 door Noordernet
Vandaag om 10:37:02
BNLS-Module: "Rvbr-Btk, Ringvaartbrug Haarlemmermeer nabij Buitenkaag" NS H0 door Hans van de Burgt
Vandaag om 10:27:09
Länderbahn en Reichsbahn locomotieven. door puntenglijder
Vandaag om 10:13:56
NTM goederenwagens in Spoor-0 door FritsT
Vandaag om 10:12:28
Haarsem aan Zee H0 door San-Markos
Vandaag om 10:10:38
MB-module: Hielan Ware door sdz1976
Vandaag om 10:01:49
DAF YA-314 Algemeen door Hans Reints
Vandaag om 09:25:02
Onlangs gespot - gefotografeerd, de foto's door Klaas Zondervan
Vandaag om 09:23:37
tandwiel draaistellen vervangen door Klaas Zondervan
Vandaag om 09:22:35
Ombouw/Pimpen Bolle neuzen door bollen neus
Vandaag om 09:15:49
Update: baan in de tropen door AndrevdG
Vandaag om 08:58:42
Havenbaantje, Duitse havenstad, periode 2e wereldoorlog. door Wim Vink
Vandaag om 08:30:11
Baanbouw Bosje77 door Wim Vink
Vandaag om 08:26:42
Nokvorsten, waar verkrijgbaar? door MOVisser
Vandaag om 08:26:12
"Litter Bin" voor Brits spoor en Britse modelspoorprojecten door Marij Stoffels
Vandaag om 08:16:16
Toon hier je nieuwe (model-) spooraanwinst(en)... door Den Zoeterdam
Vandaag om 07:18:30
Philotrain NS C10c (ex. SS), kit 15c door roadster36
Vandaag om 01:57:57
MK Modelbouwstudio NBDS 7, het onmogelijke verhaal door roadster36
Vandaag om 01:57:15
VERPLAATST: Nokvorsten, waar verkrijgbaar? door Bert van Gelder
Vandaag om 00:27:28
Projekt 083-338 door T.Spat
27 maart 2020, 23:39:41
Schwarzburg-Neuffen-Bahn door Schachbrett
27 maart 2020, 23:24:54
(BNLS modulebaan) BNLS-Forumbaan algemeen door St00mboy
27 maart 2020, 23:17:40
Mallnitzer Tauernbahnstrecke ÖBB N Spoor door Schachbrett
27 maart 2020, 23:13:29
Stationsplein Baden Baden door nighttrain1
27 maart 2020, 22:53:53
Haven/industrie rangeerbaantje in spoor 0 door sdz1976
27 maart 2020, 22:33:23
  

Auteur Topic: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie  (gelezen 9622 keer)

NS264

  • Offline Offline
  • Berichten: 5889
  • Midland Industrie, NS IV.
    • Midland
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #105 Gepost op: 25 juni 2018, 16:24:06 »
 ;D, ja die ja, het fruitmandje.

Rechtstreeks op de Arduino?

Niet eerst op de breadboard naar de Arduino?


Gr Koen.
« Laatst bewerkt op: 25 juni 2018, 16:38:40 door NS264 »
Klik op de wereldbol naar topic.
Mvg Koen. Betuwse oplossing:'kumt tied, kumt road'.

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3475
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #106 Gepost op: 25 juni 2018, 17:24:18 »
Inderdaad eerst op het breadboard de schakeling opbouwen. De voeding en de uitgang kun je hierna verbinden met de Arduino. Hoe we het straks doen zien we wel.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

NS264

  • Offline Offline
  • Berichten: 5889
  • Midland Industrie, NS IV.
    • Midland
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #107 Gepost op: 26 juni 2018, 23:22:16 »
Gerard,
Ik neem aan dat het schema gebruikt kan worden voor breadboard?
Of stel ik dan een dummy-vraag?

Had ook een schemaatje gezien met een Ledje ertussen zodat je die kan 'schakelen'.
Dan zie ik de werking van die sensor.

Ik heb een 9volt batterij met klip, dus kan ff los van Arduino gedaan worden.

Gr Koen.
Klik op de wereldbol naar topic.
Mvg Koen. Betuwse oplossing:'kumt tied, kumt road'.

NS264

  • Offline Offline
  • Berichten: 5889
  • Midland Industrie, NS IV.
    • Midland
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #108 Gepost op: 27 juni 2018, 09:20:42 »
Een klein begin van een leek;



Nu nog uitvogelen waar de draden geplaatst gaan worden.

Btw, weerstand van 220 Ohm.

Gr Koen.
Klik op de wereldbol naar topic.
Mvg Koen. Betuwse oplossing:'kumt tied, kumt road'.

72sonett

  • Team encyclopedie
  • Offline Offline
  • Berichten: 1510
    • El Carrilet
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #109 Gepost op: 27 juni 2018, 09:29:20 »
Dat gaat zo niet werken, de 5 gaatjes (11abcde) onder die weerstand zijn met elkaar verbonden (álle 'regels' met cijfers in de twee delen links en rechts van de gleuf in het midden zijn met elkaar verbonden).




Citaat van: gvandersel
...  TRCT5000  ... hoeken afgevlakt. Dit is de kant van de diode (ingang, pen 1 en 2)

Maar welke is dan 1 en welke 2? Pen 1 is meestal aangegeven met een markering (putje).

Dit is een plaatje van het www:
« Laatst bewerkt op: 27 juni 2018, 10:19:16 door 72sonett »
El Carrilet

Not sent from my Pocketline Swing 380, Xperia Z2, iPhone, C5503, ALE-L21 or SM-G900F using Tapatalk.

MH

NS264

  • Offline Offline
  • Berichten: 5889
  • Midland Industrie, NS IV.
    • Midland
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #110 Gepost op: 27 juni 2018, 11:18:17 »
Er hangen nog een lang en kort lipje onder aan de sensor.
Zou dat nog herkenning zijn?

Gr Koen.
Klik op de wereldbol naar topic.
Mvg Koen. Betuwse oplossing:'kumt tied, kumt road'.

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3475
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #111 Gepost op: 27 juni 2018, 12:19:20 »
1 is A
2 is K
3 is E
4 is C
(valt me een beetje tegen 72sonet)

Zal zo uitgebreider antwoorden.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

72sonett

  • Team encyclopedie
  • Offline Offline
  • Berichten: 1510
    • El Carrilet
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #112 Gepost op: 27 juni 2018, 12:24:59 »
Letten op de schuine kanten en het www plaatje is genoeg, er staan ook geen pennummers in deze datasheet.
« Laatst bewerkt op: 27 juni 2018, 12:26:53 door 72sonett »
El Carrilet

Not sent from my Pocketline Swing 380, Xperia Z2, iPhone, C5503, ALE-L21 or SM-G900F using Tapatalk.

MH

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3475
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #113 Gepost op: 27 juni 2018, 13:44:57 »
Allereerst excuses aan 72sonet. De opmerking was niet zo bedoeld, maar ik dacht dat jij geen vertaling kon maken van nummers naar letters.

Zoals 72sonet al aangeeft de herkenning zit in de schuine kanten aan een zijde. Dan zoals getekend de weerstand plaatsen en de twee zwarte draden en de draad naar de Arduino. Ik heb liever niet dat je met die 9V klip werkt. Als je in je enthousiasme per ongeluk de schakeling dan verbind met de Arduino, dan gaat deze naar de eeuwige jachtvelden (voorgoed kapot). Wil je nog een LED extra, dan kun je deze met de korte poot in regel 14 stoppen (a t/m e) en de lange poot op een regel daarboven (13 of 12). Doe in dezelfde regel een weerstand van 1000 ohm en de andere zijde naar de plus (rode lijn).
Als de sensor afgedekt wordt met bv een stuk papier zal de LED oplichten.

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

72sonett

  • Team encyclopedie
  • Offline Offline
  • Berichten: 1510
    • El Carrilet
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #114 Gepost op: 27 juni 2018, 14:32:08 »
Tja, mijn dag is wel verpest...  :)


Ik was er van uitgegaan dat de lichtcel op rijen 14 en 16 zat, was moeilijk te zien, maar in de datasheet zie ik nu dat de pootjes 1 & 2 (en 3 & 4) op 2,54 mm afstand zitten, dus in rijen 15 en 16, maar dat maakt voor het principe niet uit. De draad naar de Arduino en de weerstand zitten dus ook in rij 15 (15abcde resp. 15fghij).

« Laatst bewerkt op: 27 juni 2018, 14:33:44 door 72sonett »
El Carrilet

Not sent from my Pocketline Swing 380, Xperia Z2, iPhone, C5503, ALE-L21 or SM-G900F using Tapatalk.

MH

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3475
  • Als het maar elektrisch is.
    • Homepage Gerard van der Sel
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #115 Gepost op: 27 juni 2018, 15:09:40 »
Samengevat geeft het dit lijstje:

TRCT5000 op de pennen: 15e, 16e, 16f en 15f
Weerstand 220 ohm op de pennen: 15h en plus
Draad 1 op de pennen: 16h en GND
Draad 2 op de pennen: 16c en GND
Draad 3 op de pen: 15c andere einde naar Arduino
LED op de pennen: 15a en 14a
Weerstand 1000 ohm: 14d en plus

Dat is alles

Groet,

Gerard van der Sel.
Holzburg (IIIb/IVa) schaal N.
Kijk ook eens bij de bouw en lees de avonturen.

NS264

  • Offline Offline
  • Berichten: 5889
  • Midland Industrie, NS IV.
    • Midland
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #116 Gepost op: 27 juni 2018, 18:01:44 »
Dank heren,

Ik dacht dat abcd met elkaar verbonden waren, horizontaal.

Voor mij geldt wel dat ik een beetje cijferblindheid heb.
Op den duur snap ik het wel.

Ga er straks mee aan de slag, eerst nog thuiskomen.

Gr Koen.

Klik op de wereldbol naar topic.
Mvg Koen. Betuwse oplossing:'kumt tied, kumt road'.

meino

  • Offline Offline
  • Berichten: 634
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #117 Gepost op: 27 juni 2018, 18:51:12 »
Even iets anders, ik heb weer even een Internet verbinding, dus even een berichtje van mij.
Koen had het er over dat hij de bomen ook handmatig wilde kunnen bedienen en eventueel de sporen met dwergseinen beveiligen.
Ik heb een aangepaste schets, waarin een simpele aan-uitschakelaar (microswitch) verbonden kan worden.
De meeste microswitches hebben 3 pennen, verbind de middelste pen met GND en een van de andere pennen met A2. Dan kun je de overweg ook activeren met deze schakelaar.
Verder voor eventuele dwergseinen, op pin A6 kun je een of meer (parallele) rode leds aansluiten, en op pin A7 een of meerdere groene leds.

Een opmerking, de komende tijd kan ik waarschijnlijk niet al te vaak op Internet zijn, dus antwoorden op eventuele vragen kan wat langer duren.

Groet Meino
A clean desk is a sign of an empty mind

Kranenberg

NS264

  • Offline Offline
  • Berichten: 5889
  • Midland Industrie, NS IV.
    • Midland
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #118 Gepost op: 27 juni 2018, 21:33:45 »
Dankje Meino,

Heb nog een goede vakantie(?).

Voorlopig nog even zoet met de sensor testen.

Dan zie ik jou sketch vanzelf tegemoet.

Gr Koen.
Klik op de wereldbol naar topic.
Mvg Koen. Betuwse oplossing:'kumt tied, kumt road'.

meino

  • Offline Offline
  • Berichten: 634
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #119 Gepost op: 27 juni 2018, 21:52:24 »
Helaas was de schets te groot, dus dat moest even apart en toen stopte mijn Internet verbinding, dus eerst maar eens een hapje eten met mijn geduldige partner.

De schets komt dus in delen, en moet even met knipppen en plakken aan elkaar gezet worden.

Deel 1
#define DEBUG 0

#include <Servo.h>

enum SpoorState {leeg,
                 sensor1komend,
                 sensor2komend,
                 sensor1gaand,
                 sensor2gaand
                };

//
//
class AanUitSchakelaar
{
  private:
    int schakelPin;
    bool schakelState;

    unsigned long lastTime;

  public:
    //
    //  Create new instance, connect it to the specified pin, and set the state
    //
    AanUitSchakelaar(int aPin)
    {
      schakelPin = aPin;
      schakelState = false;   // Schakelaar uit
      lastTime = 0;

      pinMode(schakelPin, INPUT_PULLUP);
    }

    //
    //  Monitor the physical switch and update its state accordingly
    //
    void heartBeat()
    {
      if (digitalRead(schakelPin) == LOW)
      {
#if (DEBUG)
        if (schakelState != true)
        {
          Serial.println("[AanUitSchakelaar::heartBeat] switch goes on");
        }
#endif
        schakelState = true;        // Switch goes ON
        lastTime = 0;               // Reset interval timer
      }
      else          // sensorPin  = HIGH
      {
        if (schakelState != 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) >= 100)  // filter bouncing of the switch
            {
#if (DEBUG)
              Serial.println("[AanUitSchakelaar::heartBeat] switch goes off");
#endif
              schakelState = false;       // sensor goes OFF
              lastTime = 0;        // Reset interval timer
            }
          }
        }
      }
    }

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

//
//  Class for a single (white) led which flickers 50 times per
//  minute when on
//
class SingleLed
{
  private:
    int ledPin;
    bool ledOn = false;
   
  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;
     
      pinMode(ledPin, OUTPUT);
    }

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

    //
    //  Return the state of the led
    //
    bool getState()
    {
      return ledOn;
    }

    //
    //  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?
      {
#if (DEBUG)
        Serial.println("[SingleLed::heartBeat] led aan");
#endif
        digitalWrite(ledPin, HIGH);        // No, so switch it on               
      }
      else
      {
#if (DEBUG)
        Serial.println("[SingleLed::heartBeat] led uit");
#endif
        digitalWrite(ledPin, LOW);             // Switch ir off
      }
    }
};

/*
   A wrapper class for controlling RC servo's
*/
class ArmServo
{
  private:
#define REFRESH_TIME  30000
    Servo *myServo;
    unsigned long timeOfLastStep;
    unsigned long lastTimeActive;

    unsigned int target;
    unsigned int current;
   
    unsigned int highPosition;       //  Arm position high
    unsigned int lowPosition;        //  Arm position low
    unsigned int servoWaitTime;      //  Wait time between 2 steps
   
    int servoPin;
    bool active = false;

    void attachServo() //  Intialize the servo
    {
#if (DEBUG)
      Serial.print("[ArmServo::attachServo] Servo pin: ");
      Serial.println(this->servoPin);
#endif //DEBUG
      this->myServo->attach(this->servoPin);
      this->active = true;

      this->myServo->write(this->current);  // Restore last known position
    }
   
    void detachServo()
    {
#if (DEBUG)
      Serial.print("[ArmServo::detachServo] Servo pin: ");
      Serial.println(this->servoPin);
#endif //DEBUG

      this->myServo->detach();
      this->active = false;
    }

  public:
    ArmServo(int newServoPin, int newWaitTime, int newHighPosition, int newLowPosition)
    {
      this->active = false;
      this->myServo = new Servo();
      this->servoPin = newServoPin;
      this->servoWaitTime = newWaitTime;
      this->highPosition = newHighPosition;
      this->lowPosition = newLowPosition;
      this->target = newHighPosition;     // We asume that the arms are initial in their upper position
      if (this->highPosition > this->lowPosition)
        this->current = newHighPosition - 1;  // But force a small initial movement
      else
        this->current = newHighPosition + 1;  // But force a small initial movement
      this->active = false;
    }
   
    void laag()
    {
#if (DEBUG)
      Serial.print("[ArmServo::laag] arm going to low position: ");
      Serial.println(lowPosition);
      Serial.flush();
#endif //DEBUG

      target = lowPosition;
    }

    bool isLaag()
    {
      if (current == lowPosition)
        return true;
      else
        return false;     
    }
   
    void hoog()
    {
#if (DEBUG)
      Serial.print("[Armservo::hoog] arm going to high position: ");
      Serial.println(highPosition);
      Serial.flush();
#endif //DEBUG

      target = highPosition;
    }

    bool isHoog()
    {
      if (current == highPosition)
        return true;
      else
        return false;
    }

    bool stepServo()
    {
      //
      //  When the arm's position isn't at the target, we have to move the arm
      //
      if (this->target != this->current)
      {
        //
        //  Is the servo active? if not attach it to it's pin so it can start moving
        //
        if (!this->active)
        {
#if (DEBUG)
          Serial.println("{ArmServo::stepServo] attach");
          Serial.flush();
#endif // DEBUG

          this->attachServo();
        }

        lastTimeActive = millis();

        if ((lastTimeActive - this->timeOfLastStep) >= this->servoWaitTime)
        {
          //
          //  The servo is moving to it's new location.
          //
#if (DEBUG)
          Serial.print("[ArmServo::stepServo] target: ");
          Serial.print(this->target);
          Serial.print(", current: ");
          Serial.print(this->current);
#endif //DEBUG

          if (this->target > this->current)
          {
            this->current++;
          }
          else
          {
            this->current--;
          }

#if (DEBUG)
          Serial.print(", going to: ");
          Serial.println(this->current);
          Serial.flush();
#endif // DEBUG

          this->myServo->write(this->current);
          this->timeOfLastStep = lastTimeActive;
        }

        return true;    // The arm is still moving
      }
      else
      {

        if ((millis() - lastTimeActive) >= REFRESH_TIME)
        {
          //
          //  Is the servo active? if not attach it to it's pin so it can start moving
          //
          if (!this->active)
          {
#if (DEBUG)
            Serial.println("{ArmServo::stepServo] attach");
            Serial.flush();
#endif // DEBUG

            this->attachServo();
          }

#if (DEBUG)
          Serial.print(", refreshing to: ");
          Serial.println(this->current);
          Serial.flush();
#endif // DEBUG

          this->myServo->write(this->current);
          this->lastTimeActive = millis();
        }

        //
        //  The arm reached it's position, so we can now detach the servo (if it was attached)
        //
        if (this->active)
        {
          this->detachServo();
        }

        return false;   // The arm has stopped moving
      }
    }
};

enum AkiStaat {aan, uit};

//
//  A simple class that represents a complete AHOB with all its leds and two Servo's
//  for moving the arms
//
//  TBD, the sound of the bells
//
class AHOB
{
  private:
    SingleLed    *redLight;
    ArmServo  *arm1;
    ArmServo  *arm2;
    AkiStaat state = uit;

  public:
    //
    //  Create an instance of the AHOB, using the specified Led and ArmServo objects
    //
    AHOB(SingleLed *aRedLed, ArmServo *aServo1, ArmServo *aServo2)
    {
      redLight = aRedLed;
      arm1 = aServo1;
      arm2 = aServo2;
      state = uit;

      //
      //  AHOB is veilig, dus roodlicht uit en armen omhoog
      //
      redLight->setState(false);

      arm1->hoog();
      arm2->hoog();
    }

    //
    //  Activate the connected leds and arm servo's. TBD: the sound
    //
    void heartBeat()
    {
      if (arm1->isHoog() && arm2->isHoog())
      {
        redLight->setState(false); // Als de armen omhoog staan mag het rode licht niet branden
      }
      else
      {
        //
        //  AHOB is dicht of gaat dicht, dus roodlicht aan
        //
        redLight->setState(true);
      }
     
      redLight->heartBeat();
      arm1->stepServo();
      arm2->stepServo();
    }

    //
    //  When both arms of the gate are high, return true, else return false
    //
    bool isHoog()
    {
      if (arm1->isHoog() && arm2->isHoog())
      {
        return true;
      }
      else
      {
        return false;
      }
    }

    //
    //  When both arms of the gate are low, return true, else return false
    //
    bool isLaag()
    {
      if (arm1->isLaag() && arm2->isLaag())
      {
        return true;
      }
      else
      {
        return false;
      }
    }

    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)
      {
        //
        //  AHOB is open, armen omhoog. Het rode licht stopt pas als de armen omhoog staan
        //
        arm1->hoog();
        arm2->hoog();
      }
      else
      {
        //
        //  AHOB is dicht, dus armen omlaag, het rode licht volgt automatisch
        //
        arm1->laag();
        arm2->laag(); 
      }
    }
};

//
//  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_PULLUP);
    }

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

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

A clean desk is a sign of an empty mind

Kranenberg