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

Geluid NS Mat'46 vs NS Mat'54 door Rob Bennis
Vandaag om 21:54:12
Engelse wagon uit 1930 opgegraven in Antwerpen door willem2
Vandaag om 21:52:45
NS GLY omspuiten en opschriften door Rob Ellerman
Vandaag om 21:45:55
De Hondsrugbaan door cor_b
Vandaag om 21:40:07
welk jaar ging Marklin OVP voor wagons van blauw naar wit door Railman
Vandaag om 21:36:50
Mallnitzer Tauernbahnstrecke ÖBB N Spoor door Schachbrett
Vandaag om 21:22:18
Mijn eerste H0-modeltreinbaan in aanbouw door puntenglijder
Vandaag om 21:15:13
LokSound 4 decoders, files verbeteren (voor Roco b.v. TEE RAm, NS2400, etc) door mamory
Vandaag om 21:13:06
Bouw van materieel 40 treinstellen door Rob Bennis
Vandaag om 21:09:04
Gebruik je Arduino zonder te "programmeren" ;) door Menno
Vandaag om 20:58:29
30 maart Modelspoorbeurs Houten & HCC Kennisdag door basjuh1981
Vandaag om 20:54:43
US diorama in H0 door basjuh1981
Vandaag om 20:52:48
Raadplaatje door eemstede
Vandaag om 20:43:38
Hengelo in 1981-1982, maar dan anders: Kassenberg in N door 1200blauw
Vandaag om 20:32:41
Onlangs gespot - gefotografeerd, de foto's door eemstede
Vandaag om 20:31:17
Welke Vallejo kleur voor drijfstangen van een DB stoomlocomotief? door Ronald69
Vandaag om 20:00:39
Toon hier je nieuwe (model-) spooraanwinst(en)... door arnout
Vandaag om 19:53:27
Punt- en hartstukken door Klaas Zondervan
Vandaag om 19:41:21
MARDEC, de Multifunctionele ARduino dcc DECoder. door bord4kop
Vandaag om 19:34:37
De (3d) knutsels van Ronald. door gdh
Vandaag om 19:22:56
Piko NS 2015 stroomafname probleem door Ben
Vandaag om 19:08:30
Bauarbeiten im gange door ruudns
Vandaag om 18:50:26
HSM D1715 door vpeters1984
Vandaag om 17:34:25
Beekdaelen in H0 door Stieven76
Vandaag om 17:17:41
Al mijn goede ideeën... door Monobrachius
Vandaag om 17:10:33
Ombouw/Pimpen Bolle neuzen door bollen neus
Vandaag om 15:58:15
Kleine Baan in H0 (≤ 0.5m²) door Jack Black (NS1220)
Vandaag om 15:06:14
U-vorm beperkte ruimte (H0 C-rails) door Jelmer
Vandaag om 14:58:04
Onlangs gespot - gefotografeerd, de links door Jeroen Water
Vandaag om 14:33:00
N spur scenery elementen maken van gips of klei? door Dave.......
Vandaag om 14:30:06
  

Auteur Topic: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie  (gelezen 20554 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 #15 Gepost op: 03 juni 2018, 13:30:19 »
De weerstanden om het voltagegebruik te verdelen.

De stappencontroller, ook tegenstrijdig, maar op advies dat het nodig is om de servo's te regelen.
Volgens mij zit dan alles wat ik nogig heb in die stappencontroller.

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 #16 Gepost op: 03 juni 2018, 13:52:13 »
Het is i.h.a niet correct om voor motoren het 'voltagegebruik' te regelen met weerstanden.

Voor een servo gebruik je geen stappencontroller, die gebruik je voor een... stappenmotor. Een stappenmotor is principieel anders dan een servo.
El Carrilet
"te dom om te poepen"
MH

meino

  • Offline Offline
  • Berichten: 2088
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #17 Gepost op: 03 juni 2018, 18:11:01 »
Koen en anderen

ik gebruik ook de Mega om servo's aan te sturen (minimaal 2 per mega). Die servo's zijn direct op de mega 5v pin en gnd aangesloten, dat gaat prima. Wat van belang is om te weten is dat een IO pin maximaal 100-200 mA kan leveren, maar de 5v pin hangt rechtstreeks aan de regulator van de voeding, dus de voeding en de regulator is de limiterende factor. Als de Mega (of Uno) via de USB gevoed wordt is de maximale amperage gelimiteerd tot 500 mA (volgens de USB specs). Als de voeding via een 9-12 volt stekkervoeding loopt, moet je rekening houden met de regulator die de extra voltage moet verstoken om op 5v te komen. Ik sluit de mega's rechtstreeks op de vin pin (5v input) aan d.m.v. een gereguleerde 5v stekkervoeding. Daardoor kan de mega op de 5v pin rustig 1A leveren, Dat is voldoende om minimaal 2 micro servo's aan te sturen.

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

Kranenberg
De CanBus komt naar Kranenberg

meino

  • Offline Offline
  • Berichten: 2088
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #18 Gepost op: 03 juni 2018, 18:26:56 »
Koen

Ik had voor Edsko al een schets geschreven voor de AKI. Aangezien ik ook al uitgebreid met servo's voor armseinen aan de gang ben geweest, heb ik ook een gemodificeerde versie voor een AHOB met servo aansturing gemaakt.
#define DEBUG 0

#include <Servo.h>

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

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

/*
   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->target = 0;
      this->current = 0;
      this->highPosition = 0;       //  Arm position high
      this->lowPosition = 0;        //  Arm position low
      this->servoWaitTime = 40;     //  Wait time between 2 steps
      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
      this->current = newHighPosition;    // upper position.
      this->current = 0;
      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;
    }
   
    void hoog()
    {
#if (DEBUG)
      Serial.print("[Armservo::hoog] arm going to high position: ");
      Serial.println(highPosition);
      Serial.flush();
#endif //DEBUG

      target = highPosition;
    }

    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:
    DuoLed    *redLights;
    ArmServo  *arm1;
    ArmServo  *arm2;
    AkiStaat state = uit;

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

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

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

    //
    //  Activate the connected leds and arm servo's. TBD: the sound
    //
    void heartBeat()
    {
      redLights->heartBeat();
      arm1->stepServo();
      arm2->stepServo();
    }

    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 veilig, dus roodlicht uit en armen omhoog
        //
        redLights->setOn(false);

        arm1->hoog();
        arm2->hoog();
      }
      else
      {
        //
        //  AHOB is onvelig, dus roodlicht aan en arme omlaag
        //
        redLights->setOn(true);

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

//
//  Create 2 FSM controling two track sections
//
#define SENSOR1_PIN A0    // Analoge pin A0
#define SENSOR2_PIN A1    // Analoge pin A1
#define SENSOR3_PIN A2    // Analoge pin A2
#define SENSOR4_PIN A3    // Analoge pin A3

SpoorControl spoor1(new Sensor(SENSOR1_PIN, laag), new Sensor(SENSOR2_PIN, laag)); // Sensor works reflective
SpoorControl spoor2(new Sensor(SENSOR3_PIN, laag), new Sensor(SENSOR4_PIN, laag));

#define LED1_PIN A5       // Analoge pin A5
#define LED2_PIN A6       // Analoge pin A6

DuoLed roodlicht(LED1_PIN, LED2_PIN, false);

#define SERVO1_PIN  11          // PWM pin 11
#define SERVO1_WACHTTIJD 40     // Wachttijd (in MS) tussen 2 servo stapjes, Hogere waarden = langzamer
#define SERVO1_LAAGPOSITIE 45   // Positie arm in laag stand
#define SERVO1_HOOGPOSITIE 100  // Positie arm in hoog stand

#define SERVO2_PIN  12          // PWM pin 12
#define SERVO2_WACHTTIJD 40     // Wachttijd (in MS) tussen 2 servo stapjes, Hogere waarden = langzamer
#define SERVO2_LAAGPOSITIE 45   // Positie arm in laag stand
#define SERVO2_HOOGPOSITIE 100  // Positie arm in hoog stand

ArmServo arm_een(SERVO1_PIN, SERVO1_WACHTTIJD, SERVO1_LAAGPOSITIE, SERVO1_HOOGPOSITIE);
ArmServo arm_twee(SERVO2_PIN, SERVO2_WACHTTIJD, SERVO2_LAAGPOSITIE, SERVO2_HOOGPOSITIE);

//
// Create an instance of the AHOB
//
AHOB ahob(&roodlicht, &arm_een, &arm_twee);

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))
  {
    ahob.set(uit);         // Stop sound and flashing red lights
  }
  else
  {
    ahob.set(aan);         // Start flashing red lights and sound
  }

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

Voor de Setup en Loop routine staan een aantal definities, Van belang voor jouw is de definitie van de ArmServo's

#define SERVO1_PIN  11          // PWM pin 11
#define SERVO1_WACHTTIJD 40     // Wachttijd (in MS) tussen 2 servo stapjes, Hogere waarden = langzamer
#define SERVO1_LAAGPOSITIE 45   // Positie arm in laag stand
#define SERVO1_HOOGPOSITIE 100  // Positie arm in hoog stand

#define SERVO2_PIN  12          // PWM pin 12
#define SERVO2_WACHTTIJD 40     // Wachttijd (in MS) tussen 2 servo stapjes, Hogere waarden = langzamer
#define SERVO2_LAAGPOSITIE 45   // Positie arm in laag stand
#define SERVO2_HOOGPOSITIE 100  // Positie arm in hoog stand

ArmServo arm_een(SERVO1_PIN, SERVO1_WACHTTIJD, SERVO1_LAAGPOSITIE, SERVO1_HOOGPOSITIE);
ArmServo arm_twee(SERVO2_PIN, SERVO2_WACHTTIJD, SERVO2_LAAGPOSITIE, SERVO2_HOOGPOSITIE);

Je zult zelf de waarden van LAAGPOSITIE en HOOGPOSITIE voor de beide servo's moeten bepalen, omdat die afhangen van hoe je de servo's monteert en aansluit. De Wachttijd bestuurd de snelheid van bewegen.
Overigens, ik de code is nog niet getest.

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 #19 Gepost op: 03 juni 2018, 19:01:12 »
Hoi,

@de voeding.
DVE Switching Adapter:
Input:100/120Volt~50/60Hz, 3A
Output: +12V 1A.

Is gejat van oude router die ik nog had liggen.
Nu zit ie op de laptop aangesloten.
Als ik verder ga heb uit veiligheidsoverwegingen van de laptop een 9Volt batterij met klip.

Plus de Multimeter om ea na te meten.

In eerste instantie wou ik nog een project op de Arduino aansluiten voor een kraantje mbv twee servo's
Maar dat worden er met de overweg project al 4 wat dus niet kan.

Lampje blijft rood branden en Arduino blijft continu doorgaan met servootje, hoe zet je dat tussentijds uit?
'k heb maar ff koud de stekker eruit getrokken.

@Meino
Dat ziet er veelbelovend uit.
Heb je ook een schema met de aansluitingen voor de PIN' 's?

Kan ik hem testen voor je.
Heb alles bij de hand.

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 #20 Gepost op: 03 juni 2018, 20:46:58 »
@de voeding.
DVE Switching Adapter:
Input:100/120Volt~50/60Hz, 3A
Output: +12V 1A.

Is gejat van oude router die ik nog had liggen.
Nu zit ie op de laptop aangesloten.
Als ik verder ga heb uit veiligheidsoverwegingen van de laptop een 9Volt batterij met klip.

Die 12v voeding kan een probleem worden, omdat er 7/12 van het vermogen verstookt gaat worden in de regulator die dat terug moet brengen naar de 5v waarop de Arduino en de rest werkt. Als je alleen de arduino daarmee voedt, dan gaat het nog wel, maar je gaat ook de servo's daarmee aansturen. Dus probeer ook een 5v gereguleerde voeding te organiseren.

Citaat
Lampje blijft rood branden en Arduino blijft continu doorgaan met servootje, hoe zet je dat tussentijds uit?
'k heb maar ff koud de stekker eruit getrokken.

Dat is vaak de enige manier, de Arduino zal in een eeuwige loop de functie loop blijven uitvoeren. Wil je een vorm van controle, dan zul je dat moeten inbouwen met bijv. een schakelaar.

Citaat
@Meino
Dat ziet er veelbelovend uit.
Heb je ook een schema met de aansluitingen voor de PIN' 's?

Koen dat kun je uit de schets halen. De sensors zijn gedefinieerd voor 2 sporen (zoals Edsko dat wilde). Jij gebruikt maar 2 sensoren, dat kan, want dan laat je de pinnen van 2 sensoren onbezet. Dus gepruik SENSOR1_PIN en SENSOR2_PIN, dat zijn analoge pinnen A0 en A1. De sensors kun je in 2 typen definieren, hoog of laag (zie de code). Als je een sensor niet aansluit, moet hij als type laag gedefinieerd zijn. Of een echte sensor hoog of laagtype is, wordt bepaald door wat de sensor doet. Als de sensor een 5v naar gnd trekt bij activering (bijv een reed contact) dan definieer je hem als type laag. Als de sensor echter bij activering 5v op de pin zet (dus bij niet activering de pin aan gnd houdt) dan definieer je hem als type hoog.
De leds gebruiken analoge pinnen A5 en A6. De leds flikkeren om en om (ongeveer 50 keer per minuut). Je kunt ook een led niet aansluiten dan krijg je een aan-uit cyclus. de servo's gebruiken pin 11 en 12 (beide PWM pinnen).

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 #21 Gepost op: 03 juni 2018, 22:03:20 »
Als ik het goed begrijp kan ik die fotocellen ipv die Ali-lichtsluisjes gebruiken?
Op de plaats van die sensoren?

Kan ik die fotocellen en LED's eerst via het breadboard doen?
Ik zie nog geen weerstanden tussen de LED's maar die lijken me wel noodzakelijk evenals voor de fotocellen.

Kan het eerst op de Arduino proberen met alleen de servo's?

Uhm, hoop vragen eigenlijk :)

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 #22 Gepost op: 03 juni 2018, 23:16:00 »
Koen
Ik weet niet hoe je die fotocellen gaat gebruiken. Als je met de ali lichtsluisjes de FlyingFish sensors bedoeld die Edsko ook heeft aangeschaft, dan zou ik die adviseren, want die gebruik ik ook en die kun je makkelijk op een arduino aansluiten. Een kale fotocel heeft waarschijnlijk nog al wat ondersteunende hardware nodig en daar kan ik je niet mee helpen. Het probleem als je de Arduino alleen met servo's uitrust, dan kun je het niet testen omdat je sensor input nodig hebt om het een en ander te laten gebeuren. Overigens sluit LEDS nooit zonder weerstand aan op een Arduino, ze gaan daar onherroepelijk stuk van. Dat klinkt misschien vreemd omdat een IO pin maar 100-200mA kan leveren, maar dat is voor de meeste LEDS gewoon teveel. Verder je kunt natuurlijk de sensor input ook zelf maken, door de betreffende analoge pin even d.m.v. een los draadje met gnd te verbinden. Als je dan als sensor type laag hebt opgegeven dan zal de schets dat als een activering van de betreffende sensor zien.

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 #23 Gepost op: 04 juni 2018, 09:27:19 »
Hoi Meino,

Denk dat mijn sketch ietjes anders uitpakt dan wat je geschreven hebt.

Ik heb immers die knipper-LED's zie 1e post al met een weerstandje eraan.
Voor de servo's lijkt het me hetzelfde als bij Edsko.

Als het moeilijker wordt voor mij als leek voor de fotocellen om daar iets voor te verzinnen dan schaf ik tzt die lichtsluisjes aan, voor de prijs hoef ik dat ook niet te laten.

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 #24 Gepost op: 04 juni 2018, 10:12:56 »
Dag Koen

ik begrijp uit je mailtje dat je leds hebt die uit zich zelf al knipperen. Dat is geen probleem, ik kan de schets makkelijk aanpassen. Maar een vraagje, wat is het formaat daarvan en hoe ga je die straks inbouwen in de AHOB. Het kan zijn dat je daar voor smd (hele kleine) leds moet hebben. Laat het me maar weten.

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 #25 Gepost op: 04 juni 2018, 11:16:57 »
Hoi,
Ik meen klein, 3mm maar moet vanavond ff checken.
Wil de Led's zelf in buisjes verwerkte en die knipperlichthouder zelf maken.
Betekent dat de Arduino slechts die led's hoeft te activeren en bij bomen omhoog uit.

Kan voorlopig ook even met een drukschakelaar aan de gang. Voor activering, die heb ik ook nog.

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

spock

  • Offline Offline
  • Berichten: 652
Re: Arduino Mega 2560, voor spoorwegoverweg met fotocellendetectie
« Reactie #26 Gepost op: 04 juni 2018, 15:28:39 »
Koen
Overigens sluit LEDS nooit zonder weerstand aan op een Arduino, ze gaan daar onherroepelijk stuk van. Dat klinkt misschien vreemd omdat een IO pin maar 100-200mA kan leveren, maar dat is voor de meeste LEDS gewoon teveel.

Hoi Koen,

Even een opmerking. Volgens de specificatie van de ATmege2560 mag een poort maar 10mA (met een maximum van 14mA) syncen.
De genoemde 100-200mA maximums zijn de optellingen van een aantal poorten (meestal 8). De limiet van 10mA per poort blijft echter leidend. Het is niet zo dat als er van de 8 aangesloten poorten er maar 1 is aangesloten, dat deze ene poort 100mA kan syncen.

Het verhaal dat er een weerstand tussen moet is correct. Zonder weerstand zal er een te grote stroom gaan lopen voor zowel de led als de ATmega. Welke van de twee er kapot zal gaan is niet met zekerheid te voorspellen.

mvg spock

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 #27 Gepost op: 04 juni 2018, 15:32:49 »
Normaal moet er een weerstand voor een LED. Er zijn echter LEDs met ingebouwde weerstanden. Deze hoeven dus geen weerstand. Overigens ken ik situaties waar weerstanden niet voor een LED moeten (stroomsturing). Een LED wordt met stroom aangestuurd en niet met spanning. De weerstand zet spanning om in stroom.

@Koen,

Kun je wat meer vertellen over de lichtsensor die jij wilt gebruiken. Kijken wat deze nog nodig hebben.

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 #28 Gepost op: 04 juni 2018, 18:39:49 »
Geen idee Gerard. Auke(Dimo-dimo) heeft ze ooit meegestuurd.
Weet niet of ie nog op het forum aanwezig is.

Kan zo 123 niet vinden op de smartphone.
Ben vanavond laat nog online.

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 #29 Gepost op: 07 juni 2018, 14:33:19 »
Koen

ik heb even toegang tot Internet, dus even een gewijzigde schets voor je met een enkele led die continu geschakeld wordt.

#define DEBUG 0

#include <Servo.h>

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 = 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 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?
      {
#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->target = 0;
      this->current = 0;
      this->highPosition = 0;       //  Arm position high
      this->lowPosition = 0;        //  Arm position low
      this->servoWaitTime = 40;     //  Wait time between 2 steps
      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
      this->current = newHighPosition;    // upper position.
      this->current = 0;
      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;
    }
   
    void hoog()
    {
#if (DEBUG)
      Serial.print("[Armservo::hoog] arm going to high position: ");
      Serial.println(highPosition);
      Serial.flush();
#endif //DEBUG

      target = highPosition;
    }

    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->setOn(false);

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

    //
    //  Activate the connected leds and arm servo's. TBD: the sound
    //
    void heartBeat()
    {
      redLight->heartBeat();
      arm1->stepServo();
      arm2->stepServo();
    }

    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 veilig, dus roodlicht uit en armen omhoog
        //
        redLight->setOn(false);

        arm1->hoog();
        arm2->hoog();
      }
      else
      {
        //
        //  AHOB is onvelig, dus roodlicht aan en arme omlaag
        //
        redLight->setOn(true);

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

//
//  Create 2 FSM controling two track sections
//
#define SENSOR1_PIN A0    // Analoge pin A0
#define SENSOR2_PIN A1    // Analoge pin A1
#define SENSOR3_PIN A2    // Analoge pin A2
#define SENSOR4_PIN A3    // Analoge pin A3

SpoorControl spoor1(new Sensor(SENSOR1_PIN, laag), new Sensor(SENSOR2_PIN, laag)); // Sensor works reflective
SpoorControl spoor2(new Sensor(SENSOR3_PIN, laag), new Sensor(SENSOR4_PIN, laag));

#define LED1_PIN A5       // Analoge pin A5

SingleLed roodlicht(LED1_PIN, false);

#define SERVO1_PIN  11          // PWM pin 11
#define SERVO1_WACHTTIJD 40     // Wachttijd (in MS) tussen 2 servo stapjes, Hogere waarden = langzamer
#define SERVO1_LAAGPOSITIE 45   // Positie arm in laag stand
#define SERVO1_HOOGPOSITIE 100  // Positie arm in hoog stand

#define SERVO2_PIN  12          // PWM pin 12
#define SERVO2_WACHTTIJD 40     // Wachttijd (in MS) tussen 2 servo stapjes, Hogere waarden = langzamer
#define SERVO2_LAAGPOSITIE 45   // Positie arm in laag stand
#define SERVO2_HOOGPOSITIE 100  // Positie arm in hoog stand

ArmServo arm_een(SERVO1_PIN, SERVO1_WACHTTIJD, SERVO1_LAAGPOSITIE, SERVO1_HOOGPOSITIE);
ArmServo arm_twee(SERVO2_PIN, SERVO2_WACHTTIJD, SERVO2_LAAGPOSITIE, SERVO2_HOOGPOSITIE);

//
// Create an instance of the AHOB
//
AHOB ahob(&roodlicht, &arm_een, &arm_twee);

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))
  {
    ahob.set(uit);         // Stop sound and flashing red lights
  }
  else
  {
    ahob.set(aan);         // Start flashing red lights and sound
  }

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

Groet Meino
« Laatst bewerkt op: 07 juni 2018, 21:17:42 door meino. Reden: De kopie van de SingleLed class knipperde ook, dat uit de code verwijderd »
A clean desk is a sign of an empty mind

Kranenberg
De CanBus komt naar Kranenberg