Doel:€250.00
Donaties:€50.00

Per saldo:€-200.00

Steun ons nu!

Laatst bijgewerkt
op 03-01-2024

Vacature: secretaris bestuur
Algemeen

De stichting

Recente berichten

NS 8400 van Werps door Ivo tB
Vandaag om 00:08:14
De (3d) knutsels van Ronald. door Jan-Peter
Vandaag om 00:04:32
U-vorm beperkte ruimte (H0 C-rails) door hmmglaser
28 maart 2024, 23:42:04
Onlangs gespot - gefotografeerd, de foto's door GerardvV
28 maart 2024, 23:37:18
US diorama in H0 door Wim Vink
28 maart 2024, 23:31:57
Al mijn goede ideeën... door bask185
28 maart 2024, 23:12:12
Gebruik je Arduino zonder te "programmeren" ;) door bask185
28 maart 2024, 22:51:58
21 april Het stoomgenootschap door bloemenvelden door Seinhuis
28 maart 2024, 22:46:29
7 april De Karel on tour door Seinhuis
28 maart 2024, 22:44:31
Raadplaatje door Magic
28 maart 2024, 22:23:21
LokSound 4 decoders, files verbeteren (voor Roco b.v. TEE RAm, NS2400, etc) door Biesje
28 maart 2024, 22:06:44
Geluid NS Mat'46 vs NS Mat'54 door Rob Bennis
28 maart 2024, 21:54:12
Engelse wagon uit 1930 opgegraven in Antwerpen door willem2
28 maart 2024, 21:52:45
NS GLY omspuiten en opschriften door Rob Ellerman
28 maart 2024, 21:45:55
De Hondsrugbaan door cor_b
28 maart 2024, 21:40:07
welk jaar ging Marklin OVP voor wagons van blauw naar wit door Railman
28 maart 2024, 21:36:50
Mallnitzer Tauernbahnstrecke ÖBB N Spoor door Schachbrett
28 maart 2024, 21:22:18
Mijn eerste H0-modeltreinbaan in aanbouw door puntenglijder
28 maart 2024, 21:15:13
Bouw van materieel 40 treinstellen door Rob Bennis
28 maart 2024, 21:09:04
30 maart Modelspoorbeurs Houten & HCC Kennisdag door basjuh1981
28 maart 2024, 20:54:43
Hengelo in 1981-1982, maar dan anders: Kassenberg in N door 1200blauw
28 maart 2024, 20:32:41
Welke Vallejo kleur voor drijfstangen van een DB stoomlocomotief? door Ronald69
28 maart 2024, 20:00:39
Toon hier je nieuwe (model-) spooraanwinst(en)... door arnout
28 maart 2024, 19:53:27
Punt- en hartstukken door Klaas Zondervan
28 maart 2024, 19:41:21
MARDEC, de Multifunctionele ARduino dcc DECoder. door bord4kop
28 maart 2024, 19:34:37
Piko NS 2015 stroomafname probleem door Ben
28 maart 2024, 19:08:30
Bauarbeiten im gange door ruudns
28 maart 2024, 18:50:26
HSM D1715 door vpeters1984
28 maart 2024, 17:34:25
Beekdaelen in H0 door Stieven76
28 maart 2024, 17:17:41
Ombouw/Pimpen Bolle neuzen door bollen neus
28 maart 2024, 15:58:15
  

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

NS264

  • En maar rijden over het asfalt, kilometers.Sinds kort ook met langer materieel.
  • Offline Offline
  • Berichten: 8474
    • 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 »
Voor meer interactie voor topic Voorbereiding bouw Swalbenburg: volg Instagram@swalbenburg_moba_n#

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3602
  • 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

  • En maar rijden over het asfalt, kilometers.Sinds kort ook met langer materieel.
  • Offline Offline
  • Berichten: 8474
    • 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.
Voor meer interactie voor topic Voorbereiding bouw Swalbenburg: volg Instagram@swalbenburg_moba_n#

NS264

  • En maar rijden over het asfalt, kilometers.Sinds kort ook met langer materieel.
  • Offline Offline
  • Berichten: 8474
    • 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.
Voor meer interactie voor topic Voorbereiding bouw Swalbenburg: volg Instagram@swalbenburg_moba_n#

72sonett

  • Team encyclopedie
  • Offline Offline
  • Berichten: 2083
    • 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
"te dom om te poepen"
MH

NS264

  • En maar rijden over het asfalt, kilometers.Sinds kort ook met langer materieel.
  • Offline Offline
  • Berichten: 8474
    • 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.
Voor meer interactie voor topic Voorbereiding bouw Swalbenburg: volg Instagram@swalbenburg_moba_n#

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3602
  • 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: 2083
    • 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
"te dom om te poepen"
MH

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3602
  • 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: 2083
    • 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
"te dom om te poepen"
MH

gvandersel

  • HCC!m maar toch Selectrix (RMX)
  • Offline Offline
  • Berichten: 3602
  • 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

  • En maar rijden over het asfalt, kilometers.Sinds kort ook met langer materieel.
  • Offline Offline
  • Berichten: 8474
    • 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.

Voor meer interactie voor topic Voorbereiding bouw Swalbenburg: volg Instagram@swalbenburg_moba_n#

meino

  • Offline Offline
  • Berichten: 2088
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
De CanBus komt naar Kranenberg

NS264

  • En maar rijden over het asfalt, kilometers.Sinds kort ook met langer materieel.
  • Offline Offline
  • Berichten: 8474
    • 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.
Voor meer interactie voor topic Voorbereiding bouw Swalbenburg: volg Instagram@swalbenburg_moba_n#

meino

  • Offline Offline
  • Berichten: 2088
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
De CanBus komt naar Kranenberg