Arduino overweg detectie

[TrainSpotterSGM]

Beste forumgebruikers,
Ik ben een overweg aan het maken voor mijn baan. Ik ben in  bezit van een arduino. Ik wil mijn treinen detecteren door "reed contacts" een buisje met 2 draadjes die door een magneetje onderaan een loc geactiveerd wordt en signaal doorgeeft. Ik zou graag dat van beide kanten op 2 sporen willen doen. Heeft iemand de kant-en-klare code daarvoor? Graag wil ik ook seinen laten werken.( Blokken) ook met reed contacts en arduino.
Groeten.

[NS264]

Hoi,

Kan zo snel even mijn eigen draadje niet vinden maar klik op mijn bijdragen en hij zal er tussen staan.

Met behulp van Meino en Gerard.

Alleen ik ben nog niet aan verdere uitwerking gekomen.

Gr Koen.

[NS264]

Gevonden,

Het was even zoeken deze:(klik)

Met aanpassing zal het met reedcontacten ook lukken, denk ik.

En BTW, welkom op het forum.

Gr Koen.

[Marcel112]

Koen,

Draadje met interesse door zitten lezen.
Heb je het geheel werkend gekregen? Dat is namelijk uit de laatste posts niet op te maken.

[bask185]

Ik heb zoiets zelf nog niet gemaakt, maar hij staat wel op mn todo lijstje. En ik heb wel wat onderzoek gedaan en wil je graag helpen. Ik ben druk bezig met scripts om code voor ons te generen en ik meen dat het zeer goed moet werken voor jouw of elke andere overgang.

Ik snap dat je nieuw ben met arduino. Ik ga misschien moelijke nog niet duidelijke termen gebruiken en ingewikkelde dingen doen met scripts. Maar ik ben van plan je een werkend programma op te leveren, die je hopelijk kan lezen.

Als eerste moeten we weten wat er allemaal moet gebeuren.
Er zijn 3 processen die parallel moeten lopen.
- De overgang zelf moet open of dicht gaan.
- De reed contacten van spoor 1 moeten continu ge-poll'd worden
- De reed contacten van spoor 2 moeten continu ge-poll'd worden

De overgang kan als een statemachine met 3 states worden gemaakt. De overgang is Open en doet niks, de overgang gaat dicht en de overgang gaat weer open.

Indien we servo's willen gebruiken met armen: moeten de armen in de states geleidelijk omhoog en omlaag gaan. Hierbij moeten de servo posities met een vast interval verhoogd of verlaagd worden.
In de dicht state en de gaat open state moeten ledjes gaan knipperen en branden met een andere interval

Als een trein binnen rijdt op spoor 1 moet een er flag geset worden. En deze moet gecleared worden bij het uitrijden wanneer de andere reed contact wordt gemaakt.

De overgang is dicht als 1 of beide bezet flags gezet zijn. En hij gaat open wanneer de bezet flags niet gezet zijn.

De state machine grafisch weer gegeven:


Hiermee kan ik de state machine aanmaken en vervolgens het project assembleren:


En dan heb ik onze project:


En vanaf dit punt is het invullen. De structuur ligt al vast en is heel simpel. Vanuit void loop wordt roundRobinTasks() aangeroepen en railCrossing(). Die vind je elk in hun eigen .cpp files.

De main heeft een kleine wijziging nodig omdat mn script werk nog niet af. Ik moet io.h nog includen en initIO aanroepen. Dit initialiseert alle IO. (tot nu toe 4)

Code: [Selecteer]

#include "scheduler.h"
#include "roundRobinTasks.h"
#include "io.h"
#include "railCrossing.h"

void setup() {
initIO();
schedulerInit();
}

void loop() {
// readSerialBus(); niet nodig voor ons
processRoundRobinTasks();

railCrossing();
}


Code: [Selecteer]

// io.h
#define reedInTrack1 3 // reed contacten
#define reedOutTrack1 4
#define reedInTrack2 5
#define reedOutTrack2 6

#define burnLed 7   // de 3 leds
#define toggleLed1 8
#define toggleLed2 9

extern void initIO(void);
...
...
// io.c
#include "io.h"

extern void initIO(void) {
pinMode(reedInTrack1, INPUT);
pinMode(reedOutTrack1, INPUT);
pinMode(reedInTrack2, INPUT);
pinMode(reedOutTrack2, INPUT);

pinMode(burnLed, OUTPUT);
pinMode(toggleLed1, OUTPUT);
pinMode(toggleLed2, OUTPUT); }

Dan gaan we het echte werk doen. We willen de 4 reed contacten inlezen en flags zetten en clearen. Dit gaan we dus in roundRobinTasks doen. Deze functie is al gegenereerd en ziet er zo uit:

Code: [Selecteer]

#include "roundRobinTasks.h"
#include "io.h"
#include "roundRobinTasks.h"
#include "io.h"

extern void processRoundRobinTasks(void) {
static unsigned char taskCounter = 0;
taskCounter ++;
// HIGH priority tasks
// readSerialBus(); // heb deze module nog niet af en we hebben hem niet nodig
/* fill in a task */

// LOW priorty tasks
switch(taskCounter) {
default: taskCounter = 0;

case 0:
/* fill in a task */
break;

case 1:
/* fill in a task */
break; } }
Ik maak voor het gemak 2 functies om de reed contacten elke cyclus in te lezen.
De hele file ziet er nu zo uit:

Code: [Selecteer]

#include "roundRobinTasks.h"
#include "io.h"

bool track1occupied, track2occupied;

// deze functie lezen elk 1 van 2 reed contacten in, afhankelijk of er al een trein is of niet
static void readReedTrack1() {
if(!track1occupied) {
if(digitalRead(reedInTrack1) track1Occupied = 1;  } // trein komt aan
else {
if(digitalRead(reedOutTrack1) track1Occupied = 0;  } }// trein is weer weg

static void readReedTrack2() {
if(!track2occupied) {
if(digitalRead(reedInTrack2) track1Occupied = 1;  } // trein komt aan
else {
if(digitalRead(reedOutTrack2) track1Occupied = 0;  } }// trein is weer weg

extern void processRoundRobinTasks(void) {
static unsigned char taskCounter = 0;
taskCounter ++;
// HIGH priority tasks
// readSerialBus(); // heb deze module nog niet af en we hebben hem niet nodig
/* fill in a task */
readReedTrack1();
readReedTrack2();

// LOW priorty tasks
switch(taskCounter) {
default: taskCounter = 0;

case 0:
/* fill in a task */
break;

case 1:
/* fill in a task */
break; } }
De flaggen 'track1occupied' en 'track2occupied' zouden nu goed geset en gecleared moeten worden.
Ik moet alleen nog roundRobinTasks.h aanpassen voor deze 2 bits. De overweg state machine moet deze bits kunnen uitlezen en daarom moeten de bits ook nog extern gedeclareerd worden.

Code: [Selecteer]

extern void processRoundRobinTasks();

extern bool track1occupied, track2occupied;
We weten nu of er 1 of 2 treinen zich in het vlak bevinden.

Nu kunnen we aan het leuke gedeelte beginnen. De state machine. Deze is ook gegenereerd, ik behandel eerst de state machine zelf

Code: [Selecteer]

#define State(x) break; case x: if(x##F())
extern void railCrossing(void) {
if(enabled) switch(state){
default: case railCrossingIDLE: return;

State(closeCrossing) {
nextState(openCrossing, 0); }

State(openCrossing) {
nextState(waitCrossing, 0); }

State(waitCrossing) {
nextState(closeCrossing, 0); }

break;}
else if(!railCrossingT) enabled = true; }
#undef State
De werking is relatief simpel. Dit is de functie waar alles omdraait 'extern void railCrossing(void)'. Deze wordt aangeroepen van de void loop(). De functie roept 1 van de 3 states aan. En als deze states klaar zijn (wanneer de exit state wordt uitgevoerd) dan wordt de volgende state geselecteerd met de functie 'nextState(state, interval);'

Deze flow vind je 1:1 terug in het bollen diagram. Omdat elke state slechts naar 1 andere state kan veranderen, hoeven we helemaal niks aan te passen aan deze functie. Deze functie heeft pas wat liefde nodig wanneer een state naar meer dan 1 state kan veranderen.

Dat wat we nog moeten programmeren, zijn de 3 states. We doen 1 state tegelijk. Ze worden zo gegenereerd:

Code: [Selecteer]

#define State(x) static bool x##F(void)
State(waitCrossing) {
entryState {

}
onState {

exitFlag = true; }
exitState {
return true; } }
Dat in de 'entryState' wordt eenmalig uitgevoerd, de onState wordt continu uitgevoerd totdat de 'exitFlag' wordt geset. Dan wordt de 'exitState' eenmalig uitgevoerd en wordt de volgende state geselecteerd. In de eerste state wachten we tot er een trein is. Dat doen we zo:

Code: [Selecteer]

#include "roundRobinTasks.h" // nodig om de 2 flags te kunnen benaderen

...

State(waitCrossing) {
entryState {

}
onState {
if(track1occupied || track2occupied) exitFlag = true; } // toegvoegd, als minimaal 1 flag waar is, dan is er een trein
exitState {
return true; } }
Het is ook nodig om de roundRobinTasks te includen opdat we de 2 vlaggen kunnen benaderen.

De volgende state is wat meer werk. Dit is dan ook het leukste gedeelte  .

In de entry state moeten we de leds nog initialiseren. Er brandt 1 ledPin (die je voor meer dan 1 led gebruikt) continu en de andere 2 toggelen.

Code: [Selecteer]

entryState {
    digitalWrite(burnLed, HIGH);
    digitalWrite(toggleLed1, HIGH); // de 2 toggle leds knipperen om de beurt
    digitalWrite(toggleLed2, LOW)); }// daarom is 1 aan en en de ander uit

Ik weet niet hoe snel precies de lampen op een AHOB knipperen dus ik zet de interval op 500ms. Dat stukje code komt in de 'onState' en ziet er zo uit:

Code: [Selecteer]

if(!railCrossingT) { // als de timer 0 is
    railCrossingT = 50; // zet timer op 500ms

    digitalWrite(toggleLed1, !digitalRead()); // toggle de 2 toggle leds
    digitalWrite(toggleLed2, !digitalRead()); }


railCrossingT (naam van de state machine + 'T') is ook voor ons gegenereerd en ligt in scheduler.cpp/.h. Dit is een 8 bit softwarte timer die in het ISR wordt gedecrementeerd als hij niet 0 is. Standaard staat de tijd basis op 10ms maar je kan hem aanpassen naar een basis van 1ms of 100ms indien nodig. Voor onze toepassing voldoet de basis van 10ms (max delay van 2.55s mogelijk).

Normaliter zou ik de exitState de leds weer uit doen, maar ze staan nu nog precies goed voor de volgende state.

Het enige wat we nog moeten toevoegen is de servo. Helaas moet deze waarschijnlijk met een andere interval basis gaan werken. Ik heb even gekeken maar het is niet 1 2 3 mogelijk om dezelfde timer te gebruiken. Daarom bedenk ik nu een andere timer en maak hem later in schedulder.ccp/.h bij de andere timer. We moeten ook de servo objecten nog aanmaken en de library includen.

Stel dat de servo (en dit moet je maar proef ondervindelijk ontdekken) in 5 seconde tijd 90 graden moet draaien. Dan moet hij 1 graad opschuiven elke 5000 / 90 = 55ms. Daarom maken we straks de timer aan met een basis van 1ms. Nu eerst onze state afmaken.

We hebben een variabele nodig 'pos', 'degree' of 'pwm' kies er 1 uit. Ik ga nu voor 'pos'. De gehele state ziet er nu zo uit

Code: [Selecteer]

#define upPosition 160 // natte vinger werk hier
#define downPosition 73 // natte vinger werk hier
State(closeCrossing) {
entryState {
pos = upPosition;         // initialiseer 'pos'
digitalWrite(burnLed, HIGH);
digitalWrite(toggleLed1, HIGH); // de 2 toggle leds knipperen om de beurt
digitalWrite(toggleLed2, LOW)); }// daarom is 1 aan en en de ander uit
onState {
if(!servoT) { // nieuwe aan te maken timer
servoT = 55;  //55ms let op dus niet 550ms

servo1.write(pos); // arm 1
servo2.write(pos); // arm 2
pos -= 1;  // of += 1 net hoe die is aangesloten op je boom.
if(pos <= downPosition) pos =  downPosition; }// houdt de positie in deze stand

if(!railCrossingT) { // als de timer 0 is
railCrossingT = 50; // zet timer op 500ms

digitalWrite(toggleLed1, !digitalRead()); // toggle de 2 toggle leds
digitalWrite(toggleLed2, !digitalRead()); }

if(!track1occupied && !track2occupied) exitFlag = true; } // als beide sporen leeg zijn... volgende state open de overweg
exitState {
return true; } }
De basis timer werking is dus simpel. Met een if-statement kijk je of hij 0 is, zoja dan zet je hem op een nieuwe waarde en voer je de rest van de body uit. De timer decrementeert 'vanzelf' in het interrupt.

Als beide treinen weer weg zijn dan springen we naar de volgende state. De volgende state opent de bomen en knippert de ledjes opdezelfde manier. Alleen deze state moet pas exit'en wanneer de bomen open zijn. Dan moeten ook de leds uit. Ik zal omdat het 90% copy paste is de gehele state in 1 keer tonen:

Code: [Selecteer]

State(openCrossing) {
entryState {
pos = downPosition; // als het goed is stond pos al goed trouwens.
// de leds staan iig nog goed en hoeven niet opnieuwe geinitialiseerd te worden, dit mag natuurlijk wel
}
onState {
if(!servoT) {
servoT = 55;

servo1.write(pos);
servo2.write(pos);
pos += 1;  // nu gaan de armen weer omhoog dus doen we +=
if(pos >= upPosition) pos = upPosition; }

if(!railCrossingT) {
railCrossingT = 50;

digitalWrite(toggleLed1, !digitalRead());
digitalWrite(toggleLed2, !digitalRead()); }

if(pos == upPosition) exitFlag = true; } // let op deze regel, wanneer de bomen helemaal boven zijn -> exit
exitState {
digitalWrite(burnLed, LOW); // en zet alle leds weer uit.
digitalWrite(toggleLed1, LOW);
digitalWrite(toggleLed2, LOW)); }
return true; } }

Alle states en state machines bij elkaar:

Code: [Selecteer]

unsigned char pos;

#define State(x) static bool x##F(void)
State(waitCrossing) {
entryState {

}
onState {
if(track1occupied || track2occupied) exitFlag = true; }
exitState {
return true; } }

#define upPosition 160 // natte vinger werk hier
#define downPosition 73 // natte vinger werk hier

State(closeCrossing) {
entryState {
pos = upPosition;         // initialiseer 'pos'
digitalWrite(burnLed, HIGH);
digitalWrite(toggleLed1, HIGH); // de 2 toggle leds knipperen om de beurt
digitalWrite(toggleLed2, LOW)); }// daarom is 1 aan en en de ander uit
onState {
if(!servoT) { // nieuwe aan te maken timer
servoT = 55;  //55ms let op dus niet 550ms

servo1.write(pos); // arm 1
servo2.write(pos); // arm 2
pos -= 1;  // of += 1 net hoe die is aangesloten op je boom.
if(pos <= downPosition) pos =  downPosition; }// houdt de positie in deze stand

if(!railCrossingT) { // als de timer 0 is
railCrossingT = 50; // zet timer op 500ms

digitalWrite(toggleLed1, !digitalRead()); // toggle de 2 toggle leds
digitalWrite(toggleLed2, !digitalRead()); }

if(!track1occupied && !track2occupied) exitFlag = true; } // als beide sporen leeg zijn... volgende state open de overweg
exitState {
return true; } }


State(openCrossing) {
entryState {
pos = downPosition; // als het goed is stond pos al goed trouwens.
// de leds staan iig nog goed en hoeven niet opnieuwe geinitialiseerd te worden, dit mag natuurlijk wel
}
onState {
if(!servoT) {
servoT = 55;

servo1.write(pos);
servo2.write(pos);
pos += 1;  // nu gaan de armen weer omhoog dus doen we +=
if(pos >= upPosition) pos = upPosition; }

if(!railCrossingT) {
railCrossingT = 50;

digitalWrite(toggleLed1, !digitalRead());
digitalWrite(toggleLed2, !digitalRead()); }

if(pos == upPosition) exitFlag = true; } // let op deze regel, wanneer de bomen helemaal boven zijn -> exit
exitState {
digitalWrite(burnLed, LOW); // en zet alle leds weer uit.
digitalWrite(toggleLed1, LOW);
digitalWrite(toggleLed2, LOW)); }
return true; } }
#undef State

#define State(x) break; case x: if(x##F())
extern void railCrossing(void) {
if(enabled) switch(state){
default: case railCrossingIDLE: return;

State(closeCrossing) {
nextState(openCrossing, 0); }

State(openCrossing) {
nextState(waitCrossing, 0); }

State(waitCrossing) {
nextState(closeCrossing, 0); }

break;}
else if(!railCrossingT) enabled = true; }
#undef State

Nu hoeven alleen maar op 3 plaatsen de nieuwe servoT timer toe te voegen en de servo objecten aan te maken. Ik doe voor nu alleen laten zien hoe je de timer aanmaakt en op 1ms zet. De servo objecten en library komen nog.

In de gegenereerde scheduler.ccp.h voeg de lijnen met servoT toe:

Code: [Selecteer]

//.h
extern void schedulerInit();

extern unsigned char railCrossingT;
extern unsigned char servoT;  // deze regel <- toevoegen

//.cpp
#include <Arduino.h>
#include "scheduler.h"

extern void schedulerInit() {
/* code for starting timer */
}

// timer declarations, don't forget to declare them extern in the .h file as well
unsigned char railCrossingT;
unsigned char servoT; // deze regel <- toevoegen

ISR(TIMER2_OVF_vect) {
static unsigned char _1ms, _10ms, _100ms; // Don't complain about the indentations and add your timers. Thank you.
_1ms += 1;
// add 1ms timers here
if(servoT) servoT--; // en deze regel <- toevoegen


if(!(_1ms % 10)) { // if 10ms passed
_1ms = 0;
_10ms += 1;
// add 10ms timers


if(!(_10ms % 10)) { // if 100ms passed
_10ms = 0;
_100ms += 1;
// add 100ms timers
if(buttonTestT) buttonTestT--;
if(railCrossingT) railCrossingT--;


if(!(_100ms % 10)) { // if 1000ms passed
_100ms = 0;
// add 1000ms timers


} // mooi gezicht niet waar :P
}
}
}

Het geheel staat op mijn github en is bijnaaaa compileer baar.
De servo's staan tijdelijk in commentaar.

Alleen de call naar initIO() vanuit setup wilt maar niet compileren... Als je die in commentaar zet dan compileert het wel.

De rest volgt nog!

[TrainSpotterSGM]

Dank yoor uw reactie. Ik wil namelijk een aki overweg maken. Ik heb 2 sporen en wil graag dat de overweg van beide kanten "dicht" kan met 2 reed contacten en dat hij ook na het passeren weer "open" gaat. Zegmaar als hij de eerste passeert dan gaat de witte lamp uit en gaan de rode knipperen en een bel gaat rinkelen. Als de trein (indien lang) tussen de sensoren staat wil ik ook dar de overweg niet uit gaat. Werking van de contacten heb ik al uitgevonden met mijn arduino. Ik wil ook een klein speakertje monteren die een belgeluid afspeelt.
Met vriendlijke groet.

[Klaas Zondervan]

Heeft elk spoor een vaste rijrichting of kun je over beide sporen in twee richtingen rijden? Dat bepaalt waar je de sensoren moet plaatsen. Heb je daar zelf al een idee over? De plaatsing van de sensoren is eigenlijk het eerste waar je over na moet denken, die bepalen wanneer je een sluitbevel of een openbevel moet geven. De Arduino is naar mijn mening maar bijzaak.

[bask185]

Hmm het wordt nog echt ingewikkeld leuk ook.

Als het nodig is, kunnen we een lange vertraging inbouwen. Dat is 1 optie. Deze vertraging kunnen we ook afhankelijk maken van de snelheid van de trein. Die kunnen we meten door de tijd tussen de reed contacten te monitoren

Wat misschien ook een ontzettend slim idee is, is om een magneet te plaatsen voor en achter opder de trein te plaatsen. Dan weet je altijd wanneer de trein voorbij is.

Zo te horen moeten we alsnog een antidender regeling hebben. Daar heb ik ook een geschikte module voor gemaakt (hoewel die nog niet getest is).

Het inlezen van de reed schakelaars moet denk ik ook ver-statemachine-niseerd worden, vooral als de treinen op beide sporen van beide richtingen kunnen komen. Dat zijn 3 states per spoor. Het lijkt me sws interessant om dit te doen ook voor anderen in de toekomst

Ik had trouwens behalve een heleboel typo's nog een klein foutje gemaakt, of eigenlijk ik was iets vergeten. Als de bomen aan het openen zijn, en er komt van de andere kant een nieuwe trein binnen, dan gaan ze eerst helemaal open alvorens ze weer dicht gaan. Dat kan iig simpel worden opgelost, maar voor nu..

Informatie vergaren.
Kan en wil je 2 magneten per trein gebruiken? of gaan we met tijden werken?

[ikbenerevenniet]

Als je na een bepaalde tijd de bomen weer open laat gaan krijg je problemen wanneer een trein op de overweg gestopt is... Geen goed idee, dus!

[TrainSpotterSGM]

Hallo, voor nu ga ik waarschijnlijk een aki maken dus geen bomen en servo's. Ik denk eerlijk dat ik met tijd ga werken want ik ga dan niet heel lang stilstaan op de overweg. Het is niet zo erg belangerijk. Daar buiten... hoe kan ik belgeluid afspelen?
Groeten

[bask185]

Ten eerste, tijden is prima wat mij betreft, maar je hebt nog de vragen niet beantwoord:
- komen treinen wel of niet van 2 kanten op elk spoor
- ben je bereid om 2 magneten in je treinen te zetten?

Dan antwoord op jou vraag:
Er zijn library's waarmee je vanaf een SD kaart .WAV bestanden kan afspelen. Deze instructable legt alles uit.

[TrainSpotterSGM]

Treinen gaan inderdaad van deide kanten rijden. Sorry daarvoor.
2 magneten kan ik er ook in zetten. Waarom zou ik er bereid voor moeten zijn? Is het erg? 

[meino]

In het draadje van Koen is dat precies de situatie die beschreven wordt. De Arduino schetsen die daar in staan (van Gerard en mij) zijn daar dan ook op voorbereid. De schetsen in dat draadje, zijn voor Ali lichtsluisjes, maar het is geen enkel probleem om met reedcontacten te gaan werken. Wel kan het dan een probleem zijn als een trein op de overweg stil staat en de loc al het reed contact is gepasseerd. De oplossing met lichtsluisjes kon dat aan, omdat dan de uitgaande lichtsluis geblokkeerd blijft bij een goede positie van de lichtsluis.

Groet Meino

[TrainSpotterSGM]

Nu ik dit lees den ik dat ik misschien dit https://marnan.eu/busch-5961-tijdschakelaar-met-lichtsluis ga gebruiken. Lijkt veel makkelijker.

[Zilte]

Anders is de combinatie van Huib Maaskant er ook nog en die kan in combinatie met deze, want je heb twee meet punten, dus ook twee lichtsluizen nodig voor twee richtingen.