Doel:€250.00
Donaties:€85.00

Per saldo:€-165.00

Steun ons nu!

Laatst bijgewerkt
op 21-04-2020
Algemeen

De stichting

Recente berichten

's-Heer Heinkenspolder door Reinier Z.
Vandaag om 20:45:36
Simpel seinen aansturen door Klaas Zondervan
Vandaag om 20:45:07
NS Modelbaan Amersveld 1999 - heden door San-Markos
Vandaag om 20:39:52
Fleischmann Profi-rails, wordt het nog gemaakt? door henk
Vandaag om 20:36:44
Toon hier je nieuwe (model-) spooraanwinst(en)... door Stedahult
Vandaag om 20:35:11
Doornvliet door cor_b
Vandaag om 20:29:05
Depot + vervolg Vlieringen-2 door Hans Reints
Vandaag om 20:22:52
Groterdamse projecten door Tulpendaal
Vandaag om 20:22:07
BMB 00-modulebaan, Algemeen. door bask185
Vandaag om 20:11:29
Mijn eerste H0-modeltreinbaan in aanbouw door cor_b
Vandaag om 20:06:21
Toon hier je pas gereed gekomen (model-)spoorbouwsels ... door Mar-Cas
Vandaag om 20:04:18
Heuvelland, een tentoonstellingsbaantje in H0 door Menno
Vandaag om 20:03:34
OC 32, 3-lichtsein (CH) van Schneider aansluiten? door Remunj
Vandaag om 20:00:32
BNLS-Werkspoor - Bouw 3900 van DJH/Modelloco met tips voor beginners door TonM
Vandaag om 19:54:10
Toekomst van modeltreinbeurzen? door bernhard67
Vandaag om 19:28:12
Diorama houthandel Spoor-0 door bernhard67
Vandaag om 19:25:28
Jeugdsentiment (show je oude treintjes) door barry1972
Vandaag om 19:24:30
Digikeijs DR4018: Seinen aansturen door Bert_Apd
Vandaag om 19:14:26
Rijtuigen op De Meer door EN446
Vandaag om 18:49:02
Fleischmann lok1381 rijdt tegenovergesteld t.o.v. andere loks. door Gerke
Vandaag om 18:29:53
Buitenlust door Huib
Vandaag om 17:20:26
S88 alleen signaal als de loc rijdt door Remunj
Vandaag om 17:16:41
NS baan in Las Vegas door hvyfuji
Vandaag om 16:57:39
Raadplaatje door Hlv53
Vandaag om 16:45:26
Stationsplein Baden Baden door Dion
Vandaag om 16:01:07
Smalspoor trammetje (H0e 9mm) door JurS
Vandaag om 15:55:36
Spoor 1 modelbaan meubelfabriek Gebr. Vierling. Van de bouw tot de verkoop. door bernhard67
Vandaag om 15:32:09
Kellerstein; een nieuwe baan in H0 door zuylen
Vandaag om 15:19:54
NCS 7/8 tot NS 61 62 Maffei lok in spoor 0 door FritsT
Vandaag om 15:10:57
Bouw van de spoorlijn Leeuwarden-Harlingen Haven door Jeroenproj
Vandaag om 14:59:48
  

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

NS264

  • Offline Offline
  • Berichten: 6060
  • 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: 3507
  • 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: 6060
  • 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: 6060
  • 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
  • Online Online
  • Berichten: 1575
    • 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: 6060
  • 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: 3507
  • 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
  • Online Online
  • Berichten: 1575
    • 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: 3507
  • 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
  • Online Online
  • Berichten: 1575
    • 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: 3507
  • 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: 6060
  • 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

  • Online Online
  • Berichten: 716
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: 6060
  • 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

  • Online Online
  • Berichten: 716
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