BeneluxSpoor.net forum

Vraag en antwoord => Digitaal => Topic gestart door: TrainSpotterSGM op 28 november 2019, 18:50:53

Titel: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 28 november 2019, 18:50:53
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.
Titel: Re: Arduino overweg detectie
Bericht door: NS264 op 28 november 2019, 18:55:11
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.
Titel: Re: Arduino overweg detectie
Bericht door: NS264 op 28 november 2019, 19:10:13
Gevonden,

Het was even zoeken deze:(klik) (https://forum.beneluxspoor.net/index.php?topic=80381.msg3221880370#msg3221880370)

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

En BTW, welkom op het forum.

Gr Koen.
Titel: Re: Arduino overweg detectie
Bericht door: Marcel112 op 28 november 2019, 23:24:37
Koen,

Draadje met interesse door zitten lezen.
Heb je het geheel werkend gekregen? Dat is namelijk uit de laatste posts niet op te maken.
Titel: Re: Arduino overweg detectie
Bericht door: bask185 op 29 november 2019, 09:48:33
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:
(https://i.imgur.com/qjjOV8g.png)

Hiermee kan ik de state machine aanmaken en vervolgens het project assembleren:
(https://i.imgur.com/1CXK6Za.png)

En dan heb ik onze project:
(https://i.imgur.com/fRCrxC2.png)

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)
#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();
}

// 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:
#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:
#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.
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
#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:
#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:
#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  (y).

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.
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:
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
#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:
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:
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:
//.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 (https://github.com/bask185/railCrossing) 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!

Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 29 november 2019, 11:32:46
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.
Titel: Re: Arduino overweg detectie
Bericht door: Klaas Zondervan op 29 november 2019, 11:54:46
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.
Titel: Re: Arduino overweg detectie
Bericht door: bask185 op 29 november 2019, 13:10:03

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?
Titel: Re: Arduino overweg detectie
Bericht door: ikbenerevenniet op 29 november 2019, 13:29:12
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!
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 29 november 2019, 13:45:01
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
Titel: Re: Arduino overweg detectie
Bericht door: bask185 op 29 november 2019, 13:48:08

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 (https://www.instructables.com/id/Playing-Wave-file-using-arduino/) legt alles uit.
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 29 november 2019, 13:52:21
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?  :)
Titel: Re: Arduino overweg detectie
Bericht door: meino op 29 november 2019, 14:07:46
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
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 29 november 2019, 14:38:03
Nu ik dit lees den ik dat ik misschien dit https://marnan.eu/busch-5961-tijdschakelaar-met-lichtsluis ga gebruiken. Lijkt veel makkelijker.
Titel: Re: Arduino overweg detectie
Bericht door: Zilte op 29 november 2019, 15:01:03
Anders is de combinatie van Huib Maaskant (http://www.floodland.nl/aim/info_arduino_keerlus_1.htm) er ook nog en die kan in combinatie met deze (https://www.modelbouwled.nl/contents/nl/p1410_lichtsluis-_infrarood-model-_treinen-detecteren.html), want je heb twee meet punten, dus ook twee lichtsluizen nodig voor twee richtingen.
Titel: Re: Arduino overweg detectie
Bericht door: NS264 op 29 november 2019, 15:04:48
Hoi,

Moet erbij vermelden dat de proefopstelling in principe wel werkt.

Maar vermoedt dat ik Arduino nog een keer moet installeren en het programma van Meino erin downloaden.

Dan zou het moeten werken en kan het verder ingebouwd worden.

Ik heb ook geen kaas gegeten van techniek maar met behulp van hier ben ik een eind gekomen.

(Lees:weer een schop onder mijn## geven om er wat mee te doen)  ;D

Gr Koen.
Titel: Re: Arduino overweg detectie
Bericht door: Klaas Zondervan op 29 november 2019, 15:39:43
Met reedcontacten zou je het zo op kunnen  lossen:

(https://images.beneluxspoor.net/bnls/overweg2r.gif) (https://images.beneluxspoor.net/bnls/overweg2r.gif)

Verklaring: stel een trein komt van links over het bovenste spoor. Die activeert eerst reed 1, overweg open, Dat doet nog niks, want de overweg is al open. Direct daarna wordt reed 2 geactiveerd, overweg gaat dicht. Als de trein de overweg is gepasseerd komt hij weer op een reed 2, overweg dicht. Maar dat doet niks want hij was al dicht. Direct daarna wordt reed 1 geactiveerd, overweg open.

Reedcontacten met gelijk nummer kun je elektrisch parallel zetten. Voor de andere richting geldt hetzelfde verhaal, en voor het andere spoor idem.
De arduino (of een andere schakeling) houdt per spoor bij wat de laatst gegeven opdracht was, waarbij dicht overheerst.

De afstand A moet minstens de lengte van de langste trein zijn. Nadeel is wel dat een korte trein de overweg pas laat weer vrijgeeft.
Titel: Re: Arduino overweg detectie
Bericht door: bask185 op 29 november 2019, 18:01:03
Lijkt veel makkelijker.
Wss wel maar hij is wel ~9x duurder dan een arduino nanootje.
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 29 november 2019, 22:08:39
Want het klinkt veel makkelijker dan 4 reed contacten timers codes etc. 2 lichtsluisjes aan beide kanten plaatsen en het aan een arduino plakken on zo'n busch ralais box. Heeft iemand het script voor ir sluizen van busch voor arduino?
Titel: Re: Arduino overweg detectie
Bericht door: NS264 op 29 november 2019, 22:18:31
Met dat setje van Busch heb je geen arduino nodig volgens mij is dat compleet systeem.

Gr Koen.
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 29 november 2019, 23:45:53
Mooi, heel erg bedankt. Ik moet wel namelijk het aki aansturings systeem hebben... dus word het toch arduino of moet ik zo'n busch kastje https://images.app.goo.gl/wShyNtBbdUtW8WjZA kopen? Het kastje dat met de ir sluis komt is volgensmij alleen maar voor het besturen en ontvangen van de stralen. Daarna moet je geloof ik dat doorverbinden naar de aki besturings paneeltje die dus het witte ledje uitzet en de rode aandoet. Hebben jullie nog tips?
Titel: Re: Arduino overweg detectie
Bericht door: Marcel112 op 30 november 2019, 23:39:50
Bij de Aki van Busch zit een nader kastje. Zorgt er voor dat de LED's niet te veel op hun donder krijgen van de trafo in ieder geval.

Of er knipper leds in de AKI zitten, of dat dit kastje dat ook verzocht moet ik nog eens bekijken.
Heb de AKI zelf al op de module bak gelijmd in ieder geval.
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 02 december 2019, 07:43:38
Ik ga namelijk niet de busch aki kopen, ik vind hem niet zo realistisch, deze wel https://www.shapeways.com/product/QXQY4FAEV/aki-1-87
Titel: Re: Arduino overweg detectie
Bericht door: Sam op 02 december 2019, 11:29:14
Een beetje off topic, maar de AKI van Shapeways vind ik ook erg mooi. Alleen vraag ik mij af, gaan deze per twee of is de prijs voor 1? Dan wordt het wel weer erg prijzig ::)
En welk formaat LED kan er in? Iemand ervaring hiermee?
Titel: Re: Arduino overweg detectie
Bericht door: Edsko Hekman op 02 december 2019, 11:34:45
Ze gaan als setje voor die prijs. Dus twee voor €18,69.
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 02 december 2019, 11:36:00
Ik ga ze sowieso kopen. De busch aki's hebben kleine hoedjes boven de lampen. Ze zien er zo mwah uit
Titel: Re: Arduino overweg detectie
Bericht door: NL-modelspoor op 02 december 2019, 12:57:43
Busch AKI is veel te duur voor wat je er voor krijgt.
Het kastje dat erbij zit is alleen om de lichten te laten knipperen. Omdat dit een simpele knipper schakeling is knipperen de lampen ook nog eens verkeerd.
Daarbij zijn er geen witte LEDs gebruikt voor de witte lampen, maar gele. Dit omdat de knipper schakeling niet geschikt is voor het aansturen van de witte LEDs.
Ik heb zelf de Busch AKI jaren terug ook aangepast met witte LEDs en de aansturing gedaan met een microcontroller.
Titel: Re: Arduino overweg detectie
Bericht door: Klaas Zondervan op 02 december 2019, 13:09:57
Busch AKI is veel te duur voor wat je er voor krijgt.
is maar hoe je het bekijkt. Probeer het zelf maar eens in de handel te brengen voor die prijs. Iets anders in dat er bepaalde dingen niet aan kloppen, dat hadden ze voor hetzelfde geld meteen goed kunnen doen.
Titel: Re: Arduino overweg detectie
Bericht door: TrainSpotterSGM op 02 december 2019, 14:52:28
Heeft u het script voor de lampen met arduino?
Titel: Re: Arduino overweg detectie
Bericht door: Klaas Zondervan op 02 december 2019, 16:14:54
Aan wie vraag je dat?
Titel: Re: Arduino overweg detectie
Bericht door: NS264 op 02 december 2019, 16:16:55
Als je helder hebt wat je gaat gebruiken wil iemand vast een script schrijven of aanpassen.

Gr Koen.
Titel: Re: Arduino overweg detectie
Bericht door: bask185 op 02 december 2019, 16:54:12
Mijn software komt in ieder geval af.

Ik had trouwens bedacht dat ik de leds wil laten faden, zodat ze meer op gloeilampen gaan lijken.

Servo's voeg ik later nog wel toe. Ik wil me ook gaan focussen op het modulair houden van het geheel. Ik wil dat een arduino zowel een AKI als een AHOB kan doen en gebruik kan maken van reed contacten, lichtsluisjes en massa detectie. En de mogelijkheid voor een verschillend aantal sporen kan er misschien ook wel in. Dan hoeven we het programma 1 malig in te stellen met de terminal en voila.
Titel: Re: Arduino overweg detectie
Bericht door: NL-modelspoor op 02 december 2019, 18:12:09
Heeft u het script voor de lampen met arduino?

Mocht je het aan mij vragen. Nee, mijn script is voor een Attiny en pure C code want is nog van voor de tijd dat Arduino zo populair werd. Weet zo even uit het hoofd niet meer welk type Attiny ik had gebruikt. En ik gebruik hem in combinatie met massa detectie bij Marklin (maar zou natuurlijk ook een andere schakeling kunnen zijn aan de i/o pin). Ook stukje custom code omdat ik de overweg vlak na een wissel heb en aan de hand van de stand van de wissel ook moet bepalen of ik de overweg al moet activeren.

is maar hoe je het bekijkt. Probeer het zelf maar eens in de handel te brengen voor die prijs. Iets anders in dat er bepaalde dingen niet aan kloppen, dat hadden ze voor hetzelfde geld meteen goed kunnen doen.

Het is een leuke basis. Maar wil je het een beetje kloppend krijgen dan kan je net zo goed zelf gaan bouwen. De prijs is in de afgelopen jaren flink gestegen terwijl het nog techniek is uit de steentijd.
Titel: Re: Arduino overweg detectie
Bericht door: Marcel112 op 02 december 2019, 20:21:15
Het kastje dat erbij zit is alleen om de lichten te laten knipperen.

Mooi, dus alle openheid om met de arduino te gaan aansturen. Heb je mogelijk ook nog een idee welke waarde je voor de weerstand hebt gebruikt?
Of heb je ze kaal aangesloten, op de AtTiny in jou geval.
Titel: Re: Arduino overweg detectie
Bericht door: NL-modelspoor op 02 december 2019, 20:42:18
Een weerstand heb je eigenlijk altijd nodig bij een LED. De weerstanden had ik voor 5 Volt berekend (voedingsspanning voor de microcontroller). Preciese waardes weet ik zo niet meer. Maar voor rood zal het minimaal 180 Ohm zijn geweest die rode geven niet zoveel licht, dus richting de max stroom van 20mA gegaan. De gele LEDs had ik vervangen door witte en omdat die witte veel feller zijn had ik daar een veel hogere waarde tussen zitten kan best rond de 1 kOhm geweest zijn.
Ik had toen een schema getekend van hoe die Busch lampen intern aangesloten waren. Geen idee of ik dat schema nog ergens heb. In ieder geval kan je zonder de bedrading aan te passen ze aansluiten (met een weerstand ertussen).