Doel:€250.00
Donaties:€20.00

Per saldo:€-230.00

Steun ons nu!

Laatst bijgewerkt
op 20-10-2018
Algemeen

De stichting

Recente berichten

Digikeijs DR5000 Centrale, productbeschrijving door Chris Westerduin
Vandaag om 02:17:57
Hema by Lima door NS2200
Vandaag om 02:04:24
Heerwijk in H0 (Trambaan) door ArnodeBruin
Vandaag om 01:40:01
De laatste wagens. door Gerke
Vandaag om 00:16:44
MARDEC, de Multifunctionele ARduino dcc DECoder. door NTeering
21 oktober 2018, 23:35:51
Ostmühle, rangeerbaan in spoor 0 door g-j
21 oktober 2018, 23:33:05
Open dagen Modelspoorvereniging Hilversum - 20 en 21 Oktober 2018 door NSJDSB
21 oktober 2018, 23:27:32
Projekt 083-338 door 44
21 oktober 2018, 23:04:29
Eurospoor 2018 door Hendrik Jan
21 oktober 2018, 23:02:36
Raadplaatje door GerardvV
21 oktober 2018, 22:54:24
Korneschans. Een fictief Duits Nederlands grensstation. door Wim Vink
21 oktober 2018, 22:47:07
Van Swarzach naar Swarzburg door Wim Vink
21 oktober 2018, 22:44:26
"Litter Bin" voor Brits spoor en Britse modelspoorprojecten door Merlin674
21 oktober 2018, 22:41:11
3D/RM-IG: Onshape - Materieel 1:76 door Merlin674
21 oktober 2018, 22:39:01
Trams van de HTM in 1/87 door DE-II
21 oktober 2018, 22:38:19
Mallnitzer Tauernbahnstrecke ÖBB N Spoor door Schachbrett
21 oktober 2018, 22:15:19
MB-module: "L'Esimé" door Chris80
21 oktober 2018, 22:13:51
Mijn eerste H0 modeltreinbaan in aanbouw door MOVisser
21 oktober 2018, 22:13:32
Toon hier je nieuwe (model) spooraanwinst(en)... door prutser
21 oktober 2018, 22:10:13
Tentoonstelling MTD Edegem 2018 door Klaas Zondervan
21 oktober 2018, 22:00:46
NL Baan in Canada door ArjanB
21 oktober 2018, 21:43:56
Rocky Rail 6400 door Taigagaai
21 oktober 2018, 21:33:37
Het ontstaan van Trammenlandt door Marco EB
21 oktober 2018, 21:29:39
Small yard door sdz1976
21 oktober 2018, 21:02:51
Schwarzburg-Neuffen-Bahn door Ruud K
21 oktober 2018, 20:53:27
N baan in segmenten: Wieslauftal door trainiac
21 oktober 2018, 20:50:27
NS modelbaan Hoekdam H0 door Ronald Hofmeester
21 oktober 2018, 20:48:22
Schaal 0 baksteenplaat door Ronald Halma
21 oktober 2018, 20:45:51
Onlangs gespot - gefotografeerd, de foto's door Andre Pronk
21 oktober 2018, 20:18:32
  

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

NS264

  • Team forummoderators
  • Offline Offline
  • Berichten: 4994
  • Koen Frijlink
    • 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.
Kijk eens op Midland Industriebaan, IV
MultiMuis en Arduino Techniek. HO
NewMancavemusic

72sonett

  • Team encyclopedie
  • Offline Offline
  • Berichten: 1136
    • 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

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

MH

meino

  • Offline Offline
  • Berichten: 221
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

meino

  • Offline Offline
  • Berichten: 221
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

NS264

  • Team forummoderators
  • Offline Offline
  • Berichten: 4994
  • Koen Frijlink
    • 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.
Kijk eens op Midland Industriebaan, IV
MultiMuis en Arduino Techniek. HO
NewMancavemusic

meino

  • Offline Offline
  • Berichten: 221
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

NS264

  • Team forummoderators
  • Offline Offline
  • Berichten: 4994
  • Koen Frijlink
    • 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.
Kijk eens op Midland Industriebaan, IV
MultiMuis en Arduino Techniek. HO
NewMancavemusic

meino

  • Offline Offline
  • Berichten: 221
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

NS264

  • Team forummoderators
  • Offline Offline
  • Berichten: 4994
  • Koen Frijlink
    • 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.
Kijk eens op Midland Industriebaan, IV
MultiMuis en Arduino Techniek. HO
NewMancavemusic

meino

  • Offline Offline
  • Berichten: 221
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

NS264

  • Team forummoderators
  • Offline Offline
  • Berichten: 4994
  • Koen Frijlink
    • 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.
Kijk eens op Midland Industriebaan, IV
MultiMuis en Arduino Techniek. HO
NewMancavemusic

spock

  • Offline Offline
  • Berichten: 189
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: 3207
  • 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

  • Team forummoderators
  • Offline Offline
  • Berichten: 4994
  • Koen Frijlink
    • 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.
Kijk eens op Midland Industriebaan, IV
MultiMuis en Arduino Techniek. HO
NewMancavemusic

meino

  • Offline Offline
  • Berichten: 221
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 »
A clean desk is a sign of an empty mind