Arduino Knight Rider-looplicht: schakeling, code en snelheidsregeling
Bouw een Arduino Knight Rider-looplicht: bedrading met 8 LED's en 220 Ω, code met array en for-lus, snelheidsregeling met potmeter, millis, 74HC595, WS2812B, ESP32 en Pico.
De Arduino Knight Rider-schakeling is een klassiek LED-effect waarbij een rij LED's na elkaar oplicht, van het ene uiteinde naar het andere en weer terug. Het is vernoemd naar het scannerlicht op de voorkant van KITT, de pratende auto uit de beroemde tv-serie uit de jaren tachtig. Je hebt alleen een Arduino Uno nodig, 6 of 8 LED's, een weerstand van 220 Ω per LED en een paar jumperdraden. Als het licht maar in één richting loopt en dan opnieuw begint, heet het een looplicht of LED-chaser. Beide zijn klassieke projecten die beginners direct na een stoplicht bouwen, en het is de leukste manier om twee van de belangrijkste hulpmiddelen van het programmeren te leren: arrays en de for-lus.
In deze gids bouw je eerst de schakeling en schrijf je de code voor het looplicht, daarna de heen-en-weer-code van de Knight Rider. Vervolgens stel je de snelheid in met een potmeter, voeg je een effect toe waarbij de LED's zich aan één kant opstapelen en laat je hetzelfde effect draaien met millis(), zonder de code ooit te blokkeren. In de laatste delen lees je hoe je 8 LED's met slechts 3 pinnen aanstuurt met een 74HC595-chip, hoe je met adresseerbare WS2812B-LED's vanaf één pin een Knight Rider met een uitdovende staart bouwt, de versies voor ESP32 en Raspberry Pi Pico (MicroPython) en oplossingen voor de meest gemaakte fouten.

Wat is het Knight Rider-effect en wat is het verschil met een looplicht?
In de serie veegt het rode licht op de voorbumper van KITT non-stop heen en weer als een scannend oog. In de elektronica heet dit effect ook wel een Larson-scanner, naar Glen A. Larson, de producent van de serie; de ogen van de Cylon-robots in zijn andere serie, Battlestar Galactica, werken op dezelfde manier. Op de echte scanner zie je achter de lichtvlek een langzaam uitdovend rood spoor, een staart. In een eenvoudige LED-schakeling is elke LED helemaal aan of helemaal uit; om de staart na te bootsen moet je de LED's geleidelijk dimmen met PWM. Dat doen we later met de WS2812B en de ESP32. De tabel hieronder vat de effecten samen die je in dit artikel programmeert en hoeveel stappen één ronde met 8 LED's duurt.
| Effect | Wat het doet | Eén ronde met 8 LED's | In dit artikel |
|---|---|---|---|
| Looplicht | Eén licht loopt van links naar rechts en begint dan opnieuw | 8 stappen | Stap 1 |
| Knight Rider | Eén licht stuitert tussen de twee uiteinden | 14 stappen | Stap 2 en 3 |
| Opstapelen | Elk licht loopt naar de meest rechtse vrije plek en blijft daar | 36 stappen | Stap 4 |
| Ontmoeten in het midden | Twee lichten komen van de uiteinden naar het midden en gaan dan weer uit elkaar | 8 stappen | Deel over de 74HC595 |
| Knight Rider met staart | De kop-LED brandt op volle sterkte, de LED's erachter doven uit | 14 stappen | Delen over WS2812B en ESP32 |
Onderdelenlijst en de weerstand kiezen
| Onderdeel | Aantal | Opmerking |
|---|---|---|
| Arduino Uno (of Nano) | 1 | Een ESP32 of Raspberry Pi Pico werkt ook |
| 5 mm LED | 6–8 | Zelfde kleur en dezelfde batch, zodat ze even helder lijken |
| Weerstand van 220 Ω | 6–8 | Eén per LED; 330 Ω bij de Pico |
| Potmeter van 10 kΩ (B10K) | 1 | Alleen voor de versies met instelbare snelheid |
| Breadboard | 1 | Half formaat (400 gaatjes) is genoeg |
| Jumperdraden | 12–15 | Male-male |
| 74HC595 of een WS2812B-stick met 8 LED's | 1 | Optioneel: voor de delen over pinbesparing en het staarteffect |
Een LED begrenst zijn eigen stroom niet, dus elke LED krijgt een weerstand in serie. De waarde vind je met de wet van Ohm: R = (voedingsspanning − doorlaatspanning van de LED) / stroom. Een rode LED heeft een doorlaatspanning van ongeveer 2 V, dus bij 5 V met 220 Ω is de stroom (5 − 2) / 220 ≈ 13,6 mA. Dat laat de LED lekker helder branden en blijft onder de 20 mA die voor een Arduino-pin wordt aanbevolen. Bij het stapeleffect, wanneer alle acht LED's tegelijk aan zijn, is de totale stroom ongeveer 109 mA, wat nog binnen de limiet van 200 mA van de Uno voor alle pinnen samen valt. Een weerstand van 220 Ω herken je aan zijn kleurbanden met de tool weerstandskleurcode; voor andere kleuren en spanningen probeer je de LED-weerstandscalculator.
Bedrading: 8 LED's en een potmeter
Het lange pootje (anode) van elke LED gaat via een weerstand naar een digitale pin van het board en het korte pootje (kathode) gaat naar GND. Op een breadboard is het netst om de GND-pin van de Arduino te verbinden met de blauwe (−) rail van het breadboard en de korte pootjes van alle acht LED's naar die rail te brengen. Plaats de LED's op gelijke afstand van links naar rechts in pinvolgorde; zo komt de volgorde in de array in de code overeen met de fysieke volgorde van het licht. De twee buitenste pootjes van de potmeter gaan naar 5V en GND en het middelste pootje (de loper) gaat naar A0. De tabel hieronder toont de pinnen die elke sketch in dit artikel gebruikt; als je 6 LED's gebruikt, sla dan de laatste twee LED-rijen over en haal de laatste twee pinnen uit de array in de code. De pinindeling van je board zie je in de tool Pinout.
| Functie | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (uiterst links) | D2 | GPIO 18 | GP8 |
| LED 2 | D3 | GPIO 19 | GP9 |
| LED 3 | D4 | GPIO 21 | GP10 |
| LED 4 | D5 | GPIO 22 | GP11 |
| LED 5 | D6 | GPIO 23 | GP12 |
| LED 6 | D7 | GPIO 25 | GP13 |
| LED 7 | D8 | GPIO 26 | GP14 |
| LED 8 (uiterst rechts) | D9 | GPIO 27 | GP15 |
| Middelste pootje van de potmeter | A0 | GPIO 34 | GP26 (ADC0) |
| Buitenste pootjes van de potmeter | 5V en GND | 3V3 en GND | 3V3(OUT) en AGND |
| Kathodes van de LED's (kort pootje) | GND | GND | GND |
| Serieweerstand | 220 Ω | 220 Ω | 330 Ω |




Stap 1: code voor het looplicht met een array en een for-lus
Je zou voor acht LED's acht losse pinMode-regels en zestien losse digitalWrite-regels kunnen schrijven, maar dan wordt de code lang en is het aantal LED's aanpassen een karwei. In plaats daarvan zet je de pinnummers in een array en loop je er met een for-lus doorheen. Het eerste element van de array is LEDS[0], dat is D2; het laatste is LEDS[7], dat is D9. Zo werkt dezelfde code ongewijzigd met 6, 8 of 12 LED's; je past alleen de array aan. De basis van arrays en lussen vind je uitgebreider uitgelegd in Basis van Arduino-programmeren.
1// Yürüyen LED: 8 LED sırayla yanar / Running light: 8 LEDs light up one after another
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9}; // LED pinleri / LED pins
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]); // dizideki LED sayısı (8) / number of LEDs (8)
4const int BEKLE = 100; // adım süresi (ms) / step time (ms)
5
6void setup() {
7 for (int i = 0; i < LED_SAYISI; i++) {
8 pinMode(LEDS[i], OUTPUT); // tüm LED pinleri çıkış / all LED pins as outputs
9 }
10}
11
12void loop() {
13 for (int i = 0; i < LED_SAYISI; i++) {
14 digitalWrite(LEDS[i], HIGH); // sıradaki LED'i yak / light the next LED
15 delay(BEKLE);
16 digitalWrite(LEDS[i], LOW); // söndür ve devam et / turn it off and move on
17 }
18}| Regel | Wat het doet |
|---|---|
| const int LEDS[] = {2, ..., 9}; | Een array met de LED-pinnen op volgorde van links naar rechts; LEDS[0] = 2, LEDS[7] = 9 |
| sizeof(LEDS) / sizeof(LEDS[0]) | Berekent het aantal elementen: op de Uno 16 bytes / 2 bytes = 8; het past zichzelf aan als je pinnen toevoegt of verwijdert |
| for (int i = 0; i < LED_SAYISI; i++) | Telt de variabele i van 0 tot 7; elke ronde behandelt één element van de array |
| pinMode(LEDS[i], OUTPUT) | Maakt alle acht pinnen uitgangen met één lus |
| digitalWrite, delay(BEKLE), digitalWrite | Zet de LED aan, wacht BEKLE milliseconden, zet hem uit en gaat door naar de volgende |
Met BEKLE (de staptijd) op 100 ms passeert het licht alle acht LED's in 0,8 seconde en begint meteen opnieuw. Zet je het op 30 ms, dan loopt het licht heel snel; bij 300 ms ziet het er traag uit, alsof lampjes één voor één aangaan. Om de code te uploaden selecteer je het board en de poort in het Tools-menu en druk je op Upload; als de upload mislukt, loop dan de checklist door in Arduino-code wordt niet geüpload.
Stap 2: Knight Rider-code (heen en weer)
Voor het Knight Rider-effect moet het licht omkeren als het het rechteruiteinde bereikt. Dat doe je met twee lussen: de eerste telt van links naar rechts, de tweede van rechts naar links. Het subtiele punt zijn hier de LED's aan de uiteinden. Als beide lussen helemaal van 0 tot 7 en van 7 tot 0 tellen, licht de meest rechtse LED één keer op aan het einde van de voorwaartse lus en nog een keer aan het begin van de achterwaartse lus; het licht blijft dan twee keer zo lang aan de uiteinden en de beweging lijkt te haperen. Daarom stopt de voorwaartse lus bij 6 en de achterwaartse bij 1. Zo duurt elke ronde precies 14 stappen en blijft het licht aan de uiteinden even lang als in het midden. We hebben ook de drie regels die een LED aan- en uitzetten verplaatst naar een kleine functie met de naam yakSondur() ("aanzetten en uitzetten"); de code wordt zo korter en beter leesbaar.
1// Karaşimşek (Knight Rider): ışık iki uç arasında gidip gelir / light bounces between the two ends
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int BEKLE = 80; // adım süresi (ms) / step time (ms)
5
6void yakSondur(int i) {
7 digitalWrite(LEDS[i], HIGH);
8 delay(BEKLE);
9 digitalWrite(LEDS[i], LOW);
10}
11
12void setup() {
13 for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
14}
15
16void loop() {
17 for (int i = 0; i < LED_SAYISI - 1; i++) { // soldan sağa: 0..6 / left to right: 0..6
18 yakSondur(i);
19 }
20 for (int i = LED_SAYISI - 1; i > 0; i--) { // sağdan sola: 7..1 / right to left: 7..1
21 yakSondur(i);
22 }
23}Stap 3: snelheidsregeling met een potmeter
In plaats van elke keer de code aan te passen en opnieuw te uploaden als je een andere snelheid wilt, kun je een potmeter gebruiken. Een potmeter is een spanningsdeler: de spanning op het middelste pootje varieert tussen 0 en 5 V, afhankelijk van de stand van de as, en analogRead() zet die om in een getal tussen 0 en 1023. map(deger, 0, 1023, 400, 20) zet dat getal om in een staptijd tussen 400 en 20 ms; omdat het bereik omgekeerd is geschreven, geldt: hoe hoger de meetwaarde, hoe korter de stap en hoe sneller het licht. In welke richting je de as moet draaien om te versnellen, hangt af van welk buitenste pootje je op 5V hebt aangesloten; voelt het omgekeerd, verwissel dan de twee buitenste draden of wissel 400 en 20 in map(). Hoe een potmeter van binnen werkt, lees je in Wat is een potmeter?.

1// Hız ayarlı karaşimşek: potansiyometre adım süresini belirler / Speed-adjustable Knight Rider: the pot sets the step time
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = A0; // potansiyometrenin orta bacağı / pot wiper
5
6int adimSuresi() {
7 int deger = analogRead(POT); // 0–1023
8 return map(deger, 0, 1023, 400, 20); // değer büyüdükçe hızlanır / faster as the value rises
9}
10
11void yakSondur(int i) {
12 digitalWrite(LEDS[i], HIGH);
13 delay(adimSuresi()); // her adımda yeniden okunur / read again on every step
14 digitalWrite(LEDS[i], LOW);
15}
16
17void setup() {
18 for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
19}
20
21void loop() {
22 for (int i = 0; i < LED_SAYISI - 1; i++) yakSondur(i); // sağa / to the right
23 for (int i = LED_SAYISI - 1; i > 0; i--) yakSondur(i); // sola / to the left
24}In deze versie wordt de staptijd voor elke LED opnieuw uitgelezen, dus de snelheid verandert zodra je aan de as draait. Zolang delay() loopt, kan de Arduino echter niets anders doen: ook als je midden in een trage stap van 400 ms de as draait, geldt de nieuwe snelheid pas vanaf de volgende stap. Voor een effect met een paar LED's is dat geen probleem, maar zodra je een modusknop of sensormetingen toevoegt, moet je overstappen op de millis()-methode uit stap 5.
Stap 4: het stapeleffect
Bij het stapeleffect loopt het eerste licht helemaal naar rechts en blijft uiterst rechts branden. Het tweede licht loopt ook, maar stopt dit keer één plek verder naar links; elke ronde schuift het doel één LED naar links totdat de hele balk vol is. In code doe je dit met twee geneste lussen: de buitenste lus telt hoeveel LED's er zijn opgestapeld (dolu, "vol") en de binnenste lus telt hoeveel stappen het licht in deze ronde loopt. De LED die zijn doel (hedef) bereikt, wordt niet uitgezet; de regel if (i < hedef) zorgt daar precies voor. Met acht LED's kost het vullen van de hele balk 8 + 7 + 6 + ... + 1 = 36 stappen.
1// Birikerek dolan efekt: her ışık en boş uca kadar gider ve orada kalır / Stacking effect: each light runs to the last free spot and stays
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int BEKLE = 60;
5
6void setup() {
7 for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
8}
9
10void loop() {
11 for (int dolu = 0; dolu < LED_SAYISI; dolu++) { // dolu: sağda birikmiş LED sayısı / LEDs already stacked on the right
12 int hedef = LED_SAYISI - 1 - dolu; // bu turda ışığın duracağı yer / where the light stops this round
13 for (int i = 0; i <= hedef; i++) {
14 digitalWrite(LEDS[i], HIGH);
15 delay(BEKLE);
16 if (i < hedef) digitalWrite(LEDS[i], LOW); // hedefte yanık kalır / stays lit at the target
17 }
18 }
19 delay(600); // dolu çubuğu göster / show the full bar
20 for (int i = LED_SAYISI - 1; i >= 0; i--) { // sağdan sola boşalt / empty from right to left
21 digitalWrite(LEDS[i], LOW);
22 delay(BEKLE);
23 }
24 delay(300);
25}Aan het eind van de sketch wordt de volle balk 0,6 seconde getoond, daarna gaan de LED's één voor één uit van rechts naar links en begint het effect opnieuw. Wil je een eenvoudigere vulbalk, haal dan gewoon de binnenste lus weg en zet de LED's op volgorde aan zonder ze ooit uit te zetten; die look is ideaal voor een laadindicator of een geluidsniveaubalk. Bedenk dat in dit effect alle acht LED's tegelijk aan zijn: zolang elke LED zijn eigen weerstand heeft, daalt de helderheid niet.
Stap 5: niet-blokkerende Knight Rider met millis()
In code die delay() gebruikt, staat de Arduino bij elke stap de opgegeven tijd stil; ook als iemand intussen op een knop drukt, merkt hij dat niet. millis() geeft daarentegen de tijd in milliseconden sinds het board is aangezet. De logica gaat zo: de lus draait constant, controleert elke keer of er sinds de laatste stap genoeg tijd is verstreken, zet als dat zo is precies één stap en verlaat de lus meteen weer. In de onderstaande code draaien de Knight Rider en de ingebouwde LED tegelijk als twee onafhankelijke taken: terwijl de scanner veegt met de snelheid die de potmeter bepaalt, knippert de LED op D13 één keer per seconde in zijn eigen tempo. Meer over dit onderwerp lees je in Arduino millis() versus delay().
1// millis() ile bekletmesiz karaşimşek + potansiyometre / Non-blocking Knight Rider with millis() + pot
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = A0;
5
6int konum = 0; // şu an yanan LED / the LED that is lit now
7int yon = 1; // +1 sağa, -1 sola / +1 right, -1 left
8unsigned long sonAdim = 0; // son adımın zamanı / time of the last step
9unsigned long sonBlink = 0; // dahili LED için / for the onboard LED
10
11void setup() {
12 for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
13 pinMode(LED_BUILTIN, OUTPUT); // Uno'da D13 / D13 on the Uno
14 digitalWrite(LEDS[konum], HIGH);
15}
16
17void loop() {
18 unsigned long simdi = millis();
19 unsigned long aralik = map(analogRead(POT), 0, 1023, 400, 20); // adım süresi (ms) / step time (ms)
20
21 // Görev 1: karaşimşek / Task 1: Knight Rider
22 if (simdi - sonAdim >= aralik) { // taşmaya karşı güvenli / overflow-safe
23 sonAdim = simdi;
24 digitalWrite(LEDS[konum], LOW);
25 konum += yon;
26 if (konum == LED_SAYISI - 1 || konum == 0) yon = -yon; // uçta yön değiştir / reverse at the ends
27 digitalWrite(LEDS[konum], HIGH);
28 }
29
30 // Görev 2: dahili LED kendi temposunda yanıp söner / Task 2: the onboard LED blinks at its own pace
31 if (simdi - sonBlink >= 500) {
32 sonBlink = simdi;
33 digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
34 }
35 // Buraya buton, sensör ya da seri port kodu eklenebilir / button, sensor or serial code can go here
36}Twee details zijn hier belangrijk. Ten eerste moeten de tijdvariabelen unsigned long zijn; gebruik je int, dan loopt de waarde op de Uno na ongeveer 32,7 seconden over en klopt de timing niet meer: het effect stopt of versnelt onbeheersbaar. Ten tweede gebeurt de vergelijking met een aftrekking in de vorm simdi - sonAdim >= aralik (nu min laatste stap, vergeleken met het interval); deze methode blijft correct werken, ook als millis() ongeveer elke 49,7 dagen terugspringt naar nul. Omdat we de positie en de richting van het licht in twee variabelen bijhouden (konum en yon), zijn er geen lussen meer: bij elke stap gaat de positie één omhoog of omlaag en aan de uiteinden wisselt de richting van teken.
8 LED's met 3 pinnen via een 74HC595
Acht LED's nemen acht pinnen van de Uno in beslag; zodra je een LCD, sensoren en knoppen aan je project wilt toevoegen, raken ze op. Het 74HC595-schuifregister stuurt zijn acht uitgangen aan met slechts drie Arduino-pinnen (data, klok en latch). De toestand van elke LED is één bit van een byte: de uitdrukking 1 << i zet alleen bit i op 1, waardoor één LED oplicht. Patronen bouwen met bitbewerkingen is ook eenvoudig: (1 << i) | (0x80 >> i) levert twee lichten op die tegelijk van beide uiteinden naar het midden komen. Door twee chips te koppelen kun je met dezelfde drie pinnen ook een Knight Rider met 16 LED's bouwen; het koppelen, het snel aansturen via SPI en het gebruik van 7-segmentdisplays worden stap voor stap uitgelegd in het artikel 74HC595-schuifregister.
| Pin van de 74HC595 | Aansluiting (Arduino Uno) |
|---|---|
| DS (14) | D11 |
| SH_CP (11) | D13 |
| ST_CP (12) | D10 |
| OE (13) | GND (uitgangen altijd ingeschakeld) |
| MR (10) | 5V (reset uitgeschakeld) |
| VCC (16) / GND (8) | 5V / GND, met een condensator van 100 nF ernaast |
| Q0 (15), Q1–Q7 (1–7) | Elk via 470 Ω naar de anode van een LED |
| Middelste pootje van de potmeter | A0 |
1// 74HC595 ile 3 pinden 8 LED: karaşimşek ve ortada buluşma / 8 LEDs from 3 pins with a 74HC595: Knight Rider and meet-in-the-middle
2const int DATA_PIN = 11; // DS (14)
3const int CLOCK_PIN = 13; // SH_CP (11)
4const int LATCH_PIN = 10; // ST_CP (12)
5const int POT = A0;
6
7void yaz595(byte desen) {
8 digitalWrite(LATCH_PIN, LOW);
9 shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, desen); // 8 biti gönder / send the 8 bits
10 digitalWrite(LATCH_PIN, HIGH); // çıkışlara aktar / copy to the outputs
11}
12
13void setup() {
14 pinMode(DATA_PIN, OUTPUT);
15 pinMode(CLOCK_PIN, OUTPUT);
16 pinMode(LATCH_PIN, OUTPUT);
17 yaz595(0); // açılışta hepsi sönük / all off at startup
18}
19
20void loop() {
21 int bekle = map(analogRead(POT), 0, 1023, 400, 20);
22
23 for (int i = 0; i < 7; i++) { yaz595(1 << i); delay(bekle); } // Q0 -> Q7
24 for (int i = 7; i > 0; i--) { yaz595(1 << i); delay(bekle); } // Q7 -> Q0
25
26 for (int i = 0; i < 4; i++) { // uçlardan ortaya / from the ends to the middle
27 yaz595((1 << i) | (0x80 >> i));
28 delay(bekle);
29 }
30 for (int i = 3; i >= 0; i--) { // ortadan uçlara / from the middle to the ends
31 yaz595((1 << i) | (0x80 >> i));
32 delay(bekle);
33 }
34}Op de uitgangen van de 74HC595 wordt 470 Ω aanbevolen in plaats van 220 Ω: de totale stroom door de VCC- en GND-pinnen van de chip mag niet boven 70 mA komen. Met 470 Ω loopt er ongeveer 6,4 mA per LED en zelfs met alle acht LED's aan blijft het totaal op 51 mA. In een Knight Rider zijn er sowieso maar één of twee LED's tegelijk aan, dus de LED's blijven duidelijk zichtbaar.
Knight Rider met uitdovende staart vanaf één pin met WS2812B
De versie die het meest op de echte KITT-scanner lijkt, bouw je met adresseerbare WS2812B-LED's. Elke WS2812B heeft een eigen driver ingebouwd; hoe lang de strip ook is, je stelt de kleur en helderheid van elke LED afzonderlijk in via één datadraad. Voor de staart houden we een array bij: bij elke stap wordt de helderheid van alle LED's door drie gedeeld en wordt de kop-LED op 255 gezet. De LED's erachter doven snel via 255, 85, 28, 9 en laten een natuurlijk spoor achter het licht na. Gebruik 2 in plaats van 3 als deler en de staart wordt langer; gebruik 5 en hij wordt korter. Om met dezelfde methode van 8 naar 60 LED's te gaan, hoef je alleen NUM_LEDS te veranderen.

1// WS2812B ile kuyruklu karaşimşek (tek veri pini) / Knight Rider with a fading tail on WS2812B (one data pin)
2#include <Adafruit_NeoPixel.h>
3
4const int DATA_PIN = 6; // DIN, 330 Ω üzerinden / DIN through 330 Ω
5const int NUM_LEDS = 8; // şerit ya da çubuktaki LED sayısı / LEDs on the strip or stick
6const int POT = A0;
7
8Adafruit_NeoPixel strip(NUM_LEDS, DATA_PIN, NEO_GRB + NEO_KHZ800);
9
10uint8_t seviye[NUM_LEDS]; // her LED'in kırmızı parlaklığı / red brightness of each LED
11int konum = 0;
12int yon = 1;
13
14void setup() {
15 strip.begin();
16 strip.setBrightness(80); // 0–255; USB için düşük tut / keep it low on USB power
17 strip.show(); // hepsini söndür / all off
18}
19
20void loop() {
21 for (int i = 0; i < NUM_LEDS; i++) seviye[i] = seviye[i] / 3; // kuyruk söner / the tail fades
22 seviye[konum] = 255; // baştaki LED tam parlak / the head is full brightness
23
24 for (int i = 0; i < NUM_LEDS; i++) {
25 strip.setPixelColor(i, strip.Color(seviye[i], 0, 0)); // yalnız kırmızı / red only
26 }
27 strip.show();
28
29 konum += yon;
30 if (konum == NUM_LEDS - 1 || konum == 0) yon = -yon; // uçta yön değiştir / reverse at the ends
31 delay(map(analogRead(POT), 0, 1023, 150, 20));
32}Knight Rider op de ESP32: een PWM-staart op elke pin
Op de Uno is een Knight Rider met staart lastig te bouwen met gewone LED's, omdat PWM alleen beschikbaar is op de pinnen 3, 5, 6, 9, 10 en 11 en onze D2–D9-array er maar vier van bevat. Op de ESP32 kan bijna elke uitgangspin PWM genereren dankzij de LEDC-hardware, en de klassieke ESP32 heeft 16 PWM-kanalen. Omdat analogWrite() direct werkt in de huidige ESP32 Arduino-core, kun je de staartlogica van de WS2812B toepassen op gewone LED's. De pinnen in de tabel zijn veilige GPIO's die het opstarten niet beïnvloeden; de potmeter wordt aangesloten op GPIO 34 op een ADC1-kanaal, dat ook met Wi-Fi aan betrouwbaar leest, en omdat de ADC van de ESP32 12 bit is, loopt de waarde van 0 tot 4095. De pinnen van de ESP32 leveren 3,3 V, dus er loopt ongeveer 6 mA door een rode LED met 220 Ω; de LED's zien er iets dimmer uit dan op de Uno. Voor het instellen van het board, zie Wat is de ESP32?.
1// ESP32: her pinde PWM ile kuyruklu karaşimşek / ESP32: Knight Rider with a PWM tail on every pin
2const int LEDS[] = {18, 19, 21, 22, 23, 25, 26, 27};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = 34; // ADC1, yalnızca giriş / ADC1, input only
5
6int parlaklik[LED_SAYISI]; // 0–255
7int konum = 0;
8int yon = 1;
9unsigned long sonAdim = 0;
10
11void setup() {
12 // analogWrite() pini PWM için kendisi hazırlar / analogWrite() sets the pin up for PWM itself
13}
14
15void loop() {
16 unsigned long aralik = map(analogRead(POT), 0, 4095, 400, 20); // ESP32 ADC 12 bit: 0–4095
17 if (millis() - sonAdim >= aralik) {
18 sonAdim = millis();
19 for (int i = 0; i < LED_SAYISI; i++) parlaklik[i] /= 3; // kuyruk söner / the tail fades
20 parlaklik[konum] = 255;
21 for (int i = 0; i < LED_SAYISI; i++) analogWrite(LEDS[i], parlaklik[i]);
22 konum += yon;
23 if (konum == LED_SAYISI - 1 || konum == 0) yon = -yon;
24 }
25}Knight Rider op de Raspberry Pi Pico met MicroPython
Op de Raspberry Pi Pico schrijf je hetzelfde effect in een paar regels MicroPython. De Pin-objecten in een lijst bewaren doet hetzelfde werk als de array op de Arduino. time.ticks_ms() en time.ticks_diff() zijn de MicroPython-equivalenten van millis() en de overloopveilige aftrekking. De potmeter wordt aangesloten op GP26 (ADC0); read_u16() geeft een waarde van 0 tot 65535 en de code zet die om naar 400–20 ms. Het wordt aanbevolen dat de totale stroom uit alle GPIO's van de Pico onder 50 mA blijft; daarom hebben we in de tabel 330 Ω gekozen: er loopt ongeveer 4 mA per LED en zelfs met alle acht LED's aan blijft het totaal rond 32 mA. Het BlueGrays-project Pico Knight Rider gebruikt 6 LED's op de pinnen GP9–GP14; als je die schakeling hebt gebouwd, verander dan gewoon de lijst PINLER in [9, 10, 11, 12, 13, 14]. Voor het instellen en het uploaden van code met Thonny, zie Wat is de Raspberry Pi Pico?.
1# Raspberry Pi Pico: potansiyometreyle hız ayarlı karaşimşek / Pico: Knight Rider with pot speed control
2from machine import Pin, ADC
3import time
4
5PINLER = [8, 9, 10, 11, 12, 13, 14, 15] # GP8–GP15
6leds = [Pin(p, Pin.OUT) for p in PINLER]
7pot = ADC(26) # GP26 = ADC0
8
9def adim_suresi():
10 # read_u16: 0–65535 -> 400–20 ms
11 return 400 - pot.read_u16() * 380 // 65535
12
13konum, yon = 0, 1
14leds[konum].on()
15son = time.ticks_ms()
16
17while True:
18 if time.ticks_diff(time.ticks_ms(), son) >= adim_suresi(): # millis() benzeri / like millis()
19 son = time.ticks_ms()
20 leds[konum].off()
21 konum += yon
22 if konum == len(leds) - 1 or konum == 0:
23 yon = -yon # uçta yön değiştir / reverse at the ends
24 leds[konum].on()Elke GPIO van de Pico kan ook PWM genereren; met machine.PWM en een duty_u16()-waarde voor elke LED breng je het staarteffect van de ESP32 over naar de Pico. Als je WS2812B-LED's wilt gebruiken, stuurt de ingebouwde neopixel-module van MicroPython een strip aan vanaf één GPIO; een WS2812B die op 5 V wordt gevoed, leest het datasignaal van 3,3 V van de Pico echter niet altijd betrouwbaar, dus als de kleuren haperen, voeg dan een niveauconverter toe.
Projectideeën met Knight Rider
- Geluidsniveaumeter (VU-meter): gebruik de luidheid die je meet met een KY-038-geluidssensor om te bepalen hoeveel LED's van de vulbalk oplichten.
- LED-balk voor een parkeersensor: laat meer LED's oplichten naarmate de afstand die je meet met een HC-SR04 kleiner wordt en laat ze allemaal knipperen als je heel dichtbij komt.
- Vang-het-licht-spel: probeer, terwijl de scanner snel heen en weer veegt, precies op een knop te drukken als de middelste LED brandt; maak de staptijd na elk succes korter.
- Automatische nachtdecoratie: laat het effect vanzelf starten als een LDR merkt dat het donker wordt.
- Achterlicht voor een modelauto of fiets: maak een rode Knight Rider met staart op een WS2812B-stick en laat alle LED's op volle sterkte branden als de remknop wordt ingedrukt.
- Niveau-indicator: toon de stand van een potmeter of een batterijspanning als vulbalk.
- Grotere displays: neem dezelfde logica mee naar een MAX7219-ledmatrix of een LED-kubus.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| De LED's branden erg zwak | pinMode(OUTPUT) ontbreekt; digitalWrite schakelt alleen de interne pull-upweerstand in | Maak alle pinnen OUTPUT met een lus in setup() |
| Eén LED licht nooit op | De LED zit verkeerd om, of een weerstand of draad zit één rij verkeerd | Lang pootje naar de weerstand en pin, kort pootje naar GND; test de LED los met 5V en een weerstand |
| De LED's aan de uiteinden blijven twee keer zo lang branden | Beide lussen bevatten de LED's aan de uiteinden | Gebruik i < LED_SAYISI − 1 in de voorwaartse lus en i > 0 in de achterwaartse lus |
| Een willekeurige pin flikkert of het programma gedraagt zich vreemd | Voorbij het einde van de array lezen: i <= LED_SAYISI | Verander de voorwaarde in i < LED_SAYISI; er is geen element LEDS[8] |
| De code wordt niet geüpload, of de LED's flikkeren tijdens het uploaden | LED's zijn aangesloten op D0 en D1 | Laat de array bij D2 beginnen |
| De potmeter verandert de snelheid niet | Een buitenste pootje zit op A0 in plaats van het middelste pootje, of de waarde wordt maar één keer buiten de lus gelezen | Sluit het middelste pootje aan op A0; roep analogRead bij elke stap aan |
| Het effect gaat na ongeveer 32 seconden fout | De millis()-waarde wordt opgeslagen in een int-variabele | Maak de tijdvariabelen unsigned long |
| De WS2812B's lichten helemaal niet op of tonen willekeurige kleuren | Geen gemeenschappelijke GND, geen dataweerstand, of de strip is aan het verkeerde uiteinde aangesloten (DOUT) | Verbind de GND's, voeg 330 Ω toe en sluit aan op het DIN-uiteinde, waar de pijlen vandaan wijzen |
De Knight Rider ziet er eenvoudig uit, maar bevat de basisideeën die je later in elk project gebruikt: arrays, lussen, analoge metingen, map(), niet-blokkerende timing, bitbewerkingen en adresseerbare LED's. Bekijk als volgende stap het project Arduino-stoplicht of de lijst met Arduino-projectideeën. In de BlueGrays-app vind je het looplicht, de Knight Rider en de versies met instelbare snelheid, de WS2812B-stapel- en Knight Rider-effecten en de projecten ESP32-looplicht en Pico Knight Rider, elk met een stapsgewijs schakelschema en kant-en-klare code om op je eigen board te proberen.
Veelgestelde vragen
Hoeveel LED's kan een Arduino Uno aansturen?
De Uno heeft 20 pinnen die als digitale uitgang kunnen dienen, D0–D13 en A0–A5; als je D0 en D1 vrijlaat voor seriële communicatie, kun je 18 LED's direct aansturen. Geef elke LED een eigen weerstand en houd de totale stroom onder 200 mA; als alle 18 tegelijk aan zijn, kies dan 330 Ω of meer. Gebruik voor meer LED's een 74HC595-schuifregister of een WS2812B-strip, die honderden LED's vanaf één pin aanstuurt.
Welke weerstand heb ik nodig voor een LED-chaser?
Op een Arduino Uno van 5 V past 220 Ω bij rode LED's en geeft dat ongeveer 13,6 mA per LED; 330 Ω werkt ook, maar dan zijn de LED's iets dimmer. Op de ESP32 van 3,3 V wordt 220 Ω aanbevolen en op de Pico 330 Ω. Bij effecten waarin maar één LED tegelijk brandt, werkt ook één gedeelde weerstand, maar de helderheid daalt als er meerdere LED's oplichten, dus één weerstand per LED is de juiste keuze.
Kun je een Knight Rider-schakeling bouwen zonder Arduino?
Ja, de klassieke manier is een 555-timer en een CD4017-tellerchip. De 555 maakt klokpulsen en de 4017 zet zijn 10 uitgangen na elkaar op HIGH, wat op zichzelf al een looplicht geeft. Voor de heen-en-weerbeweging worden de uitgangen met diodes gecombineerd: de 10 uitgangen worden in de volgorde 1-2-3-4-5-6-5-4-3-2 met 6 LED's verbonden en de snelheid stel je in met een potmeter op de 555.
Wat is het verschil tussen een looplicht en een Knight Rider-effect?
Bij een looplicht loopt het licht in één richting en begint het na de laatste LED opnieuw; met 8 LED's is één ronde 8 stappen. Bij een Knight Rider keert het licht aan het einde om en stuitert het tussen de twee uiteinden; met 8 LED's is één ronde 14 stappen. Ook in de code is het verschil klein: voor de Knight Rider voeg je een tweede lus toe die achteruit telt.
Waarom millis() gebruiken in plaats van delay() voor een LED-chaser?
Zolang delay() loopt, kan de Arduino niets anders doen; hij mist knopdrukken en kan geen sensoren lezen. Met millis() zet elke doorloop van de lus pas een stap als de tijd om is en draaien andere taken in de resterende tijd. Dus terwijl de scanner veegt, reageren knoppen, potmeters of seriële commando's direct.
Hoe voeg je een uitdovende staart toe aan het Knight Rider-effect?
Voor de staart moet je de LED's achter de kop geleidelijk dimmen, wat PWM vereist. Op de Uno is PWM alleen beschikbaar op de pinnen 3, 5, 6, 9, 10 en 11, dus op die pinnen kun je een Knight Rider met 6 LED's en een staart bouwen. De makkelijkere route is een WS2812B-strip, waarbij je elke LED afzonderlijk instelt, of een ESP32 of Pico, die op elke pin PWM hebben.
Projecten om hierna te bouwen
Alle projecten bekijken
Knight Rider-ledeffect
Het klassieke scannerlicht: een lichtpunt schuift van het ene uiteinde van zes LED's naar het andere en komt dan terug.

LED-looplicht
Lichten die na elkaar aangaan, alsof ze rennen. De Arduino laat zes LED's een voor een branden; elke LED licht even op en gaat uit, zodat het licht van begin tot eind loopt en dan opnieuw begint.

Knight Rider-ledeffect met instelbare snelheid
Een licht rent van het ene uiteinde van zes LED's naar het andere, draait om en rent weer terug.

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.

WS2812B Knight Rider-effect
Een rood lichtpuntje glijdt van het ene uiteinde van een slimme ledstrip naar het andere en komt dan terug, heen en weer zonder ooit te stoppen.

WS2812B-looplicht (opbouweffect)
Een lichtstrip die zich vult en leegt als een glas water. De Arduino laat tien kleurenleds een voor een oranje branden en houdt ze aan; als de strip vol is, schakelt hij ze in dezelfde volgorde een…

ESP32 Knight Rider-ledlicht
6 leds die na elkaar van links naar rechts en van rechts naar links bewegen (Knight Rider-stijl). Een basisvoorbeeld van het gebruik van for-lussen en arrays. Leert je de logica van richtingswisseling.

Raspberry Pi Pico Knight Rider-ledscanner (6 leds heen en weer)
Het klassieke "Knight Rider"-ledscannereffect met de Pico! 6 leds lopen van links naar rechts en dan terug, eindeloos, zoals de voorgrille van KITT uit de iconische tv-serie uit de jaren 80. Een upgrade van het looplichtproject: dezelfde schakeling met 6 leds (GP9-GP14), ander codepatroon. Je leert reversed() om een lijst om te draaien, twee for-lussen voor het heen-en-weer-patroon en meerdere animaties op dezelfde schakeling.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

