Arduino programmeren: variabelen, lussen en functies voor beginners
Leer Arduino programmeren vanaf nul: setup en loop, int, long, byte, overflow, const, #define, if-else, switch-case, lussen, arrays en functies met LED's.
Arduino programmeren betekent dat je een Arduino-board in de taal C/C++ vertelt wat het moet doen: je schrijft welke led wanneer oplicht, wat er gebeurt als je op een knop drukt en hoe een getal van een sensor wordt geïnterpreteerd. Het board herhaalt die instructies duizenden keren per seconde. Het goede nieuws is dat bijna elke sketch die je tegenkomt, van een knipperende led tot een robotauto, is opgebouwd uit dezelfde tien bouwstenen. Dat zijn setup() en loop(), variabelen, constanten, operatoren, if-else, switch-case, for- en while-lussen, arrays en functies.
In deze gids leer je die bouwstenen een voor een, elk met een echt voorbeeld met een led of knop. Alle voorbeelden draaien op dezelfde eenvoudige schakeling en zijn gecompileerd en getest voor de Arduino Uno. De plekken waar beginners het vaakst vastlopen, namelijk overflow van variabelen, = en == door elkaar halen, een vergeten break en een teller die bij elke ronde opnieuw begint, worden apart uitgelegd. In de laatste delen zie je ook hoe dezelfde logica werkt op de ESP32 en hoe het eruitziet in MicroPython op de Raspberry Pi Pico.

Wat is Arduino programmeren en welke taal gebruikt het?
Arduino-code is gebaseerd op C++; er bestaat geen aparte "Arduino-taal". De Arduino-core voegt kant-en-klare functies zoals pinMode(), digitalWrite() en delay() toe aan C++. Het bestand dat je schrijft heet een sketch en heeft de extensie .ino. Als je op Verify klikt, voegt de Arduino IDE de header Arduino.h bovenaan het bestand toe en maakt de functiedeclaraties voor je aan. De compiler zet de code vervolgens om in machinecode die de processor begrijpt. De Upload-knop stuurt die uitvoer daarna via USB naar de bootloader van het board. Heb je de IDE nog niet geïnstalleerd, begin dan met de gids Arduino IDE installeren.
Bij het schrijven van code gelden een paar basisregels. Als je ze vooraf leert, voorkom je de helft van de compileerfouten die je anders in je eerste dagen ziet:
| Regel | Goed | Als je de regel overtreedt |
|---|---|---|
| Elke instructie eindigt met een puntkomma | digitalWrite(13, HIGH); | expected ';' before '}' token |
| Hoofdletters en kleine letters maken verschil | pinMode(13, OUTPUT); | 'pinmode' was not declared in this scope |
| Codeblokken staan tussen accolades | void loop() { ... } | Bij elke { hoort een } |
| Opmerking van één regel | // deze regel wordt niet uitgevoerd | Opmerkingen worden niet gecompileerd, ze dienen als uitleg |
| Opmerking over meerdere regels | /* ... */ | Als je hem niet afsluit, wordt alles eronder commentaar |
| Tekst staat tussen dubbele aanhalingstekens, een enkel teken tussen enkele | "Hello" en 'A' | Als je de soorten aanhalingstekens door elkaar haalt, krijg je een verkeerde waarde of een foutmelding |
De schakeling in de voorbeelden
Alle voorbeelden draaien op één schakeling. Sluit zes LED's aan op pin D8–D13, elk via een weerstand van 220 Ω; het korte pootje (kathode) van elke led gaat naar GND. De weerstandswaarde voor jouw led controleer je met de LED-weerstandscalculator. Sluit één pootje van de knop aan op D2 en het diagonaal tegenoverliggende pootje op GND. Omdat de code INPUT_PULLUP gebruikt, is geen externe weerstand nodig: de pin leest HIGH als de knop los is en LOW als hij is ingedrukt. Meer details vind je in Een drukknop aansluiten op Arduino en Wat is een led?.
| Onderdeel | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| 6 LED's (elk met 220 Ω, kathode naar GND) | D8, D9, D10, D11, D12, D13 | GPIO 18, 19, 21, 22, 23, 25 | GP14, GP13, GP12, GP11, GP10, GP9 |
| Knop (andere pootje naar GND) | D2 | GPIO 4 | GP2 |
| Ingebouwde led | D13 (de led met de markering L) | GPIO 2 (de meeste DevKits) | GP25 ("LED" op de Pico W) |
| Seriële snelheid | 9600 baud | 115200 baud | Thonny Shell |
setup() en loop(): het skelet van elke sketch
Elke Arduino-sketch heeft twee verplichte functies. setup() wordt maar één keer uitgevoerd, wanneer het board stroom krijgt of de resetknop wordt ingedrukt; voorbereidingen zoals pininstellingen en Serial.begin() horen hier. loop() herhaalt zich daarna eindeloos zodra setup() klaar is. Achter de schermen heeft de Arduino-core een verborgen functie main(): die maakt eerst de hardware gereed, roept dan één keer setup() aan en roept loop() steeds opnieuw aan in een oneindige lus. Het gedeelte bovenaan het bestand, buiten deze twee functies, is het globale gebied; constanten en variabelen die overal bereikbaar moeten zijn, definieer je daar.
1// 1) Global alan: sabitler ve değişkenler / Global area: constants and variables
2const int LED_PIN = 13; // dahili LED / built-in LED
3unsigned long passCount = 0; // loop() kaç kez döndü / how many times loop() has run
4
5// 2) setup(): açılışta bir kez çalışır / runs once at power-up or reset
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 Serial.begin(9600);
9 Serial.println("setup() bitti / setup() done");
10}
11
12// 3) loop(): sonsuza kadar tekrar eder / repeats forever
13void loop() {
14 passCount++; // her turda 1 artır / add 1 on every pass
15 Serial.print("Tur / Pass: ");
16 Serial.println(passCount);
17
18 digitalWrite(LED_PIN, HIGH); // LED'i yak / LED on
19 delay(500); // 500 ms bekle / wait 500 ms
20 digitalWrite(LED_PIN, LOW); // LED'i söndür / LED off
21 delay(500);
22}Upload de code en open de Serial Monitor op 9600 baud: je ziet één keer "setup() done", gevolgd door een rondenummer dat elke seconde oploopt, terwijl de ingebouwde led in hetzelfde ritme knippert. De twee delay(500)-aanroepen in loop() rekken elke ronde op tot ongeveer één seconde; een loop() zonder wachttijd en zonder seriële uitvoer kan op een Uno honderdduizenden keren per seconde draaien. Wil je meer uit de Serial Monitor halen, lees dan de gids Arduino Serial Monitor.
Variabelen en datatypes: int, long, float, bool, byte
Een variabele is een benoemd vakje in het geheugen waarin een waarde staat. Als je er een definieert, schrijf je eerst het type, dan de naam en eventueel een beginwaarde, bijvoorbeeld int counter = 0;. Het type bepaalt hoeveel bytes het vakje inneemt en welk bereik aan getallen erin past. De Arduino Uno heeft maar 2 KB RAM, dus het kiezen van het juiste type is belangrijk. Namen van variabelen beginnen met een letter of een underscore en mogen geen spaties of letters met accenten zoals é, ü of ç bevatten.
| Type | Grootte op Uno | Bereik | Typisch gebruik |
|---|---|---|---|
| bool | 1 byte | true of false | Is de led aan, is de knop ingedrukt |
| byte | 1 byte | 0 – 255 | Pinnummer, PWM-helderheid |
| char | 1 byte | -128 – 127 | Eén teken: 'A' |
| int | 2 bytes | -32.768 – 32.767 | Tellers, resultaten van analogRead() |
| unsigned int | 2 bytes | 0 – 65.535 | Alleen positieve getallen |
| long | 4 bytes | -2.147.483.648 – 2.147.483.647 | Grote gehele getallen |
| unsigned long | 4 bytes | 0 – 4.294.967.295 | Tijd meten met millis() |
| float | 4 bytes | Ongeveer ±3,4 × 10^38, 6–7 cijfers nauwkeurig | Temperatuur, spanning, gemiddelden |
| double | 4 bytes (hetzelfde als float op de Uno) | Hetzelfde als float | 8 bytes op de ESP32 |
Een paar praktische regels besparen je veel gedoe. analogRead() geeft een getal van 0 tot 1023, dus een int is genoeg. millis() geeft daarentegen een unsigned long; als je de tijd in een int-variabele bewaart, loopt de waarde na 32,7 seconden over en gaat je timing stuk. Op de Uno gebeurt rekenen met floats in software, dus dat is trager dan rekenen met gehele getallen, en alles voorbij 6–7 cijfers is niet betrouwbaar; daarom vergelijk je twee floats niet met ==. Wil je een type waarvan de grootte op elk board gelijk blijft, gebruik dan types met de grootte in de naam, zoals uint8_t, int16_t en uint32_t.
Overflow: wat gebeurt er als een variabele over zijn grens gaat?
Als je een getal probeert op te slaan dat groter is dan wat het type aankan, geeft de Arduino geen fout; het getal slaat om zoals de kilometerteller van een auto. Op de Uno bevat een int maximaal 32.767 en als je er 1 bij optelt, wordt het -32.768. Een byte springt van 255 naar 0. Een gemenere valkuil is rekenen met constanten: een uitdrukking als 60 * 1000 wordt eerst als int berekend en loopt over, zelfs als je het resultaat in een long-variabele opslaat. De onderstaande sketch print al deze gevallen naar de Serial Monitor en zijn loop() toont een byte-overflow op een led:
1const int LED_PIN = 9; // PWM destekli pin (~9) / PWM-capable pin (~9)
2byte brightness = 0; // byte: 0-255
3
4void setup() {
5 pinMode(LED_PIN, OUTPUT);
6 Serial.begin(9600);
7
8 int a = 32767; // Uno'da int'in en büyük değeri / largest int on an Uno
9 a = a + 1; // taşma: -32768 olur / overflow: becomes -32768
10 Serial.println(a);
11
12 long wrong = 60 * 1000; // int ile hesaplanır, taşar: -5536 / computed as int, overflows: -5536
13 long right = 60 * 1000L; // L eki hesabı long yapar: 60000 / the L suffix makes it long math: 60000
14 Serial.println(wrong);
15 Serial.println(right);
16
17 float half = 5 / 2; // tam sayı bölmesi: 2.00 / integer division: 2.00
18 float half2 = 5 / 2.0; // ondalıklı bölme: 2.50 / floating-point division: 2.50
19 Serial.println(half);
20 Serial.println(half2);
21}
22
23void loop() {
24 analogWrite(LED_PIN, brightness); // parlaklığı uygula / apply the brightness
25 brightness++; // 255'ten sonra 0'a döner / wraps to 0 after 255
26 delay(10);
27}| Regel code | Uitvoer op Uno | Uitvoer op ESP32 en Pico | Waarom? |
|---|---|---|---|
| a = 32767 + 1 | -32768 | 32768 | int is 2 bytes op de Uno, 4 bytes op de andere boards |
| 60 * 1000 | -5536 | 60000 | Constanten worden eerst als int berekend |
| 60 * 1000L | 60000 | 60000 | Het achtervoegsel L maakt de berekening long |
| 5 / 2 | 2.00 | 2.00 | Twee gehele getallen delen geeft een geheel getal |
| 5 / 2.0 | 2.50 | 2.50 | Als één getal een decimale punt heeft, krijgt het resultaat die ook |
Kijk naar de led op D9: de helderheid stijgt langzaam van 0 naar 255, daarna maakt de regel brightness++ er 0 van in plaats van 256 en gaat de led plotseling uit. Zo zie je overflow het makkelijkst met je eigen ogen. D9 is een van de PWM-pinnen van de Uno, gemarkeerd met ~, dus analogWrite() werkt daar; PWM wordt uitgebreid behandeld in Wat is PWM?. Dat millis() na ongeveer 49,7 dagen overloopt, is ook een overflow, en in correct geschreven code geeft dat geen problemen; hoe je dat schrijft, lees je in de gids millis() versus delay().
const en #define: waarden die nooit veranderen
Er zijn twee manieren om getallen die tijdens het programma niet veranderen, zoals pinnummers en drempelwaarden, een naam te geven. Een constante die je met const definieert heeft een type, volgt de regels voor bereik en als je hem per ongeluk probeert te wijzigen, stopt de compiler je met assignment of read-only variable 'LED_PIN'. #define is daarentegen een preprocessor-instructie: voordat het compileren begint, vervangt die elke BUTTON_PIN in de code door 2. Het heeft geen type en de regel krijgt geen puntkomma en geen is-gelijkteken. Bij simpele getallen gebruikt geen van beide RAM, omdat de compiler de waarde rechtstreeks in de code zet. Tegenwoordig heeft const de voorkeur en constantenamen in HOOFDLETTERS schrijven is een gangbare gewoonte. Het onderstaande voorbeeld gebruikt beide: de led blijft aan zolang je de knop ingedrukt houdt.
1#define BUTTON_PIN 2 // önişlemci: derlemeden önce metin değişimi / preprocessor: text swap before compiling
2const int LED_PIN = 13; // tipi olan, salt okunur sabit / typed, read-only constant
3
4void setup() {
5 pinMode(LED_PIN, OUTPUT);
6 pinMode(BUTTON_PIN, INPUT_PULLUP); // dahili pull-up: basılınca LOW / internal pull-up: LOW when pressed
7}
8
9void loop() {
10 if (digitalRead(BUTTON_PIN) == LOW) { // buton basılı mı? / is the button pressed?
11 digitalWrite(LED_PIN, HIGH); // evet: LED yanar / yes: LED on
12 } else {
13 digitalWrite(LED_PIN, LOW); // hayır: LED söner / no: LED off
14 }
15}Operatoren: rekenkundig, vergelijken en logica
Met operatoren reken je met variabelen, vergelijk je ze en combineer je voorwaarden. Bijna elke operator die je in alledaagse projecten gebruikt, staat in deze tabel:
| Groep | Operator | Betekenis | Voorbeeld |
|---|---|---|---|
| Rekenkundig | + - * / | De vier basisbewerkingen | x = a * 2; |
| Rest | % | Rest van een deling (alleen gehele getallen) | 7 % 3 geeft 1 |
| Toekenning | = += -= *= /= | Instellen, ophogen, verlagen… | total += 5; |
| Ophogen, verlagen | ++ -- | 1 erbij of 1 eraf | i++; |
| Vergelijking | == != < > <= >= | Het resultaat is true of false | if (x >= 10) |
| Logica | && || ! | EN, OF, NIET | if (a && !b) |
| Voorwaardelijk | ? : | Korte if-else | x > 0 ? HIGH : LOW |
| Bitgewijs | & | ^ ~ << >> | Werkt op de bits van een getal | 1 << 3 geeft 8 |
De twee paren die het vaakst door elkaar worden gehaald, zijn = en == en & en &&. Een enkel is-gelijkteken kent een waarde toe, een dubbel vergelijkt. Een enkele & werkt op de bits van getallen, terwijl && vraagt of beide voorwaarden waar zijn. De waarheidstabellen van AND, OR en NOT kun je uitproberen in de tool Logische poorten en bitoperatoren worden uitgebreid uitgelegd in de gids getalsystemen en bitbewerkingen. Het onderstaande voorbeeld telt hoe vaak de knop is ingedrukt en laat de led branden na een oneven aantal keren:
1const int LED_PIN = 13;
2const int BUTTON_PIN = 2;
3
4int presses = 0; // toplam basış sayısı / total number of presses
5bool lastPressed = false; // önceki turdaki durum / state on the previous pass
6
7void setup() {
8 pinMode(LED_PIN, OUTPUT);
9 pinMode(BUTTON_PIN, INPUT_PULLUP);
10 Serial.begin(9600);
11}
12
13void loop() {
14 bool pressed = (digitalRead(BUTTON_PIN) == LOW); // karşılaştırma: true ya da false / comparison: true or false
15
16 if (pressed && !lastPressed) { // şimdi basılı VE önceden değildi: yeni basış / pressed now AND not before: new press
17 presses++; // 1 artır / increment by 1
18 Serial.print("Basış / Presses: ");
19 Serial.println(presses);
20 delay(50); // basit debounce / simple debounce
21 }
22 lastPressed = pressed;
23
24 // Kalan (%) ile tek mi çift mi? / odd or even using the remainder (%)
25 digitalWrite(LED_PIN, (presses % 2 == 1) ? HIGH : LOW);
26}De sleutel hier is de voorwaarde pressed && !lastPressed: die betekent "nu ingedrukt EN in de vorige ronde niet ingedrukt". Zo blijft het getal niet oplopen terwijl je de knop vasthoudt en wordt elke druk maar één keer geteld. presses % 2 geeft de rest van het getal gedeeld door 2: 1 voor oneven getallen, 0 voor even. De operator ? : op de laatste regel kiest dan HIGH of LOW op basis van dat resultaat.
if, else if en else: beslissingen nemen
if voert de code tussen de accolades uit als de voorwaarde tussen de haakjes waar is. Is de voorwaarde onwaar, dan wordt het else-blok uitgevoerd, als dat er is. Heb je meer opties nodig, dan voeg je else if ertussen toe. Voorwaarden worden van boven naar beneden gecontroleerd en zodra het blok van de eerste ware voorwaarde is uitgevoerd, worden de rest overgeslagen. In C++ telt elke waarde die niet nul is als waar, dus if (counter) betekent "als de teller niet nul is". Een eenvoudig if-else-voorbeeld zagen we al in het deel over const. Nu schrijven we er een die een korte druk van een lange druk onderscheidt:
1const int LED_PIN = 13;
2const int BUTTON_PIN = 2;
3
4void setup() {
5 pinMode(LED_PIN, OUTPUT);
6 pinMode(BUTTON_PIN, INPUT_PULLUP);
7 Serial.begin(9600);
8}
9
10void loop() {
11 if (digitalRead(BUTTON_PIN) == LOW) { // basıldı / pressed
12 unsigned long start = millis();
13 while (digitalRead(BUTTON_PIN) == LOW) { // bırakılana kadar bekle / wait until released
14 }
15 unsigned long held = millis() - start; // basılı kalma süresi (ms) / hold time (ms)
16
17 if (held < 50) {
18 return; // 50 ms'den kısa: parazit, yok say / under 50 ms: bounce, ignore
19 } else if (held < 1000) {
20 digitalWrite(LED_PIN, HIGH); // kısa basış: LED yak / short press: LED on
21 Serial.println("Kısa basış / Short press");
22 } else {
23 digitalWrite(LED_PIN, LOW); // uzun basış: LED söndür / long press: LED off
24 Serial.println("Uzun basış / Long press");
25 }
26 }
27}Op het moment dat de knop wordt ingedrukt, legt de code de tijd vast met millis(), wacht in een while-lus tot de knop wordt losgelaten en berekent de tijd ertussen. Drukken korter dan 50 ms worden behandeld als ruis door het mechanische contactdender van de knop en return beëindigt die ronde van loop() vroegtijdig. Een druk korter dan 1 seconde zet de led aan, een langere zet hem uit. De volgorde van de voorwaarden is belangrijk: had je de controle held < 1000 eerst gezet, dan zou ook een storing van 30 ms als een "korte druk" tellen.
switch-case: kiezen uit veel gevallen
Als je afhankelijk van de waarde van een variabele veel verschillende dingen moet doen, is switch-case beter leesbaar dan een lange else if-keten. switch vergelijkt de waarde tussen de haakjes met elk case-label en begint uit te voeren bij het label dat overeenkomt. Sluit elke case af met break; anders loopt het programma door in de code van de volgende case. Komt geen enkele case overeen, dan wordt het default-blok uitgevoerd. switch werkt alleen met types voor gehele getallen zoals int, byte, char en enum; voor String, float of bereiken zoals "tussen 10 en 20" heb je if nodig. In het onderstaande voorbeeld zet elke druk de lamp in de volgende stand: uit, aan, langzaam knipperen, snel knipperen.
1const int LED_PIN = 13;
2const int BUTTON_PIN = 2;
3
4byte mode = 0; // 0 kapalı, 1 açık, 2 yavaş, 3 hızlı / 0 off, 1 on, 2 slow, 3 fast
5bool lastPressed = false;
6
7void setup() {
8 pinMode(LED_PIN, OUTPUT);
9 pinMode(BUTTON_PIN, INPUT_PULLUP);
10}
11
12void loop() {
13 bool pressed = (digitalRead(BUTTON_PIN) == LOW);
14 if (pressed && !lastPressed) {
15 mode = (mode + 1) % 4; // 0 → 1 → 2 → 3 → 0
16 delay(50); // basit debounce / simple debounce
17 }
18 lastPressed = pressed;
19
20 switch (mode) {
21 case 0: // kapalı / off
22 digitalWrite(LED_PIN, LOW);
23 break;
24 case 1: // sürekli açık / always on
25 digitalWrite(LED_PIN, HIGH);
26 break;
27 case 2: // 500 ms'de bir değiş / toggle every 500 ms
28 digitalWrite(LED_PIN, (millis() / 500) % 2 ? HIGH : LOW);
29 break;
30 case 3: // 100 ms'de bir değiş / toggle every 100 ms
31 digitalWrite(LED_PIN, (millis() / 100) % 2 ? HIGH : LOW);
32 break;
33 default: // beklenmeyen değer: başa dön / unexpected value: reset
34 mode = 0;
35 break;
36 }
37}De regel mode = (mode + 1) % 4 laat de stand door 0, 1, 2, 3 lopen en dankzij de operator % weer terug naar 0 als hij 4 bereikt. Merk op dat we voor het knipperen geen delay() gebruiken: de uitdrukking (millis() / 500) % 2 wisselt elke 500 ms tussen 0 en 1, dus de knop reageert direct terwijl de led knippert. De volwassen versie van deze "standen"-aanpak heet een toestandsmachine; hoe die in projecten zoals verkeerslichten en menu's wordt gebruikt, zie je in de gids Arduino-toestandsmachine.
for-, while- en do-while-lussen
Lussen voeren een codeblok steeds opnieuw uit. De haakjes van een for-lus bestaan uit drie delen: het begin (int i = 0), de voorwaarde om door te gaan (i < 6) en de stap na elke ronde (i++). for is ideaal als je weet hoe vaak je moet herhalen. while gaat door zolang de voorwaarde waar is en controleert de voorwaarde vóór elke ronde, dus het past bij wachttijden waarvan je de lengte vooraf niet kent. do-while controleert de voorwaarde aan het eind en wordt dus altijd minstens één keer uitgevoerd. In een lus verlaat break de lus meteen en slaat continue de rest van de huidige ronde over en gaat naar de volgende. Omdat loop() zelf al een oneindige lus is, hoef je daarbinnen meestal geen while (true) te schrijven.
| Lus | Wanneer wordt de voorwaarde gecontroleerd? | Wanneer gebruik je hem? | Voorbeeld |
|---|---|---|---|
| for | Vóór elke ronde | Als het aantal herhalingen bekend is | for (int i = 0; i < 6; i++) |
| while | Vóór elke ronde | Tijdens het wachten tot er iets gebeurt | while (digitalRead(2) == HIGH) |
| do-while | Na elke ronde | Als hij minstens één keer moet draaien | do { ... } while (x < 10); |
Het onderstaande voorbeeld maakt een Knight Rider-effect met zes LED's. De for-lus in setup() maakt alle zes pinnen in één regel tot uitgangen en de while-lus in loop() wacht tot de knop wordt ingedrukt. Zolang je de knop vasthoudt, loopt het licht van D8 naar D13 en terug:
1const int FIRST_LED = 8; // ilk LED pini / first LED pin
2const int LAST_LED = 13; // son LED pini / last LED pin
3const int BUTTON_PIN = 2;
4
5void setup() {
6 for (int pin = FIRST_LED; pin <= LAST_LED; pin++) {
7 pinMode(pin, OUTPUT); // 6 pini tek döngüyle çıkış yap / make 6 pins outputs with one loop
8 }
9 pinMode(BUTTON_PIN, INPUT_PULLUP);
10}
11
12void loop() {
13 while (digitalRead(BUTTON_PIN) == HIGH) {
14 // butona basılana kadar burada bekle / wait here until the button is pressed
15 }
16
17 for (int pin = FIRST_LED; pin <= LAST_LED; pin++) { // ileri: 8 → 13 / forward: 8 → 13
18 digitalWrite(pin, HIGH);
19 delay(80);
20 digitalWrite(pin, LOW);
21 }
22 for (int pin = LAST_LED - 1; pin > FIRST_LED; pin--) { // geri: 12 → 9 / back: 12 → 9
23 digitalWrite(pin, HIGH);
24 delay(80);
25 digitalWrite(pin, LOW);
26 }
27}De terugweg beginnen bij LAST_LED - 1 en hem alleen laten lopen zolang de pin groter is dan FIRST_LED is een bewuste keuze: de LED's aan de uiteinden lichten niet twee keer achter elkaar op, zodat de beweging soepel oogt. Voor snelheidsregeling, een opvuleffect en meer patronen, zie de gids Arduino Knight Rider en looplicht.
Arrays: veel waarden onder één naam bewaren
Een array bewaart meerdere waarden van hetzelfde type op volgorde onder één naam. De regel const byte LEDS[] = {8, 9, 10, 11, 12, 13}; maakt een array met zes elementen. Je bereikt de elementen met vierkante haken en het tellen begint bij 0: LEDS[0] is 8 en LEDS[5] is 13. De lengte van een array kan na de definitie niet meer veranderen. Als je sizeof(LEDS) / sizeof(LEDS[0]) het aantal elementen laat berekenen in plaats van het met de hand te typen, passen je lussen zich automatisch aan wanneer je een nieuwe pin aan de array toevoegt. Een index buiten de array, zoals LEDS[6], veroorzaakt geen fout; hij leest of beschadigt een andere variabele in het geheugen. Daarom moet je zorgen dat de index tussen 0 en het aantal elementen min één blijft. Het onderstaande voorbeeld verandert de zes LED's in een elektronische dobbelsteen:
1const byte LEDS[] = {8, 9, 10, 11, 12, 13}; // LED pinleri / LED pins
2const byte LED_COUNT = sizeof(LEDS) / sizeof(LEDS[0]); // eleman sayısı: 6 / number of elements: 6
3const byte BUTTON_PIN = 2;
4
5void setup() {
6 for (byte i = 0; i < LED_COUNT; i++) { // indeks 0'dan başlar / index starts at 0
7 pinMode(LEDS[i], OUTPUT);
8 }
9 pinMode(BUTTON_PIN, INPUT_PULLUP);
10 randomSeed(analogRead(A0)); // boştaki A0'ın gürültüsüyle tohumla / seed from noise on the unconnected A0
11}
12
13void loop() {
14 if (digitalRead(BUTTON_PIN) == LOW) {
15 byte dice = random(1, 7); // 1 ile 6 arası / between 1 and 6
16 for (byte i = 0; i < LED_COUNT; i++) {
17 digitalWrite(LEDS[i], (i < dice) ? HIGH : LOW); // ilk 'dice' kadar LED yanar / the first 'dice' LEDs light up
18 }
19 delay(300); // basılı tutarsan zar dönmeye devam eder / keeps rolling while held
20 }
21}random(1, 7) geeft een getal van 1 tot 6, omdat de bovengrens niet in het resultaat zit. Zoveel LED's lichten op: als de dobbelsteen 4 toont, gaan de vier LED's van LEDS[0] tot LEDS[3] aan. De regel randomSeed(analogRead(A0)) gebruikt de elektrische ruis op de niet-aangesloten pin A0 als beginwaarde; zonder die regel zou het board bij elke start dezelfde reeks getallen maken. Nog iets moois aan arrays: als je de LED's naar andere pinnen verplaatst, hoef je alleen de eerste regel te wijzigen.
Functies schrijven: code in stukken verdelen
Als je in je programma op meerdere plekken dezelfde taak uitvoert, maak van die taak dan een functie. Een functie bestaat uit een returntype, een naam, parameters tussen haakjes en een body tussen accolades. Functies die geen waarde teruggeven hebben het type void; functies die dat wel doen, geven hun resultaat terug met return. Parameters worden als kopie doorgegeven, dus een parameter binnen de functie wijzigen verandert de variabele op de plek van de aanroep niet. De Arduino IDE maakt de declaraties voor functies in .ino-bestanden zelf aan, dus je kunt een functie ook onder loop() schrijven. In .cpp-bestanden of in PlatformIO moet je een functie echter declareren voordat je hem gebruikt. Geef je functies namen die zeggen wat ze doen, zoals blinkLed of isPressed.
1const byte LED_PIN = 13;
2const byte BUTTON_PIN = 2;
3
4// Değer döndürmeyen (void) fonksiyon / function that returns nothing (void)
5void blinkLed(byte pin, byte times, int ms) {
6 for (byte i = 0; i < times; i++) {
7 digitalWrite(pin, HIGH);
8 delay(ms);
9 digitalWrite(pin, LOW);
10 delay(ms);
11 }
12}
13
14// bool döndüren fonksiyon / function that returns a bool
15bool isPressed(byte pin) {
16 return digitalRead(pin) == LOW; // INPUT_PULLUP: basılı = LOW / pressed = LOW
17}
18
19void setup() {
20 pinMode(LED_PIN, OUTPUT);
21 pinMode(BUTTON_PIN, INPUT_PULLUP);
22 blinkLed(LED_PIN, 3, 100); // açılışta 3 hızlı yanıp sönme / 3 quick blinks at start-up
23}
24
25void loop() {
26 if (isPressed(BUTTON_PIN)) {
27 blinkLed(LED_PIN, 2, 250); // basınca 2 yavaş yanıp sönme / 2 slow blinks per press
28 }
29}blinkLed() neemt de pin, het aantal keren knipperen en de snelheid als parameters, zodat je dezelfde functie kunt hergebruiken voor een andere led en een andere snelheid. isPressed() geeft een bool terug en houdt de logica "ingedrukt = LOW" van INPUT_PULLUP op één plek; als je de knop ooit andersom aansluit, wijzig je alleen deze regel. De delay() in de functie stopt het programma echter nog steeds. Voor functies die meerdere dingen tegelijk doen, heb je timing op basis van millis() nodig.
Globale, lokale en statische variabelen
Waar een variabele zichtbaar is, heet zijn bereik (scope). Globale variabelen, buiten de functies gedefinieerd, leven zolang het hele programma draait en kunnen overal worden gelezen en gewijzigd. Lokale variabelen, gedefinieerd binnen een functie of een blok accolades, worden elke keer dat dat blok draait opnieuw aangemaakt en verdwijnen als het eindigt. Hier komt de meest gehoorde klacht van beginners vandaan: "mijn teller blijft steeds op 1". Zet je static voor een lokale variabele, dan krijgt die zijn beginwaarde alleen de eerste keer en behoudt hij zijn waarde tussen de rondes, maar hij is nog steeds alleen binnen die functie zichtbaar.
1const byte LED_PIN = 13;
2const byte BUTTON_PIN = 2;
3
4int globalCount = 0; // global: her yerden görünür, değerini korur / global: visible everywhere, keeps its value
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 pinMode(BUTTON_PIN, INPUT_PULLUP);
9 Serial.begin(9600);
10}
11
12void loop() {
13 int localCount = 0; // yerel: her turda yeniden 0 olur / local: back to 0 on every pass
14 static int staticCount = 0; // static yerel: değerini korur, yalnız burada görünür / static local: keeps its value, visible only here
15
16 if (digitalRead(BUTTON_PIN) == LOW) {
17 globalCount++;
18 localCount++;
19 staticCount++;
20 Serial.print(globalCount);
21 Serial.print(' ');
22 Serial.print(localCount);
23 Serial.print(' ');
24 Serial.println(staticCount); // 3. basışta: 3 1 3 / on the 3rd press: 3 1 3
25 digitalWrite(LED_PIN, (staticCount % 2) ? HIGH : LOW);
26 delay(300);
27 }
28}Als je de knop drie keer indrukt, toont de Serial Monitor de regels 1 1 1, 2 1 2 en 3 1 3: de globale en de statische teller blijven oplopen, terwijl de lokale teller altijd op 1 blijft omdat hij bij elke ronde van loop() opnieuw vanaf 0 begint. Als je een lokale variabele definieert met dezelfde naam als een globale, overschaduwt de lokale de globale en raak je binnen die functie de globale variabele helemaal niet aan. Globale variabelen die door een interruptfunctie (ISR) worden gewijzigd, moeten bovendien als volatile worden gedeclareerd; de details vind je in de gids Arduino-interrupts.
Arduino programmeren op de ESP32: dezelfde taal, andere groottes
Als je de ESP32 met de Arduino IDE programmeert, gebruik je dezelfde taal C++ en dezelfde commando's, maar er zijn een paar verschillen. Omdat de ESP32 een 32-bits processor is, is int 4 bytes en bevat hij waarden van -2.147.483.648 tot 2.147.483.647, dus 32767 + 1 in het overflowvoorbeeld geeft 32768. double is 8 bytes, analogRead() geeft waarden van 0 tot 4095 en de pinnen werken op 3,3 V. Met Serial.printf() kun je opgemaakt printen. random() gebruikt standaard de hardware-generator voor willekeurige getallen, dus de regel randomSeed() is niet nodig. Het onderstaande programma combineert alles wat je in dit artikel hebt geleerd: een array, een functie, switch-case en een knop die de stand wisselt. Voor de algemene eigenschappen van het board, zie Wat is de ESP32?.
1// ESP32: aynı dil, farklı pinler / ESP32: same language, different pins
2const byte LEDS[] = {18, 19, 21, 22, 23, 25}; // güvenli GPIO'lar / safe GPIOs
3const byte LED_COUNT = sizeof(LEDS) / sizeof(LEDS[0]);
4const byte BUTTON_PIN = 4; // diğer bacağı GND'ye / other leg to GND
5
6byte mode = 0; // 0 kapalı, 1 yürüyen ışık, 2 hepsi yanıp söner / 0 off, 1 chaser, 2 all blink
7bool lastPressed = false;
8
9void setAll(bool on) {
10 for (byte i = 0; i < LED_COUNT; i++) {
11 digitalWrite(LEDS[i], on ? HIGH : LOW);
12 }
13}
14
15void setup() {
16 Serial.begin(115200);
17 for (byte i = 0; i < LED_COUNT; i++) {
18 pinMode(LEDS[i], OUTPUT);
19 }
20 pinMode(BUTTON_PIN, INPUT_PULLUP);
21 Serial.printf("int = %d bayt / bytes\n", (int)sizeof(int)); // ESP32'de 4 / 4 on the ESP32
22
23 int a = 32767;
24 a = a + 1;
25 Serial.println(a); // ESP32'de 32768, taşma yok / 32768 on the ESP32, no overflow
26}
27
28void loop() {
29 bool pressed = (digitalRead(BUTTON_PIN) == LOW);
30 if (pressed && !lastPressed) {
31 mode = (mode + 1) % 3; // 0 → 1 → 2 → 0
32 delay(50);
33 }
34 lastPressed = pressed;
35
36 switch (mode) {
37 case 0:
38 setAll(false);
39 break;
40 case 1: { // case içinde değişken için süslü parantez / braces for a variable inside a case
41 byte step = (millis() / 120) % LED_COUNT; // sıradaki LED / LED whose turn it is
42 for (byte i = 0; i < LED_COUNT; i++) {
43 digitalWrite(LEDS[i], (i == step) ? HIGH : LOW);
44 }
45 break;
46 }
47 case 2:
48 setAll((millis() / 300) % 2); // 300 ms'de bir hepsi / all of them every 300 ms
49 break;
50 }
51}Om dit programma op een Uno te draaien, hoef je alleen de array LEDS te wijzigen in {8, 9, 10, 11, 12, 13}, BUTTON_PIN op 2 te zetten en de regel Serial.printf(), die de Uno niet ondersteunt, te vervangen door Serial.print(). Dat is precies het voordeel van pinnummers bovenaan als constanten en arrays definiëren. Merk ook op dat het blok van case 1 tussen accolades staat; omdat de variabele step erin wordt gedefinieerd, zijn die accolades op de ESP32 verplicht.
Raspberry Pi Pico: dezelfde logica in MicroPython
Je kunt de Raspberry Pi Pico in C++ programmeren door het RP2040-boardpakket aan de Arduino IDE toe te voegen; dan werkt de code uit dit artikel zodra je de pinnummers wijzigt en is int weer 4 bytes. De meest gebruikelijke manier om de Pico te gebruiken is echter MicroPython. In Python schrijf je geen variabeletypes, blokken worden bepaald door inspringing in plaats van accolades, er staat geen puntkomma aan het eind van een regel en gehele getallen lopen niet over maar groeien zo groot als nodig is. De onderstaande code is de MicroPython-versie van het voorbeeld met de elektronische dobbelsteen. Voor de installatie, zie Wat is de Raspberry Pi Pico?, en voor de details van de taal MicroPython-basis.
1from machine import Pin
2import time, random
3
4leds = [Pin(n, Pin.OUT) for n in (14, 13, 12, 11, 10, 9)] # liste = dizi / list = array
5button = Pin(2, Pin.IN, Pin.PULL_UP) # basılınca 0 / reads 0 when pressed
6
7def show(count): # fonksiyon / function
8 for i, led in enumerate(leds): # for döngüsü / for loop
9 led.value(1 if i < count else 0)
10
11show(0) # setup() karşılığı: bir kez çalışır / like setup(): runs once
12while True: # loop() karşılığı / like loop()
13 if button.value() == 0: # buton basılı mı? / is the button pressed?
14 show(random.randint(1, 6)) # 1-6 arası zar at / roll a number from 1 to 6
15 time.sleep_ms(300)| Concept | Arduino (C++) | MicroPython |
|---|---|---|
| Deel dat één keer draait | setup() | De code vóór de regel while True: |
| Deel dat eindeloos herhaalt | loop() | while True: |
| Variabele | int x = 5; | x = 5 |
| Constante | const int PIN = 2; | PIN = const(2) (from micropython import const) |
| Voorwaarde | if / else if / else | if / elif / else |
| Meerkeuze | switch-case | if / elif-keten |
| Telllus | for (int i = 0; i < 6; i++) | for i in range(6): |
| Array | byte a[] = {1, 2, 3}; | a = [1, 2, 3] |
| Functie | void blink(int pin) { ... } | def blink(pin): |
| Logica | && || ! | and or not |
| Opmerking | // opmerking | # opmerking |
Projectideeën die je met deze basis kunt bouwen
- Verkeerslicht: bouw een kruispunt met een voetgangersknop met const-waarden, delay() en if; de stap-voor-stapgids staat in Arduino-verkeerslicht.
- Knight Rider en looplichten: maak tientallen verschillende lichtpatronen met een for-lus en een array.
- Elektronische dobbelsteen: verplaats de dobbelsteen met 6 LED's naar een 7-segmentdisplay met een array, random() en een functie; zie daarvoor de gids 7-segmentdisplay.
- Reactietest: laat op een willekeurig moment een led oplichten en meet hoe snel je op de knop drukt met een unsigned long en millis().
- Lamp met meerdere standen: uit, constant, ademend en flitsend vanaf één knop met switch-case; voor een kleurenversie, kijk bij Een RGB-led gebruiken.
- Codeslot: verzamel de ingedrukte toetsen in een array en vergelijk ze met de opgeslagen code; details staan in de gids keypad.
Veelgemaakte fouten en hoe je ze oplost
| Fout | Symptoom | Oplossing |
|---|---|---|
| = gebruiken in een vergelijking | Het if-blok wordt altijd uitgevoerd | Gebruik == om te vergelijken |
| Een ; of = op een #define-regel | expected ')' before ';' token | Schrijf het als #define LED_PIN 13 |
| Verkeerde hoofdletters in een commando | 'pinmode' was not declared in this scope | Let op hoofdletters en kleine letters, zoals in pinMode |
| Letter met accent in een variabelenaam | stray '\303' in program | Gebruik in namen alleen Engelse letters, cijfers en _ |
| 60 * 1000 als int berekenen | Het resultaat is -5536 | Schrijf 60 * 1000L of 60000UL |
| millis() opslaan in een int | De timing gaat na 32 seconden stuk | Gebruik unsigned long |
| Deling van gehele getallen | 5 / 2 geeft 2 | Schrijf 5 / 2.0 of converteer naar float |
| Break vergeten aan het eind van een case | De volgende case wordt ook uitgevoerd | Sluit elke case af met break |
| Buiten een array schrijven | Willekeurige waarden, vastlopers | Houd de index tussen 0 en het aantal elementen - 1 |
| Een teller lokaal maken | De teller blijft steeds op 1 | Maak hem globaal of static |
Als je deze bouwstenen kent, is de volgende stap kennismaken met de meest gebruikte commando's: de lijst met Arduino-commando's behandelt alles van pinMode() tot attachInterrupt() met voorbeelden. In de BlueGrays-app vind je ook projecten zoals een knipperende led, een led bedienen met een knop, Knight Rider, een verkeerslicht en een dobbelsteen, stap voor stap met schakelschema's en kant-en-klare code, zodat je elke structuur die je hier hebt geleerd op een echte schakeling kunt uitproberen.
Veelgestelde vragen
Welke programmeertaal gebruikt Arduino?
Arduino-code is gebaseerd op C++. De Arduino-core voegt kant-en-klare functies zoals pinMode(), digitalWrite() en delay() aan de taal toe en de code wordt geschreven in bestanden met de extensie .ino. Boards zoals de ESP32 en de Raspberry Pi Pico kun je als je dat liever doet ook in MicroPython programmeren.
Waar begin ik met Arduino leren programmeren?
Installeer eerst de Arduino IDE en upload het voorbeeld Blink, dat de ingebouwde led laat knipperen. Probeer daarna in deze volgorde setup() en loop(), variabelen, if-else, lussen, arrays en functies, elk met een schakeling met een led of knop. Elk nieuw onderwerp in een klein project gebruiken blijft veel beter hangen dan er alleen over lezen.
Wat is het verschil tussen int en long in Arduino?
Op de Arduino Uno is een int 2 bytes en bevat hij getallen van -32.768 tot 32.767, terwijl een long 4 bytes is en tot ongeveer ±2,1 miljard gaat. Een getal dat deze grens overschrijdt, slaat zonder foutmelding om, dus voor grote waarden zoals millis() gebruik je long of unsigned long. Op de ESP32 en de Pico is int ook 4 bytes.
Wat is het verschil tussen const en #define in Arduino?
Een constante die je met const definieert heeft een type, volgt de regels voor bereik en de compiler meldt een fout als je hem probeert te wijzigen. #define is een tekstvervanging vóór het compileren; het heeft geen type en veroorzaakt onverwachte fouten als je het met een puntkomma afsluit. Bij simpele getallen gebruikt geen van beide RAM, maar const heeft meestal de voorkeur omdat het veiliger is.
Wat is het verschil tussen een for-lus en een while-lus in Arduino?
Een for-lus zet het begin, de voorwaarde en de stap op één regel en wordt gebruikt als je weet hoe vaak je moet herhalen, bijvoorbeeld om zes LED's na elkaar te laten oplichten. Een while-lus controleert alleen een voorwaarde en blijft draaien zolang die waar is, wat past bij situaties met onbekende duur, zoals wachten op een druk op de knop.
Kun je Arduino in Python programmeren?
8-bits boards zoals de Arduino Uno kunnen geen Python draaien, dus die worden in C++ geprogrammeerd. De ESP32 en de Raspberry Pi Pico kun je wel in MicroPython programmeren. Een Python-programma op je computer kan ook indirect een Uno aansturen door via de seriële poort met hem te praten.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

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.

Knight Rider-ledeffect
Het klassieke scannerlicht: een lichtpunt schuift van het ene uiteinde van zes LED's naar het andere en komt dan terug.

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…

ESP32-ledbesturing met drukknop (Push)
De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.

Raspberry Pi Pico: led aan/uit met een knop (toggle)
Knop + led, een niveau hoger! Je hoeft de knop niet ingedrukt te houden. Indrukken en loslaten → led aan. Nog een keer → led uit (toggle). Dezelfde schakeling (led GP14, knop GP2), maar andere code. Je leert edge detection (het moment van 1→0 vastleggen), toestand bijhouden en debounce (filter tegen contactdender). led.toggle() van MicroPython wisselt de toestand in één regel. De basis van interactieve knopprojecten.

Dobbelsteenproject
Nooit meer een zoekgeraakte dobbelsteen bij bordspellen: elke keer dat je op de knop drukt, verschijnt er een willekeurig getal van 1 tot 6 op het 7-segmentdisplay.
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

