BeneluxSpoor.net forum
Vraag en antwoord => Elektronica en analoog => Topic gestart door: NS264 op 28 mei 2018, 17:25:08
-
Hallo,
Daar beginnen we dan.
De Arduino kwam bij mij pas in beeld nadat ik hem van een forumlid had overgenomen. Tot dan toe wist ik er nog niks van.
Mijn elektrotechnische kennis is ook laag maar de interesse is groot.
In samenwerking met een soldeerloos breadboard en een bos brugdraad male en female, en de beschikbare sketches moet je toch een eind kunnen komen en vooral met de technische kennis hier op het forum.
De technische situatie lijkt heel erg op die van Edsko.
Hier zal ik de beschikbare ingrediënten even opnoemen.
- Arduino Mega 2560 ( met al een sketch erin voor knipperende LED's)
- L298N Dual Bridge DC Stepper Controllerboard, 2A/35V. (voor 2 servo's of 1 motor)
- Esu Servo-motoren.
- breadboard.
- brugdraad+ krimpkousen.
- diverse Ohm weerstanden.
- een drukbutton.
- Oranje knipper LED's SMD - 0805 9- 12 V, aansluiting + en 1,5 Ohm weerstand.
Eventueel ook rood.
Ik heb even een demo A4 formaat gemaakt.
Mijn situatie is in het midden een hoofdspoor.
Boven en onder een rangeerspoor waarvan eventueel 1 of allebei gevlagd zouden kunnen worden.
Eigenlijk alleen maar rangeerbewegingen van fiddle-yard naar omloopspoor en de rangeersporen.
Van een doorgaande trein of passerende treinen is geen sprake.
Het leek me juist leuk het rangeerproces te vertragen door een spoorwegovergang in de stad dwars over het emplacement te creëren.
Het rangeerpersoneel moet er dan alles aan doen om de overgang zo snel mogelijk weer vrij te krijgen voor het stadsverkeer.
Dit dan door middel van de fotocellen, ik heb er 4.
Zie tekening:
(rood = detectiezone, inbouwgebied)
(https://images.beneluxspoor.net/bnls/Midland-5.0-001_1.jpg) (https://images.beneluxspoor.net/bnls/Midland-5.0-001_1.jpg)
A4Demo:
(https://images.beneluxspoor.net/bnls/DSCN2652.jpg) (https://images.beneluxspoor.net/bnls/DSCN2652.jpg)
Hier kunnen we een eindje mee opweg komen en kan ieder meekijken en suggesties doen qua programmering van de Arduino.
Dankzij het breadboard hoef ik alleen maar de draadjes op de juiste PIN te zetten om van start te gaan.
Grtz Koen.
Ow, en we kijken later wel of dit nou onder AC of DC valt, grensgevalletje. ???
Met de steppercontrol lijkt het me DC, digitaal dus maar ik sluit het niet digitaal aan op een MultiMaus of iets dergelijks.
-
[...]
- L298N Dual Bridge DC Stepper Controllerboard, 2A/35V. (voor 2 servo's of 1 motor)
Een beetje off-topic, maar waarom zou je zo'n zwaar IC gebruiken om 2 servo's mee te sturen? Of mis ik iets en is er een revolutionair nieuwe manier van het aansturen van servo's die ik niet ken...
De L298 is bedoeld voor het in twee richtingen kunnen besturen van twee gelijkstroommotoren of 1 bipolaire stappenmotor.
-
Koen
zo te zien op de foto zijn het standaard micro servo's. Zijn het 9g types?. Die kun je rechtstreeks op de mega aansluiten. Je moet even uitvogelen wat de aansluiting is, dat zijn er drie, 5v, gnd en een signaal aansluiting. De 5v en de gnd verbind je met de 5v en de gnd pinnen van de arduino. De signaal aansluiting moet je op een PWM pin van de arduino aansluiten. Er zijn bibliotheken beschikbaar om servo's aan te sturen. Ik kan je ook wel een stukje code toesturen, want ik gebruik servo's om armseinen te bedienen. Alleen ben ik nu op trektocht door Italie, dus niet altijd online.
Groet Meino
-
Ik zal van de week kijken wat ik kan gebruiken.
Het heeft absoluut geen haast, dit project.
Gr Koen.
-
Ik ben benieuwd wanneer de overwegbomen dicht en weer open gaan.
Wil je met de 4 sensoren het hele detectiegebied bestrijken (kruislings) en de bomen dicht laten gaan als er één of meerdere lichtsluizen onderbroken zijn? (wat gebeurt er als er een trein over je hoofdspoor rijdt met iets hogere snelheid, zijn de bomen dan dicht als de loc voorbij is?)
Of heb je een soort van inrij lichtsluis (bomen dicht als hij onderbroken is) en uitrij lichtsluis (bomen weer open als deze lichtsluis weer ononderbroken is), wat gebeurt er dan als bv een sikje van spoor 1 via wissel naar overweg rijdt, daar stopt en over wissel terug rijdt naar spoor 3?
René
-
Dit filmpje bracht me op het idee (https://youtu.be/jExIgGqu54w).
Koen.
-
Koen,
Leuk baanplan. Dit moet anders aangepakt als bij Edsko. Komt na het weekend. De aansluitingen van je servo zijn:
Zwart: gnd
Rood: +5v
Wit: stuursignaal
De witte kan direct op een pen van de Arduino. Eventueel met een kleine weerstand (100 ohm) ertussen.
Groet,
Gerard van der Sel.
-
bv een sikje van spoor 1 via wissel naar overweg rijdt, daar stopt en over wissel terug rijdt naar spoor 3?
Daarom is mijn plan om spoor 2 of 3 dan "af te vlaggen" en niet mee te detecteren. Hoogstwaarschijnijk wordt dat dan spoor 2.
Meino & Gerard, beide nog een goede vakantie.
Ik mag vandaag weer de weg op :D
Gr Koen.
-
Hoi,
Eindelijk wat verkoeling 8).
Meteen de kans gegrepen weer eventjes te prutsen hiermee!
En ik heb een draaiend servootje. :D Jeee!
Gelijk weer kritiek van mezelf, gegeven was dat ie behoorlijk geruisloos zou zijn, die Esu, maar dat valt tegen, behoorlijk geratel maar misschien veranderd dat nog.
Het is de eerste de beste servo-sketch die ik gebruikt heb voor Sweeb.
Heb verder nog niks met de instellingen gedaan.
Idd op de 5V, GND en PIN 9.
Weer verder.
Gr Koen.
-
... De 5 V en de gnd verbind je met de 5 V en de gnd pinnen van de arduino.
Ik zou voor de servo's een aparte voeding nemen, dus nooit servo's aansluiten op de 5 V van de Arduino, alleen signaal en Gnd.
-
Dit is een eerste stap, er zullen meerdere volgen.
Wel tegenstrijdig dat de een zegt dat wel rechtstreeks kan aansluiten en nu de ander dus niet.
Arduino geeft zelf aan dat het wel kan.
Precies gedaan wat er in de sketch staat.
Gr Koen.
-
...Wel tegenstrijdig dat de een zegt dat wel rechtstreeks kan aansluiten en nu de ander dus niet.
Arduino geeft zelf aan dat het wel kan.
Nou, dan doe je het toch gewoon... maar lees dit wel eerst even: Powering servos (http://forum.arduino.cc/index.php?topic=12495.0)
-
Een simpel standaard servootje gebruikt stroom met pieken tot wel 500 mA.
Grotere servoos vaak nog veel meer.
De 5V stabilisator op een Arduino kan 1 servo wel aan, maar meer zou ik niet doen.
Er zijn gelukkig veel goedkope 5V voedingen te koop, zie voorbeeld:
https://nl.aliexpress.com/item/free-shipping-1-pcs-DC-5V-5A-led-Regulated-Switching-Power-Supply/32494739030.html (https://nl.aliexpress.com/item/free-shipping-1-pcs-DC-5V-5A-led-Regulated-Switching-Power-Supply/32494739030.html)
Ik zou lekker overdimensioneren met 1A per servo...
-
Ok, hitte kan dus een probleem worden.
Maar ik heb voor de zekerheid ook een controller en heb ook weerstanden dus ik kan nog wel wat regelen qua voltagegebruik.
En ook een Multimeter tot beschikking al moet ik nog leren hoe dat ding werkt.
Gr Koen.
-
... controller ... weerstanden dus ik kan nog wel wat regelen qua voltagegebruik.
Eh... wat wil je precies regelen met die controller en de weerstanden?
-
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.
-
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.
-
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
-
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
-
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.
-
@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.
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.
@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
-
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.
-
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
-
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.
-
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
-
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.
-
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
-
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.
-
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.
-
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
-
Meino,
Bedankt voor het schrijven.
Neem aan dat de kleur van de LED's niet uitmaakt?
Kun je me een beetje toelichting geven wat de sensors precies zijn en doen in deze sketch.
Ik zie ook een stukje erbij staan over de bel, die heb ik nog niet weet niet precies welk deel ik moet weglaten dan.
Ik zal me er de komende dagen in verdiepen.
Gr Koen.
-
Kan je die knipperleds niet beter vervangen door gewone LED's? Dan kunnen ze netjes afwisselend knipperen, de één aan, de ander uit. Met knipperled's wordt het denk ik zo een zooitje.
René
-
Je kon wel eens gelijk hebben Rene,
Maar ik moet eerst deze stroom aan verkregen kennis beetje verwerken en kijken hoever ik met deze verzamelde gegevens kom.
Het is nog steeds interessant maar wel aardig wat materie om te begrijpen.
Vanaf O toch redelijk veel stof. :D
Ga er van het weekend mee door.
Gr Koen.
-
Koen,
Even je baanplan erbij gehaald. Uit een aantal berichten zijn je wensen te halen. En ik denk dat er nog wat veranderd moet worden.
Als we je baanplan erbij pakken:
(https://images.beneluxspoor.net/bnls/Midland-5.0-001_1.jpg) (https://images.beneluxspoor.net/bnls/Midland-5.0-001_1.jpg)
De afstand van melder tot aan de overweg is kort. Ik ga ervan uit dat je de bomen niet net zo als een wissel een hoek van 90 graden wil laten maken binnen een fractie van een seconde. De melder zou aan het begin van de laatste gebogen rail moeten komen. De stand van het sein moet dan meegenomen worden, want de overweg sluiten bij rood lijkt me niet verstandig.
Aan de andere kant kun je de sensor verplaatsen naar het gewone rechte spoor.
Verder zou ik een drukknop(pen) toevoegen om de trein op de sporen 1 en 3 over de overweg te laten gaan.
Groet,
Gerard van der Sel.
-
Hoi,
Gerard, het sein is wel getekend maar heb hem nog niet.
Ik twijfel ook erg of ik niet een dummy inzet want je ziet nauwelijks iets van de sein-lampjes.
Vandaar.
Gr Koen.
-
Koen,
Laten we op het stuk rond de overweg de processen even doornemen:
IK heb het baanplan opnieuw getekend in SCARM.
(https://images.beneluxspoor.net/bnls/Koen_baan.jpg) (https://images.beneluxspoor.net/bnls/Koen_baan.jpg)
De twee rode lijnen zijn de twee sensoren. Naast de sensoren zijn er twee schakelaars (drukknoppen).
Voor de bediening van de overwegbomen zijn er twee servo's
Voor het laten knipperen van de waarschuwingslampen zijn er twee knipper LEDs aanwezig.
Treinbewegingen:
Doorgaand over spoor 2 (middelste spoor):
Geheel automatisch met behulp van de twee sensoren.
Van spoor 2 naar spoor 1 (bovenste) of spoor 3 (onderste) als rangeer beweging.
Druk op de knop "Overweg sluiten" of laat de sensor de overweg sluiten. Bij aankomst op spoor 1 of spoor 3 met de drukknop "Overweg openen" de overweg weer openen.
Van spoor 1 over de overweg heen (niet naar spoor 2, beide richtingen).
Druk op de knop "Overweg sluiten" en rijdt de trein over de overweg. Als de overweg weer vrij is druk op de knop "Overweg openen".
Van spoor 1 overde overweg naar spoor 2.
Druk op de knop "Overweg sluiten" en rijdt de trein over de overweg. De sensor in spoor 2 zal de overweg weer vrijgeven.
Bovenstaande geldt ook voor spoor 3.
Kun je met deze manier van werken leven?
Groet,
Gerard van der Sel.
-
Even voor de goede orde… Als je iets met servo's wilt, regel een servo shield... op lange termijn is dat goedkoper dan het periodiek uitroken van je spanningsregelaar. Daar zit een apart voeding circuit op waar alleen de servo's mee gevoed worden met een stuk hoger aantal ampere da je Arduino ooit kan leveren.
Wat de herrie betreft: duurdere zijn stiller... Als je ook bij stilstand gepruttel blijft horen bij die TowerPro klonen heb je te weinig vermogen op de 5V staan
-
En ik dacht, ik kan me wel redden met wat ik heb.
Resumé :
- andere voeding.
- shield ipv steppencontroller ::)
- gewone Led's.
- mogelijk andere sensors(licht, fotocel)
Weet niet wat Gerard in petto heeft voor me maar de bedoeling is nog steeds de boel werkend te krijgen op dat demo plankje van mij.
Als ik dat plankje eerst met een drukknop kan demonstreren is het mij goed.
Kunnen we later piekeren over de definitieve inbouw.
Gr Koen.
-
...je gaat servo's gebruiken? Stuk of 4? En een paar LEDs en sensors? Niet meer dan 20? En je hebt een Mega? Waar heb je dan een shield voor nodig?
EDIT: Ah, servo shield. Kan handig zijn, maar als je de servos rechtstreeks uit een 5V power supply voedt is ook dat niet nodig...
EDIT 2: Zoiets bijvoorbeeld https://nl.aliexpress.com/item/10W-LED-Switch-Switching-Power-Supply-Driver-Transformer-AC-110-220V-To-DC-5V-2A-For/32824394060.html (https://nl.aliexpress.com/item/10W-LED-Switch-Switching-Power-Supply-Driver-Transformer-AC-110-220V-To-DC-5V-2A-For/32824394060.html)
-
Voor de duidelijkheid:
2 servo's.
2 Led's aan de zichtzijde van de module.
Lijkt me niet nodig lichtjes naar de achtergrond toe te installeren.
Gr Koen.
-
Koen
begin gewoon met wat je hebt. Die Mega trekt echt wel die twee servo's, een aparte servo shield is hiervoor niet nodig. Ook omdat de servo's niet in een keer naar hun eind positie gaan, maar dat laten we ze staps gewijs doen en als het nodig is doen we dat om en om.
Andere ledjes dat kan altijd nog.
Groet Meino
-
Meino,
Het gaat om de opstart. Als je er spanning opzet gaan beide servo's bewegen. De Arduino is dan zelf ook met opstarten bezig. Ik weet dat 4 servo's minder dan 1A trekken, want mijn 7805 blijft 5V leveren.
Groet,
Gerard van der Sel.
-
Zal vanavond eens proberen met Meino's als eerste.
Als in Tiel het licht uit is en de rest van NL niet dan weet je het.
Gr Koen.
-
Hoi,
En na alles nog eens doorgelezen te hebben kan ik nog niks opstarten omdat de sketch van Meino voor een Flyhing Fish(?) sensor is en niet voor die dingen die ik heb liggen.
Ik wacht geduldig het advies af van de heren, Meino en Gerard.
Heb de Arduino nog niet geprogrammeerd dus.
Gr Koen.
-
Koen
Ja en Nee, de schets interesseert het niets wat er aan hangt. De schets reageert alleen op het wel of niet aanwezig zijn van een 5v op de betreffende pinnen. Op dit moment is de schets zo geconfigureerd dat hij altijd 5v op de pinnen verwacht en op het moment dat de pin naar 0v (gnd) gaat dat dat als een sensor trigger ziet. Vandaar dat je dat makkelijk kunt nabootsen door de betreffende pin even met gnd te verbinden.
Probeer dat maar eens.
Groet Meino
-
Koen, zoals Meino al schreef gewoon met een draad even de ingang naar 0V of gnd halen. Wat betreft de aanpassing naar jouw opnemen. Neem er een paar foto's van met je mobiel dat ze lekker groot in beeld zijn. Kan ik aangeven wat je hebt. Ik kom nu niet verder dan een LDR.
Groet,
Gerard van der Sel.
-
Hoi,
;D
Wat een snelle antwoorden weer. (y)
Maar ik heb net nog ff voor vertrek naar werk, de weg op.
Ik houdt jullie nog lekker even in spanning, ik wil er ook echt even rustig voor zitten vanavond bij terugkomst.
Het zou me toch helpen voor het overzicht met een schemaatje voor de PIN's dan kan ik ze makkelijker er inpluggen die brugdraadjes vanavond.
Ben bang dat ik anders teveel ga klooien met de plaatsing.
Gr Koen.
-
Your wish is my command ;D
Dit zijn de aansluitingen:
(https://images.beneluxspoor.net/bnls/AansluitingenOverweg.jpg) (https://images.beneluxspoor.net/bnls/AansluitingenOverweg.jpg)
Groet,
Gerard van der Sel.
-
Hoi,
Ik wordt er niet helemaal wijs uit.
Heb aangesloten zoals getekend, ik neem aan dat je de draadjes opeen volgend op de PIN ingangen kan aansluiten als je meerdere naast elkaar hebt.
De sketch geeft foutmelding aan Arduino: 1.6.5 (Windows 8.1), Board:"Arduino Mega or Mega 2560, ATmega2560 (Mega 2560)"
De schets gebruikt 5.368 bytes (2%) programma-opslagruimte. Maximum is 253.952 bytes.
Globale variabelen gebruiken 241 bytes (2%) van het dynamisch geheugen. Resteren 7.951 bytes voor lokale variabelen. Maximum is 8.192 bytes.
avrdude: ser_open(): can't open device "\\.\COM3": Het systeem kan het opgegeven bestand niet vinden.
avrdude: ser_drain(): read error: De ingang is ongeldig.
Probleem bij het uploaden naar het board. Zie
Dit rapport zou meer informatie hebben met
"Tijdens de compilatie uitgebreide uitvoer weergeven"
ingeschakeld in Bestand > Voorkeuren.
Van waar naar waar moet ik een extra draadje trekken?
Ik heb even twee gewone LED's gebruikt die ik al had daarvan zitten de zwarte draden aan elkaar op 1 PIN.
Ook zonder de LED's gebeurd er niks.
De void "set up" en ""loop" zijn niet duidelijk aangegeven, misschien pakt ie hem daarom niet of is de capaciteit van mijn PC te klein voor de sketch?
LED's branden nu wel (de gewone) maar knipperen (nog) niet.
Ik lees het straks wel ;).
Gr Koen.
-
Je hebt een PC probleem. Je compoort is ongeldig. Controleer welke poort er gebruikt wordt voor communicatie tussen PC en Arduino mega en stel deze in in de Arduino IDE.
Groet,
Gerard van der Sel.
-
Ik heb even twee gewone LED's gebruikt
Zonder weerstandje?
... De void "set up" en ''loop" zijn niet duidelijk aangegeven
Wat bedoel je precies daarmee? Een programma, of 'sketch' zoals dat in de Arduinowereld heet, moet tenminste die twee functies bevatten, zo niet dan krijg je meteen foutmeldingen bij compileren.
Dit is het kortste Arduino programma wat foutloos compileert:
void setup () {
}
void loop () {
}
In het programma uit bericht #30 van Meino staat 'setup' op regel 623 en 'loop' op regel 636.
-
Koen
het is wat Gerard zegt, de correcte comm poort is niet geselecteerd. De Schets compileert goed, het gaat fout tijdens het uploaden. Je moet voordat je de compile en upload start even naar het tabblad "hulpmiddeene" gaan en de correcte poort selecteren (zie de beschrijving die ik je een tijd geleden gestuurd heb).
Groet Meino
-
Hoi,
Ik krijg die poort niet open geklikt, kan ik die ergens her-activeren dan???
De sketch is overigens wel opgeslagen dus ik denk dat ie inderdaad wel goed gaat overkomen op de Arduino.
De controlelampjes lichtten groen op in elk geval.
Alleen die poort werkt nu niet.
Die term void setup en loop, had begrepen dat je die altijd aan begin en aan eind moet hebben staan.
Maar dat klopt dus wel.
Gr Koen.
-
Je kan de poort niet heractiveren. Haal je Arduino Mega los van je computer. Start de IDE en kijk onder tools poorten. De poorten die er nu staan even onthouden. Nu de IDE weer afsluiten en daarna de Arduino Mega weer aansluiten. Start de IDE en ga weer neer Tools en ports en kijk welke poort er is bijgekomen. Tenminste als even tijdens het insteken van de Arduino Mega een geluid heeft geklonken. Selecteer de poort die erbij is gekomen.
Groet,
Gerard van der Sel.
-
Altijd even de Device Manager (Apparaatbeheer) open zetten als je een 'tegenwerkend' USB apparaat hebt. Niets zo hinderlijk als een 'onbekend apparaat' omdat de driver niet wil laden. Geeft ook het 'geluidje' dat Gerard omschrijft, maar nog geen garantie op een geladen driver ;)
Is het een echte Arduino Mega (met Atmel 32Unogwat of FTDI) of één van de 'compatibles' (vaak met een CH340)?
Suc6!
-
Heb de IDE-app opnieuw geïnstalleerd maar de button wil nog niet meewerken.
Zal ff kijken, jouw bericht komt als geroepen :)
Koen.
-
Programmer AVRISP mkll, is dat hem? Vervolgens kan ik uit een rijtje kiezen.
Koen
-
Arduino: 1.6.5 (Windows 8.1), Board:"Arduino Mega or Mega 2560, ATmega2560 (Mega 2560)"
sketch_jun17a:12: error: variable or field 'set' declared void
sketch_jun17a:12: error: 'AkiStaat' was not declared in this scope
sketch_jun17a:18: error: 'SpoorState' does not name a type
sketch_jun17a.ino: In function 'void setup()':
sketch_jun17a:78: error: multiple types in one declaration
sketch_jun17a:626: error: a function-definition is not allowed here before '{' token
sketch_jun17a:639: error: a function-definition is not allowed here before '{' token
sketch_jun17a:654: error: expected '}' at end of input
variable or field 'set' declared void
Dit rapport zou meer informatie hebben met
"Tijdens de compilatie uitgebreide uitvoer weergeven"
ingeschakeld in Bestand > Voorkeuren.
Gaat niet helemaal lekker.... :-\
-
Dat zijn allemaal compilerfouten. Blijkbaar heb je onbedoeld het programma overschreven of gewijzigd. De originele code uit bericht #30 in een lege IDE plakken, opslaan met een geschikte naam, en opnieuw compileren.
-
Koen,
Er is inderdaad nu iets mis met de code. Ik heb een voorstel. Aangezien we met een PC <>Arduino probleem zitten, start met het minimale programma. Doe file > New en je krijgt een lege sketch. Als je deze opslaat en daarna naar de Arduino verstuurd heb je weer de compoort fout terug. Gaan we deze eerst oplossen en daarna weer terug naar de code van Koen. We doen dit stap voor stap en maken het niet moeilijker dan noodzakelijk.
Groet,
Gerard van der Sel.
-
Staat die AVRISP MkII bij de Device Manager of is het een optie in de Arduino IDE?
Het is in ieder geval niet de COM-poort naar de Arduino; die van mij staat als "Arduino Mega 2560 (COM5)" onder COM&LPT in de Device Manager en in de IDE na het selecteren van de MEGA 2560 wordt ook COM5 als poort getoond. De Programmers staan verderop maar die gebruik je niet om de MEGA 2560 van jouw programma te voorzien...
Net als bij modelspoorautomatisering eerst klein beginnen; Ovaaltje-Inhaalspoortje oftwel eerst een Blink of HelloWorld sketch en dan pas verder.
Heeft deze Mega al wel eerder gewerkt op deze computer, of is dit de eerste poging?
Suc6!
-
Hoi,
De Com poort werkt weer.
Hij staat op COM3.
De Led's branden nu wel weer en af en toe draait er 1 servo.
De min van de 2 gewone Led's zitten bij elkaar gedraaid in 1 Pin, voorheen heeft dat bij testen gewerkt.
De Arduino heb ik eerder getest met die Led's en apart met een sketch van Arduino voor 1 servo, dat werkte ook.
Het hele gebeuren zit sowieso niet op een baan maar bij een demo opstelling de Arduino nog niet gemonteerd kan er nog alle kanten mee op.
Gisteravond de sketch tig keer in een nieuwe file gedaan en de oudere weer verwijderd.
Ik vroeg me af welk 'programmer' je moet inschakelen, misschien dat die niet goed staat nu.
Om de jumpers te checken, ik krijg een plaatje ervan niet geupload momenteel.
Thanks voor de hulp tot nu toe ;)
Gr Koen.
-
Koen
als je mijn laatste schets geladen hebt, dan moet er het volgende gebeuren.
- direct na het starten van de arduino, gebeurt er niets, led brandt niet, servo beweegt niet, of gaat naar de stand die hoort bij open bomen.
- Verbind pin 11 even met gnd
Servo beweegt langzaam naar de stand die hoort bij een gesloten boom, led gaat branden.
- Verbind pin 12 met gnd. Op het moment dat je pin 12 van gnd losmaakt gebeurt het volgende.
Servo beweegt langzaam naar de stand die hoort bij een geopende boom, led stopt met branden.
Vanuit de geopende (veilige) toestand, kun je het ook in de omgekeerde volgorde doen, beginnen met pin 12.
Groet Meino
-
Meino bedoelt de ingangen A0 en A1 of A2 en A3. Druk een draadje in A0 en een tweede draadje in A1. Doe eerst A0 tegen GND houden (Doe hier een kort stukje draad in zonder isolatie). Tik daarna A1 tegen GNG en zie de LED uitgaan en de servo weer draaien. Dit kan veel of weinig zijn, want Meino kan natuurlijk niet de juiste hoek opgeven. Die wordt als alles is ingebouwd pas definitief bepaald.
Groet,
Gerard van der Sel.
-
Meino,
Een veilige overweg is een overweg die geblokkeerd is voor wegverkeer.
Groet,
Gerard van der Sel.
-
Don't try this at home without professional help....
;D
-
Hoi,
Heren, U mag het even doen met de melding dat het gelukt is ;D.
Ik heb nu twee, bijna synchroon draaiende servo's.
Ze gaan rustig omhoog maar vallen als een speer naar beneden.
Zal even zien of ik dat morgenochtend op YouTube vertoond kan krijgen.
Ik heb zoals aangegeven die ingangen gebruikten en een jumper(met geïsoleerde pluggen, tenminste, ik hoef er niks aan te doen)
En A0 of A1 verbonden met GND en het werkt .
De Led's zijn nu wel uit en flikkeren heel zachtjes op.
Ik druk nu wel "koud" op de resetknop bij gebrek aan drukknop dus zo gaat het wel even.
Ik ben blij (y)
Gr Koen.
-
... servo's ... rustig omhoog maar vallen als een speer naar beneden.
Wat is de waarde van 'SERVO1_WACHTTIJD' en 'SERVO2_WACHTTIJD' (vanaf regel 604)?
-
Heren,
Een kort filmpje (https://youtu.be/RTkxpKynEnw).
De groene jumper overdwars is de kabel geplaatst volgens beschrijving van Meino en Gerard.
Te zien is ook het type Led wat ik kaar heb liggen, zeer minuscuul en dun draad.
En btw ik denk dat het geen fotocel is maar een lichtsluis dat micro-onderdeel op het breadboard.
Grtz Koen.
-
Hoi Koen,
Ik kan me geen groene jumper herinneren. De servo's bewegen, maar hopeloos verkeerd. Na druk op de knop moeten ze 90 graden draaien en dan blijven staan. Bij de volgende druk op de knop bewegen ze weer terug naar de oorspronkelijke positie. Je beweegt de servo's door op de reset toets te drukken. Dat is echt niet de bedoeling. Deze toets zou je nooit nodig moeten hebben.
Even een test:
Haal de groene draad eens los aan de kant van de gele draden. Laat de andere kant maar in de GND zitten.
Opstart:
1) Zet de Arduino aan en wacht even tot alles tot rust is gekomen.
Werking:
2) Druk nu de groene draad in de A0 en wacht even tot alles weer tot rust is gekomen.
3) Haal nu de groene draad los, als het goed is gebeurt er niets.
4) Stop de Groene draad in A1. Ook nu gebeurt er niets.
5) Verwijderen de groene draad, nu zullen de servo's gaan bewegen.
Herhaal de stappen 2 t/m 5 net zo vaak als je wilt.
In een van de twee standen zullen de LEDs branden/knipperen.
Wat beterft je lichtsensor. Dit is inderdaad een lichtsluis, zoals je in de draad van Edskoo hebt gezien. Echter de aanstuur electronica ontbreekt.
Die moet er nog bij.
Groet,
Gerard van der Sel.
-
Hoi,
Ik was in de veronderstelling dat ie al op de sketch draaide.
De kwartslag beweging....
Verkeerde gedachtengang dus.
Zal vanavond de groene jumper omzetten.
Gr Koen.
-
... als je mijn laatste schets geladen hebt
Meino,
In jouw programma zie ik vanaf regel 122 het volgende stukje:
...
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; // Wait time between 2 steps
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;
}
Het lijkt mij dat na de eerste toekenning veel variabelen meteen een andere waarde krijgen, bij deze lijkt me dat niet correct :
this->current = newHighPosition;
this->current = 0;
Doet het volgende niet hetzelfde?
...
public:
ArmServo(int newServoPin, int newWaitTime, int newHighPosition, int newLowPosition)
{
this->myServo = new Servo();
this->servoPin = newServoPin;
this->servoWaitTime = newWaitTime; // Wait time between 2 steps
this->highPosition = newHighPosition;
this->lowPosition = newLowPosition;
this->target = newHighPosition; // We asume that the arms are initial in their upper position.
this->current = 0;
this->active = false;
}
Waarom gebruik je #define ipv const (https://www.arduino.cc/reference/en/language/variables/variable-scope--qualifiers/const/)?
-
Hoi Koen,
Even voor de zekerheid:
Dit niet
Zal vanavond de groene jumper omzetten.
Maar dit
Haal de groene draad eens los aan de kant van de gele draden. Laat de andere kant maar in de GND zitten.
Opstart:
1) Zet de Arduino aan en wacht even tot alles tot rust is gekomen.
Werking:
2) Druk nu de groene draad in de A0 en wacht even tot alles weer tot rust is gekomen.
3) Haal nu de groene draad los, als het goed is gebeurt er niets.
4) Stop de Groene draad in A1. Ook nu gebeurt er niets.
5) Verwijderen de groene draad, nu zullen de servo's gaan bewegen.
Herhaal de stappen 2 t/m 5 net zo vaak als je wilt.
In een van de twee standen zullen de LEDs branden/knipperen.
Groet,
Gerard van der Sel.
-
@72sonett
je hebt gelijk, dat stukje code is niet goed. Dat komt ervan als je met snel knip en plakwerk even wat in elkaar zet.
Ik realiseerde me ook dat bij AHOB's de rode lichten pas stoppen als de bomen helemaal open zijn, dus dat heb ik ook nog even aangepast.
@NS264
Koen ik heb nog even een stukje gewijzigde code, die je even moet laden in je Arduino Mega
Groet Meino
#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->active = false;
this->myServo = new Servo();
this->servoPin = newServoPin;
this->servoWaitTime = newWaitTime;
this->highPosition = newHighPosition;
this->lowPosition = newLowPosition;
this->target = newHighPosition; // We asume that the arms are initial in their upper position
if (this->highPosition > this->lowPosition)
this->current = newHighPosition - 1; // But force a small initial movement
else
this->current = newHighPosition + 1; // But force a small initial movement
this->active = false;
}
void laag()
{
#if (DEBUG)
Serial.print("[ArmServo::laag] arm going to low position: ");
Serial.println(lowPosition);
Serial.flush();
#endif //DEBUG
target = lowPosition;
}
bool isLaag()
{
if (current == lowPosition)
return true;
else
return false;
}
void hoog()
{
#if (DEBUG)
Serial.print("[Armservo::hoog] arm going to high position: ");
Serial.println(highPosition);
Serial.flush();
#endif //DEBUG
target = highPosition;
}
bool isHoog()
{
if (current == highPosition)
return true;
else
return false;
}
bool stepServo()
{
//
// When the arm's position isn't at the target, we have to move the arm
//
if (this->target != this->current)
{
//
// Is the servo active? if not attach it to it's pin so it can start moving
//
if (!this->active)
{
#if (DEBUG)
Serial.println("{ArmServo::stepServo] attach");
Serial.flush();
#endif // DEBUG
this->attachServo();
}
lastTimeActive = millis();
if ((lastTimeActive - this->timeOfLastStep) >= this->servoWaitTime)
{
//
// The servo is moving to it's new location.
//
#if (DEBUG)
Serial.print("[ArmServo::stepServo] target: ");
Serial.print(this->target);
Serial.print(", current: ");
Serial.print(this->current);
#endif //DEBUG
if (this->target > this->current)
{
this->current++;
}
else
{
this->current--;
}
#if (DEBUG)
Serial.print(", going to: ");
Serial.println(this->current);
Serial.flush();
#endif // DEBUG
this->myServo->write(this->current);
this->timeOfLastStep = lastTimeActive;
}
return true; // The arm is still moving
}
else
{
if ((millis() - lastTimeActive) >= REFRESH_TIME)
{
//
// Is the servo active? if not attach it to it's pin so it can start moving
//
if (!this->active)
{
#if (DEBUG)
Serial.println("{ArmServo::stepServo] attach");
Serial.flush();
#endif // DEBUG
this->attachServo();
}
#if (DEBUG)
Serial.print(", refreshing to: ");
Serial.println(this->current);
Serial.flush();
#endif // DEBUG
this->myServo->write(this->current);
this->lastTimeActive = millis();
}
//
// The arm reached it's position, so we can now detach the servo (if it was attached)
//
if (this->active)
{
this->detachServo();
}
return false; // The arm has stopped moving
}
}
};
enum AkiStaat {aan, uit};
//
// A simple class that represents a complete AHOB with all its leds and two Servo's
// for moving the arms
//
// TBD, the sound of the bells
//
class AHOB
{
private:
SingleLed *redLight;
ArmServo *arm1;
ArmServo *arm2;
AkiStaat state = uit;
public:
//
// Create an instance of the AHOB, using the specified Led and ArmServo objects
//
AHOB(SingleLed *aRedLed, ArmServo *aServo1, ArmServo *aServo2)
{
redLight = aRedLed;
arm1 = aServo1;
arm2 = aServo2;
state = uit;
//
// AHOB is veilig, dus roodlicht uit en armen omhoog
//
redLight->setOn(false);
arm1->hoog();
arm2->hoog();
}
//
// Activate the connected leds and arm servo's. TBD: the sound
//
void heartBeat()
{
if (arm1->isHoog() && arm2->isHoog())
{
redLight->setOn(false); // Als de armen omhoog staan mag het rode licht niet branden
}
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 open, armen omhoog. Het rode licht stopt pas als de armen omhoog staan
//
arm1->hoog();
arm2->hoog();
}
else
{
//
// AHOB is dicht, 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
}
-
... dat stukje code is niet goed.
Dit staat er nog 2x in;
this->active = false;
Ik heb nog een witte led aan de AHOB toegevoegd die zou moeten knipperen als de bomen omhoog zijn. Het compileert OK maar ik weet niet of het werkt want ik heb even geen Arduino om te testen.
In de tekst staat dat de rode leds knipperen met 50x/minuut, maar ik zie niet hoe dat gerealiseerd wordt. Het zou mooi zijn als de witte leds knipperen met de halve freq van de rode, 25x/min dus.
Verder heb ik #define vervangen door een const int declaratie (const byte is nog beter) en ze allemaal bovenin het programma gezet zodat het makkelijker is om b.v. pinnummers te veranderen
Code deel 1:
#include <Servo.h>
bool DEBUG = false; // zodra alles werkt, anders true
const int SENSOR1_PIN = A0; // Analoge pin voor lichtsluis 1
const int SENSOR2_PIN = A1; // Analoge pin voor lichtsluis 2
const int SENSOR3_PIN = A2; // Analoge pin voor lichtsluis 3
const int SENSOR4_PIN = A3; // Analoge pin voor lichtsluis 4
const int LED_RED_PIN = A5; // Analoge pin voor rode leds
const int LED_WHITE_PIN = A6; // Analoge pin voor witte leds
const int BEL_PIN = A7; // Analoge pin voor bel
const int SERVO1_PIN = 11; // PWM pin voor servo 1
const int SERVO1_WACHTTIJD = 40; // Wachttijd (in MS) tussen 2 servo stapjes, hogere waarden = langzamer
const int SERVO1_LAAGPOSITIE = 45; // Positie arm in laag stand (0..180 graden servo)
const int SERVO1_HOOGPOSITIE = 100; // Positie arm in hoog stand (0..180 graden servo)
const int SERVO2_PIN = 12; // PWM pin voor servo 2
const int SERVO2_WACHTTIJD = 40; // Wachttijd (in MS) tussen 2 servo stapjes, hogere waarden = langzamer
const int SERVO2_LAAGPOSITIE = 45; // Positie arm in laag stand
const int SERVO2_HOOGPOSITIE = 100; // Positie arm in hoog stand
enum SpoorState {leeg,
sensor1komend,
sensor2komend,
sensor1gaand,
sensor2gaand
};
enum AkiStaat {aan, uit};
enum SensorTrigger {laag, hoog};
//
// ---------------------------------------------------------------------------------
//
// Class for a single red led which flickers 50 times per
// minute when on
//
class SingleRedLed
{
private:
int ledPin;
bool ledOn = false;
public:
//
// Create a new instance of a red led, connect it to the specified
// digital pin and put it in the specified state (true = on, false = off)
//
SingleRedLed(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("[SingleRedLed::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("[SingleRedLed::heartBeat] rode led aan");
#endif
digitalWrite(ledPin, HIGH); // No, so switch it on
}
else
{
#if (DEBUG)
Serial.println("[SingleRedLed::heartBeat] led uit");
#endif
digitalWrite(ledPin, LOW); // Switch it off
}
}
};
// --------------------------------
class SingleWhiteLed
{
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)
//
SingleWhiteLed(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("[SingleWhiteLed::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("[SingleWhiteLed::heartBeat] witte led aan");
#endif
digitalWrite(ledPin, HIGH); // No, so switch it on
}
else
{
#if (DEBUG)
Serial.println("[SingleWhiteLed::heartBeat] witte led uit");
#endif
digitalWrite(ledPin, LOW); // Switch it off
}
}
};
// ----------------------------------------------------------------------
/*
A wrapper class for controlling RC servos
*/
class ArmServo
{
private:
const int REFRESH_TIME = 30000;
Servo *myServo;
unsigned long timeOfLastStep;
unsigned long lastTimeActive;
unsigned int target;
unsigned int current;
unsigned int highPosition; // Arm position high
unsigned int lowPosition; // Arm position low
unsigned int servoWaitTime; // Wait time between 2 steps
int servoPin;
bool active = false;
void attachServo() // Intialize the servo
{
#if (DEBUG)
Serial.print("[ArmServo::attachServo] Servo pin: ");
Serial.println(this->servoPin);
#endif //DEBUG
this->myServo->attach(this->servoPin);
this->active = true;
this->myServo->write(this->current); // Restore last known position
}
void detachServo()
{
#if (DEBUG)
Serial.print("[ArmServo::detachServo] Servo pin: ");
Serial.println(this->servoPin);
#endif //DEBUG
this->myServo->detach();
this->active = false;
}
public:
ArmServo(int newServoPin, int newWaitTime, int newHighPosition, int newLowPosition)
{
// this->active = false;
this->myServo = new Servo();
this->servoPin = newServoPin;
this->servoWaitTime = newWaitTime; // Wait time between 2 steps
this->highPosition = newHighPosition;
this->lowPosition = newLowPosition;
this->target = newHighPosition; // We asume that the arms are initial in their
if (this->highPosition > this->lowPosition)
this->current = newHighPosition - 1; // But force a small initial movement
else
this->current = newHighPosition + 1; // But force a small initial movement
this->active = false;
}
void laag()
{
#if (DEBUG)
Serial.print("[ArmServo::laag] arm going to low position: ");
Serial.println(lowPosition);
Serial.flush();
#endif //DEBUG
target = lowPosition;
}
bool isLaag()
{
if (current == lowPosition)
return true;
else
return false;
}
void hoog()
{
#if (DEBUG)
Serial.print("[Armservo::hoog] arm going to high position: ");
Serial.println(highPosition);
Serial.flush();
#endif //DEBUG
target = highPosition;
}
bool isHoog()
{
if (current == highPosition)
return true;
else
return false;
}
bool stepServo()
{
//
// When the arm's position is not at the target, we have to move the arm
//
if (this->target != this->current)
{
//
// Is the servo active? if not attach it to its 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 its 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 its 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 its position, so we can now detach the servo (if it was attached)
//
if (this->active)
{
this->detachServo();
}
return false; // The arm has stopped moving
}
}
};
//
-
Code deel 2 (was te lang om in 1x te plakken):
// -------------------------------------------------------------------------------------
//
// A simple class that represents a complete AHOB with all its leds and two servos
// for moving the arms
//
// TBD, the sound of the bells
//
class AHOB
{
private:
SingleRedLed *redLight;
SingleWhiteLed *whiteLight;
ArmServo *arm1;
ArmServo *arm2;
AkiStaat state = uit;
public:
//
// Create an instance of the AHOB, using the specified Led and ArmServo objects
//
AHOB(SingleWhiteLed *aWhiteLed, SingleRedLed *aRedLed, ArmServo *aServo1, ArmServo *aServo2)
{
redLight = aRedLed;
whiteLight = aWhiteLed;
arm1 = aServo1;
arm2 = aServo2;
state = uit;
//
// AHOB is veilig, dus armen omhoog, roodlicht uit, wit licht aan
//
arm1->hoog();
arm2->hoog();
redLight->setOn(false);
whiteLight->setOn(true);
}
//
// Activate the connected leds and arm servos. TBD: the sound
//
void heartBeat()
{
if (arm1->isHoog() && arm2->isHoog())
{
redLight->setOn(false); // Als de armen omhoog staan mag het rode licht niet branden
whiteLight->setOn(true); // armen omhoog = wit licht aan
}
redLight->heartBeat();
whiteLight->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 open, dus roodlicht uit, witlicht aan en armen omhoog
//
arm1->hoog();
arm2->hoog();
whiteLight->setOn(true);
}
else
{
//
// AHOB is dicht, dus witlicht uit, roodlicht aan en armen omlaag
//
whiteLight->setOn(false);
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 the "hoog" setting in that case.
//
// If the sensor does not 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
//
// -----------------------------------------------------------------
// A simple class which represents the state of a single sensor
//
class Sensor
{
private:
int sensorPin;
SensorTrigger type = hoog; // of laag, zie boven
bool state = false; // true = on, false = off
unsigned long lastTime = 0; // Timer to ignore short interrupts
const int 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
//
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));
SingleRedLed roodlicht(LED_RED_PIN, false);
SingleWhiteLed witlicht(LED_WHITE_PIN, false);
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(&witlicht, &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
// Start flashing white lights
}
else
{
ahob.set(aan); // Start flashing red lights and sound
// Stop flashing white lights
}
ahob.heartBeat(); // Let the AKI update its connected bells and leds
}
// =======================================================================
-
Het gebruik van const int of #define is meer een kwestie van codering stijl. Ik ben gewend om dat met #define te doen. Een klein voordeel is dat deze geen fysieke ruimte in nemen, wat een const int wel doet. Dat is bij deze schets echter niet relevant.
Over die witte led, dat was niet wat Koen van plan was te implementeren, wat ik begrepen heb van Koen is dat hij een enkele led wilde gebruiken die uit zich zelf knippert. Vandaar dat je in de kode geen voorzieningen hebt om dat knipperen te doen. De kode is gekopieerd van de AKI schets waar wel een witte led en 2 rode leds gebruikt worden en waar de code voor het knipperen zorgt. Helaas heb ik tijdens het knip en plakwerk niet al het commentaar aangepast.
Groet Meino
-
Bovendien heeft een AHOB geen witte lampen. Alleen rode om aan te geven dat de bomen sluiten/gesloten zijn.
Groet,
Gerard van der Sel.
-
Goedemorgen,
Ik ben er gisteravond niet aan toe gekomen.
Ik had al begrepen dat Meino's sketch nog aangepast moest worden.
De Led is overigens oranje, dat maakt mij niet zoveel uit.
Kan altijd nog een rode overzetten.
Ik wil jullie vragen nogmaals te kijken naar die controller die ik aangeschaft heb, door de winkel was mij geadviseerd dat je er 2 servo,''s mee kan afstellen, dat lijkt me dan toch wel bruikbaar als buffer tussen de Arduino en de servo's.
Gr Koen.
-
Het gaat om dit type: Dual Bridge (http://www.okaphone.com/artikel.asp?id=484451)
En hier in de pdf staat in de handleiding de sketches en specificaties voor gebruik: Pdf (https://www.velleman.eu/downloads/29/vma409_a4v01.pdf).
Lijkt me dat ie best te gebruiken is om die servo's mooi in te stellen.
Gr Koen.
-
Er is geen buffer nodig tussen Arduino en servos. Een stevige 5 volt voeding is wel zeer aan te raden.
Dat ding is een H-brug voor het aansturen van gewone motoren.
Naar de winkel waar ze zeggen dat het bedoeld is voor het aansturen van modelbouw servos zou ik niet meer terug gaan...
-
Geen man overboord, dan bewaar ik hem wel.
Ik begrijp dat ik de laatste sketch van Martin moet gebruiken vanavond?
Gr Koen.
-
Koen,
laten we het simpel houden. blijf voorlopig even bij de laatste schets die ik gisteren heb gepubliceerd, Martin heeft een witte led toegevoegd aan de schets die je niet gaat gebruiken.
En verder wat Gerard zegt, blijf de servos gewoon aansluiten rechtstreeks op de arduino.
Groet Meino
-
Bovendien heeft een AHOB geen witte lampen.
Ik zie het; AKI, AHOB... Het maakt mij allemaal niet uit, als het maar knippert en beweegt... :)
... die controller die ik aangeschaft heb, door de winkel was mij geadviseerd ...
Wij van WC eend... Ik zou een andere winkel zoeken.
Dat type controller gebruik je voor gewone DC motortjes, niet voor servo's. Als je al iets zou willen bufferen zou dat een aparte 5 V voeding zijn voor de servo's.
Ik begrijp dat ik de laatste sketch van Martin moet gebruiken vanavond?
Nee dus, hou het bij de laatste van Meino, reactie #74.
-
Koen,
Mag ik je feliciteren. Je hebt op een na de complete vrijwillige BNLS technische staf in je draadje verzameld. ;D ;D Is mijn een raadsel waarom die ene er nog niet is. Normaal komt hij nog voordat ik bezig ben al met goede adviezen. Hij zal gezien de tijd van het jaar wel op vakantie zijn.
Groet,
Gerard van der Sel.
-
Hoi,
Ik ben ook zeker blij met zulke technische kunde.
Mijn onkunde hierin gaat helemaal terug naar mijn jeugd en kom nu pas tot de ontdekking dat het best te leren is.
Of ik ooit zelf iets kan schrijven of ontwerpen weet ik niet.
Nog een lange weg te gaan.
Ik gok zomaar dat je op Klaas doelt :D.
BTW moest nou ik met de laatste sketch van Meino die groene jumper aanpassen of niet.
Ga nu de nieuwe sketch overzetten.
Gr Koen.
-
Bumper los halen. En na opstarten eerst in A0 doen en dan eruit, vervolgens in A1 doen en eruit.
Groet,
Gerard van der Sel.
-
Ok, en dat werkt. De slagboompjes draaien een halve van een kwartslag ::) en ergens gaan de Led's aan.
Op naar de nieuwe sketch van Meino.
- bij mijn knipperled moet ik nog een pin, volgens mij heet dat een header maken.
Kwestie van header draadje solderen (?) krimpkous erom?
Het is heel dun draad.
Gr Koen. ;)
-
... De slagboompjes draaien een halve van een kwartslag
In het programma staan o.a. de regels
#define SERVO1_LAAGPOSITIE 45 // Positie arm in laag stand
#define SERVO1_HOOGPOSITIE 100 // Positie arm in hoog stand
De waarde 45 en 100 is de hoek (in graden) waar de servo naar toe draait in de uiterste standen, De servo verdraait dus over 100° - 45° = 55°
Nadat de boel ingebouwd is, kun je de slag afstellen door die waarden te veranderen (en opnieuw compileren en uploaden).
-
Hoi,
Even onduidelijk welke sketch ik moet gebruiken die laatste van Meino of de aangepaste van Martin, beide geven foutmeldingen.
Bij de twee van Martin gaat er ongetwijfeld iets mis bij het plaatsen in 1 opslag.
Concentratieverlies, ga er een nachtje over slapen.
Gr Koen.
-
Koen,
De laatste van Meino (reactie #73) is diegene waarvan wij verwachten (ook Martin) dat je gebruikt. De IDE van Arduino heeft een nogal vervelend gebrek overgenomen van C++. Alle code bestanden in de subdirectory worden gecompileerd. Als je dus meerdere ino, cpp of h bestanden in de subdirectory hebt staan, worden die allemaal in de compilatie meegenomen, met alle gevolgen van dien.
Maak de subdirectory even leeg, met alleen het ino file van Meino uit reactie #73 erin.
Bij mij compileert deze foutloos. Dus het is aan jouw om te checken of het werkt.
Groet,
Gerard van der Sel.
-
met alle gevolgen van dien.
Volgens mij heb ik dat nu.
Heb alle opslagbestanden met sketches verwijderd maar krijg die nieuwe niet gecompileerd.
Koen.
-
Je hebt via PB de source van bericht #73 gekregen. Ik heb deze gecontroleerd en die compileert.
Groet,
Gerard van der Sel.
-
Reactie #74 van Meino, compileert bij mij ook foutloos.
-
Uitgaande van de schets in #73, is het volgende scenario te volgen om de werking te controleren.
Pin A0 en A1 los van GND (ground), zet de arduino aan, of gebruik de reset knop op de Arduino.
- De servos kunnen met een schok naar een bepaalde stand gaan. Dit is de stand van de servo als de bomen omhoog staan. De Led is uit.
Verbind pin A0 met GND en laat dan na 1 sec de pin weer los van GND.
- De servos zullen nu langzaam (2-3 sec) naar een andere stand gaan (dit is de stand als de bomen gesloten zijn). De Led gaat aan.
Verbind pin A1 met GND en laat hem aan GND.
- Er gebeurt niets.
Maak pin A1 los van GND
- De servos gaan weer langzaam (2-3sec) naar de stand van de geopende bomen. Als de servos die stand bereikt hebben gaat de led uit.
Je kunt de test hierna ook herhalen door de volgorde van de pinnen te veranderen. Dus als de bomen hoog staan beginnen met pin A1, waarop de bomen sluiten en daarna pin A0 zodat de bomen weer omhoog gaan. Het is belangrijk om te weten dat als je met een pin bijv A0, begonnen bent en de bomen omlaag zijn en de led brandt, dat je dan de bomen alleen omhoog gaan als je de andere pin aan GND zet en weer los maakt.
Groet Meino
-
Uitgaande van de schets in #73...
Is mijn nummering anders??
(https://images.beneluxspoor.net/bnls/reactie74.jpg)
-
Nee,
Dat niet, maar het werkte ook niet in 1 keer om met 2 sketches te werken, je moet wel weten waar je wat plakt achtereenvolgens.
In pb heb nog een nieuwe doorgekregen, heb alle eerdere sketches waar ik mee gewerkt heb verwijderd uit de bestanden op mijn laptop.
Daarna alles nog nog 1 keer gedownload en opnieuw opgeslagen.
Naar mijn idee is er nu geeneen ander programma waar de Arduino op draaid dus nu kan er voorzichtig geconcludeerd worden dat de sketch van Meino uit post 73 werkt.
Ik voeg nog een filmpje toe.... zie hier (https://youtu.be/XA6n-hvPbJs).
-
Is mijn nummering anders??
(https://images.beneluxspoor.net/bnls/reactie74.jpg)
Bij mij is dat bericht #73. Dus beide sketches zijn gelijk.
Groet,
Gerard van der Sel.
-
Even wat verdere research gedaan naar het genoemde micro-onderdeel, een optische sensor.
Dat blijkt dus om de TCRT5000 te gaan, ik heb er 4 van.
Ik heb het onderdeel op deze site teruggevonden en lijkt me wel goed bruikbaar.
- 5 V.
- 12 mm
Er staat zelfs een Arduino-sketch bij: schema en code (https://www.hobbyelectronica.nl/product/tcrt5000-optische-sensor/).
Nu nog inpassen bij de rest.
Ik weet niet of het bij een sein aangesloten kan worden maar mijn idee hierover is het hele overweggebied te detecteren met dit en het sein langs het vertrekspoor handmatig te schakelen.
Eigenlijk komt het dan neer op een automatisch gedetecteerde spoorwegovergang.
Er komt dan een sein aan het vertrekspoor voor de driewegwissel.
(https://images.beneluxspoor.net/bnls/Midland-5.0-001_2.jpg) (https://images.beneluxspoor.net/bnls/Midland-5.0-001_2.jpg)
Gr Koen.
-
Koen,
Lees bericht #35 eens door (van mij). Ik denk dat je zo een betere realistischer overweg krijgt.
Groet,
Gerard van der Sel.
-
Dat verhaal bedoel ik ook.
Ik zit voormezelf een beetje hardop te bedenken hoe of wat er bedacht gaat worden.
De drukknoppen worden eigenlijk de seinen die zouden moeten werken.
Een sein op het vertrekspoor zou wel kunnen.
Gr Koen.
-
Koen,
Hierbij wat gegevens van de TCRT5000 (https://forum.beneluxspoor.net/index.php?action=post;topic=80381.90;last_msg=3221880412). Hiermoet alle elektronica voor het aansturen nog bij. Dit kan simpel (2 weerstanden) of complexer. Wat zijn jouw ideeën daar over?
Groet,
Gerard van der Sel.
-
Hoi,
Het linkje opent niet. Maar als hetzelfde is als in ##post98 dan is het goed.
- simpele versie; ja graag, maar ik heb ook gelezen dat je iets kan doen met Fruit erbij of schildjes hoe die dingen ook mogen heetten.
Versie met weerstanden, ok. Ik heb er een aantal van diverse waarden op voorraad.
- complexe versie:
Geen idee waar dat naar toe leidt, daar zal ik dan waarschijnlijk nog wat moeten voor aanschaffen.
Ik wil mezelf wat elektronikakunde en kennis bijbrengen en misschien leuk voor het forum om daarmee aan de slag te gaan.
Zoals ik al zei, de simpele versie kan ik proefbouwen op mijn breadboard met wat aanwijzingen waar wat geplaatst moet worden.
De complexere versie(analoog/digitaal?) heb ik meer hup nodig en misschien meer materiaal om te bouwen.
Om te testen zou ik zeggen, beginnen met het simpele :D, maar sta open voor beide.
Gr Koen.
-
Oke de simpele eerst. Ik heb me vergist. Het kan zelfs met 1 weerstand. Waarde 390 ohm, maar mag gerust iets kleiner (100 ohm ondergrens), je wilt de schakeling tenslotte uit de Arduino Mega voeden. Ik ga uit van reflectie, anders moet je de schakeling slopen, en ben je je daglicht filter kwijt. Met een breedte van 6 mm zou het geheel tussen twee bielzen moeten passen. De TRCT5000 is niet rechthoekig. Aan een zijde zijn de hoeken afgevlakt. Dit is de kant van de diode (ingang, pen 1 en 2)
(https://images.beneluxspoor.net/bnls/LichtsluisTCRT5000_simpel.jpg) (https://images.beneluxspoor.net/bnls/LichtsluisTCRT5000_simpel.jpg)
Als je de afgevlakte hoeken rechts hebt, dan moeten de twee pennen aan de onderkant of het dichtst bij je verbonden met de GND (zijn dus pennen 2 en 3). Pen 4 kan zo naar de Arduino Mega, want Meino heeft de ingangen met pull-ups ingesteld. Deze weerstand is voldoende om een logische true te maken als er geen licht op de transistor valt.
Groet,
Gerard van der Sel.
-
... iets kan doen met Fruit erbij...
:D
Je bedoelt Adafruit (https://www.adafruit.com/category/61)?
-
;D, ja die ja, het fruitmandje.
Rechtstreeks op de Arduino?
Niet eerst op de breadboard naar de Arduino?
Gr Koen.
-
Inderdaad eerst op het breadboard de schakeling opbouwen. De voeding en de uitgang kun je hierna verbinden met de Arduino. Hoe we het straks doen zien we wel.
Groet,
Gerard van der Sel.
-
Gerard,
Ik neem aan dat het schema gebruikt kan worden voor breadboard?
Of stel ik dan een dummy-vraag?
Had ook een schemaatje gezien met een Ledje ertussen zodat je die kan 'schakelen'.
Dan zie ik de werking van die sensor.
Ik heb een 9volt batterij met klip, dus kan ff los van Arduino gedaan worden.
Gr Koen.
-
Een klein begin van een leek;
(https://images.beneluxspoor.net/bnls/DSCN2654.jpg) (https://images.beneluxspoor.net/bnls/DSCN2654.jpg)
Nu nog uitvogelen waar de draden geplaatst gaan worden.
Btw, weerstand van 220 Ohm.
Gr Koen.
-
Dat gaat zo niet werken, de 5 gaatjes (11abcde) onder die weerstand zijn met elkaar verbonden (álle 'regels' met cijfers in de twee delen links en rechts van de gleuf in het midden zijn met elkaar verbonden).
(https://images.beneluxspoor.net/bnls/breadboard_1.jpg)
... TRCT5000 ... hoeken afgevlakt. Dit is de kant van de diode (ingang, pen 1 en 2)
Maar welke is dan 1 en welke 2? Pen 1 is meestal aangegeven met een markering (putje).
Dit is een plaatje van het www:
(http://www.bajdi.com/wp-content/uploads/2012/04/tcrt5000-connection.jpg)
-
Er hangen nog een lang en kort lipje onder aan de sensor.
Zou dat nog herkenning zijn?
Gr Koen.
-
1 is A
2 is K
3 is E
4 is C
(valt me een beetje tegen 72sonet)
Zal zo uitgebreider antwoorden.
Groet,
Gerard van der Sel.
-
Letten op de schuine kanten en het www plaatje is genoeg, er staan ook geen pennummers in deze datasheet (https://www.digchip.com/datasheets/parts/datasheet/1820/TCRT5000-pdf.php).
-
Allereerst excuses aan 72sonet. De opmerking was niet zo bedoeld, maar ik dacht dat jij geen vertaling kon maken van nummers naar letters.
Zoals 72sonet al aangeeft de herkenning zit in de schuine kanten aan een zijde. Dan zoals getekend de weerstand plaatsen en de twee zwarte draden en de draad naar de Arduino. Ik heb liever niet dat je met die 9V klip werkt. Als je in je enthousiasme per ongeluk de schakeling dan verbind met de Arduino, dan gaat deze naar de eeuwige jachtvelden (voorgoed kapot). Wil je nog een LED extra, dan kun je deze met de korte poot in regel 14 stoppen (a t/m e) en de lange poot op een regel daarboven (13 of 12). Doe in dezelfde regel een weerstand van 1000 ohm en de andere zijde naar de plus (rode lijn).
Als de sensor afgedekt wordt met bv een stuk papier zal de LED oplichten.
Groet,
Gerard van der Sel.
-
Tja, mijn dag is wel verpest... :)
Ik was er van uitgegaan dat de lichtcel op rijen 14 en 16 zat, was moeilijk te zien, maar in de datasheet zie ik nu dat de pootjes 1 & 2 (en 3 & 4) op 2,54 mm afstand zitten, dus in rijen 15 en 16, maar dat maakt voor het principe niet uit. De draad naar de Arduino en de weerstand zitten dus ook in rij 15 (15abcde resp. 15fghij).
-
Samengevat geeft het dit lijstje:
TRCT5000 op de pennen: 15e, 16e, 16f en 15f
Weerstand 220 ohm op de pennen: 15h en plus
Draad 1 op de pennen: 16h en GND
Draad 2 op de pennen: 16c en GND
Draad 3 op de pen: 15c andere einde naar Arduino
LED op de pennen: 15a en 14a
Weerstand 1000 ohm: 14d en plus
Dat is alles
Groet,
Gerard van der Sel.
-
Dank heren,
Ik dacht dat abcd met elkaar verbonden waren, horizontaal.
Voor mij geldt wel dat ik een beetje cijferblindheid heb.
Op den duur snap ik het wel.
Ga er straks mee aan de slag, eerst nog thuiskomen.
Gr Koen.
-
Even iets anders, ik heb weer even een Internet verbinding, dus even een berichtje van mij.
Koen had het er over dat hij de bomen ook handmatig wilde kunnen bedienen en eventueel de sporen met dwergseinen beveiligen.
Ik heb een aangepaste schets, waarin een simpele aan-uitschakelaar (microswitch) verbonden kan worden.
De meeste microswitches hebben 3 pennen, verbind de middelste pen met GND en een van de andere pennen met A2. Dan kun je de overweg ook activeren met deze schakelaar.
Verder voor eventuele dwergseinen, op pin A6 kun je een of meer (parallele) rode leds aansluiten, en op pin A7 een of meerdere groene leds.
Een opmerking, de komende tijd kan ik waarschijnlijk niet al te vaak op Internet zijn, dus antwoorden op eventuele vragen kan wat langer duren.
Groet Meino
-
Dankje Meino,
Heb nog een goede vakantie(?).
Voorlopig nog even zoet met de sensor testen.
Dan zie ik jou sketch vanzelf tegemoet.
Gr Koen.
-
Helaas was de schets te groot, dus dat moest even apart en toen stopte mijn Internet verbinding, dus eerst maar eens een hapje eten met mijn geduldige partner.
De schets komt dus in delen, en moet even met knipppen en plakken aan elkaar gezet worden.
Deel 1
#define DEBUG 0
#include <Servo.h>
enum SpoorState {leeg,
sensor1komend,
sensor2komend,
sensor1gaand,
sensor2gaand
};
//
//
class AanUitSchakelaar
{
private:
int schakelPin;
bool schakelState;
unsigned long lastTime;
public:
//
// Create new instance, connect it to the specified pin, and set the state
//
AanUitSchakelaar(int aPin)
{
schakelPin = aPin;
schakelState = false; // Schakelaar uit
lastTime = 0;
pinMode(schakelPin, INPUT_PULLUP);
}
//
// Monitor the physical switch and update its state accordingly
//
void heartBeat()
{
if (digitalRead(schakelPin) == LOW)
{
#if (DEBUG)
if (schakelState != true)
{
Serial.println("[AanUitSchakelaar::heartBeat] switch goes on");
}
#endif
schakelState = true; // Switch goes ON
lastTime = 0; // Reset interval timer
}
else // sensorPin = HIGH
{
if (schakelState != false) // Process this signal only when the current state is ON
{
if (lastTime == 0)
{
lastTime = millis(); // start Interval
}
else
{
unsigned long currTime = millis();
if ((currTime - lastTime) >= 100) // filter bouncing of the switch
{
#if (DEBUG)
Serial.println("[AanUitSchakelaar::heartBeat] switch goes off");
#endif
schakelState = false; // sensor goes OFF
lastTime = 0; // Reset interval timer
}
}
}
}
}
//
// Return the current logical state of the switch
//
bool getState()
{
return schakelState;
}
};
//
// Class for a single (white) led which flickers 50 times per
// minute when on
//
class SingleLed
{
private:
int ledPin;
bool ledOn = false;
public:
//
// Create a new instance of a (white) led, connect it to the specified
// digital pin and put it in the specified state (true = on, false = off)
//
SingleLed(int aPin, bool state)
{
ledPin = aPin;
ledOn = state;
pinMode(ledPin, OUTPUT);
}
//
// Set the state of the led (true = on, false = off)
//
void setState(bool state)
{
#if (DEBUG)
if (ledOn != state)
{
Serial.print("[SingleLed::setOn]");
if (state)
Serial.println(" aan");
else
Serial.println(" uit");
}
#endif
ledOn = state;
}
//
// Return the state of the led
//
bool getState()
{
return ledOn;
}
//
// If the state is on, put power on the pin of the led, using timers
// to make the flicker work.
// If the led is off, remove the power from the pin of the led.
//
void heartBeat()
{
if (ledOn) // Do we need to light the led?
{
#if (DEBUG)
Serial.println("[SingleLed::heartBeat] led aan");
#endif
digitalWrite(ledPin, HIGH); // No, so switch it on
}
else
{
#if (DEBUG)
Serial.println("[SingleLed::heartBeat] led uit");
#endif
digitalWrite(ledPin, LOW); // Switch ir off
}
}
};
/*
A wrapper class for controlling RC servo's
*/
class ArmServo
{
private:
#define REFRESH_TIME 30000
Servo *myServo;
unsigned long timeOfLastStep;
unsigned long lastTimeActive;
unsigned int target;
unsigned int current;
unsigned int highPosition; // Arm position high
unsigned int lowPosition; // Arm position low
unsigned int servoWaitTime; // Wait time between 2 steps
int servoPin;
bool active = false;
void attachServo() // Intialize the servo
{
#if (DEBUG)
Serial.print("[ArmServo::attachServo] Servo pin: ");
Serial.println(this->servoPin);
#endif //DEBUG
this->myServo->attach(this->servoPin);
this->active = true;
this->myServo->write(this->current); // Restore last known position
}
void detachServo()
{
#if (DEBUG)
Serial.print("[ArmServo::detachServo] Servo pin: ");
Serial.println(this->servoPin);
#endif //DEBUG
this->myServo->detach();
this->active = false;
}
public:
ArmServo(int newServoPin, int newWaitTime, int newHighPosition, int newLowPosition)
{
this->active = false;
this->myServo = new Servo();
this->servoPin = newServoPin;
this->servoWaitTime = newWaitTime;
this->highPosition = newHighPosition;
this->lowPosition = newLowPosition;
this->target = newHighPosition; // We asume that the arms are initial in their upper position
if (this->highPosition > this->lowPosition)
this->current = newHighPosition - 1; // But force a small initial movement
else
this->current = newHighPosition + 1; // But force a small initial movement
this->active = false;
}
void laag()
{
#if (DEBUG)
Serial.print("[ArmServo::laag] arm going to low position: ");
Serial.println(lowPosition);
Serial.flush();
#endif //DEBUG
target = lowPosition;
}
bool isLaag()
{
if (current == lowPosition)
return true;
else
return false;
}
void hoog()
{
#if (DEBUG)
Serial.print("[Armservo::hoog] arm going to high position: ");
Serial.println(highPosition);
Serial.flush();
#endif //DEBUG
target = highPosition;
}
bool isHoog()
{
if (current == highPosition)
return true;
else
return false;
}
bool stepServo()
{
//
// When the arm's position isn't at the target, we have to move the arm
//
if (this->target != this->current)
{
//
// Is the servo active? if not attach it to it's pin so it can start moving
//
if (!this->active)
{
#if (DEBUG)
Serial.println("{ArmServo::stepServo] attach");
Serial.flush();
#endif // DEBUG
this->attachServo();
}
lastTimeActive = millis();
if ((lastTimeActive - this->timeOfLastStep) >= this->servoWaitTime)
{
//
// The servo is moving to it's new location.
//
#if (DEBUG)
Serial.print("[ArmServo::stepServo] target: ");
Serial.print(this->target);
Serial.print(", current: ");
Serial.print(this->current);
#endif //DEBUG
if (this->target > this->current)
{
this->current++;
}
else
{
this->current--;
}
#if (DEBUG)
Serial.print(", going to: ");
Serial.println(this->current);
Serial.flush();
#endif // DEBUG
this->myServo->write(this->current);
this->timeOfLastStep = lastTimeActive;
}
return true; // The arm is still moving
}
else
{
if ((millis() - lastTimeActive) >= REFRESH_TIME)
{
//
// Is the servo active? if not attach it to it's pin so it can start moving
//
if (!this->active)
{
#if (DEBUG)
Serial.println("{ArmServo::stepServo] attach");
Serial.flush();
#endif // DEBUG
this->attachServo();
}
#if (DEBUG)
Serial.print(", refreshing to: ");
Serial.println(this->current);
Serial.flush();
#endif // DEBUG
this->myServo->write(this->current);
this->lastTimeActive = millis();
}
//
// The arm reached it's position, so we can now detach the servo (if it was attached)
//
if (this->active)
{
this->detachServo();
}
return false; // The arm has stopped moving
}
}
};
enum AkiStaat {aan, uit};
//
// A simple class that represents a complete AHOB with all its leds and two Servo's
// for moving the arms
//
// TBD, the sound of the bells
//
class AHOB
{
private:
SingleLed *redLight;
ArmServo *arm1;
ArmServo *arm2;
AkiStaat state = uit;
public:
//
// Create an instance of the AHOB, using the specified Led and ArmServo objects
//
AHOB(SingleLed *aRedLed, ArmServo *aServo1, ArmServo *aServo2)
{
redLight = aRedLed;
arm1 = aServo1;
arm2 = aServo2;
state = uit;
//
// AHOB is veilig, dus roodlicht uit en armen omhoog
//
redLight->setState(false);
arm1->hoog();
arm2->hoog();
}
//
// Activate the connected leds and arm servo's. TBD: the sound
//
void heartBeat()
{
if (arm1->isHoog() && arm2->isHoog())
{
redLight->setState(false); // Als de armen omhoog staan mag het rode licht niet branden
}
else
{
//
// AHOB is dicht of gaat dicht, dus roodlicht aan
//
redLight->setState(true);
}
redLight->heartBeat();
arm1->stepServo();
arm2->stepServo();
}
//
// When both arms of the gate are high, return true, else return false
//
bool isHoog()
{
if (arm1->isHoog() && arm2->isHoog())
{
return true;
}
else
{
return false;
}
}
//
// When both arms of the gate are low, return true, else return false
//
bool isLaag()
{
if (arm1->isLaag() && arm2->isLaag())
{
return true;
}
else
{
return false;
}
}
void set(AkiStaat aState)
{
#if (DEBUG)
if (state != aState)
{
Serial.print("[AKI::set]");
if (aState == uit)
Serial.println(" uit");
else
Serial.println(" aan");
}
#endif
state = aState;
if (state == uit)
{
//
// AHOB is open, armen omhoog. Het rode licht stopt pas als de armen omhoog staan
//
arm1->hoog();
arm2->hoog();
}
else
{
//
// AHOB is dicht, dus armen omlaag, het rode licht volgt automatisch
//
arm1->laag();
arm2->laag();
}
}
};
//
// Some sensors use a digital signal and keep it high when not active and drop the signal
// when the sensor trips, use in that case the "laag" setting. Others use a digital signal
// and are low when not active and make the signal high when the sensor trips, use in that case
// the "hoog" setting.
// if the sensor doesn't generate a digital signal, you have to use a pullup resistor (or INPUT_PULLUP)
// and in that case specify hoog.
//
// The Flying Fish proximity detectors, when used in reflective mode, need the "laag" setting,
// when their sensors are removed and positioned opposit each other, they need the "hoog" setting
//
enum SensorTrigger {laag, hoog};
//
// A simple class which represents the state of a single sensor
//
class Sensor
{
private:
int sensorPin;
SensorTrigger type = hoog;
bool state = false; // true = on, false = off
unsigned long lastTime = 0; // Timer to ignore short interrupts
#define JITTER_TIME 1000 // wait a second before the sensor goes off
public:
//
// Create a new instance
//
Sensor(int aPin)
{
sensorPin = aPin;
pinMode(sensorPin, INPUT_PULLUP);
}
//
// Create a new instance
//
Sensor(int aPin, SensorTrigger aType)
{
sensorPin = aPin;
type = aType;
pinMode(sensorPin, INPUT_PULLUP);
}
//
// Return the current logical state of the sensor
//
bool getState()
{
return state;
}
//
// Monitor the physical sensor and update the state accordingly
//
void heartBeat()
{
if (digitalRead(sensorPin) == HIGH)
{
if (type == laag) // For sensors type laag an high signal means they are in the off state
{
if (state != false) // Process this signal only when the current state is ON
{
if (lastTime == 0)
{
lastTime = millis(); // start Interval
}
else
{
unsigned long currTime = millis();
if ((currTime - lastTime) >= JITTER_TIME)
{
#if (DEBUG)
Serial.println("[Sensor::heartBeat] sensor(laag) goes off");
#endif
state = false; // sensor goes OFF
lastTime = 0; // Reset interval timer
}
}
}
}
else
{
#if (DEBUG)
if (state != true)
{
Serial.println("[Sensor::heartBeat] sensor(hoog) goes on");
}
#endif
state = true; // Sensor goes ON
lastTime = 0; // Reset interval timer
}
}
else // sensorPin = LOW
{
if (type == laag)
{
#if (DEBUG)
if (state != true)
{
Serial.println("[Sensor::heartBeat] sensor(laag) goes on");
}
#endif
state = true; // Sensor goes ON
lastTime = 0; // Reset interval timer;
}
else
{
if (state != false) // Process this signal only when the current state is ON
{
if (lastTime == 0)
{
lastTime = millis(); // start Interval
}
else
{
unsigned long currTime = millis();
if ((currTime - lastTime) >= JITTER_TIME)
{
#if (DEBUG)
Serial.println("[Sensor::heartBeat] sensor(hoog) goes off");
#endif
state = false; // sensor goes OFF
lastTime = 0; // Reset interval timer
}
}
}
}
}
}
};
//
// A finite state machine that guards a occupance of a single track
//
class SpoorControl
{
private:
Sensor *sensor1;
Sensor *sensor2;
SpoorState state = leeg;
//
// Based on the state of sensor 1 and the current state of the FSM, a new state
// is calculated.
//
void handleSensor1(bool trigger)
{
if (trigger) // Sensor 1 is ON
{
if (state == leeg) // If the state is "leeg" it means that a train enters the section
{
#if (DEBUG)
Serial.println("[SpoorControl::handleSensor1] state is sensor1komend");
#endif
state = sensor1komend; // so set it to state komend
}
else if (state == sensor2komend) // if the other sensor tripped first
{
#if (DEBUG)
Serial.println("[SpoorControl::handleSensor1] state is sensor1gaand");
#endif
state = sensor1gaand; // The train is starting to leave the section
}
}
else
{ // Sensor went OFF
if (state == sensor1gaand) // If the train started to leave via sensor 1
{
#if (DEBUG)
Serial.println("[SpoorControl::handleSensor1] state is leeg");
#endif
state = leeg; // the section is "leeg"
}
}
}
//
// Based on the state of sensor 2 and the current state of the FSM, a new state
// is calculated.
//
void handleSensor2(bool trigger)
{
if (trigger) // Sensor 2 is ON
{
if (state == leeg) // Is the section "leeg"?
{
#if (DEBUG)
Serial.println("[SpoorControl::handleSensor2] state is sensor2komend");
#endif
state = sensor2komend; // A Train entered the section via sensor 2
}
else if (state == sensor1komend) // No a train entered the section via the other sensor
{
#if (DEBUG)
Serial.println("[SpoorControl::handleSensor2] state is sensor2gaand");
#endif
state = sensor2gaand; // Start the leaving process
}
}
else
{
if (state == sensor2gaand) // A train is in the process of leaving
{
#if (DEBUG)
Serial.println("[SpoorControl::handleSensor2] state is leeg");
#endif
state = leeg; // Section is empty again
}
}
}
public:
//
// Create an instance with two sensors
//
SpoorControl(Sensor *aSensor1, Sensor *aSensor2)
{
sensor1 = aSensor1;
sensor2 = aSensor2;
}
//
// Get give the sensors a kick and check their state so we can update our own
// state.
//
void heartBeat()
{
sensor1->heartBeat();
sensor2->heartBeat();
handleSensor1(sensor1->getState());
handleSensor2(sensor2->getState());
}
//
// Return the current state of the section
//
SpoorState getState()
{
return state;
}
};
-
deel 2
//
// Create 2 FSM controling two track sections
//
#define SENSOR1_PIN A0 // Analoge pin A0
#define SENSOR2_PIN A1 // Analoge pin A1
SpoorControl spoor1(new Sensor(SENSOR1_PIN, laag), new Sensor(SENSOR2_PIN, laag)); // Sensor works reflective
#define SWITCH_PIN A2
AanUitSchakelaar aanUit(SWITCH_PIN);
#define LED1_PIN A5 // Analoge pin A5
SingleLed roodlicht(LED1_PIN, false);
#define LED2_PIN A6
#define LED3_PIN A7
SingleLed dwergRood(LED2_PIN, false);
SingleLed dwergGroen(LED3_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
aanUit.heartBeat(); // so they can update their states
if ((spoor1.getState() == leeg) && (aanUit.getState() != true))
{
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
//
// There are some signals that block the track when the gates are open.
// These signals follow the state of the redLicht of the AHOB. If that is off, the signal
// may show save (green light)
//
if (ahob.isLaag()) // Are both arms in their lowest position?
{
dwergGroen.setState(true); // Turn on the green light
dwergRood.setState(false); // Turn off the red light
}
else
{
dwergGroen.setState(false); // Turn off the green light
dwergRood.setState(true); // Turn on the red ligh
}
//
// Keep the aspidistra flying
//
dwergGroen.heartBeat();
dwergRood.heartBeat();
}
groet Meino
-
Dank wederom,
Benieuwd hoe deze uitpakt.
Maar ivm knippen en plakken wacht ik even want dat ging de laatste keer niet zo vanzelfsprekend.
Kijk er van het weekend naar met iets meer tijd ervoor.
Gr Koen.
-
Hoi,
Weerstand 1000 ohm: 14d en plus
Is 1 k Ohm hetzelfde als 1000 Ohm weerstand(?), want dan heb ik hem.
Waar komen de pinnen van de batterij-klip op het breadboard?
Bovenaan links +- of op de plek van de in en uitgang naar de Arduino?
Ik heb liever niet dat je met die 9V klip werkt
Not!!! ::)
(https://images.beneluxspoor.net/bnls/DSCN2657.jpg) (https://images.beneluxspoor.net/bnls/DSCN2657.jpg)
De pinnen in de min-zijde rechts blijven niet zo geweldig zitten, is daar iets aan te doen? die passen ook maar op 1 manier.... :-X
In afwachting van het antwoord 1k-Ohm(1000 Ohm)
Grtz Koen.
-
Zo als een kilogram 1000 gram is , is ook een kilo-ohm 1000 ohm.
-
Top!!!!!! (y)
Gr Koen.
-
Zo,
Voor slapen gaan, nu met 1k Ohm!
(https://images.beneluxspoor.net/bnls/DSCN2661.jpg) (https://images.beneluxspoor.net/bnls/DSCN2661.jpg)
Vraag ik me wel af of de weerstanden ook een plus en minkant hebben en of ze er zo goed inzitten.
Goedenacht,
Koen.
-
Weerstanden mag je gewoon omdraaien , maakt niet uit.
-
Dan zal het zo goed zijn, neem ik aan.
Welterusten,
Koen.
-
Het enige onderdeel wat polariteit gevoelig is is de LED. Aan gezien de plus draad iets langer is en jij je LED schuin in je breadbord hebt gestoken (compensatie lengte?) kan ik aan de hoek zien dat hij er goed in zit. Nu alleen hopen dat plus links en plus rechts in je breadbord doorverbonden zijn.
Wie het weet mag het zeggen, anders even een draad van plus rechts naar plus links. Alternatief is de weerstand naar plus links laten lopen (dat was ook mijn bedoeling).
Groet,
Gerard van der Sel.
PS: Effe miereneuken: IK zou de beide GND (min) draden blauw nemen. Kun je de groene voor signalering naar de Arduino gebruiken. Ik weet wel het is een breadbord schakeling, maar een beetje professionaliteit mag best.
-
Het knippen en plakken gaat goed. Hierna de sketch met de V gecontroleerd, compileerd als een zonnetje (Kan ook niet anders komt uit Italie ;D).
Hierbij weer de link naar Dropbox: https://www.dropbox.com/s/orpjrvx7jbql3yz/OverwegMeino.ino?dl=0 (https://www.dropbox.com/s/orpjrvx7jbql3yz/OverwegMeino.ino?dl=0)
Overigens het forum is te klein voor deze sketch ;D
Groet,
Gerard van der Sel.
-
Hoi,
Even de boel van de servo's erafgehaald en de schakeling voor de sensor aangesloten.
Niks om een fotootje te maken, alleen de Led brandt.
Even op advies van Gerard ++ aangesloten, eerst brandde de Led ook niet.
Nog maar is alles nalopen en bezig de nieuwe sketch te laden.
Gr Koen.
-
(https://images.beneluxspoor.net/bnls/Printscreentest-2.png) (https://images.beneluxspoor.net/bnls/Printscreentest-2.png)
Bij het uploaden moet je een "programmer" aangegeven, ik begrijp hier niet helemaal goed wat je hier moet aangeven.
De laatste sketch van Meino geeft: "receive message" time out en "getsync() timeout communicating programmer".
- Blijft ook uploaden.
De sensor heb ik ook nog niet aan de gang gekregen na het nalopen van de aansluitingen.
Gr Koen.
-
Je hoeft niets met een programmer te doen, gewoon in het menu 'Sketch' --> 'Upload' (of Ctrl-U) en klaar.
(Jouw plaatje is niet te lezen, maar bij mij staat programmer in 'Tools' --> 'Programmer' overigens op AVRISP mkII.)
-
Misschien heb ik de 2-delige sketch niet goed geknipt of geplakt.
Heb beide geselecteerd en na elkaar in de IDE gezet.
Gr Koen.
-
Koen,
Je hebt weer een communicatie probleem. Vermoedelijk start jij de IDE voor je de Aduino aan de PC koppeld. Als de Arduino aan de PC gekoppeld wordt, zal com3 door de driver aangemaakt worden. Als jij dus vlak voor of net na het koppelen van de Arduino de IDE start dan is je compoort er nog niet. De IDE is helaas zo ontwikkeld dat er alleen tijdens de opstart naar de compoorten gekeken wordt. Als je te vroeg bent zal je dus de IDE weer af moeten sluiten en opnieuw opstarten.
En verder om het voor ons en jouw te vereenvoudigen:
(https://images.beneluxspoor.net/bnls/ArduinoIDE.png) (https://images.beneluxspoor.net/bnls/ArduinoIDE.png)
Kun je volgens bovenstaande methodiek gaan werken. Als je de code van Meino hebt samengevoegd, druk je op de knop "Controleren code". Hier ga je mee door totdat er geen foutmeldingen meer zijn.
Hierna gebruik je de knop "Uploaden software". Als je niets aan de code veranderd hebt, zullen de problemen die dan optreden in ieder geval NIET in de sketch zitten. Dit is voor ons gemakkelijker. We hoeven dan alleen maar in de software of in de hardware te zoeken.
Groet,
Gerard van der Sel.
-
De controleknop gaat goed, dan zegt ie 'voltooid'
De foutmeldingen komen als ik op 'upload' klik.
die upload is toch om de sketch naar de Arduino te uploaden?
Zal voor vanavond nog een poging wagen.
Heb voor mezelf al een boek over Arduino gereserveerd, dat zal ook veel verduidelijken.
Ahum: klik (https://youtu.be/a14Y2V5zJlY). ::)
Gr Koen.
-
Klopt Upload is om de sketch naar de arduino te verplaatsen. Deze knop heeft echter de slechte gewoonte om eerst alle functies die je met de knop "controleren code" uit te voeren. Onwetenden (en waaghalzen en idioten) slaan de knop over, omdat de tweede knop toch alles doet.
Software zelf werkt snel, het proces om er te komen kun je het beste als een slak benaderen.
Maak vanavond ook een foto van je hardware. IK denk dat je sensor er verkeerd om inzit, waardoor je ingang en uitgang verwisseld zijn.
Groet,
Gerard van der Sel.
-
Bij deze;
(https://images.beneluxspoor.net/bnls/DSCN2665.jpg) (https://images.beneluxspoor.net/bnls/DSCN2665.jpg)
Het breadboard is van het merk: Velleman (http://www.okaphone.com/artikel.asp?id=485313).
Gr Koen.
-
Koen,
Software: Je Upload problemen opgelost?
Hardware: Ik zie iets vreemds. De weerstand lijkt aan de min (GND) te hangen. Het pootje dat nu aan de blauwe kant in het breadboard steekt, moet een gat naar buiten, zodat het in de rode terecht komt. (Kan optisch bedrog zijn, maar check het even.)
Haal de blauwe draad van A0 naar de uitgang (15c?) even weg. Straks zetten we die weer terug als het werkt.
Kijk dan of de diode uit blijft als je de Arduino aan zet. Probeer dan met een papiertje of de LED aan en uit gaat.
Als het allemaal werkt gaan we weer verder.
Groet,
Gerard van der Sel.
-
Helaas, het loopt niet zoals ik wil.
Nog steeds niet geupload en de sensor ook niet.
Gr Koen.
-
Hallo Koen
is er nog iets gebeurd de afgelopen tijd?
Groet Meino
-
Nee,
Ook weekendje weg geweest.
Het programmeren lukt niet en heb nog niet verder geprobeerd.
Gr Koen.
-
Stuur effe via een PB waar je woont. Ik zit vrij centraal in NL. Misschien kunnen we wat afspreken. Ik dacht zelfs dat je in de buurt zit.
Groet,
Gerard van der Sel.
-
Tiel-Houten is niet ver.
Kan ook hele handeltje meenemen.
Stuur pb vanavond.
Gr Koen.
-
Misschien kan er al iets gezegd worden over de plaatsing van de lichtsensors?
Ben nu bezig de rails te leggen en de module definitief op te bouwen dan kan ik er al rekening mee houden.
Gr Koen.
-
De lichtsensors zover mogelijk van de overweg af. In jouw geval zou ik voor een iets andere optie gaan. Namelijk een automatische overweg via het middenspoor en met schakelaars (drukknoppen) de beide zijsporen regelen. Je kunt dan met de drukknoppenals een trein vertrekt of aankomt de overweg bedienen. Ik weet niet of je iets van een bedieningstableau hebt, maar dan kunnen ze daar op geplaatst worden.
Groet,
Gerard van der Sel.
-
Is een reedcontact hier niet gemakkelijker? Magneetje onder de loc, reedcontact in de rail. Geen kans op lichtlekken tussen de wagons en bijbehorende foutmeldingen.
-
Zou kunnen, maar ik heb nu die sensors in huis.
Gr Koen.
-
Ok, zorg er dan wel voor, dat je in je schets een tijdvertraging (delay) opneemt om te vroeg openen door lichtlekken tussen de wagons op te vangen.
-
Zit er al in. Een soort van eigen "ontdenderen" van de schakelaars of sensors.
Groet,
Gerard van der Sel.