Basis · 11 min leestijd

Arduino millis() vs delay(): timing zonder je code te blokkeren

Leer Arduino millis() gebruiken: waarom delay() je sketch bevriest, blink without delay, meerdere taken tegelijk, timing die 49 dagen overleeft, micros(), ESP32 en Pico.

De Arduino-functie millis() geeft de tijd sinds het board is gaan draaien terug, in milliseconden, en is de standaardmanier om dingen te timen zonder delay(). Als je delay(1000) schrijft, doet de Arduino een hele seconde niets anders: een druk op de knop blijft onopgemerkt, sensoren worden niet uitgelezen en het display wordt niet bijgewerkt. Met millis() vraag je in plaats daarvan: "hoeveel tijd is er verstreken sinds de laatste taak?" Je voert de taken uit die aan de beurt zijn, slaat de andere over en loop() stopt nooit. Zo kan één Arduino tegelijk LED's laten knipperen, knoppen uitlezen, sensoren meten en meldingen naar de seriële poort sturen.

In deze gids leer je waarom delay() je programma vastzet, het beroemde voorbeeld blink without delay, hoe je meerdere taken tegelijk laat draaien, hoe je veilig de overflow overleeft die na 49,7 dagen optreedt, de functie micros() die microseconden telt en herbruikbare timerpatronen. In de laatste delen zie je hoe dezelfde logica wordt geschreven op de ESP32 en op de Raspberry Pi Pico (MicroPython).

Arduino Uno-board met de ingebouwde L-led
Arduino Uno: dankzij de ingebouwde "L"-led op pin 13 heb je geen extra onderdelen nodig om millis() uit te proberen.

Wat is delay() en waarom stopt het je programma?

delay(ms) houdt de processor in een lus draaiende tot de opgegeven tijd voorbij is. In die tijd wordt de volgende regel in loop() niet bereikt; dit heet een blokkerende wachttijd. Voor één knipperende LED is dat prima, maar de problemen beginnen zodra je een knop aan het project toevoegt. De onderstaande code laat een LED één keer per seconde knipperen en controleert ook of een knop is ingedrukt:

C++ (Arduino IDE)
1const int LED_PIN = 13;                   // dahili LED / built-in LED
2const int BUTON_PIN = 2;                  // buton, diğer ucu GND / button, other leg to GND
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6  pinMode(BUTON_PIN, INPUT_PULLUP);
7  Serial.begin(9600);
8}
9
10void loop() {
11  digitalWrite(LED_PIN, HIGH);
12  delay(1000);                            // 1 sn bekle, buton okunmaz / wait 1 s, button is not read
13  digitalWrite(LED_PIN, LOW);
14  delay(1000);
15  if (digitalRead(BUTON_PIN) == LOW) {    // 2 saniyede bir bakılır / checked once every 2 s
16    Serial.println(F("Butona basildi / Button pressed"));
17  }
18}

In deze code wordt de knop maar eens in de twee seconden opgemerkt, en alleen als hij net op dat moment wordt vastgehouden; een korte druk gaat verloren tussen de twee delay()-aanroepen. Interrupts blijven wel werken tijdens delay(): millis() blijft tellen en bytes die binnenkomen op de seriële poort worden opgeslagen in de buffer van 64 bytes. Maar je code wacht. Naarmate je een display, sensoren en een buzzer toevoegt, houdt elke delay() al het andere werk op en voelt het apparaat traag aan. De oplossing is stoppen met wachten en beginnen met tijd meten.

Wat is millis() en hoe werkt het?

millis() geeft het aantal milliseconden sinds het board werd ingeschakeld of gereset terug, als unsigned long (32 bits, zonder teken). Op de Arduino Uno wordt deze teller op de achtergrond bijgewerkt door de overflow-interrupt van de hardwaretimer Timer0. Bij 16 MHz loopt Timer0 elke 1,024 ms over; de core-code verzamelt de extra 0,024 ms en verhoogt de teller ongeveer elke 43 ms met 2 in plaats van 1. millis() slaat dus sommige waarden helemaal over, en daarom zijn gelijkheidscontroles zoals millis() == 5000 onbetrouwbaar; gebruik altijd >=. Houd er ook rekening mee dat millis() niet doortelt zolang interrupts zijn uitgeschakeld (bijvoorbeeld binnen een interruptroutine).

FunctieWat het doetResolutie (Uno, 16 MHz)Loopt over naBlokkeert het programma?
delay(ms)Wacht het opgegeven aantal milliseconden1 ms-Ja
delayMicroseconds(us)Korte wachttijd (nauwkeurig van 3 tot 16383 µs)Ongeveer 1 µs-Ja
millis()Milliseconden sinds het opstarten1 ms (soms een stap van 2)Ongeveer 49,7 dagenNee
micros()Microseconden sinds het opstarten4 µsOngeveer 71,6 minutenNee
  1. Maak een unsigned long-variabele om te onthouden wanneer de taak voor het laatst is uitgevoerd (oncekiZaman).
  2. Lees bij elke doorloop van loop() de huidige tijd uit met millis().
  3. Controleer met de voorwaarde simdi - oncekiZaman >= ARALIK of er genoeg tijd is verstreken.
  4. Is de tijd om, voer dan de taak uit (de LED omschakelen) en werk oncekiZaman bij.
  5. Is de tijd nog niet om, doe dan niets en laat loop() doorlopen; precies dan worden je andere taken uitgevoerd.
C++ (Arduino IDE)
1const int LED_PIN = LED_BUILTIN;          // Uno'da 13 / pin 13 on the Uno
2const unsigned long ARALIK = 500;         // yanıp sönme aralığı (ms) / blink interval (ms)
3
4unsigned long oncekiZaman = 0;            // son değişim anı / time of the last toggle
5bool ledDurumu = false;
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);
9}
10
11void loop() {
12  unsigned long simdi = millis();         // şu anki zaman / current time
13  if (simdi - oncekiZaman >= ARALIK) {    // taşmaya karşı güvenli / overflow-safe
14    oncekiZaman += ARALIK;                // kaymayı önler / prevents drift
15    ledDurumu = !ledDurumu;
16    digitalWrite(LED_PIN, ledDurumu);
17  }
18  // burada başka işler beklemeden çalışır / other work runs here without waiting
19}

In de code schreven we oncekiZaman += ARALIK in plaats van oncekiZaman = simdi. Het verschil is klein maar belangrijk: als loop() soms een paar milliseconden te laat is, telt de eerste methode die vertraging telkens op en loopt de LED in de loop van de uren uit de pas, terwijl de tweede de doeltijd in vaste stappen vooruit schuift, zodat de gemiddelde periode precies 500 ms blijft. Gebruik += voor klokken, metronomen en regelmatige metingen. Als je programma lang geblokkeerd kan raken (bijvoorbeeld tijdens het wachten op Wi-Fi), probeert += de gemiste stappen achter elkaar in te halen; in dat geval is = simdi veiliger. Wil je ook de helderheid van de LED aanpassen zonder je code te stoppen, lees dan het artikel over PWM en analogWrite.

Meerdere dingen tegelijk doen: multitasking met millis()

De Arduino Uno heeft een processor met één kern en kan niet echt twee dingen tegelijk doen. Maar omdat loop() tienduizenden keren per seconde kan draaien, lijkt het van buiten "gelijktijdig" als je elke taak een paar microseconden geeft wanneer die aan de beurt is. Dit heet coöperatieve multitasking. De regel is simpel: elke taak heeft een eigen tijdvariabele en een eigen interval, en geen enkele taak wacht lang. In het onderstaande voorbeeld draaien vier taken naast elkaar:

C++ (Arduino IDE)
1const int KIRMIZI_LED = 8;                // 300 ms'de bir yanıp söner / blinks every 300 ms
2const int YESIL_LED = 9;                  // 1000 ms'de bir yanıp söner / blinks every 1000 ms
3const int SARI_LED = 10;                  // butonla açılıp kapanır / toggled by the button
4const int BUTON = 2;                      // diğer ucu GND / other leg to GND
5
6unsigned long kirmiziZaman = 0, yesilZaman = 0, butonZaman = 0, seriZaman = 0;
7bool kirmizi = false, yesil = false, sari = false;
8int sonOkuma = HIGH;                      // son ham okuma / last raw reading
9int kararliDurum = HIGH;                  // titreşimsiz durum / debounced state
10
11void setup() {
12  pinMode(KIRMIZI_LED, OUTPUT);
13  pinMode(YESIL_LED, OUTPUT);
14  pinMode(SARI_LED, OUTPUT);
15  pinMode(BUTON, INPUT_PULLUP);
16  Serial.begin(9600);
17}
18
19void loop() {
20  unsigned long simdi = millis();
21
22  // Görev 1: kırmızı LED / Task 1: red LED
23  if (simdi - kirmiziZaman >= 300) {
24    kirmiziZaman = simdi;
25    kirmizi = !kirmizi;
26    digitalWrite(KIRMIZI_LED, kirmizi);
27  }
28
29  // Görev 2: yeşil LED / Task 2: green LED
30  if (simdi - yesilZaman >= 1000) {
31    yesilZaman = simdi;
32    yesil = !yesil;
33    digitalWrite(YESIL_LED, yesil);
34  }
35
36  // Görev 3: 50 ms debounce ile buton / Task 3: button with 50 ms debounce
37  int okuma = digitalRead(BUTON);
38  if (okuma != sonOkuma) {                // değişti, sayacı yeniden başlat / changed, restart the timer
39    butonZaman = simdi;
40    sonOkuma = okuma;
41  }
42  if (simdi - butonZaman >= 50 && okuma != kararliDurum) {
43    kararliDurum = okuma;
44    if (kararliDurum == LOW) {            // basıldı / pressed
45      sari = !sari;
46      digitalWrite(SARI_LED, sari);
47    }
48  }
49
50  // Görev 4: saniyede bir seri rapor / Task 4: serial report once per second
51  if (simdi - seriZaman >= 1000) {
52    seriZaman = simdi;
53    Serial.print(F("Calisma suresi (s) / Uptime (s): "));
54    Serial.println(simdi / 1000);
55  }
56}
TaakPinIntervalWat het doet
Rode led8300 msKnippert snel
Groene led91000 msKnippert langzaam
Knop + gele led2 en 1050 ms debounceSchakelt de gele led om bij elke druk
Seriële melding-1000 msPrint de looptijd in seconden

De knoplogica is ook op millis() gebaseerd: elke keer dat de ruwe waarde verandert, start de timer opnieuw, en als de waarde 50 ms stabiel blijft, wordt de druk als echt geaccepteerd. Zo maakt het mechanische dender van de knop geen tientallen drukken van één druk, en wacht de code nooit. Voor details over het aansluiten van een knop en de interne pull-upweerstand, zie Hoe sluit je een knop aan op Arduino. Een weerstand van 220 Ω is genoeg voor de LED's; voor andere kleuren en stromen gebruik je de led-weerstandscalculator.

De overflow na 49,7 dagen en overflowveilige vergelijkingen

Een unsigned long kan maximaal 4.294.967.295 bevatten. Wanneer millis() dat getal bereikt, na ongeveer 49 dagen, 17 uur en 2 minuten, begint het weer vanaf 0 te tellen. Als je board weken aan blijft staan (kassenbesturing, een aquarium, een alarmsysteem), komt dat moment. Het goede nieuws: code die met aftrekken is geschreven, in de vorm simdi - onceki >= aralik, heeft geen last van de overflow. Aftrekken zonder teken gebeurt modulo 2 tot de macht 32. Als bijvoorbeeld onceki = 4.294.967.000 en na de overflow simdi = 200, geeft simdi - onceki geen negatief getal, maar het juiste resultaat: 496. Zolang het interval waarop je wacht korter is dan 49,7 dagen, werkt de vergelijking dus altijd.

CodeResultaatWaarom?
if (millis() - onceki >= aralik)GoedAftrekken zonder teken geeft ook over de overflow heen het juiste verschil
if (millis() >= onceki + aralik)FoutAls onceki + aralik overloopt, wordt het een klein getal en gaat de voorwaarde te vroeg af
if (millis() == hedef)Foutmillis() maakt soms een stap van 2, dus de exacte waarde komt misschien nooit voor
int onceki = millis();FoutOp de Uno is een int 16 bits en bevat die na 32,7 seconden verkeerde waarden
long onceki = millis();RiskantEen type met teken wordt negatief na 24,8 dagen; gebruik unsigned long om verwarring te voorkomen
Declareer tijdvariabelen nooit als int. Op de Arduino Uno is een int 16 bits en kan maximaal 32.767 bevatten, waardoor je programma vanaf de 33e seconde vreemd gaat doen. Elke variabele die met millis() of micros() werkt, moet een unsigned long (of uint32_t) zijn. Gebruik bij grote intervallen ook de vorm 60000UL: op de Uno overschrijdt een product als 60 * 1000 de intgrens en wordt het een negatief getal.

Microseconden meten met micros()

micros() werkt op dezelfde manier, maar geeft de microseconden sinds het opstarten terug. Op boards van 16 MHz zoals de Arduino Uno en Nano is de resolutie 4 µs (8 µs op boards van 8 MHz), en de teller loopt ongeveer elke 71,6 minuten over; de aftrekregel geldt ook hier. Het wordt gebruikt voor nauwkeurig werk, zoals meten hoe lang een stuk code duurt, korte pulsen timen of geluid maken. Het onderstaande voorbeeld meet twee keer per seconde hoe lang een analogRead()-aanroep duurt; op de Uno zie je ongeveer 110–120 µs:

C++ (Arduino IDE)
1unsigned long raporZaman = 0;
2
3void setup() {
4  Serial.begin(9600);
5}
6
7void loop() {
8  if (millis() - raporZaman >= 500) {         // yarım saniyede bir ölç / measure every half second
9    raporZaman = millis();
10    unsigned long basla = micros();           // başlangıç (µs) / start (µs)
11    int deger = analogRead(A0);
12    unsigned long sure = micros() - basla;    // geçen süre (µs) / elapsed time (µs)
13    Serial.print(F("A0 = "));
14    Serial.print(deger);
15    Serial.print(F("  sure / time: "));
16    Serial.print(sure);
17    Serial.println(F(" us"));
18  }
19}

Gebruik voor langere intervallen liever millis() dan micros(); een overflowperiode van 71 minuten is te kort voor lange wachttijden. delayMicroseconds() is alleen bedoeld voor korte, onvermijdelijke wachttijden van een paar microseconden, zoals het sturen van de triggerpuls van 10 µs naar de TRIG-pin van de HC-SR04-afstandssensor. Zulke korte wachttijden vertragen je andere taken niet merkbaar.

Timerpatronen: periodiek, eenmalig en toestandsmachine

  • Periodieke taak: een taak die met een vast interval wordt herhaald, zoals een knipperende LED, elke 2 seconden een sensor uitlezen of elke seconde een display verversen. Dit patroon heb je hierboven al gezien.
  • Eenmalige timer (timeout): draait één keer, een bepaalde tijd na een gebeurtenis. Een trapverlichting is een goed voorbeeld: zet het licht aan bij beweging, bewaar de tijd en zet het uit als er 30 seconden lang geen nieuwe beweging komt. Als je de tijd bij nieuwe beweging vernieuwt, wordt de periode verlengd.
  • Wachten met een timeout: als je wacht op een antwoord of signaal, stel je een bovengrens in zodat je nooit eeuwig vastzit; toon bijvoorbeeld een foutmelding als er binnen 2 seconden geen data binnenkomt.
  • Toestandsmachine: je bewaart de huidige stap van het apparaat in een variabele en gaat naar de volgende stap zodra de tijd van elke stap om is. Stoplichten, wasmachineprogramma's en gamelevels worden zo geschreven.
  • Lang-indrukdetectie: door met millis() te meten hoe lang een knop wordt ingedrukt, kun je korte en lange drukken verschillende taken geven.
C++ (Arduino IDE)
1// Yeniden kullanılabilir zamanlayıcı / Reusable timer
2struct Zamanlayici {
3  unsigned long baslangic = 0;
4  unsigned long sure = 0;
5
6  void kur(unsigned long ms) {              // süreyi şimdiden başlat / start the period from now
7    baslangic = millis();
8    sure = ms;
9  }
10  bool doldu() const {                      // süre doldu mu? / has it expired?
11    return millis() - baslangic >= sure;
12  }
13};
14
15const int KIRMIZI = 11, SARI = 12, YESIL = 13;
16enum Durum { DUR, HAZIRLAN, GEC, YAVASLA }; // trafik lambası adımları / traffic light states
17Durum durum = DUR;
18Zamanlayici isik;
19
20void lambalar(bool k, bool s, bool y) {
21  digitalWrite(KIRMIZI, k);
22  digitalWrite(SARI, s);
23  digitalWrite(YESIL, y);
24}
25
26void setup() {
27  pinMode(KIRMIZI, OUTPUT);
28  pinMode(SARI, OUTPUT);
29  pinMode(YESIL, OUTPUT);
30  lambalar(true, false, false);
31  isik.kur(5000);                           // kırmızı 5 sn / red for 5 s
32}
33
34void loop() {
35  if (isik.doldu()) {
36    switch (durum) {
37      case DUR:      durum = HAZIRLAN; lambalar(true, true, false);  isik.kur(1500); break;
38      case HAZIRLAN: durum = GEC;      lambalar(false, false, true); isik.kur(5000); break;
39      case GEC:      durum = YAVASLA;  lambalar(false, true, false); isik.kur(2000); break;
40      case YAVASLA:  durum = DUR;      lambalar(true, false, false); isik.kur(5000); break;
41    }
42  }
43  // loop serbest: buton, sensör, ekran... / loop stays free: buttons, sensors, display...
44}

In deze code maakt een kleine structuur (struct) met de naam Zamanlayici van het starten van een periode en het vragen of die verlopen is één enkele regel. Het stoplicht is een toestandsmachine met vier stappen: in elke stap worden de lampen ingesteld en wordt de tijd van de volgende overgang gestart. Omdat loop() nooit wacht, kun je makkelijk een voetgangersknop, een LDR-lichtsensor voor een nachtmodus of een display met de resterende tijd aan hetzelfde board toevoegen. Als je veel timers nodig hebt, werken de kant-en-klare timerbibliotheken in de Library Manager volgens hetzelfde principe.

millis(), delay() en Ticker op de ESP32

In de ESP32 Arduino-core hebben millis() en micros() dezelfde namen en hetzelfde 32-bits unsigned long-type; hun waarden worden berekend uit de 64-bits teller esp_timer_get_time(). Dat betekent dat de overflowperiodes van 49,7 dagen en 71,6 minuten ook op de ESP32 gelden, en dat je dezelfde aftrekregel gebruikt. Het belangrijke verschil zit in delay(): op de ESP32 roept delay() vTaskDelay() van FreeRTOS aan. De processor draait niet nutteloos rond; andere taken zoals Wi-Fi en Bluetooth blijven draaien terwijl je wacht. Je loop() wacht echter nog steeds, dus taken als een webserver, MQTT of het uitlezen van knoppen lopen vertraging op. Voor periodieke taken is ook de Ticker-bibliotheek handig die bij de ESP32-core zit:

C++ (Arduino IDE)
1#include <Ticker.h>
2
3const int LED1 = 2;                         // çoğu DevKit'te dahili LED / built-in LED on most DevKits
4const int LED2 = 4;
5
6Ticker ticker;
7bool led1Durum = false;
8bool led2Durum = false;
9unsigned long oncekiZaman = 0;
10
11void led1Degistir() {                       // kısa tut, uzun iş yapma / keep it short, no long work
12  led1Durum = !led1Durum;
13  digitalWrite(LED1, led1Durum);
14}
15
16void setup() {
17  Serial.begin(115200);
18  pinMode(LED1, OUTPUT);
19  pinMode(LED2, OUTPUT);
20  ticker.attach_ms(250, led1Degistir);      // her 250 ms'de çağır / call every 250 ms
21}
22
23void loop() {
24  unsigned long simdi = millis();
25  if (simdi - oncekiZaman >= 1000) {        // Arduino ile aynı desen / same pattern as on Arduino
26    oncekiZaman = simdi;
27    led2Durum = !led2Durum;
28    digitalWrite(LED2, led2Durum);
29    int64_t us = esp_timer_get_time();      // 64 bit, pratikte taşmaz / 64-bit, practically never overflows
30    Serial.printf("millis=%lu  esp_timer=%lld us\n", simdi, us);
31  }
32}

De functie die je aan Ticker geeft, wordt op de achtergrond aangeroepen door een timertaak; doe daarin niets traags (HTTP-verzoeken, lange seriële uitvoer, delay), maar zet alleen een vlag of verander een pin. De 64-bits esp_timer_get_time() loopt honderdduizenden jaren niet over, dus je kunt hem gebruiken voor metingen die microseconden nauwkeurig moeten zijn op een apparaat dat maandenlang aan blijft. De pin van de ingebouwde LED kan per board verschillen; je kunt de pinindeling van je board bekijken in de tool Pinout. Als je nieuw bent met de ESP32, is het artikel Wat is de ESP32? een goed begin voor de installatie en het kiezen van pins.

Raspberry Pi Pico (MicroPython): ticks_ms() en ticks_diff()

In MicroPython gebruik je time.sleep(), time.sleep_ms() en time.sleep_us() in plaats van delay(), en time.ticks_ms() in plaats van millis(). Maar pas op: tickwaarden lopen niet rond bij 2 tot de macht 32 zoals op Arduino, maar bij een kleinere grens die van de port afhangt. Op de Pico is die grens 2 tot de macht 30 ms, ongeveer 12,4 dagen (je kunt het op je board controleren met time.ticks_add(0, -1)). Trek dus nooit twee tickwaarden rechtstreeks van elkaar af en vergelijk ze ook niet direct; bepaal het verschil met time.ticks_diff(new, old) en gebruik time.ticks_add() om een toekomstig tijdstip te berekenen. De onderstaande code laat de onboard-led van de Pico knipperen zonder te blokkeren, terwijl een knop op GP14 een LED op GP15 omschakelt:

MicroPython
1from machine import Pin
2import time
3
4led = Pin("LED", Pin.OUT)                       # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
5dis_led = Pin(15, Pin.OUT)                      # GP15'e harici LED / external LED on GP15
6buton = Pin(14, Pin.IN, Pin.PULL_UP)            # GP14 buton, diğer ucu GND / GP14 button, other leg to GND
7
8ARALIK = 500                                    # ms
9onceki = time.ticks_ms()
10son_okuma = 1                                   # son ham okuma / last raw reading
11kararli = 1                                     # titreşimsiz durum / debounced state
12degisim = time.ticks_ms()                       # son değişim anı / time of the last change
13
14while True:
15    simdi = time.ticks_ms()
16    if time.ticks_diff(simdi, onceki) >= ARALIK:   # taşmaya karşı güvenli / wrap-safe
17        onceki = time.ticks_add(onceki, ARALIK)    # kaymasız / drift-free
18        led.toggle()
19    okuma = buton.value()
20    if okuma != son_okuma:                      # değişti, sayacı yeniden başlat / changed, restart the timer
21        degisim = simdi
22        son_okuma = okuma
23    if time.ticks_diff(simdi, degisim) >= 50 and okuma != kararli:   # 50 ms debounce
24        kararli = okuma
25        if kararli == 0:                        # basıldı / pressed
26            dis_led.toggle()
27

Voor periodieke taken heeft MicroPython ook machine.Timer: de regel Timer(period=500, mode=Timer.PERIODIC, callback=function) roept je functie elke 500 ms aan. Houd deze callbacks kort, net als bij Ticker. Als je de Pico programmeert vanuit de Arduino IDE (met de arduino-pico-core), werken millis() en micros() precies zoals op Arduino. Om MicroPython op de Pico te installeren en de pins te leren kennen, zie het artikel Wat is de Raspberry Pi Pico?.

Projectideeën met millis()

  • Reactietest: laat een LED op een willekeurig moment oplichten, meet met millis() de tijd tot de knop wordt ingedrukt en toon het resultaat in milliseconden.
  • Trapverlichting: zet het licht aan wanneer een PIR-sensor beweging detecteert en 30 seconden na de laatste beweging weer uit, terwijl de code ondertussen ander werk blijft doen.
  • Parkeersensor die versnelt: verkort het piepinterval van de buzzer naarmate de door de HC-SR04 gemeten afstand kleiner wordt.
  • Melodie zonder blokkeren: laat de noten op een buzzer met millis() op elkaar volgen in plaats van met delay(), zodat de knoppen blijven werken terwijl het deuntje speelt.
  • Sensor en display tegelijk: lees de DHT11-sensor elke 2 seconden uit, maar ververs het display elke 250 ms.
  • Stopwatch: bouw een stopwatch met start-, stop- en resetknoppen die de tijd toont op een 7-segmentdisplay.

Veelgemaakte fouten en hoe je ze oplost

FoutSymptoomOplossing
Tijdvariabele gedeclareerd als intHet programma gaat na ongeveer 33 seconden raar doenMaak van elke tijdvariabele een unsigned long
millis() >= onceki + aralik schrijvenDe timing gaat kapot na 49,7 dagenSchakel over op de vorm millis() - onceki >= aralik
millis() == hedef controlerenDe gebeurtenis gaat soms nooit afGebruik >= in plaats van gelijkheid
Vergeten onceki bij te werkenZodra de tijd om is, wordt de taak bij elke doorloop herhaaldSchrijf onceki = simdi of onceki += aralik binnen de voorwaarde
Een delay() die in de timercode is blijven staanAndere taken worden nog steeds vertraagdSplits lange wachttijden op in een toestandsmachine
Wachten met millis() binnen een interruptHet board loopt vastWacht nooit binnen een ISR; zet alleen een vlag
Een int-product zoals 60 * 1000Het interval wordt negatief of veel te kortSchrijf 60000UL of 60UL * 1000
Een makkelijke manier om te controleren of je code echt zonder blokkeren draait, is tellen hoe vaak loop() per seconde wordt uitgevoerd: verhoog bij elke doorloop een teller, print die één keer per seconde naar de seriële poort en reset hem. Als het getal plotseling van duizenden naar enkele cijfers zakt, wacht er ergens iets (delay, pulseIn of een lange while-lus).

Als je millis() eenmaal doorhebt, veranderen je projecten volledig: LED's, knoppen, sensoren en displays werken samen zonder op elkaar te wachten. Als volgende stap kun je uit de lijst met Arduino-projectideeën een project kiezen waarvoor timing nodig is. In de BlueGrays-app kun je projecten zoals Stoplicht, Politieknipperlicht, Slimme trap- en gangverlichting en de Reactietest met geluidssignaal stap voor stap verkennen, met schakelschema en kant-en-klare code, en ze op je eigen board uitproberen.

Veelgestelde vragen

Wat is millis() in Arduino?

millis() is een functie die de tijd sinds het inschakelen of resetten van de Arduino teruggeeft, in milliseconden. De waarde is een unsigned long en begint na ongeveer 49,7 dagen weer bij nul. Het wordt gebruikt om dingen te timen zonder het programma te stoppen.

Wat is het verschil tussen millis() en delay()?

delay() pauzeert het programma voor de opgegeven tijd, waardoor er ondertussen niets anders kan gebeuren, zoals knoppen uitlezen of een display bijwerken. millis() vertelt je alleen hoeveel tijd er is verstreken en wacht nooit. Door de verstreken tijd te controleren en de taak uit te voeren die aan de beurt is, kun je meerdere taken tegelijk laten draaien.

Gaat mijn programma kapot als millis() na 49 dagen overloopt?

Niet als je de tijd controleert met aftrekken in de vorm millis() - onceki >= aralik; aftrekken zonder teken geeft ook over de overflow heen het juiste verschil. Problemen ontstaan alleen bij vergelijkingen met optellen, zoals millis() >= onceki + aralik, en bij int-variabelen.

Kun je millis() op Arduino resetten?

Er is geen officiële functie om millis() te resetten, en de interne variabele van de core aanpassen wordt afgeraden. Dat hoeft ook niet: bewaar het moment vanaf wanneer je wilt beginnen in een variabele en bereken vandaar de verstreken tijd. Het resetten van het board start millis() vanzelf weer op vanaf 0.

Kan een Arduino twee dingen tegelijk doen?

Omdat de Uno één kern heeft, kan hij fysiek geen twee instructies tegelijk uitvoeren, maar als je elke taak met millis() in korte stappen opdeelt, draait loop() duizenden keren per seconde en krijgt elke taak zijn beurt. Van buiten lijken de LED, knop, sensor en display allemaal tegelijk te werken. De ESP32 heeft bovendien twee kernen en FreeRTOS-taken.

Is millis() nauwkeurig genoeg om een klok te bouwen?

millis() hangt af van de oscillator van het board; door de keramische resonator op de Arduino Uno kan het tot enkele minuten per dag afwijken. Het is prima voor het meten van korte intervallen, maar voor een klok die dagenlang correct moet blijven, is een RTC-module zoals de DS1307 of DS3231, of het ophalen van de tijd via NTP op een ESP32, nauwkeuriger.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

LED laten knipperen

De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

4.6(200)
1246
Verkeerslicht
AR-3Beginner

Verkeerslicht

Een kleine kopie van het verkeerslicht dat je elke dag op straat ziet. Rood brandt twee seconden, geel knippert even, groen brandt twee seconden en daarna gaat het via geel weer naar rood, steeds…

4.8(137)
440
LED-politielichten
AR-4Beginner

LED-politielichten

Net als de lichten van een politieauto: de rode LED knippert drie keer snel achter elkaar, daarna knippert de blauwe LED drie keer, en dit patroon herhaalt zich zonder pauze.

4.7(105)
282
LED-looplicht met instelbare snelheid
AR-7Gemiddeld

LED-looplicht met instelbare snelheid

Zes LED's gaan na elkaar aan, zodat het licht van het ene uiteinde naar het andere lijkt te rennen.

4.6(72)
148
LED schakelen met een knop (aan/uit)
AR-10Beginner

LED schakelen met een knop (aan/uit)

Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

4.7(103)
177
Slimme trap- en gangverlichting
AR-82Gemiddeld
Premium

Slimme trap- en gangverlichting

Stap op de trap of in de gang en de lampjes gaan trede voor trede aan, in de richting waarin je loopt.

5.0(36)
52
Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
AR-95Gemiddeld
Premium

Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)

Hoe snel zijn je reflexen? Druk op de knop: rood zegt maak je klaar, geel zegt wacht, en er begint een willekeurige wachttijd van 1,5 tot 3,5 seconden. Gaat de groene led aan en piept de buzzer, druk dan opnieuw; je reactietijd verschijnt in milliseconden op de I2C-LCD, met je beste en gemiddelde tijd. Druk je vóór groen, dan toont het scherm TOO EARLY! (te vroeg) met een verliesgeluid. Houd de knop ingedrukt voor een nieuwe speler.

4.6(33)
50
Digitale klok met 7-segmentdisplay met 4 cijfers
AR-48Gemiddeld
Premium

Digitale klok met 7-segmentdisplay met 4 cijfers

Een lichtgevende digitale klok met vier cijfers, zoals op een keukenoven. De DS1302-klokmodule houdt de tijd bij en de Arduino leest elke seconde uren en minuten uit en toont ze op het display met…

4.8(56)
73