Gidsen · 14 min leestijd

Arduino-verkeerslicht: schakeling, code, voetgangersknop, kruispunt

Bouw een Arduino-verkeerslicht: 3 leds met 220 Ω-bedrading, code met delay en millis, voetgangersknop, kruispunt met twee richtingen, Tinkercad, ESP32 en Pico.

Een Arduino-verkeerslicht is het klassieke eerste project in de elektronica: drie leds, rood, geel en groen, gaan na elkaar aan en uit, precies zoals een echt verkeerslicht. Je hebt alleen een Arduino Uno, drie leds, drie weerstanden van 220 Ω en een paar jumperdraden nodig, en je eerste werkende versie is in een halfuur klaar. Toch leer je met dit eenvoudige project veel: digitale uitgangen, rekenen met leds en weerstanden, timing, een knop uitlezen en de toestandsmachine, de overzichtelijkste manier om je code te ordenen, alles zit in deze paar leds.

In deze gids zie je eerst in welke volgorde en hoe lang echte verkeerslichten schakelen, bouw je daarna de schakeling en schrijf je de eenvoudigste code met delay(). Vervolgens voeg je een voetgangersdrukknop toe, schrijf je dezelfde logica opnieuw met millis() en een toestandsmachine zodat het programma nooit blokkeert, en stuur je een kruispunt met twee richtingen aan. In de laatste delen lees je hoe je het project in Tinkercad uitprobeert zonder iets te installeren, zie je de versies voor ESP32 en Raspberry Pi Pico (MicroPython) en krijg je tips voor een schoolverslag over het project.

Rode, gele en groene leds van 5 mm voor een Arduino-verkeerslicht
Leds van 5 mm: één rode, één gele en één groene zijn genoeg voor het verkeerslicht; houd er nog een paar over voor het voetgangerslicht en het kruispunt.

Hoe werkt een echt verkeerslicht?

Een verkeerslicht is een timer die elke verkeersstroom zijn beurt geeft. In het Verenigd Koninkrijk, Duitsland en Turkije is de cyclus rood → rood + geel (oranje) → groen → geel → rood. Rood en geel samen betekenen "groen komt eraan, maak je klaar, maar rijd nog niet weg", terwijl geel alleen betekent "het licht springt op rood, bereid je voor om te stoppen". In de VS, Frankrijk, Italië en Spanje bestaat er geen fase met rood + geel: het licht gaat direct van rood naar groen. De geeltijd is ook niet willekeurig: de Duitse regels schrijven 3 seconden geel voor op wegen met een limiet van 50 km/u, 4 seconden bij 60 km/u en 5 seconden bij 70 km/u, omdat een bestuurder die te dichtbij is om te stoppen wanneer het licht op geel springt het kruispunt nog veilig moet kunnen verlaten.

FaseLamp(en) aanBetekenisTijd in deze gids
1RoodStoppen5 s
2Rood + geelGroen komt eraan, maak je klaar1 s
3GroenRijden5 s
4GeelRood komt eraan, stoppen3 s
Bij een kruispuntAlle richtingen roodVeiligheidstijd om het kruispunt vrij te maken1 s

Onderdelenlijst en de berekening van de weerstand van 220 Ω

OnderdeelAantalOpmerking
Arduino Uno (of Nano)1Een ESP32 of Raspberry Pi Pico werkt ook
Leds van 5 mm: rood, geel, groenvan elk 1+1 rode en +1 groene voor het voetgangerslicht, +1 set voor het kruispunt
Weerstand van 220 Ω3Eén per led; 8 voor alle versies
Drukknop (6×6 mm)1Alleen voor de voetgangersversie
Breadboard1Een half formaat (400 gaatjes) is genoeg
Jumperdraden10–20Male naar male
USB-kabel1Om de code te uploaden en het board van stroom te voorzien

Leds beperken hun eigen stroom niet; een led die direct op 5 V is aangesloten trekt meer stroom dan hij en de pin aankunnen. Daarom krijgt elke led een voorschakelweerstand. De waarde vind je met de wet van Ohm: R = (voedingsspanning − doorlaatspanning van de led) / stroom. Voor een rode led geldt (5 V − 2,0 V) / 0,015 A ≈ 200 Ω; met de dichtstbijzijnde standaardwaarde, 220 Ω, is de stroom ongeveer 13,6 mA. Dat laat de led helder genoeg branden en blijft onder de 20 mA die voor een Arduino-pin wordt aanbevolen. Een weerstand van 220 Ω is gemarkeerd met rood-rood-bruin-goud bij onderdelen met vier ringen en rood-rood-zwart-zwart-bruin bij onderdelen met vijf ringen; gebruik voor de zekerheid de weerstandskleurcode-tool, en voor andere kleuren en spanningen de ledweerstandcalculator.

Kleur van de ledDoorlaatspanning (ca.)Stroom bij 5 V (220 Ω)Stroom bij 3,3 V (220 Ω)
Rood1,8–2,2 V≈ 13,6 mA≈ 5,9 mA
Geel1,9–2,2 V≈ 13,2 mA≈ 5,5 mA
Groen (geelachtig groen)2,0–2,4 V≈ 13,2 mA≈ 5,5 mA
Groen (fel, zuiver groen)2,8–3,4 V≈ 9,1 mA≈ 1,4 mA (zeer zwak)

De schakeling bedraden en de pintabel

Het lange pootje (anode, +) van elke led gaat via een weerstand naar een digitale pin van de Arduino en het korte pootje (kathode, −) gaat naar GND. Het maakt niet uit of de weerstand aan de anode- of de kathodekant zit, zolang hij maar in serie staat. Op een breadboard is het netst om de GND-pin van de Arduino met de blauwe (−) rail te verbinden en de korte pootjes van alle drie de leds naar die rail te brengen. De tabel hieronder toont de pins die alle sketches in deze gids gebruiken; de eerste sketch gebruikt alleen de eerste drie rijen. De pinindeling van je board zie je in de Pinout-tool.

FunctieArduino UnoESP32Raspberry Pi Pico
Voertuig rood (richting A)D10GPIO 5GP13
Voertuig geel (richting A)D9GPIO 18GP12
Voertuig groen (richting A)D8GPIO 19GP11
Voetganger roodD7GPIO 21GP15
Voetganger groenD6GPIO 22GP14
Voetgangersknop (andere pootje naar GND)D2GPIO 23GP4
Richting B rood / geel / groenD5 / D4 / D3GPIO 25 / 26 / 27GP8 / GP7 / GP6
Kathodes van de leds en knopGNDGNDGND
Een omgekeerd aangesloten led blijft gewoon donker en raakt niet beschadigd, maar als je de weerstand vergeet, worden de led en de pin overbelast en kan de led snel vervagen. Mik op de Arduino Uno op hooguit 20 mA per pin (het absolute maximum is 40 mA) en houd het totaal van alle pins onder 200 mA. Als er helemaal geen led brandt, controleer dan eerst GND: als de blauwe rail van het breadboard niet met een GND-pin van de Arduino is verbonden, wordt de schakeling nooit gesloten.

Stap 1: de eenvoudigste verkeerslichtcode met delay()

C++ (Arduino IDE)
1// Arduino trafik lambası: delay() ile en basit sürüm / simplest version with delay()
2const int KIRMIZI = 10;  // kırmızı LED / red LED
3const int SARI = 9;      // sarı LED / yellow LED
4const int YESIL = 8;     // yeşil LED / green LED
5
6// Üç LED'i tek satırda ayarla / set all three LEDs in one line
7void lambalar(int k, int s, int y) {
8  digitalWrite(KIRMIZI, k);
9  digitalWrite(SARI, s);
10  digitalWrite(YESIL, y);
11}
12
13void setup() {
14  pinMode(KIRMIZI, OUTPUT);
15  pinMode(SARI, OUTPUT);
16  pinMode(YESIL, OUTPUT);
17}
18
19void loop() {
20  lambalar(HIGH, LOW, LOW);   // DUR: kırmızı / STOP: red
21  delay(5000);
22  lambalar(HIGH, HIGH, LOW);  // HAZIRLAN: kırmızı + sarı / GET READY: red + yellow
23  delay(1000);
24  lambalar(LOW, LOW, HIGH);   // GEÇ: yeşil / GO: green
25  delay(5000);
26  lambalar(LOW, HIGH, LOW);   // YAVAŞLA: sarı / SLOW DOWN: yellow
27  delay(3000);
28}

De sketch zet de drie pins in setup() als uitgang en doorloopt in loop() de vier fasen in volgorde. In plaats van steeds drie digitalWrite-regels te schrijven, gebruiken we een kleine functie met de naam lambalar() ("lampen"), zodat elke fase als één regel leest en een fout makkelijk te zien is. Kies voor het uploaden in het Tools-menu Arduino Uno als board en de juiste poort en klik op Upload. Als het uploaden mislukt, loop dan de checklist in Arduino-code wordt niet geüpload door. Om de timing aan te passen, wijzig je gewoon de waarden in milliseconden binnen delay(): 5000 is 5 seconden.

Stap 2: verkeerslicht met een voetgangersdrukknop

Bij de oversteekplaatsen met drukknop in de stad blijft het verkeer op groen staan en krijgen voetgangers pas hun beurt als iemand op de knop drukt. In deze versie voegen we aan het verkeerslicht een voetgangerslicht met twee leds (rood en groen) en een knop op D2 toe. Eén pootje van de knop gaat naar D2 en het diagonaal tegenoverliggende pootje naar GND; omdat de code INPUT_PULLUP gebruikt, is er geen externe weerstand nodig en leest de pin LOW zolang de knop is ingedrukt. Meer over de interne verbindingen van een knop met vier pootjes en over contactdender lees je in Een drukknop aansluiten op Arduino.

Drukknop met vier pootjes van 6×6 mm
Drukknop van 6×6 mm: de vier pootjes zijn intern in paren verbonden; als je twee diagonaal tegenover elkaar liggende pootjes gebruikt, is de bedrading altijd goed.
C++ (Arduino IDE)
1// Yaya butonlu trafik lambası (delay ile) / pedestrian push-button light (with delay)
2const int KIRMIZI = 10, SARI = 9, YESIL = 8;  // araç lambası / vehicle light
3const int YAYA_KIRMIZI = 7, YAYA_YESIL = 6;   // yaya lambası / pedestrian light
4const int BUTON = 2;                          // diğer ucu GND / other leg to GND
5
6void setup() {
7  pinMode(KIRMIZI, OUTPUT);
8  pinMode(SARI, OUTPUT);
9  pinMode(YESIL, OUTPUT);
10  pinMode(YAYA_KIRMIZI, OUTPUT);
11  pinMode(YAYA_YESIL, OUTPUT);
12  pinMode(BUTON, INPUT_PULLUP);               // basılınca LOW okunur / reads LOW when pressed
13  digitalWrite(YESIL, HIGH);                  // araçlar geçer / cars go
14  digitalWrite(YAYA_KIRMIZI, HIGH);           // yayalar bekler / pedestrians wait
15}
16
17void loop() {
18  if (digitalRead(BUTON) == LOW) {            // yaya butona bastı / pedestrian pressed
19    delay(2000);                              // araçlara kısa süre tanı / short grace time for cars
20    digitalWrite(YESIL, LOW);
21    digitalWrite(SARI, HIGH);                 // sarı / yellow
22    delay(3000);
23    digitalWrite(SARI, LOW);
24    digitalWrite(KIRMIZI, HIGH);              // araçlar durur / cars stop
25    delay(1000);                              // tüm kırmızı güvenlik payı / all-red safety gap
26    digitalWrite(YAYA_KIRMIZI, LOW);
27    digitalWrite(YAYA_YESIL, HIGH);           // yayalar geçer / pedestrians cross
28    delay(6000);
29    for (int i = 0; i < 6; i++) {             // yaya yeşili 3 kez yanıp söner / green man flashes 3 times
30      digitalWrite(YAYA_YESIL, i % 2 == 0 ? LOW : HIGH);
31      delay(500);
32    }
33    digitalWrite(YAYA_YESIL, LOW);
34    digitalWrite(YAYA_KIRMIZI, HIGH);
35    delay(1000);                              // tüm kırmızı / all red
36    digitalWrite(SARI, HIGH);                 // kırmızı + sarı / red + yellow
37    delay(1000);
38    digitalWrite(KIRMIZI, LOW);
39    digitalWrite(SARI, LOW);
40    digitalWrite(YESIL, HIGH);                // araçlar yeniden geçer / cars go again
41    delay(8000);                              // en kısa yeşil süresi / minimum green time
42  }
43}

Deze sketch werkt, maar heeft een ernstige zwakte: zodra de knop is ingedrukt, zit de Arduino ongeveer 25 seconden vast in delay()-regels. Een tweede druk in die tijd wordt niet opgemerkt, er kan niets van de seriële poort worden gelezen en geen display worden bijgewerkt. Drukken tijdens de wachttijd van 8 seconden aan het eind gaat helemaal verloren: de voetganger drukt en laat los, er gebeurt niets en hij moet opnieuw drukken. Met geluid of een aftelling erbij wordt deze opzet nog lastiger om mee te werken. De oplossing is niet meer wachten maar de tijd meten.

Stap 3: niet-blokkerende code met millis() en een toestandsmachine

Een toestandsmachine is een ontwerp waarin het systeem altijd in precies één toestand is en naar de volgende toestand gaat wanneer aan bepaalde voorwaarden is voldaan. Een verkeerslicht is hier een perfect voorbeeld van: "groen voor auto's", "geel voor auto's" en "voetgangers steken over" zijn elk een toestand. De code wacht niet meer met delay(); bij elke ronde stelt loop() maar twee vragen: in welke toestand ben ik en hoe lang zit ik daarin? De verstreken tijd wordt gemeten met millis() - durumBaslangic (het moment waarop de toestand begon) en als de tijd om is, gaat de code verder. Als millis() nieuw voor je is, lees dan eerst Arduino millis() versus delay(). Het helpt enorm om de toestanden eerst in een tabel te zetten voordat je gaat coderen:

ToestandVerkeerslichtVoetgangerslichtDuurVolgende toestand
ARAC_YESILGroenRoodMinstens 8 s, tot er een verzoek komtARAC_SARI
ARAC_SARIGeelRood3 sYAYA_BEKLE
YAYA_BEKLERoodRood1 sYAYA_GECER
YAYA_GECERRoodGroen6 sYAYA_FLAS
YAYA_FLASRoodGroen knipperend3 sYAYA_BITTI
YAYA_BITTIRoodRood1 sKIRMIZI_SARI
KIRMIZI_SARIRood + geelRood1 sARAC_YESIL
C++ (Arduino IDE)
1// Yaya butonlu trafik lambası: millis() + durum makinesi / pedestrian light: millis() + state machine
2const int KIRMIZI = 10, SARI = 9, YESIL = 8;  // araç lambası / vehicle light
3const int YAYA_KIRMIZI = 7, YAYA_YESIL = 6;   // yaya lambası / pedestrian light
4const int BUTON = 2;                          // diğer ucu GND / other leg to GND
5
6enum Durum { ARAC_YESIL, ARAC_SARI, YAYA_BEKLE, YAYA_GECER, YAYA_FLAS, YAYA_BITTI, KIRMIZI_SARI };
7const char* const ISIM[] = { "ARAC_YESIL", "ARAC_SARI", "YAYA_BEKLE", "YAYA_GECER",
8                             "YAYA_FLAS", "YAYA_BITTI", "KIRMIZI_SARI" };
9
10// Süreler (ms) / durations (ms)
11const unsigned long MIN_YESIL = 8000;   // araçlara en az yeşil / minimum green for cars
12const unsigned long SARI_SURE = 3000;   // sarı / yellow
13const unsigned long GUVENLIK = 1000;    // tüm kırmızı / all red
14const unsigned long YAYA_SURE = 6000;   // yaya yeşili / pedestrian green
15const unsigned long FLAS_SURE = 3000;   // yanıp sönen yaya yeşili / flashing green man
16const unsigned long KS_SURE = 1000;     // kırmızı + sarı / red + yellow
17
18Durum durum = ARAC_YESIL;
19unsigned long durumBaslangic = 0;       // durumun başladığı an / when the state started
20bool yayaTalebi = false;                // butona basıldı mı? / was the button pressed?
21
22void aracLamba(bool k, bool s, bool y) {
23  digitalWrite(KIRMIZI, k);
24  digitalWrite(SARI, s);
25  digitalWrite(YESIL, y);
26}
27
28void yayaLamba(bool k, bool y) {
29  digitalWrite(YAYA_KIRMIZI, k);
30  digitalWrite(YAYA_YESIL, y);
31}
32
33// Yeni duruma geç: lambaları ayarla, saati başlat / enter a state: set the lamps, restart the clock
34void gec(Durum yeni) {
35  durum = yeni;
36  durumBaslangic = millis();
37  switch (yeni) {
38    case ARAC_YESIL:   aracLamba(0, 0, 1); yayaLamba(1, 0); break;
39    case ARAC_SARI:    aracLamba(0, 1, 0); yayaLamba(1, 0); break;
40    case YAYA_BEKLE:   aracLamba(1, 0, 0); yayaLamba(1, 0); break;
41    case YAYA_GECER:   aracLamba(1, 0, 0); yayaLamba(0, 1); yayaTalebi = false; break;
42    case YAYA_FLAS:    aracLamba(1, 0, 0); yayaLamba(0, 1); break;
43    case YAYA_BITTI:   aracLamba(1, 0, 0); yayaLamba(1, 0); break;
44    case KIRMIZI_SARI: aracLamba(1, 1, 0); yayaLamba(1, 0); break;
45  }
46  Serial.println(ISIM[yeni]);           // durum günlüğü / state log
47}
48
49void setup() {
50  Serial.begin(9600);
51  pinMode(KIRMIZI, OUTPUT);
52  pinMode(SARI, OUTPUT);
53  pinMode(YESIL, OUTPUT);
54  pinMode(YAYA_KIRMIZI, OUTPUT);
55  pinMode(YAYA_YESIL, OUTPUT);
56  pinMode(BUTON, INPUT_PULLUP);
57  gec(ARAC_YESIL);
58}
59
60void loop() {
61  unsigned long gecen = millis() - durumBaslangic;  // bu durumda geçen süre / time spent in this state
62
63  // yaya yeşili yanarken basış yok sayılır / presses during the green man are ignored
64  if (digitalRead(BUTON) == LOW && durum != YAYA_GECER) {
65    yayaTalebi = true;                  // talebi hatırla / remember the request
66  }
67
68  switch (durum) {
69    case ARAC_YESIL:
70      if (yayaTalebi && gecen >= MIN_YESIL) gec(ARAC_SARI);
71      break;
72    case ARAC_SARI:
73      if (gecen >= SARI_SURE) gec(YAYA_BEKLE);
74      break;
75    case YAYA_BEKLE:
76      if (gecen >= GUVENLIK) gec(YAYA_GECER);
77      break;
78    case YAYA_GECER:
79      if (gecen >= YAYA_SURE) gec(YAYA_FLAS);
80      break;
81    case YAYA_FLAS:
82      digitalWrite(YAYA_YESIL, (gecen / 250) % 2 == 0);  // 250 ms'de bir yanıp söner / toggles every 250 ms
83      if (gecen >= FLAS_SURE) gec(YAYA_BITTI);
84      break;
85    case YAYA_BITTI:
86      if (gecen >= GUVENLIK) gec(KIRMIZI_SARI);
87      break;
88    case KIRMIZI_SARI:
89      if (gecen >= KS_SURE) gec(ARAC_YESIL);
90      break;
91  }
92}

Het hart van de sketch is de functie gec() ("ga naar"): ze slaat de nieuwe toestand op, start de timer opnieuw, zet de lampen voor die toestand en print de naam van de toestand naar de Serial Monitor. De switch in loop() controleert alleen of de tijd om is. Een druk op de knop activeert niet direct iets; hij zet de vlag yayaTalebi (voetgangersverzoek) en de cyclus start zodra de auto's minstens 8 seconden groen hebben gehad. Drukken gaat nu nooit meer verloren en omdat de knop alleen een vlag verandert, geeft contactdender ook geen problemen. Drukken terwijl het groene voetgangerslicht al brandt wordt genegeerd; anders zou er direct nadat de voetgangers zijn overgestoken een nieuwe, onnodige cyclus beginnen. Open de Serial Monitor op 9600 baud om de naam van elke overgang te zien; deze uitvoer helpt zowel bij het debuggen als in je schoolverslag.

Als je een functie wilt toevoegen, voeg dan eerst een rij aan de tabel toe en schrijf daarna een case in de code. Je kunt bijvoorbeeld een nachttoestand toevoegen waarin het gele licht knippert en daarnaartoe schakelen wanneer een LDR-lichtsensor duisternis detecteert. Om toestandsmachines dieper te leren, zie Arduino-toestandsmachine.

Stap 4: een kruispunt met twee richtingen

Op een echt kruispunt zijn de lichten van de twee wegen aan elkaar gekoppeld: terwijl weg A groen is, moet weg B rood zijn. Deze versie gebruikt zes leds: D10, D9 en D8 voor richting A, en D5, D4 en D3 voor richting B. Een belangrijk detail is het korte alles-rood-interval om het kruispunt vrij te maken: wanneer de ene richting op rood springt, wordt de andere niet meteen groen; de regeling wacht 1 seconde zodat voertuigen die nog op het kruispunt zijn, kunnen vertrekken. Deze keer komen de toestanden in een tabel (een array) in plaats van in een switch; per stap worden de brandende lampen als bits in één byte opgeslagen en de duur in milliseconden.

C++ (Arduino IDE)
1// İki yönlü kavşak: tablo tabanlı durum makinesi / two-way junction: table-driven state machine
2const byte A_KIRMIZI = 10, A_SARI = 9, A_YESIL = 8;  // A yönü (ana yol) / direction A (main road)
3const byte B_KIRMIZI = 5,  B_SARI = 4, B_YESIL = 3;  // B yönü (ara yol) / direction B (side road)
4const byte PINLER[6] = { A_KIRMIZI, A_SARI, A_YESIL, B_KIRMIZI, B_SARI, B_YESIL };
5
6struct Adim {
7  byte maske;            // bit sırası: A_K A_S A_Y B_K B_S B_Y / bit order: A_R A_Y A_G B_R B_Y B_G
8  unsigned long sure;    // ms
9};
10
11const Adim PLAN[] = {
12  { 0b001100, 8000 },   // A yeşil, B kırmızı / A green, B red
13  { 0b010100, 3000 },   // A sarı, B kırmızı / A yellow, B red
14  { 0b100100, 1000 },   // tüm yönler kırmızı / all red
15  { 0b100110, 1000 },   // A kırmızı, B kırmızı + sarı / A red, B red + yellow
16  { 0b100001, 5000 },   // A kırmızı, B yeşil / A red, B green
17  { 0b100010, 3000 },   // A kırmızı, B sarı / A red, B yellow
18  { 0b100100, 1000 },   // tüm yönler kırmızı / all red
19  { 0b110100, 1000 },   // A kırmızı + sarı, B kırmızı / A red + yellow, B red
20};
21const byte ADIM_SAYISI = sizeof(PLAN) / sizeof(PLAN[0]);
22
23byte adim = 0;
24unsigned long adimBaslangic = 0;
25
26void uygula(byte maske) {
27  if ((maske & 0b001000) && (maske & 0b000001)) {  // iki yeşil aynı anda yanamaz / never two greens
28    maske = 0b100100;                              // güvenli durum: tüm kırmızı / fail-safe: all red
29  }
30  for (byte i = 0; i < 6; i++) {
31    digitalWrite(PINLER[i], (maske >> (5 - i)) & 1);  // soldaki bit A_KIRMIZI / leftmost bit is A_RED
32  }
33}
34
35void setup() {
36  for (byte i = 0; i < 6; i++) pinMode(PINLER[i], OUTPUT);
37  uygula(PLAN[0].maske);
38  adimBaslangic = millis();
39}
40
41void loop() {
42  if (millis() - adimBaslangic >= PLAN[adim].sure) {
43    adimBaslangic += PLAN[adim].sure;   // kaymasız zamanlama / drift-free timing
44    adim = (adim + 1) % ADIM_SAYISI;
45    uygula(PLAN[adim].maske);
46  }
47  // Burada buton, sensör ya da ekran işleri çalışabilir / buttons, sensors or a display can run here
48}

Elke rij van de PLAN-array is één stap. In binaire getallen zoals 0b001100 staan de bits van links naar rechts voor A rood, A geel, A groen, B rood, B geel en B groen; 1 betekent aan en 0 betekent uit. De functie uygula() ("toepassen") schrijft deze zes bits in volgorde naar de pins. De controle aan het begin van de functie voorkomt dat een typfout in beide richtingen tegelijk groen laat zien en zet het kruispunt in plaats daarvan op alles rood. Echte kruispuntregelaars hebben ook een apart veiligheidscircuit dat conflicterende groensignalen opvangt. Om timings te wijzigen of stappen toe te voegen pas je alleen de tabel aan en blijft de rest van de code onaangeroerd. Als je pins tekortkomt doordat het aantal leds groeit, geeft een 74HC595-schuifregister je acht uitgangen vanaf drie pins.

Probeer het in Tinkercad: simulatie zonder onderdelen

  1. Maak een gratis account aan op tinkercad.com en start een nieuwe schakeling in het onderdeel Circuits.
  2. Sleep een Arduino Uno R3, een breadboard, drie leds en drie weerstanden uit de componentenlijst aan de rechterkant. Klik op een led om de kleur te kiezen en op een weerstand om de waarde op 220 Ω te zetten.
  3. Teken de draden: ledanodes via de weerstanden naar D10, D9 en D8, kathodes naar GND. Als je kleuren voor de draden instelt (bijvoorbeeld zwart voor GND), is het schema makkelijk te lezen.
  4. Klik op Code, kies Text in het uitklapmenu, verwijder de voorbeeldcode en plak de sketch uit deze gids.
  5. Klik op Start Simulation; de leds beginnen na elkaar te schakelen. De seriële uitvoer verschijnt in de Serial Monitor onderaan het codepaneel.

Tinkercad is de makkelijkste manier om bedrading en code te testen voordat je met echte onderdelen bouwt; als je een weerstand vergeet, toont de simulator op de led een waarschuwing dat de stroom te hoog is. Om de voetgangersversie te testen, klik je tijdens de simulatie gewoon met de muis op de knop. Op een trage computer kan de simulatie langzamer lopen dan real time, waardoor de timings wat lang kunnen lijken. Voor een schoolopdracht kun je de deellink van Tinkercad of een screenshot van de schakeling inleveren. Voor uitgebreide instructies zie Tinkercad Arduino-simulatie, en voor een alternatief dat ook de ESP32 en Pico ondersteunt, zie Wokwi.

ESP32-verkeerslicht met nachtmodus

De Arduino-sketches in deze gids draaien ook op de ESP32: kies in de Arduino IDE ESP32 Dev Module als board en pas de pinconstanten aan zoals in de tabel. De versie hieronder voegt één functie toe: de nachtmodus. In rustige uren schakelen veel kruispunten over op knipperend geel. ESP32 DevKit-boards hebben een BOOT-knop die op GPIO 0 is aangesloten, dus je hebt zelfs geen extra knop nodig: zodra het board is opgestart, kun je hem uitlezen als een gewone ingang. Elke druk wisselt tussen de normale modus en de nachtmodus.

C++ (Arduino IDE)
1// ESP32 trafik lambası + gece modu (BOOT düğmesi) / ESP32 traffic light + night mode (BOOT button)
2const int KIRMIZI = 5;      // GPIO 5
3const int SARI = 18;        // GPIO 18
4const int YESIL = 19;       // GPIO 19
5const int BOOT_BUTON = 0;   // kart üzerindeki BOOT düğmesi / on-board BOOT button
6
7struct Adim { bool k, s, y; unsigned long sure; };
8const Adim PLAN[] = {
9  { true,  false, false, 5000 },   // kırmızı / red
10  { true,  true,  false, 1000 },   // kırmızı + sarı / red + yellow
11  { false, false, true,  5000 },   // yeşil / green
12  { false, true,  false, 3000 },   // sarı / yellow
13};
14const int ADIM_SAYISI = sizeof(PLAN) / sizeof(PLAN[0]);
15
16int adim = 0;
17unsigned long adimBaslangic = 0;
18bool geceModu = false;
19int sonOkuma = HIGH, kararli = HIGH;     // debounce için / for debouncing
20unsigned long degisimZamani = 0;
21
22void lambalar(bool k, bool s, bool y) {
23  digitalWrite(KIRMIZI, k);
24  digitalWrite(SARI, s);
25  digitalWrite(YESIL, y);
26}
27
28void setup() {
29  Serial.begin(115200);
30  pinMode(KIRMIZI, OUTPUT);
31  pinMode(SARI, OUTPUT);
32  pinMode(YESIL, OUTPUT);
33  pinMode(BOOT_BUTON, INPUT_PULLUP);
34  lambalar(PLAN[0].k, PLAN[0].s, PLAN[0].y);
35  adimBaslangic = millis();
36}
37
38void loop() {
39  unsigned long simdi = millis();
40
41  // 50 ms kararlı kalan basışı kabul et / accept a press that stays stable for 50 ms
42  int okuma = digitalRead(BOOT_BUTON);
43  if (okuma != sonOkuma) {
44    sonOkuma = okuma;
45    degisimZamani = simdi;
46  }
47  if (simdi - degisimZamani >= 50 && okuma != kararli) {
48    kararli = okuma;
49    if (kararli == LOW) {                  // yeni basış / new press
50      geceModu = !geceModu;
51      Serial.println(geceModu ? "Gece modu / Night mode" : "Normal mod / Normal mode");
52      adim = 0;                            // normal mod kırmızıdan başlar / normal mode restarts on red
53      adimBaslangic = simdi;
54      lambalar(PLAN[0].k, PLAN[0].s, PLAN[0].y);
55    }
56  }
57
58  if (geceModu) {
59    lambalar(false, (simdi / 500) % 2 == 0, false);  // yanıp sönen sarı / flashing yellow
60    return;
61  }
62
63  if (simdi - adimBaslangic >= PLAN[adim].sure) {
64    adimBaslangic = simdi;
65    adim = (adim + 1) % ADIM_SAYISI;
66    lambalar(PLAN[adim].k, PLAN[adim].s, PLAN[adim].y);
67  }
68}

Het uitlezen van de knop bevat een eenvoudige debounce: een druk telt pas mee als de meting 50 ms ongewijzigd blijft. De PLAN-tabel met de lampstanden is een beter leesbare vorm van het idee uit de kruispuntsketch. Omdat de ESP32-pins 3,3 V leveren, trekken de leds minder stroom dan op de Arduino en lijken ze iets zwakker. Rode en gele leds zijn met 220 Ω helder genoeg, maar een felgroene led met een doorlaatspanning van rond de 3 V kan erg zwak blijven; verlaag in dat geval de groene weerstand naar 100 Ω. Als de ESP32 nieuw voor je is, is Wat is de ESP32? een goed beginpunt voor de installatie en veilige pins.

Voetgangersverkeerslicht met Raspberry Pi Pico (MicroPython)

Op de Raspberry Pi Pico schrijven we dezelfde toestandsmachine in MicroPython. Deze keer staan de toestanden in een lijst: elke rij bevat de naam van de toestand, de waarden van de vijf lampen en de duur. De knop gebruikt een interrupt: wanneer GP4 naar LOW valt, wordt de functie buton_kesmesi() ("knopinterrupt") uitgevoerd die alleen de verzoekvlag zet. Als je de code met Thonny als main.py op de Pico opslaat, start ze automatisch elke keer dat het board wordt ingeschakeld.

MicroPython
1# Raspberry Pi Pico (MicroPython): yaya butonlu trafik lambası / pedestrian traffic light
2from machine import Pin
3import time
4
5yesil = Pin(11, Pin.OUT)              # araç yeşil / vehicle green
6sari = Pin(12, Pin.OUT)               # araç sarı / vehicle yellow
7kirmizi = Pin(13, Pin.OUT)            # araç kırmızı / vehicle red
8yaya_yesil = Pin(14, Pin.OUT)         # yaya yeşil / pedestrian green
9yaya_kirmizi = Pin(15, Pin.OUT)       # yaya kırmızı / pedestrian red
10buton = Pin(4, Pin.IN, Pin.PULL_UP)   # GP4, diğer ucu GND / other leg to GND
11
12# (durum, kırmızı, sarı, yeşil, yaya kırmızı, yaya yeşil, süre ms)
13# (state, red, yellow, green, ped red, ped green, duration ms)
14DURUMLAR = [
15    ("ARAC_YESIL",   0, 0, 1, 1, 0, 8000),   # en az yeşil süresi / minimum green
16    ("ARAC_SARI",    0, 1, 0, 1, 0, 3000),
17    ("YAYA_BEKLE",   1, 0, 0, 1, 0, 1000),   # tüm kırmızı / all red
18    ("YAYA_GECER",   1, 0, 0, 0, 1, 6000),
19    ("YAYA_FLAS",    1, 0, 0, 0, 1, 3000),
20    ("YAYA_BITTI",   1, 0, 0, 1, 0, 1000),   # tüm kırmızı / all red
21    ("KIRMIZI_SARI", 1, 1, 0, 1, 0, 1000),
22]
23
24talep = False
25adim = 0                              # şu anki durumun sırası / index of the current state
26
27def buton_kesmesi(pin):               # kesmede yalnız bayrak kaldır / only set a flag in the IRQ
28    global talep
29    if DURUMLAR[adim][0] != "YAYA_GECER":   # yaya yeşilinde basış yok sayılır / ignored during the green man
30        talep = True
31
32buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesmesi)
33
34def uygula(i):
35    global talep
36    ad, k, s, y, yk, yy, _ = DURUMLAR[i]
37    kirmizi.value(k)
38    sari.value(s)
39    yesil.value(y)
40    yaya_kirmizi.value(yk)
41    yaya_yesil.value(yy)
42    if ad == "YAYA_GECER":
43        talep = False                 # talep karşılandı / request served
44    print("Durum / state:", ad)
45
46uygula(adim)
47baslangic = time.ticks_ms()
48
49while True:
50    gecen = time.ticks_diff(time.ticks_ms(), baslangic)   # taşmaya karşı güvenli / wrap-safe
51    ad = DURUMLAR[adim][0]
52
53    if ad == "YAYA_FLAS":
54        yaya_yesil.value((gecen // 250) % 2 == 0)          # yanıp sönen yaya yeşili / flashing green man
55
56    if gecen >= DURUMLAR[adim][6] and (ad != "ARAC_YESIL" or talep):
57        adim = (adim + 1) % len(DURUMLAR)                   # yeşil, talep gelene kadar sürer / green lasts until a request
58        uygula(adim)
59        baslangic = time.ticks_ms()
60
61    time.sleep_ms(10)

In MicroPython gebruik je time.ticks_ms() in plaats van millis() en time.ticks_diff() in plaats van gewone aftrekking; de ticks-teller begint na een bepaalde waarde opnieuw, dus twee metingen rechtstreeks van elkaar aftrekken kan foute resultaten geven. Houd de interrupt-handler kort: geen print, geen sleep en geen lange berekeningen, verander alleen een vlag. De pins van de Pico werken ook op 3,3 V, dus de opmerking over de groene led uit het ESP32-deel geldt hier ook. Hoe je MicroPython installeert en hoe de pinnummering werkt, lees je in Wat is de Raspberry Pi Pico? en de basis van de taal in MicroPython-basis.

Veelgemaakte fouten en hoe je ze oplost

VerschijnselWaarschijnlijke oorzaakOplossing
Geen enkele led brandtGND niet aangesloten, of de voedingsrail van het breadboard is in het midden onderbrokenVerbind Arduino GND met de blauwe rail; overbrug de twee helften op een lang breadboard
Eén led blijft donkerLed omgekeerd of op de verkeerde pin aangeslotenLang pootje (anode) via de weerstand naar de pin, kort pootje naar GND; vergelijk het pinnummer met de code
De verkeerde kleur brandtDe rode en groene pin zijn in de code verwisseldCorrigeer de draden of de constanten volgens de pintabel
Led brandt heel fel en wordt warmGeen weerstand geplaatstPlaats een voorschakelweerstand van 220 Ω bij elke led
Knop doet niets of lijkt altijd ingedruktKnop geplaatst over twee pootjes die intern al verbonden zijn, of INPUT_PULLUP vergetenGebruik diagonale pootjes en schrijf pinMode(BUTON, INPUT_PULLUP)
Geen directe reactie op de knopDe minimale groentijd van de auto's is nog niet voorbijGeen bug; verlaag MIN_YESIL
Het programma gaat na een tijdje raar doenEen tijdvariabele is gedeclareerd als intDeclareer elke variabele die met millis() wordt gebruikt als unsigned long

Tips voor je schoolopdracht en projectverslag

Het verkeerslicht is een van de meest voorkomende Arduino-opdrachten in lessen natuurkunde, techniek en robotica. Je docent wil meestal niet alleen een werkende schakeling zien, maar ook dat je hem begrijpt en kunt uitleggen. Als je je verslag met de volgende onderdelen opbouwt, ziet het er overzichtelijk uit en mis je niets belangrijks:

  • Doel: Beschrijf in een of twee zinnen wat het project laat zien, bijvoorbeeld "de timing van een verkeerslicht regelen met digitale uitgangen".
  • Onderdelenlijst: Geef de naam, het aantal en de waarde (220 Ω) van elk onderdeel, zoals in de tabel hierboven.
  • Schakelschema: Voeg een screenshot uit Tinkercad of Fritzing toe; als je het met de hand tekent, gebruik dan de juiste symbolen. Een schakelschema lezen helpt hierbij.
  • Berekening van de weerstand: Toon R = (5 − 2) / 0,015 ≈ 200 Ω en leg uit waarom je 220 Ω hebt gekozen.
  • Toestandstabel of stroomschema: Neem de tabel met toestanden, duren en overgangen op; het is het sterkste bewijs dat je de code begrijpt.
  • Code en uitleg: Neem de volledige code op en leg de belangrijke regels in je eigen woorden uit.
  • Tests en waarnemingen: Meet de fasen met een stopwatch, meet de stroom van één led met een multimeter en vergelijk die met je berekening.
  • Conclusie en verbeteringen: Beschrijf de problemen die je tegenkwam, hoe je ze hebt opgelost en welke functies je zou kunnen toevoegen (voetgangersknop, geluid, nachtmodus).
Als je wilt opvallen, vergelijk dan je eerste delay()-versie met de millis()-versie: leg uit waarom drukken op de knop in de eerste worden gemist en in de tweede nooit. Een video van 20–30 seconden van de werkende schakeling en een screenshot van de uitvoer van de Serial Monitor maken het verslag nog sterker.

Ideeën om je verkeerslicht verder uit te bouwen

  • Aftelweergave: Toon de seconden tot het einde van groen op een 7-segmentdisplay.
  • Geluidssignaal voor slechtziende voetgangers: Laat een buzzer snel piepen zolang het voetgangerslicht groen is en langzaam zolang het rood is.
  • Slim kruispunt: Detecteer een wachtende auto op de zijweg met een HC-SR04-afstandssensor en geef richting B alleen groen als er een auto staat.
  • Automatische nachtmodus: Gebruik een LDR om over te schakelen op knipperend geel wanneer het donker wordt.
  • Afstandsbediening: Bouw een webpagina op de ESP32 en wijzig de modus en timings vanaf je telefoon.
  • Spoorwegovergang: Gebruik dezelfde logica voor de lichten van een spoorwegovergang met twee rode leds die om en om knipperen; de projecten Knight Rider en looplicht gebruiken vergelijkbare timingideeën.

Een verkeerslicht lijkt een klein project, maar de ideeën erin, toestandsmachines, niet-blokkerende timing en veilige overgangen, vormen ook de basis van de robots, alarmsystemen en domoticaapparaten die je later gaat bouwen. Om te kiezen wat je hierna bouwt, bekijk je de lijst met Arduino-projectideeën. In de BlueGrays-app vind je verkeerslichtprojecten voor Arduino, ESP32 en Raspberry Pi Pico, plus vervolgprojecten zoals het Pico-verkeerslicht met vier modi, elk met een schakelschema stap voor stap en kant-en-klare code om op je eigen board te proberen.

Veelgestelde vragen

Hoe maak je een verkeerslicht met Arduino?

Sluit de lange pootjes van een rode, een gele en een groene led via weerstanden van 220 Ω aan op digitale pins van de Arduino (bijvoorbeeld D10, D9 en D8) en de korte pootjes op GND. Zet die pins in de code als OUTPUT en schakel de leds in loop() na elkaar aan en uit. delay() is genoeg voor een eerste versie; voor knoppen en extra functies heb je millis() nodig.

Welke weerstand heb ik nodig voor een led van het verkeerslicht?

Op een Arduino Uno met 5 V is 220 Ω per led een gangbare en veilige keuze; een rode led trekt dan ongeveer 13–14 mA. 330 Ω geeft een zwakker maar nog duidelijk zichtbaar licht. 220 Ω werkt ook op de ESP32 en Pico met 3,3 V; alleen als een felgroene led zwak blijft, ga je terug naar 100 Ω.

Waarom branden rood en geel samen bij een verkeerslicht?

In landen als het Verenigd Koninkrijk, Duitsland en Turkije kondigen rood en geel samen aan dat groen zo meteen aangaat: bestuurders maken zich klaar maar rijden pas weg als groen verschijnt. De VS, Frankrijk, Italië en Spanje gebruiken deze fase niet en gaan direct van rood naar groen. In je Arduino-project kun je deze fase opnemen of weglaten, zoals je zelf wilt.

Moet ik delay of millis gebruiken voor een Arduino-verkeerslicht?

Als je de leds alleen na elkaar schakelt, is delay() de eenvoudigste optie en werkt het prima. Zodra je een knop, sensor, display of geluid toevoegt, pauzeert delay() het programma en worden die invoeren gemist. Code die met millis() en een toestandsmachine is geschreven, wacht nooit en kan alles tegelijk bijhouden.

Kan ik het verkeerslichtproject in Tinkercad bouwen?

Ja. Tinkercad Circuits bevat de Arduino Uno, leds, weerstanden en drukknoppen als kant-en-klare componenten; teken de schakeling, plak de code in de teksteditor en start de simulatie. Het is ideaal om de schakeling en code zonder echte onderdelen te testen en om een screenshot of deellink voor je opdracht te krijgen.

Hoe werkt een verkeerslicht met voetgangersdrukknop?

Auto's hebben normaal groen en een druk op de knop registreert een verzoek. Zodra de minimale groentijd van de auto's voorbij is, springt het licht op geel en daarna op rood, en na een korte veiligheidstijd wordt het voetgangerslicht groen. In de code van deze gids knippert het groene voetgangerslicht voordat het eindigt, en daarna keert de cyclus terug naar de auto's.

Alle projecten bekijken
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
ESP32-stoplicht
ES-5Beginner

ESP32-stoplicht

Een echt stoplicht nabootsen met 3 leds: rood, geel en groen. De tijden lijken op de echte verkeerslogica: rood lang, geel kort, groen lang. Een klassiek voorbeeld van sequentiële GPIO-besturing.

4.4(22)
45
Raspberry Pi Pico-stoplicht (3 leds na elkaar)
PI-4Beginner

Raspberry Pi Pico-stoplicht (3 leds na elkaar)

We bouwen de logica van een echt stoplicht na met een rode, gele en groene led, het eerste Pico-project met 3 leds! Groen zegt 4 seconden "rijden", geel 1,5 seconde "maak je klaar", rood 3 seconden "stop" en rood+geel 1 seconde "optrekken" (het Europese stoplichtpatroon). Je leert functies definiëren (def all_off()), toestandsmachinelogica en het synchroniseren van meerdere GPIO's.

4.0(1)
12
Twee LED's om en om laten knipperen
AR-2Beginner

Twee LED's om en om laten knipperen

Twee LED's knipperen snel om de beurt: als de ene aangaat, gaat de andere uit, alsof ze elkaar een bal toegooien.

4.6(110)
362
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
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
Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)
PI-12Gemiddeld

Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)

4 stoplichtstanden met 1 knop! Elke druk schakelt de stand om: normale cyclus (rood → geel → groen), alleen rood (stop), knipperend geel (waarschuwing/nachtstand) en uit (onderhoud). Je leert de state machine (de variabele mode bepaalt welk gedrag draait) en het doorlopen van de standen met (mode + 1) % 4.

5.0(1)
16