Beste specialisten,
Ik tracht de tijd te berekenen tussen twee hall sensoren, die op de baan gemonteerd zijn, als een loc passeert.
Aan de hand van hun afstand ken ik ook de snelheid van de loc.
Het ingangssignaal is hoog met een pull-down weerstand van 10kohm.
Het signaal wordt laag als de loc de sensor passeert omwille van de magneet die eronder is geplakt.
Dit werkt en is getest.
Om nu te testen of de interrupt voor sensor1 werkt heb ik volgend programma samengesteld.
In de pintoewijzing van mijn programma staat : const byte S1interrupt = 2; // sensor1
unsigned long int gemtijd_a;
boolean sensor1 = false;
const int led1 = 11;
const int led2 = 12;
In de setup staat : attachInterrupt (digitalPinToInterrupt(S1interrupt),tijd_a,CHANGE);
pinMode (led1,OUTPUT);
pinMode (led2,OUTPUT);
In het programma staat :
void loop () {
delay (5000);
if (sensor1 == true) {
digitalWrite (led1,LOW);
}
if (gemtijd_a > 0) {
digitalWrite (led2,LOW);
}
}
void tijd_a () {
sensor1 = true;
gemtijd_a = millis();
digitalWrite (led1,HIGH);
digitalWrite (led2,HIGH);
}
Probleem : het werkt niet.
Ik heb al verschillende codes uitgeprobeerd, maar ik krijg het niet werkende.
Wellicht zit ik op een verkeerd spoor.
Hopelijk kan iemand onder jullie mij helpen.
Dank op voorhand.
Ludo.
Ik heb nog nooit interrupts gebruikt in mijn Arduino code, hiermee kan ik niet helpen.
Echter, als dit het enige is dat de arduino moet doen... waarom dan eigenlijk een interrupt met delay gaan gebruiken?
Waarom laat je 'em niet gewoon in de loop zonder enige delay continue de sensor in de gaten houden? Ik zou denken dat de Arduino dat sneller kan dan je modeltrein kan rijden op de baan?
Patrick,
De arduino moet natuurlijk veel meer doen.
Maar als je dat ineens in een programma implementeerd, en uw programma werkt niet, begin dan maar te zoeken.
Vandaar de stap voor stap test van programma onderdelen die ik voor de eerste keer gebruik.
In totaal moeten er vier sensoren gemonitord worden naast een aantal andere opdrachten zoals wissels schakelen, seinen zetten enz.
Groeten.
Ludo.
misschien zie ik erover, maar waar definieer je de input pin (als zijnde input)?
Ik zie 2 x pinmode met output maar niets met input ?
zie ook : https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
=> pinMode(interruptPin, INPUT_PULLUP);
Patrick,
Inderdaad, dat staat er niet bij in de setup.
Wel vreemd dat ik geen foutmelding kreeg bij de verificatie.
Ik ga morgen de aanpassing doorvoeren en kijken wat dat geeft.
Bedankt om mee te denken.
Ludo.
Ik heb het programma aangepast en in de setup pinMode (S1interrupt,INPUT); toegevoegd.
Helaas werkt niet.
Ik vraag mij af of het nodig is dat er een internetverbinding tijdens het uploaden nodig is. De draadloze verbinding op mijn zolder werkt niet en een vaste verbinding daar heb ik niet.
Als dat nodig is zal ik een wifi versterker moeten installeren denk ik.
Ludo.
Dag Ludo,
Als ik de code lees snap ik niet zo goed wat de bedoeling is. Wat doet je denken dat deze niet werkt? M.a.w. , wat verwacht je te zien?
Zoals ik de code lees wordt de led uitgang voor een fractie van een seconde (<5ms) hoog gezet telkens als de ingang van toestand gewijzigd is. Ik kan me niet voorstellen dat dit de bedoeling is. Haal beide codelijnen
digitalWrite (led1,LOW);
eens tijdelijk uit je programma. Zo kan je zien of de interrupt uitgevoerd wordt.
Ik doe een simpele println naar de seriële monitor als debug.
gewoon een lijn afdrukken als een deel van het programma doorlopen word. Soms doe ik daar dan ook de variabelen in, zo kan ik zien wat de berekeningen echt doen.
Achteraf haal ik die debug code er dan uit.
Het voordeel is dat je dan een hoop debug stapje voor stapje kan lezen en beter kan inzien hoe het programma loopt.
Ik denk ook niet dat je internet verbinding nodig hebt, tenzij je libraries gaat nodig hebben bij compilatie
maar dan zou je een fout moeten krijgen bij het compileren
Ik begrijp ook je testprogramma niet helemaal (maar ja, ik begrijp vaak mijn eigen programma's de volgende dag niet meer)
elke 5 seconden ga je de led1 afzetten, maar alleen als de interrupt al geweest is.
Want ik zie nergens een andere manier voor de led1 van status te veranderen. Er is zelfs geen initiële status dus gaat ie aan bij het begin?
Dus we gaan van iets ongedefinieerd (geen idee hoe Arduino dat verwerkt, als 1 of 0)
zodra de trein erover gaat, gaat de led1 zeker aan.
Maar binnen de 5 seconden daarna, gaat ie weer uit. Je kan wel niet voorspellen of dat binnen de 4, 4.5 of 0.00001 seconde is.
sensor1 gaat ook nooit meer naar false
In je interrupt definitie gebruik je 'CHANGE', dus als de trein over de magneet gaat - dan ga je 2 interupts genereren.
Wellicht is dit beter : 'FALLING' for when the pin goes from high to low.
Kleine correctie voor mijn posting na reactie van Perk.
Delay(5000) is inderdaad 5000ms of 5s en geen 5000us of 5ms, foutje van mij. Je zou dus wel iets moeten kunnen zien aan de LEDs dat de Arduino het grootste deel van de tijd in Delay aan het wachten is.
Println is een prima manier om te kijken wat er aan de hand is echter vanuit een interrupt routine aangeroepen zou dit toch wel wat neveneffecten kunnen hebben. Ledje aan of uit zetten in een interrupt routine lijkt me veiliger.
Ben je zeker dat je beide leds direct vanuit de hoofdlus aan en uit kan zetten? Zou dit als eerste werkende willen zien. Vervolgens digitale ingang aan led knopen zodat je kan zien dat de ingang werkt. Vervolgens ingang lezen via de interrupt. Heel eenvoudig starten en stap voor stap met kleine stapjes complexiteit toevoegen. Bedoeling is dat je de boel werkende houdt. Werkt het plots niet meer dan zit het probleem in de relatief kleine wijziging die je gemaakt hebt.
Even wat meer toelichting.
Ik rij analoog DC.
Mijn baan is niet groot, het zichtbare gedeelte bestaat uit een dubbel spoor station met uitrijseinen.
Het overige is een schaduwstation met 9 opstelsporen.
Bedoeling is om treinen te laten stoppen in het station of voor het uitrijsignaal indien rood.
Het afremmen en stoppen via pwm heb ik reeds uitgetest en werkt.
Probleem is stoppen op de juiste plaats, aan het perron (reizigers) of voor het uitrijsein indien rood (reizigers en goederen).
Via een code weet ik op voorhand welke trein er komt en wat hij zal moeten doen afhankelijk van de seintoestand.
De voedings transfo heeft een vaste stand voor de snelheid.
Wat wil ik nu doen.
Ik heb 2 hall sensoren ingebouwd op een vaste afstand. Met de tijd tussen 2 pulsen kan ik de snelheid berekenen.
Ik heb voor elke type loc uitgetest hoeveel cm deze nodig heeft om te stoppen. Afhankelijk van de plaats waar moet gestopt worden kan ik kan ik dus berekenen hoeveel seconden er moet gewacht worden alvorens de afremprocedure in te zetten.
Alleen het werken met interrupts heb ik nog nooit gedaan.
De pulsen van de sensoren komen door, dat heb ik getest met een led. Deze is normaal aan en gaat uit als de loc de sensor passeert.
Wat ik dus nu wil nagaan is als het signaal nul wordt, de subroutine aangesproken wordt via het aanzetten van de led en het inlezen van de processor tijd door te controleren of de variabele groter is dan nul.
Als dat eenmaal werkt dan kan ik ook met de tweede sensor de processortijd opnemen. Het verschil tussen deze twee zijn dan toch het aantal seconden tussen de twee pulsen (uiteraard met de nodige berekeningen).
Het aantal seconden en de afstand geeft de snelheid en nadien deze snelheid en de af te leggen weg geven mij het aantal seconden dat na de tweede puls moet gewacht worden alvorens het remmen in te zetten.
Er bestaan wellicht andere technieken om dat te doen, maar ik dacht dat deze manier via eenvoudige code toch zou moeten werken, daar ik maar een amateur programmeur ben.
Dit is dus de laatste stap, maar precies niet de eenvoudigste.
Hopelijk begrijpen jullie mijn doelstelling.
Groeten.
Ludo.
heel belangrijk om te weten is dat als je met interrupts werkt, je dan best NIET met delay(x) in parallel werkt, want als je arduino in een delay commando zit dan stop alles, dus ook de interrupts.
Ik heb dat zelf ook met schade en schande geleerd.
Ben nu aan het werk dus ik heb niet de tijd om je programma in detail te bekijken maar ik kom er op terug !!!
Dani
"Het ingangssignaal is hoog met een pull-down weerstand van 10kohm."
Dat is al een tegenstrijdigheid ..; Je bedoelt waarschijnlijk pull_up weerstand.
Dat kan je ook in je code doen met pinMode(<pin>, INPUT_PULLUP);
Dani zorgt de arduino zelf voor de weerstand , geen extra hardware nodig.
(maar dat is niet relevant voor je interrupt)
--- verder moet je in jouw geval met "falling" signalen werken op je sensor.
Citaat van: bumper op 08 januari 2024, 22:04:52 PMIn totaal moeten er vier sensoren gemonitord worden naast een aantal andere opdrachten zoals wissels schakelen, seinen zetten enz.
Groeten.
Ludo.
Ook hier zie ik een probleem, een UNO / NANO / MINI heeft geloof ik maar 2 interrupts.
Arduino Uno, Nano, Mini 2, 3
Arduino Mega 2, 3, 18, 19, 20, 21
Arduino Micro, Leonardo 0, 1, 2, 3, 7
Arduino Zero All digital pins except 4
Dani,
Ik werk met een Mega.
Dat systeem met een Pull-UP weerstand ken ik, maar ik bedoel wel degelijk een PULL-DOWN weerstand extern dus.
Want als mijn signaal weg valt, moet de ingang naar nul of massa getrokken worden, anders is de ingang niet ondubbelzinnig gedefinieerd.
Dat van delay in parallel met interrupts wist ik niet, ik ga er in het definitieve programma rekening mee houden.
In mijn testprogramma is het enkel om de led duidelijk te zien branden.
Signaaltoestand falling ga ik aanpassen.
Groeten.
Ludo.
Dag Ludo,
probeer de hoofdlus eens als in onderstaand voorbeeld.
Alle credits naar Dani. Wat dit voorbeeld doet is ook met 5sec intervallen kijken of er interrupt geweest is.
Er wordt echter geen gebruik gemaakt van Delay() omdat die volgens info van Dani de interrupts uitschakelt zolang er gewacht wordt. Ik ben geen Arduino programmeur dus ben wel ik enorm verrast door dit gegeven en tegelijk ook weer iets bijgeleerd.
unsigned long basetime;
void loop () {
if (millis() - basetime >= 5000)
{
basetime = millis();
if (sensor1 == true) {
digitalWrite (led1,LOW);
}
if (gemtijd_a > 0) {
digitalWrite (led2,LOW);
}
}
}
met elke delay schakelt elke processor (atmel ,arduino of pic)zich uit en reageert dan niet meer tot die tijd verstreken is
gr raf
Ik ben er niet zo zeker van : https://forum.arduino.cc/t/interrupts-and-delay/704157
Volgens bronnen op het internet kan delay() onderbroken worden door interrupt in Arduino code.
In al mijn projecten heb ik nog nooit een interrupt nodig gehad. De arduino is in mijn beleving snel genoeg om simpelweg in de loop functie de nodige inputs na te kijken en erop te reageren. Toch in mijn modelbouw wereld. Zo snel gaan de dingen hier niet. Je hebt alleen een goed gebruik van je eigen timers nodig, zoals in het voorbeeld van patrick smout. Dus nooit delay gebruiken tenzij bij het opstarten ofzo.
Ik zie wel mogelijke timing problemen als je schermen of tragere devices zoals DS18B20 gaat gebruiken. Dan heb ik al een hickup gemerkt in de performantie.
Voor de opendeur van 'De Pijl' had ik een demo met stappenmotor, 2 servo's met vertragingen, ettelijke Leds (al dan niet knipperend), neopixels, TFT scherm, DS18B20 en een IR sluis. Alles tegelijk werkend en zonder delay.
Alleen als ik de DS18B20 uitlas of het tft scherm aanpaste (zaten beide in dezelfde subroutine) haperde de stappenmotor even.
Maar ik vind het wel een interesant onderwerp.
Patrick,
Delay heb ik hier enkel in het testprogramma gezet om zeker te zijn dat ik de led zie branden. Anders gaat het soms zo snel dat het met het blote oog niet zichtbaar is met mogelijk verkeerde conclusies tot gevolg.
Uw laatste post is al veel te ingewikkeld voor mij. Hetgeen ik nodig heb is gewoon het aantal seconden tussen die twee pulsen. Meer niet en ik dacht van dat zo op te lossen. Verder reikt mijn kennis op dat punt niet.
Ik heb het programma volgens Patrick Smout aangepast maar dat werkt ook niet goed. Het vreemde is dat led 1 van in het begin oplicht en aan blijft. Verder is er geen enkele reactie bij het binnenkomen van de puls te merken. Led 2 blijft onveranderd uit.
Ik begin te denken dat mijn Mega stuk is. Hoe dat is kunnen gebeuren weet ik echt niet. Is dat soms uit te testen?
Ik ga een nieuwe bestellen, dan is hopelijk dat geknoei voorbij. Ik laat wel weten als ik hem heb.
Dank en groeten.
Ludo.
Ik vrees dat andere dingen ook meespelen, zoals wellicht bouncing effect van de sensor.
Voordat je de arduino aanpast, waarom niet eens gewoon zonder sensor maar met een simpele drukknop testen. Zelfs dan ga je bouncing hebben dus verkeerde meetgegevens hebben.
Ik zou een avondje nodig hebben om eens te zien of ik hier een stukje code voor kan schrijven
Patrick,
De code om contactdender tegen te gaan ken ik.
Vanavond lukt dat niet meer, ik zal het morgenvoormiddag proberen.
Groeten.
Ludo.
ik doe het anders
eens ik een puls gemeten heb spring ik naar een sub routine want ik moet geen tweede puls meer meten de loc heeft zich aangemeld
in die sub routine wacht ik dan op de volgende puls van de andere sensor en spring dan terug naar het main programma
gr raf
well, omdat het mijn interesse heeft gewekt wou ik nu toch eens die interrupts proberen.
Ik heb een Uno op een test boardje staan.
Dit is het programma :
===========
int interruptteller=0;
int vorigeteller=0;
const byte sensorPin = 2;
void setup() {
pinMode(sensorPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(sensorPin), teller, FALLING);
Serial.begin(9600);
Serial.println();
Serial.println();
Serial.println();
Serial.println();
Serial.println();
Serial.println("programma is bezig");
}
void loop() {
if (interruptteller>vorigeteller)
{
Serial.print("interrupt gezien , nummer :");
Serial.println(interruptteller);
vorigeteller=interruptteller;
}
Serial.print("nummer :");
Serial.println(interruptteller);
}
void teller() {
interruptteller = interruptteller+1;
}
==========
als ik pin 2 op de grond breng (simpel jumpekabeltje), zie ik dit soort zaken op de seriele monitor :
nummer :10
nummer :10
nummer :10
nummer :10
nummer :10
nummer :10
nummer :10
nummer :10
interrupt gezien , nummer :12
nummer :12
nummer :12
nummer :12
nummer :12
nummer :12
Je ziet echter dat de aantallen ophoog springen, ik vermoed door bouncing?
Nog steeds, ik zou het zonder interrupts proberen met gewoon debouncer code - maar dit is gewoon voor de interupt te testen.
En dat stukje lijkt best te werken.
Dag Ludo,
neem onderstaande code eens over voor de loop. Verder ook de aanname dat je de interrupt op FALLING hebt staan nu (RISING mag ook overigens).
Volgens mij gaat LED1 onmiddellijk aan omdat de interrupt al getriggerd wordt bij opstart van het programma.
Als de systeemtimer dan nog 0ms is dan blijft die LED uit. Nu is voor mij onduidelijk wat je wil bereiken/bewijzen met het aansturen van LED2 dus die heb ik er even uit gelaten in onderstaande code.
unsigned long basetime;
void loop () {
if (sensor1 == true)
{
if (millis() - basetime >= 5000)
{
sensor1=false;
digitalWrite (led1,LOW);
}
}
else
{
basetime = millis();
}
}
En voor de snelheidsmeting zou het zoiets kunnen worden (wegens gebrek aan een Arduino niet getest, onder voorbehoud van een typo links of rechts). Variabelen zijn niet aangemaakt net zomin als initialisatie voor de 2e interruptingang.
In ElapsedTime komt de tijd die verstrijkt tussen het actief worden van sensor1 en sensor2.
Er is een basic interlocking voorzien die vereist dat eerst sensor1 en dan sensor2 actief moet worden alvorens de tijd berekent wordt. Zoals het nu is werkt de meting maar in één rijrichting. Kan ook voor beide richtingen maar maakt het (weer) wat complexer.
Persoonlijk zou ik er ook voor kiezen om een statemachine te gebruiken maar dat kan later nog.
Eerst even dit aan het werken krijgen op basis van zoveel mogelijk originele code en kleinere stappen.
@ Ludo, test eerst even het programma in mijn vorige post. Als dat niet werkt zal dit ook niets doen.
void loop ()
{
if (sensor1 == true)
{
if (millis() - basetime1 >= 500)
{
digitalWrite (led1,LOW);
}
}
else
{
basetime1 = millis();
}
if (sensor2 == true)
{
if (millis() - basetime2 >= 500)
{
digitalWrite (led2,LOW);
if(sensor1==true)
{
elapsedtime = gemtijd2 - gemtijd1;
sensor1=false;
}
sensor2=false;
}
}
else
{
basetime2 = millis();
}
}
void tijd_1 () {
if(sensor1==false)
{
gemtijd_1 = millis();
digitalWrite (led1,HIGH);
}
sensor1 = true;
}
void tijd_2 () {
if(sensor2==false)
{
gemtijd_2 = millis();
digitalWrite (led2,HIGH);
}
sensor2 = true;
}
Hallo Patrick & Patrick,
Laat het nu even rusten, ik ga alle info en voorstellen uitproberen en geef daarvan de resultaten door.
Aan de hand daarvan kunnen we dan eens bekijken welke stappen we verder gaan ondernemen.
De aanpassing van de code in de "loop" volgens uw eerste post werkt niet, heb dit reeds gemeld. In de reactie daarop begrijp ik niet hoe de interrupt reeds kan getriggerd worden bij de opstart (led 1 gaat branden zelfs zonder passage van de loc).
Met led 1 wil ik nagaan of de interrupt is binnengekomen en met led 2 wil ik nagaan of de code die gebruik maakt van millis() wel werkt. Ik dacht ergens gelezen te hebben dat dit niet altijd lukt.
In ieder geval nogmaals bedankt om mee te helpen.
Hallo Raf,
Ik begrijp wel wat je bedoeld, maar weet niet goed hoe dat moet geprogrammeerd worden in arduino taal.
Ik vraag mij toch af hoe je op die manier 100% zeker kunt zijn dat je geen puls mist.
Groeten.
Ludo.
Citaat van: bumper link=msg=510873 In de reactie daarop begrijp ik niet hoe de interrupt reeds kan getriggerd worden bij de opstart (led 1 gaat branden zelfsquote author=bumper link=msg=510873 date=1705073528]
In de reactie daarop begrijp ik niet hoe de interrupt reeds kan getriggerd worden bij de opstart (led 1 gaat branden zelfs zonder passage van de loc).
Dag Ludo,
De interrupt zou getriggerd kunne worden door een opstartverschijnsel ( initialisatie van de Io of zo) dat zich enkel voordat als je het programma start. Zekerheid heb ik daar niet over en zonder bordje hier op tafel blijft het een best guess maar ik zie daat wel een verklaring in waarom LED1 aan is een LED2 uit.
Bij perk lijkt de interrupt wel te werken dus ik zou verder ook niet direct weten wat er aan de hand is. Wat je nog kan verder kan helpen is ook een println in de interrupt routine zetten van mijn code zoals in het vb van Perk. Dit geeft je ook een indicatie dat de interrupt wel degelijk uitgevoerd wordt.
Verder kan je ook eens de ingang hard aan de +5V leggen ipv via de hall sensor. Geeft je ook zekerheid dat het schakelen goed gaat. Er zijn best nog wat opties open die op afstand moeilijk te beoordelen zijn of ze wel/niet uitgesloten kunnen worden.
Ben wel erg benieuwd wat nu maakt dat dit niet werkt dus laat zeker de uitkomst weten.
Wat ik dit weekend gevonden heb.
Wanneer ik opstart dan gaan beide leds branden ongeacht de volgorde van opstarten. Eerst de arduino en dan de signalen of andersom.
Wanneer een trein de sensor1 passeert gebeurt er niets. De spanning valt wel weg en komt terug. Maar de leds blijven branden. Bij toeval ontdekt dat als de magneet boven de sensor blijft, dus de spanning blijft nul, dan gaan de twee leds na een tijdje( ongeveer 3 à 4 seconden) uit. Als de magneet dan weggenomen wordt, dus als de spanning terug komt, dan gaan de leds terug branden.
Dit is dus geen bruikbaar systeem, maar het is schijnbaar het omgekeerde van wat we willen bereiken.
Welke trigger voor het interrupt gebruikt wordt ( falling,rising,high,low,change enz.) maakt niet uit. Het resultaat is steeds hetzelfde.
Patrick Smout, dit is getest volgens uw eerste code.
Groeten.
Ludo.
Ludo,
ik ben nog altijd van mening dat LEDS nu niet direct de beste manier van ontdekken is wat ere juist gebeurd.
Een seriele monitor en print statements in de code werken veel beter vind ik. Dan kan je je variabelen en elke stap van het programma uitlezen als het ware.
Heb je geen mogelijkheid mijn stukje code met je sensor eens te proberen?
groeten,
P.
welk exact type sensor gebruik je juist? Kan je een merk en type delen?
Patrick,
Kan dat met dezelfde kabel voor het uploaden van een programma op een laptop via usb?
Anders heb ik geen mogelijkheid.
Het juiste type sensor : Hall sensor TLE4905L.
In mijn handboek Arduino programmeren van Elector staat echter dat INPUT-PULLUP niet mag gebruikt worden met Attachinterrupt (uitzonderlijk geval).
Groeten.
Ludo.
Effe snel gekeken.
Dus deze sensor : https://cdn-reichelt.de/documents/datenblatt/B400/TLE49X5L.pdf
figure 6 - geeft de output versus de inductie.
a) je hebt het non-latching type , dus da's goed
b) de output is omgekeerd met de inductie. dus als de magneet in de buurt komt, gaat de output van de sensor LAAG. Is dat wat je verwacht met je programma en met het meten van de voltages?
>Kan dat met dezelfde kabel voor het uploaden van een programma op een laptop via usb?
jazeker, gewoon dezelfde kabel. En gewoon met het arduino programma dat je al gebruikt voor de compilatie.
>In mijn handboek Arduino programmeren van Elector staat echter dat INPUT-PULLUP niet mag gebruikt worden met Attachinterrupt (uitzonderlijk geval).
geen idee, maar je kan voor de veiligheid dan gewoon je eigen pullup weerstand gebruiken. Dat deed je toch al?
Is het mogelijk nu even het exactle stukje code wat je gebruikte voor de test? Want ik weet nu met al die versies niet meer welke je gebruikte.
Als je wil, kan ik je ook wat uitleg geven over de seriele monitor en hoe dat te gebruiken, het is ECHT handig hoor.
Maar da's makkelijker aan de telefoon - dus als je wil stuur me dan via PM je nummer en dan bellen we eens.
Volgens mij gaat dat veel makkelijker zijn dan naar ledjes te kijken
Patrick,
Mijn code :
const int led1=11;
const int led2=12;
const byte S1interrupt=2;
boolean sensor1=false;
unsigned long int gemtijd_a;
unsigned long basetime;
void setup() {
pinMode(led1,OUTPUT);
pinmode(led2,OUTPUT);
attachInterrupt(digitalPinToInterrupt(S1interrupt),tijd_a,FALLING);
pinMode(S1interrupt,INPUT);
}
void loop(){
if(sensor==true){
if(millis()-basetime>=5000){
basetime=millis();
if(sensor1==true){
digitalWrite(led1,LOW);
}
if(gemtijd_a>0){
digitalWrite(led2,LOW);
}
sensor1=false;
}
}
}
void tijd_a() {
sensor1=true;
gemtijd_a=millis();
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
}
Voor alle duidelijkheid :
Geen magneet over sensor, signaal input hoog. Wel magneet over sensor, signaal input laag.
Signaal blijft maar ongeveer 1 sec laag (rijdende trein).
Vermits mijn input signaal hoog is, gebruik ik een PULL-DOWN weerstand anders is de ingang zwevend als de magneet
de sensor bediend.
Hetgeen ik wil bereiken is de tijd die verloopt tussen het bedienen van de twee sensoren.
Met deze test wil ik zien of een interrupt werkt, alvorens het volledige programma te schrijven.
Groeten.
Ludo.
Heb je al eens nagedacht over hoe de signalen van uw Hall-sensoren moeten aangeboden worden aan de Arduino?
Ik heb de indruk dat je wilt werken met niveau's (hoog of laag), waar het aangewezen is om flanken (edges) te gebruiken.
Mvg, Erik.
Erik,
In mijn handboek staan vier mogelijkheden vermeld.(LOW,CHANGE,RISING en FALLING)
Ik dacht dat de neergaande flank het meest aangewezen was.
Verder rijkt mijn kennis niet.
Groeten.
Ludo.
Die neergaande flank moet dan wel snel genoeg zijn. Ik denk dat dit met Hall's niet het geval is. Je kunt dat oplossen door er een Schmitt-trigger achter te plaatsen. Dat is nog even studeren.
Mvg, Erik.
>Vermits mijn input signaal hoog is, gebruik ik een PULL-DOWN weerstand anders is de ingang zwevend als de magneet
ik denk dat dit goed fout zit. Figuur 3 in de datasheet https://cdn-reichelt.de/documents/datenblatt/B400/TLE49X5L.pdf toont dat je echt wel een pullup weerstand nodig hebt. Anders ga je de uitgang continue naar de massa trekken, ongeacht wat de sensor wil doen.
De sensor is eigenlijk een schakelaar die aan gaat tussen de grond en de Q uitgang als er een magneet tegen zit (en nog wel de juiste kant). Dus je trekt als het ware de uitgang naar beneden ALS er een magneet in de buurt is. Als er geen is, wil je de Q uitgang (die dan zweeft) gewoon hoog houden - dus PULL UP.
ivm FALLING or RISING.
Als de magneet over de sensor gaat, gaat de spanning eerst vallen en daarna terug omhoog. Het maakt dus niet erg veel uit welke je kiest maar FALLING lijkt het meest logische (de snelste respons ook)
Ps - in alle eerlijkheid ik heb die dingen nog nooit gebruikt maar probeer de datasheet te begrijpen
Het hele LED gebeuren verwart me nog steeds, maar ik geef je anders morgen even een belletje en dan spreken we wel eens over hoe de seriele monitor van de arduino te gebruiken
Citaat van: bumper op 14 januari 2024, 22:15:38 PMPatrick Smout, dit is getest volgens uw eerste code.
Dag Ludo, ik sluit me aan bij de bevinding van Perk dat het een pullup moet zijn. Na die aanpassing het geheel nog eens ff testen.
Beste allemaal,
Toch even wat nieuwe resultaten.
Ik was fout met de output van de sensor.
Het moet zijn : geen magneet boven de sensor dan is de output van de sensor laag (0V).
wel een magneet boven de sensor dan is de output van de sensor hoog (4.5V).
Als de sensor bediend wordt en snel terug niet bediend (rijdende trein), beginnen beide leds te branden wat wil zeggen dat de interrupt gewerkt heeft. Na ongeveer 5 sec gaan beide leds uit dit wil zeggen dat de sensor bediend is en dat de tijd gemeten is en de waarde groter dan 0.
Maar als de sensor traag bediend wordt (meer dan 5 sec), dan gaan de twee leds uit nog voor de magneet van de sensor is en gaan opnieuw aan als de magneet weg is en gaan na +/-5sec weer uit. De interrupt wordt dus twee maal getriggerd. Dat moet dus opgelost worden.
Ook het opstarten is een probleem. Als de 5V van de sensors aan is alvorens de arduino spanning krijgt werkt het normaal. Als de spanning van de arduino op is voor de 5v van de sensoren wordt de interrupt getriggerd ongeacht de sensor bediend is of niet. Daar moet in het programma rekening mee gehouden worden.
Blijkbaar is de manier van triggeren met dalende of opgaande flank altijd van toepassing. Dat zal dus een andere manier moeten worden.
Ik heb nog wat info bijeengezocht en getracht met een NE555 timer een schmitt-trigger te maken, maar dat is niet gelukt. Ik zal een ander schema moeten opzoeken.
In ieder geval het interrupt programma werkt eindelijk, en mits wat aanpassingen kan dit dienen.
Nu verder proberen met twee sensoren en de tijd berekenen.
Groeten.
Ludo.
Dag Ludo,
Mooi zo!
Welk programma gebruik je momenteel? Hoe staat de triggering ingesteld?
Kijk ook eens naar mijn voorbeeld van 11 januari 22:19 (snelheidsmeting).
In dit voorbeeld zit een vergrendelmechanisme in dat, als het werkt zoals bedacht ;) , voorkomt dat een sensor dubbel gezien wordt. Na sensor1 moet sensor2 volgen en vervolgens terug sensor1. Zoals het nu in die code is werkt het enkel voor 1-richting verkeer. Beide richtingen kan ook mits een uitbreiding van de code.
ah, er komt schot in de zaak zie ik . Mooi zo.
Ik ben er nog niet aan toe geraakt om zelf aan de slag te gaan met dit progje.
Momenteel aan een ander Arduino project bezig dat tegen zaterdag helemaal af moet
Beste allemaal,
Het voorbije weekend nog wat kunnen prutsen en resultaat gehad.
Wat heb zoal gedaan.
1) op de datasheet staat een klein stukje elektronica achter de sensor. Op een stukje strokenprint voor 2 sensoren toegepast. Wat daar de reden er voor is en wat het doet weet ik niet, maar ik heb het toch maar toegepast.
2) Heb een externe pull-upp van 10kohm gebruikt.
3) Programma wat aangepast aan de hand van de gegeven info en het trager laten werken zodat de leds beter zichtbaar worden. Ps een monitor heb ik niet. Enkel een laptop, maar ik weet niet of dat daar mee gaat. Dus vandaar nog steeds de leds. Achteraf gaan die dus uit het programma, want dan zijn die niet meer nodig.
4) Na wat tegenvallende resultaten, de triggering op RISING gezet, en dat werkt prima.
De interrupt wordt telkens goed gezien en de variabelen die worden juist gezet.
Dus ik ga nog verder testen om te kijken of de verschillende bedrijfsmogelijkheden een goed en betrouwbaar resultaat opleveren. (bijvoorbeeld bij zeer traag of zeer snel rijdende treinen enz.)
Bedankt om mee te helpen zoeken om resultaat te krijgen.
Het verder verloop laat ik wel weten.
Groeten.
Ludo.
Om dit draadje af te sluiten. Met 4 hall sensoren in de baan en 4 interrupt routines in mijn arduino Mega ben ik tot een goed resultaat gekomen. Bij rood stopt de trein, ongeacht zijn snelheid steeds op dezelfde plaats voor het rode licht. Als het sein op groen gezet wordt, trekt de trein langzaam op en als de loc 1,5 maal zijn lengte voorbij het sein is wordt dit automatisch op rood gezet. Zo ook bij groen en twee geel, maar dan stopt de loc uiteraard niet. Bevredigend resultaat, op een analoge baan, dat veel weg heeft van de realiteit bij het grootspoor.
Bij deze bedankt aan diegenen die mij op weg geholpen hebben.
Ludo.