Goedemorgen allen,
voor verlichting van aanhangers wil ik een tester maken die automatische de verlichting een voor een aanstuurt. dit heb ik wel werkend, alleen wil ik wanneer ik de schakelaar uit zet, dat de loop direct stopt. Ik krijg dit alleen niet voor elkaar( ben niet goed met het programmeren van arduino), zullen jullie mij hiermee kunnen helpen?
dit is wat ik nu heb:
const int AUTO = 5;
const int HAND = 6;
const int lamp1 = 7; // knipperlicht links
const int lamp2 = 8; // knipperlicht rechts
const int lamp3 = 9; // mist lamp
const int lamp4 = 10; // achter verlichting links
const int lamp5 = 11; // achter verlichting rechts
const int lamp6 = 12; // rem verlichting
void setup() {
// put your setup code here, to run once:
pinMode(AUTO,INPUT);
pinMode(HAND,INPUT);
pinMode(lamp1, OUTPUT);
pinMode(lamp2, OUTPUT);
pinMode(lamp3, OUTPUT);
pinMode(lamp4, OUTPUT);
pinMode(lamp5, OUTPUT);
pinMode(lamp6, OUTPUT);
}
int StartAUTO = 0;
int StartHAND = 0;
void loop() {
// put your main code here, to run repeatedly:
StartAUTO = digitalRead(AUTO);
if(StartAUTO==HIGH)
{
for (byte teller = 7; teller <=12; teller++)
{
digitalWrite(teller, HIGH);
delay(3000);
digitalWrite(teller,LOW);
delay(30);
}
}
}
Wanneer ik de schakelaar omzet stopt het programma na het aflopen van alle lampen, maar ik wil eigenlijk dat wanneer ik de schakelaar omzet, hij direct stopt met het aflopen van alle lampen.
Hoop dat het een beetje duidelijk is,
Alvast bedankt!
[Bericht gewijzigd door Henry S. op (0%)]
ik zou zoiets doen, ik weet echter niet wat je met de HAND input wilt doen.
In onderstaande code gaat hij dus continu de lampen aanzetten, enkel als die auto input hoog is wordt de teller automatisch verhoogd, is hij laag dan blijft de desbetreffende lamp geselecteerd.
hij start nu wel direct na het aanzetten van de spanning. Weet niet exact wat je voor ogen had met de inputs.
Heb het niet getest, maar zoiets zou wel moeten doen wat je wilt ongeveer
const int AUTO = 5;
const int HAND = 6;
const int lamp1 = 7; // knipperlicht links
const int lamp2 = 8; // knipperlicht rechts
const int lamp3 = 9; // mist lamp
const int lamp4 = 10; // achter verlichting links
const int lamp5 = 11; // achter verlichting rechts
const int lamp6 = 12; // rem verlichting
void setup() {
// put your setup code here, to run once:
pinMode(AUTO,INPUT);
pinMode(HAND,INPUT);
pinMode(lamp1, OUTPUT);
pinMode(lamp2, OUTPUT);
pinMode(lamp3, OUTPUT);
pinMode(lamp4, OUTPUT);
pinMode(lamp5, OUTPUT);
pinMode(lamp6, OUTPUT);
}
int StartAUTO = 0;
int StartHAND = 0;
void loop() {
// put your main code here, to run repeatedly:
StartAUTO = digitalRead(AUTO);
if (StartAUTO == HIGH) {
if (teller < 12) {
teller++;
} else {
teller = 7;
}
digitalWrite(teller, HIGH);
delay(2900);
digitalWrite(teller, LOW);
delay(30);
} else {
digitalWrite(teller, HIGH);
}
delay(100);
}buckfast_beekeeper
Van Lambiek wordt goede geuze gemaakt.
Met deze opzet kijk je alleen dat elke lamp afzonderlijk werkt. Zodra er meerdere gelijktijdig aan zijn en er knipperlichten worden gebruikt, dan pas zie je dat alles OK is, ook je massa.
Achteruitrijlicht is verplicht voor alle aanhangwagens >750kg in het verkeer gebracht na 31/12/2012. Zeker niet fout om dat mee te nemen.
ps: int is 2 byte. uint8_t, int8_t of byte is voldoende. Hier zal het niet zoveel uitmaken wat grootte betreft. Bij een groter programma kan het een degelijk verschil maken.
Bijna goed:
- teller is niet gedeclareerd.
- hij stopt pas als de lamp die aan is zijn volle tijd aan heeft gestaan. Misschien geen probleem.
- Uit-tijd tussen lampen is nu 130 mS ipv 30. (30 + 100)
Op dinsdag 8 oktober 2024 10:45:52 schreef buckfast_beekeeper:
Met deze opzet kijk je alleen dat elke lamp afzonderlijk werkt. Zodra er meerdere gelijktijdig aan zijn en er knipperlichten worden gebruikt, dan pas zie je dat alles OK is, ook je massa.Achteruitrijlicht is verplicht voor alle aanhangwagens >750kg in het verkeer gebracht na 31/12/2012. Zeker niet fout om dat mee te nemen.
ps: int is 2 byte. uint8_t, int8_t of byte is voldoende. Hier zal het niet zoveel uitmaken wat grootte betreft. Bij een groter programma kan het een degelijk verschil maken.
Klopt daarvoor is het automatische bedrijf ook(echt alleen kijken of de lamp zelf niet defect is, er komt ook een handmatige functie op om alles handmatig aan te zetten.
Op dinsdag 8 oktober 2024 10:09:02 schreef Stijnos:
ik zou zoiets doen, ik weet echter niet wat je met de HAND input wilt doen.In onderstaande code gaat hij dus continu de lampen aanzetten, enkel als die auto input hoog is wordt de teller automatisch verhoogd, is hij laag dan blijft de desbetreffende lamp geselecteerd.
hij start nu wel direct na het aanzetten van de spanning. Weet niet exact wat je voor ogen had met de inputs.
Heb het niet getest, maar zoiets zou wel moeten doen wat je wilt ongeveer
const int AUTO = 5; const int HAND = 6; const int lamp1 = 7; // knipperlicht links const int lamp2 = 8; // knipperlicht rechts const int lamp3 = 9; // mist lamp const int lamp4 = 10; // achter verlichting links const int lamp5 = 11; // achter verlichting rechts const int lamp6 = 12; // rem verlichting void setup() { // put your setup code here, to run once: pinMode(AUTO,INPUT); pinMode(HAND,INPUT); pinMode(lamp1, OUTPUT); pinMode(lamp2, OUTPUT); pinMode(lamp3, OUTPUT); pinMode(lamp4, OUTPUT); pinMode(lamp5, OUTPUT); pinMode(lamp6, OUTPUT); } int StartAUTO = 0; int StartHAND = 0; void loop() { // put your main code here, to run repeatedly: StartAUTO = digitalRead(AUTO); if (StartAUTO == HIGH) { if (teller < 12) { teller++; } else { teller = 7; } digitalWrite(teller, HIGH); delay(2900); digitalWrite(teller, LOW); delay(30); } else { digitalWrite(teller, HIGH); } delay(100); }
Handmatig word nu nog niet gebruikt, wellicht later nog. Ik zal eigenlijk wel willen dat wanneer je hem uit/aan zet, dat hij weer bij lamp 1 begint. weet niet of dat mogelijk is
Je moet dan tijdens het doorlopen met het tellertje de schakelaar blijven uitlezen.
const int AUTO = 5;
const int HAND = 6;
const int lamp1 = 7; // knipperlicht links
const int lamp2 = 8; // knipperlicht rechts
const int lamp3 = 9; // mist lamp
const int lamp4 = 10; // achter verlichting links
const int lamp5 = 11; // achter verlichting rechts
const int lamp6 = 12; // rem verlichting
void setup() {
// put your setup code here, to run once:
pinMode(AUTO,INPUT);
pinMode(HAND,INPUT);
pinMode(lamp1, OUTPUT);
pinMode(lamp2, OUTPUT);
pinMode(lamp3, OUTPUT);
pinMode(lamp4, OUTPUT);
pinMode(lamp5, OUTPUT);
pinMode(lamp6, OUTPUT);
}
int StartAUTO = 0;
int StartHAND = 0;
void loop() {
for (byte teller = 7; teller <=12; teller++)
{
StartAUTO = digitalRead(AUTO);
if(StartAUTO==LOW) { break; } // exit the for 'teller' loop
digitalWrite(teller, HIGH);
delay(3000);
digitalWrite(teller,LOW);
delay(30);
}
}
Als je ook van de 3 seconden delay af wil kan het nog iets geavanceerder gedaan:
const int AUTO = 5;
const int HAND = 6;
const int lamp1 = 7; // knipperlicht links
const int lamp2 = 8; // knipperlicht rechts
const int lamp3 = 9; // mist lamp
const int lamp4 = 10; // achter verlichting links
const int lamp5 = 11; // achter verlichting rechts
const int lamp6 = 12; // rem verlichting
void setup() {
// put your setup code here, to run once:
pinMode(AUTO,INPUT);
pinMode(HAND,INPUT);
pinMode(lamp1, OUTPUT);
pinMode(lamp2, OUTPUT);
pinMode(lamp3, OUTPUT);
pinMode(lamp4, OUTPUT);
pinMode(lamp5, OUTPUT);
pinMode(lamp6, OUTPUT);
}
int StartAUTO = 0;
int StartHAND = 0;
void loop() {
for (byte teller = 7; teller <=12; teller++)
{
digitalWrite(teller, HIGH);
for (byte delayCounter = 1; delayCounter <=10; delayCounter++){
delay(300); //smaller delay will be done 10 times.
StartAUTO = digitalRead(AUTO);
if(StartAUTO==LOW) {
digitalWrite(teller,LOW);
teller=99; // we want to stop the teller, so put it >12.
break; // exit the for 'delayCounter' loop right away
}
} //end delayCounter loop
if (teller!=99) { digitalWrite(teller,LOW); } //small protection to not set 99 low
delay(30);
}
}
SparkyGSX
Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken
Wat een rare constructie, een loop variabele out-of-range zetten, en het netto effect is dat de for-loop wordt afgebroken, je uit de functie loop() stapt, die natuurlijk weer meteen begint, dus hij stopt niet eens, hij blijft alleen resetten zolang die ingang laag is. De "break" voegt niets toe, en persoonlijk vind ik dat sowieso een hele vieze constructie, naderend naar een goto.
ik vind loops breaken ook niet echt netjes, maar laten we die discussie vermijden.
Ik was inderdaad vergeten de teller te declareren.
Ik heb een en ander aangepast.
Ik heb gewoon een functie gemaakt die 1 lamp aanzet en vooraf automatisch de rest eerst uitzet. Dat voorkomt gedoe in volgorde en bijhouden welke je nu eerst uitmoet zetten voor je ene andere aanzet.
Ik heb ook getracht om als de AUTO knop niet aan staat je met 1 enkele druk op de hand knop ook 1 stap verder gaat.
Alles is maar even ingeklopt op best guess, heb hier geen arduino omgeving geinstalleerd staan. Weet ook niet zeker of arduino functie prtotypes verwacht en functies static mogen / kunnen zijn.
uiteraard kan het allemaal netter, maar het is maar om je op weg te helpen
de 30ms delay na uitschakelen heb ik weggelaten. Is denk ik nergens voor nodig.
Het gebruik van dit soort delays (en zeker van 3 sec) is echt vies, maar soms in arduino wel lekker makkelijk als je programmaatje verder toch niks hoeft te doen.
const int AUTO = 5;
const int HAND = 6;
const int lamp1 = 7; // knipperlicht links
const int lamp2 = 8; // knipperlicht rechts
const int lamp3 = 9; // mist lamp
const int lamp4 = 10; // achter verlichting links
const int lamp5 = 11; // achter verlichting rechts
const int lamp6 = 12; // rem verlichting
int teller = 7; //na powerup begint hij weer bij lamp 7
bool handSwitchWasLow = false;
int StartAUTO = 0;
int StartHAND = 0;
static void SwitchOnSingleLamp(int lampIndex);
void setup() {
// put your setup code here, to run once:
pinMode(AUTO,INPUT);
pinMode(HAND,INPUT);
pinMode(lamp1, OUTPUT);
pinMode(lamp2, OUTPUT);
pinMode(lamp3, OUTPUT);
pinMode(lamp4, OUTPUT);
pinMode(lamp5, OUTPUT);
pinMode(lamp6, OUTPUT);
SwitchOnSingleLamp(teller);
}
void loop() {
// put your main code here, to run repeatedly:
StartAUTO = digitalRead(AUTO);
StartHAND = digitalRead(HAND);
if (StartAUTO == HIGH) {
if (teller < 12) {
teller++;
} else {
teller = 7;
}
SwitchOnSingleLamp(teller);
delay(2900);
} else {
if (StartHAND == HIGH) {
//we willen enkel 1x ophogen per druk op de knop, eerst loslaten en weer indrukken voor volgende lamp
if (handSwitchWasLow) {
digitalWrite(teller, LOW);
if (teller < 12) {
teller++;
} else {
teller = 7;
}
SwitchOnSingleLamp(teller);
}
handSwitchWasLow = false;
} else {
handSwitchWasLow = true;
}
}
delay(100);
}
static void SwitchOnSingleLamp(int lampIndex) {
//eerst alles uit
digitalWrite(lamp1, LOW);
digitalWrite(lamp2, LOW);
digitalWrite(lamp3, LOW);
digitalWrite(lamp4, LOW);
digitalWrite(lamp5, LOW);
digitalWrite(lamp6, LOW);
//nu de gewenste aan
if ((lampIndex >= 7) && (lampIndex <= 12)) {
digitalWrite(lampIndex, HIGH);
}
}Op dinsdag 8 oktober 2024 13:14:15 schreef SparkyGSX:
Wat een rare constructie, een loop variabele out-of-range zetten, en het netto effect is dat de for-loop wordt afgebroken, je uit de functie loop() stapt, die natuurlijk weer meteen begint, dus hij stopt niet eens, hij blijft alleen resetten zolang die ingang laag is. De "break" voegt niets toe, en persoonlijk vind ik dat sowieso een hele vieze constructie, naderend naar een goto.
Raar en heel vies, dankje. Heb je geleerd je kritiek te uiten op de lomperikenschool?
@stijnos, dankje voor je nette kritiek 
Ik deed het niet 'op netheid'. Ik vind 4 geneste if statements, zeker in een else, ook niet ideaal.
Weet ook niet zeker of arduino functie prtotypes verwacht en functies static mogen / kunnen zijn.
De arduino IDE heeft een ingebouwde preprocessor. Die genereert automatisch alle prototypes, zonder dat je die ooit te zien krijgt. Die worden dan wel naar de compiler gestuurd zodat je je geen zorgen hoeft te maken over forward references.
En static funkties kan wel, mag ook, maar heeft weinig nut omdat alles toch in een enkele sketch zit.
klopt, de knop detectie moet je ook gewoon apart afhandelen in een separate functie, maar dit was even een snel brouwsel, laten we het voor de TS niet te ingewikkeld maken
Allemaal bedankt voor jullie input, word zeer gewaardeerd!
ga vanavond even de 3D printer aan zetten voor een mooi bedien panel, en eind van de week alles solderen!
ik zal van mij laten horen wanneer alles gereed is.
nogmaals bedankt
SparkyGSX
Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken
K7Jz: laten we de nieuwelingen vooral geen slechte gewoontes aanleren. Als je niet tegen kritiek kan, moet je misschien ook geen code posten die overduidelijk niet gaat werken.
Nu ik nog iets beter kijk, je doet ook niets met "HAND" en "StartHAND", en er bestaat geen datatype "byte" in C.
De definities van de output pinnen aan het begin suggereert dat je die kunt aanpassen, maar dat werkt natuurlijk niet als de loop van 7 t/m 12 loopt. Ik zou daar een array van maken:
const unsigned char Lamps[ 6 ] = { 7, 8, 9, 10, 11, 12 };
en die met een loop van 0 t/m 5 indexeren. Op die manier kun je ook de volgorde aanpassen zonder de hardware te veranderen.
@Brian, let even goed op hoe je je buttons aan sluit.
jij controleerd of ze hoog zijn.
Doorgaans is het gebruikelijker om ze een pull up te geven of zelfs de arduino gewoon input met pull up configureren en dan schakeld je knop naar ground.
Je moet dan in je code wel kijken of ze LOW zijn, dan zijn ze ingedrukt
Roland van Leusden
It's the rule that you live by and die for It's the one thing you can't deny Even though you don't know what the price is. It is justified.
Ik mis een detectie van kortsluitingen / open verbindingen, kun je prima met een ACS712 5A bordje doen.
SparkyGSX
Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken
ik zou in ieder geval een flinke koplamp in serie zetten of zo, dan blijft de stroom beperkt bij een kortsluiting, als je naar een ACS712 moet kijken voor een kortsluiting ben je waarschijnlijk al te laat.
Op dinsdag 8 oktober 2024 16:42:29 schreef SparkyGSX:
K7Jz: laten we de nieuwelingen vooral geen slechte gewoontes aanleren.
Daar ben ik het helemaal mee eens.
Beste manier om dat te doen is met "arduino" stoppen en C of C++ leren.
Om het netjes te doen moet je beginnen met een timer biepje schijven. Dat had eigenlijk al 15 jaar geleden in "arduino" moeten zitten, maar "arduino" is nooit een serieus platform geweest. Het is geschreven door een handje vol studenten in italie ooit, en er is nooit verbetering in struktuur aangebracht. Er wordt vooral code bij gebroddeld door andere beginners, en iedereen daar leert elkaar foute dingen aan.
Een simpel timer biepje kun je in C++ schijven in ongeveer 15 regels code.
Je kunt dan een "stopwatch" starten door een hardware timer uit te lezen (of "millies() in arduino taal) en die waarde in een variabele te onthouden. (in de class, het is C++ toch).
In een tweede funktie kun je dan een vertragingstijd uitrekenen door de start tijd af te trekken van de huidige timer waarde. Het is belangrijk om het verschil uit te rekenen door deze twee waarden van elkaar af te trekken. Je mag b.v. niet de "startwaarde" en de "delay" bij elkaar optellen voor de eind waarde en dan vergelijken, want dan gaat het fout als er een overflow van de timer is. Om die overflow problemen te omzijlen, MOET je het verschil uitrekenen, en de timer waarden moeten signed zijn. met unsigned werkt het ook niet goed.
Met zo een paar funkties kun je eenvoudig kijken waanneer een "stopwatch" / timer" voorbij z'n vertragings tijd is, en dan de stopwatch opnieuw starten en een bijbehorende andere aktie (een lamp schakelen ofzo) uit te voeren.
Je kunt dan zoveel timers maken als er in je RAM passen om de variabelen te onthouden, dus een paar honderd timers is geen probleem.
De main loop doet dan niets anders dan kijken of een van de timers is afgelopen, en als een timer is afgelopen, wordt de bijbehorende code uitgevoerd.
Je kunt de timers zelfs in een array zetten en dan de array doorlopen.
De main loop is op die manier zeer overzichtelijk en gemakkelijk te begrijpen, en het is onafhankelijk van de hoeveelheid timers er zijn, of hoe komplex de code achter die timers is. Voor de main loop is het gewoon een funkie aanroep en hij bekommert zich er niet om wat er in die funktie gebeurt. Een van de belangrijkste beperkingen is dat die funktie snel weer terugkeert. Dus geen software delays gebruiken in die funkties. Verder kunnen zulke funkties b.v. een hele statemachine bevatten, die bij elke aanroep kijkt of er iets gedaan moet worden, of naar een andere state sprigt. Zo kun je heel complexe dingen doen die onafhankelijk van elkaar werken, en zonder dat je zelf het overzicht verliest.
Bovenstaand is al 50 jaar geleden ofzo uitgevogeld en min of meer gestandaardizeerd. Het is gewoon triest dat beginners met arduino nog steeds wordt aangeleed om delay() te gebruiken.
En ik bedoel echt 50 jaar. De oude mainframes van voordat C bestond werkten al met ongeveer zulke code. Het is echt het eerste beginsel van "time slicing" en "cooperative multitasking". En dat was een noodzaak voor de eerste computters, omdat die veel te duur waren om door een enkel persoon bezet te worden gehouden.
benleentje
Golden Member
Om het netjes te doen moet je beginnen met een timer biepje schijven.
Dat zit er ook in en dat heet millis(). millis() is een 32 bit counter die het aantal milliseconde bijhoud.
Beste manier om dat te doen is met "arduino" stoppen en C of C++ leren.
Arduino = C++
Maar wel met je eens om als je de arduino ide goed wilt begrijpen je dat eerst moet leren dat heb ik ook gedaan.
Het is gewoon triest dat beginners met arduino nog steeds wordt aangeleed om delay() te gebruiken.
Er zijn genoeg voorbeelden te vinden die iets met millis() doet. Degene die in delays blijven hangen hebben zelf niet de moeite gedaan om het beter te doen. Maar ik denk dat de meeste al blij zijn als ze het al werkend krijgen.
Dat het merendeel in de delays blijft hang of dat maar een klein deel over gaat naar millis() is gewoon het niveau verschil wat je ook bij werkende mensen ziet.
[Bericht gewijzigd door benleentje op (38%)]
SparkyGSX
Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken
Arduino is ook gewoon C, en ik vind het onzinnig om C++ te gebruiken op een dergelijke kleine target, de overhead van dynamisch memory management is daarbij erg groot.
Natuurlijk moeten ze leren om geen delay te gebruiken, want geen serieuze programmeur zal dat doen, maar ik vind het beter om ze eerst iets simpels te laten schrijven het delays, om vervolgens zelf te ontdekken waarom dat zo onhandig is. Je moet de eerste stapjes ook niet te moeilijk maken.
Je hebt gelijk dat veel Arduino libraries vol zitten met slechte code, die veelal duiken staat te draaien terwijl er iets gebeurd, maar dat is ook wel een beetje inherent aan zo'n kleine target met zo weinig hardware timers, libraries zouden elkaar al snel bijten omdat ze dezelfde hardware proberen te gebruiken, als daar geen laagje tussen zit.
Op die oude 8-bitters heb je ook geen DMA, waardoor SPI, I2C, UART, LCD aansturing etc. veel interventie van de CPU vereisen. Vaak is de tijd daartussen zo kort dat de overhead van interrupts alweer een significant van de CPU tijd opvreet.
ik gebruik zelf zelden arduino en al helemaal niet op professioneel vlak, daar vind ik de IDE veel te beperkt voor en is het lastig om structuur aan te brengen.
Ik moet wel zeggen dat als ik echt snel iets simpels wil maken,waarbij netheid minder belangrijk is dat het snel werkt ik wel neid naar een arduino. Je hebt die printjes zo voor een habbekrats voorhanden en binnen no time heb je van alles wel werkend.
Ik heb 1x een wel veel groter project voor iemand gedaan wat met arduino compileerde. Ik had daarvoor wel een visual studio plugin, waarmee ik kon debuggen en echt wel gewoon structuur in source files kon maken. HEt was eigenlijk gewoon een project zoals ik he tin C zou maken, maar wilde gewoon gebruik kunnen maken van allerhande arduino libraries om met een REST api te kunnen babbelen over een netwerk interface en om een wieland kaartlezer uit te lezen etc.
Als ikd at allemaal zelf had moeten uitvogelen en ontwikkelen, was het project verre van rendabel geweest.
Helemaal eens dat er veel mensen bral maken met arduino, maar van de andere kant maakt het voor veel mensen met technische interesse mogelijk om toch iets simpel te kunnen programmeren. En zoals Sparky inderdaad aangeeft. Ze leren bij enige serieuze interesse van zelf de valkuilen en verbeteren zich zelf indien mogelijk. Ik denk dat als er zoiets niet was dat de drempel om iets met microcontrollers te gaan doen gewoon veel te hoog is, want waar moet je beginnen.
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Toetsen altijd monitoren in de interrupt routine, dan is de reactie altijd direct...
Op dinsdag 8 oktober 2024 16:42:29 schreef SparkyGSX:
K7Jz: laten we de nieuwelingen vooral geen slechte gewoontes aanleren. Als je niet tegen kritiek kan, moet je misschien ook geen code posten die overduidelijk niet gaat werken.
...
Het is me helemaal duidelijk, nu ik er goed over heb nagedacht zie ik helemaal in wat je bedoelt. Jouw manier is echt de beste manier, dankje dat je het zo duidelijk, helder en direct communiceert. 
Op dinsdag 8 oktober 2024 23:51:47 schreef Arco:
Toetsen altijd monitoren in de interrupt routine, dan is de reactie altijd direct...
Als je een toets op een 10 a 50ms polt dan is je reactietijd voor je gevoel nog direct. Ik vind het probleem met op interrupt basis (pin change of int) vaak de debouncing. Debouncing op basis van tijd vind ik persoonlijk altijd wat makkelijker
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
ALs je iedere mS een interrupt hebt, kun je simpel een tellertje bijhouden voor een toets.
Als je een minimale toetsdruk van 50mS wilt dan verhoog je bij ingedrukte toets het tellertje tot 'ie op 50 komt en zet dan een flag 'toets ingedrukt.
Bij niet ingedrukte toets zet je het tellertje weer terug op 0 en reset de flag.
Voordeel is dat je zo ook makkelijk repeterende toetsen (à la pc keyboard) kunt afhandelen.