Basis · 16 min leestijd

Arduino-commando's: overzicht met syntaxis, voorbeelden en veelgemaakte fouten

Arduino-commando's uitgelegd: pinMode, digitalWrite, analogRead, analogWrite, millis, Serial, map, tone, pulseIn en attachInterrupt met voorbeelden en valkuilen.

Arduino-commando's zijn kant-en-klare functies die het board vertellen wat het moet doen: pinMode() maakt van een pin een uitgang, digitalWrite() laat een LED branden, analogRead() leest een sensor uit en Serial.println() stuurt een bericht naar je computer. De meeste Arduino-sketches zijn eigenlijk niet meer dan een twintigtal basiscommando's die op verschillende manieren worden gecombineerd. Als je deze commando's en hun betekenis begrijpt, kun je elke code lezen die je tegenkomt, van een knipperende LED tot een robotauto, en een eigen project helemaal zelf schrijven.

In deze gids hebben we de meestgebruikte Arduino-commando's in vier categorieën verdeeld: in- en uitgang, tijd, wiskunde en communicatie. Bij elk commando vind je de syntaxis, wat de parameters betekenen, een kort voorbeeld dat compileert en draait op een Arduino Uno, en de fout die beginners het vaakst maken. In de laatste delen kijken we ook naar hoe dezelfde commando's zich op de ESP32 anders gedragen en wat hun MicroPython-equivalenten zijn op de Raspberry Pi Pico.

Arduino Uno-board met zijn digitale en analoge pins
Arduino Uno: digitale pins 0–13, analoge ingangen A0–A5 en de met ~ gemarkeerde PWM-pins is alles wat je nodig hebt om elk commando uit dit artikel uit te proberen.

Wat is een Arduino-commando en hoe wordt een sketch uitgevoerd?

Arduino-code is gebouwd op C/C++; wat we "commando's" noemen zijn meestal functies die de Arduino-core voor je klaarzet. Een functie krijgt parameters tussen haakjes (bijvoorbeeld een pinnummer en een waarde) en sommige geven een resultaat terug: digitalRead() geeft je de toestand van een pin, millis() de verstreken tijd. Elke Arduino-sketch heeft twee verplichte functies: setup() wordt maar één keer uitgevoerd wanneer het board wordt gevoed of gereset, en loop() herhaalt zich daarna eindeloos. Voorbereidingen zoals pininstellingen en Serial.begin() horen in setup(), en het werk dat continu moet gebeuren hoort in loop().

C++ (Arduino IDE)
1// Her Arduino programı bu iki fonksiyondan oluşur / Every Arduino sketch has these two functions
2void setup() {
3  // Açılışta ya da resetten sonra bir kez çalışır / Runs once at power-up or after reset
4  pinMode(13, OUTPUT);      // dahili LED pini çıkış / built-in LED pin as output
5}
6
7void loop() {
8  // Sonsuza kadar tekrar eder / Repeats forever
9  digitalWrite(13, HIGH);   // LED'i yak / turn the LED on
10  delay(500);               // 500 ms bekle / wait 500 ms
11  digitalWrite(13, LOW);    // LED'i söndür / turn the LED off
12  delay(500);
13}

Als je vanaf het begin drie regels onthoudt, bespaar je jezelf veel compileerfouten: commando's zijn hoofdlettergevoelig (als je digitalwrite typt, krijg je de foutmelding "'digitalwrite' was not declared in this scope"), elke instructie eindigt met een puntkomma, en tekst staat tussen dubbele aanhalingstekens terwijl losse tekens tussen enkele staan. Over variabeletypen en structuren zoals if en for lees je meer in Basis van Arduino-programmeren.

Lijst met Arduino-commando's: tabellen per categorie

De vier onderstaande tabellen vatten bijna elk commando samen dat je in alledaagse projecten gebruikt. De eerste groep zijn de in- en uitgangscommando's; ze bepalen de rol van een pin, zetten er een spanning op of lezen er een waarde van. De pinnummers van jouw board zie je in de tool Pinout.

CommandoSyntaxisWat het doetVoorbeeld
pinModepinMode(pin, mode)Maakt van een pin een ingang of een uitgangpinMode(13, OUTPUT);
digitalWritedigitalWrite(pin, value)Zet een pin HIGH (5 V) of LOW (0 V)digitalWrite(13, HIGH);
digitalReaddigitalRead(pin)Leest of een pin HIGH of LOW isint b = digitalRead(2);
analogReadanalogRead(pin)Zet een spanning van 0–5 V om in een getal van 0 tot 1023int v = analogRead(A0);
analogWriteanalogWrite(pin, value)Genereert een PWM-signaal van 0 tot 255analogWrite(9, 128);
analogReferenceanalogReference(type)Kiest de referentiespanning voor analogReadanalogReference(INTERNAL);
tone / noTonetone(pin, frequency, duration)Maakt geluid met een blokgolf; noTone stopt hettone(8, 440, 500);
pulseInpulseIn(pin, value, timeout)Meet de lengte van een puls in µspulseIn(10, HIGH, 30000);
shiftOutshiftOut(dataPin, clockPin, order, byte)Verstuurt een byte bit voor bit (bijv. naar een 74HC595)shiftOut(11, 12, MSBFIRST, 255);
attachInterruptattachInterrupt(interrupt, function, mode)Roept een functie aan op het moment dat een pin verandertattachInterrupt(digitalPinToInterrupt(2), say, FALLING);

De tweede groep zijn de tijdcommando's. Het verschil begrijpen tussen delay(), dat wacht, en millis() en micros(), die tijd meten, is de sleutel tot een sketch die soepel draait.

CommandoSyntaxisWat het doetLet op
delaydelay(ms)Wacht het opgegeven aantal millisecondenHet programma staat in die tijd stil
delayMicrosecondsdelayMicroseconds(us)Wacht een aantal microsecondenNauwkeurig tussen 3 en 16383 µs
millismillis()Geeft de milliseconden sinds het opstarten terugunsigned long; begint na ongeveer 49,7 dagen weer bij nul
microsmicros()Geeft de microseconden sinds het opstarten terugStappen van 4 µs op de Uno, begint na ongeveer 70 minuten weer bij nul

De derde groep zijn de wiskundecommando's; daarmee reken je een sensorwaarde om naar een ander bereik, begrens je die of genereer je een willekeurig getal. De vierde groep, de communicatiecommando's, laat het board gegevens uitwisselen met je computer en andere apparaten.

CommandoSyntaxisWat het doetVoorbeeldresultaat
mapmap(x, fromLow, fromHigh, toLow, toHigh)Schaalt het ene bereik om naar het anderemap(512, 0, 1023, 0, 255) → 127
constrainconstrain(x, low, high)Houdt een waarde tussen twee grenzenconstrain(300, 0, 255) → 255
min / maxmin(a, b) / max(a, b)Geeft de kleinste of grootste waarde terugmin(7, 3) → 3
absabs(x)Absolute waardeabs(-12) → 12
pow / sqrt / sqpow(base, exponent), sqrt(x), sq(x)Macht, wortel, kwadraatpow(2, 10) → 1024.0
randomrandom(min, max)Willekeurig geheel getal (max niet inbegrepen)random(1, 7) → 1 tot 6
randomSeedrandomSeed(seed)Verandert het beginpunt van de willekeurige reeksrandomSeed(analogRead(A3));
CommandoWat het doetVoorbeeld
Serial.begin(speed)Opent de seriële poort met de opgegeven baudrateSerial.begin(9600);
Serial.print(data)Stuurt data en blijft op dezelfde regelSerial.print(temperature);
Serial.println(data)Stuurt data en gaat naar een nieuwe regelSerial.println("Hello");
Serial.available()Geeft het aantal bytes terug dat klaarstaat om gelezen te wordenif (Serial.available() > 0)
Serial.read()Leest één byte, geeft -1 terug als er geen data ischar c = Serial.read();
Serial.readStringUntil(c)Leest tekst tot een bepaald tekenString s = Serial.readStringUntil('\n');
Serial.parseInt()Haalt een geheel getal uit binnenkomende tekstint n = Serial.parseInt();
Serial.write(byte)Verstuurt een ruwe byteSerial.write(65); // 'A'
Wire.begin()Start de I2C-bus (Wire.h)Wire.begin();
SPI.begin()Start de SPI-bus (SPI.h)SPI.begin();

pinMode(): de rol van een pin instellen

pinMode(pin, mode) vertelt het board of een digitale pin een ingang of een uitgang is, en je schrijft het meestal één keer in setup(). Er zijn drie modi: OUTPUT maakt de pin een uitgang (om een LED, een buzzer of een relais aan te sturen), INPUT maakt er een ingang met hoge impedantie van (voor schakelingen met een externe pull-up- of pull-downweerstand), en INPUT_PULLUP maakt er een ingang van en verbindt een interne weerstand van ongeveer 20–50 kΩ met 5 V. De analoge pins (A0–A5) kun je met pinMode ook als digitale pins gebruiken; pinMode(A0, OUTPUT) is bijvoorbeeld een geldig commando.

Als je pinMode(pin, OUTPUT) vergeet en toch digitalWrite(pin, HIGH) gebruikt, wordt de pin geen uitgang; op de Uno schakelt het commando dan alleen de interne pull-upweerstand in. De LED gaat branden, maar ziet er erg zwak uit omdat de stroom door een weerstand van 20–50 kΩ moet. Brandt je LED zwak, controleer dan eerst de pinMode-regel in setup().

digitalWrite() en digitalRead(): digitale uitgang en ingang

digitalWrite(pin, HIGH) trekt een uitgangspin op de Uno naar 5 V en digitalWrite(pin, LOW) trekt hem naar 0 V. Tot 20 mA uit een pin halen is veilig (het absolute maximum is 40 mA); sluit een LED altijd aan met een weerstand, en de juiste waarde vind je met de LED-weerstandcalculator. digitalRead(pin) kijkt naar de spanning op de pin en geeft HIGH of LOW terug; op de Uno geldt grofweg alles boven 3 V als HIGH en alles onder 1,5 V als LOW. In het onderstaande voorbeeld gaat de ingebouwde LED branden wanneer je op de knop op D2 drukt:

C++ (Arduino IDE)
1const int BUTON_PIN = 2;   // buton: bir ucu D2, diğer ucu GND / button: one leg to D2, the other to GND
2const int LED_PIN = 13;    // dahili LED / built-in LED
3
4void setup() {
5  pinMode(BUTON_PIN, INPUT_PULLUP);   // dahili pull-up direnci açık / internal pull-up resistor enabled
6  pinMode(LED_PIN, OUTPUT);
7}
8
9void loop() {
10  int durum = digitalRead(BUTON_PIN); // HIGH ya da LOW döner / returns HIGH or LOW
11  if (durum == LOW) {                 // pull-up ile basılı = LOW / with pull-up, pressed = LOW
12    digitalWrite(LED_PIN, HIGH);
13  } else {
14    digitalWrite(LED_PIN, LOW);
15  }
16}

Met INPUT_PULLUP is de logica omgekeerd: als de knop los is, leest de pin HIGH dankzij de interne weerstand, en als hij is ingedrukt leest de pin LOW omdat hij met GND is verbonden. Sluit je de knop zonder weerstand aan in INPUT-modus, dan zweeft de pin en geeft digitalRead() willekeurige waarden; zelfs je hand dichtbij brengen kan het resultaat veranderen. Over contactdender en de juiste manieren om een knop aan te sluiten lees je meer in Een knop aansluiten op Arduino.

analogRead() en analogWrite(): analoge ingang en PWM

analogRead(pin) gebruikt een 10-bits omzetter (ADC) om een spanning tussen 0 en 5 V op pins A0–A5 om te zetten in een getal van 0 tot 1023. Eén meting duurt ongeveer 100 µs, dus je kunt zo'n 10.000 metingen per seconde doen. Om het getal om te rekenen naar een spanning gebruik je waarde × 5,0 / 1023; een meting van 512 betekent bijvoorbeeld ongeveer 2,5 V. De referentiespanning kun je wijzigen met analogReference(): de optie INTERNAL gebruikt de interne referentie van 1,1 V van de Uno en verbetert de resolutie bij kleine spanningen. Details over resolutie en referentie vind je in ADC en analoog-digitaalomzetting.

Ondanks de naam produceert analogWrite(pin, value) geen echte analoge spanning. Het schakelt de pin heel snel aan en uit om een PWM-signaal te maken: 0 betekent altijd uit, 255 altijd aan en 127 ongeveer half aan. Dat gemiddelde is de reden dat een LED voor onze ogen half zo fel lijkt en een motor langzaam draait. Op de Uno leveren alleen pins 3, 5, 6, 9, 10 en 11, op het board gemarkeerd met ~, PWM; de frequentie is 490 Hz op de meeste pins en 980 Hz op pins 5 en 6. analogWrite() zet de pin zelf als uitgang, dus pinMode is niet nodig. De onderstaande code stelt de helderheid van een LED in met een potmeter en toont de meting samen met de spanning in de Serial Monitor; voor details over duty cycle en frequentie, zie Wat is PWM?.

C++ (Arduino IDE)
1const int POT_PIN = A0;   // potansiyometrenin orta bacağı / potentiometer wiper
2const int LED_PIN = 9;    // ~9 PWM pini + 220 ohm direnç / ~9 PWM pin + 220 ohm resistor
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  int ham = analogRead(POT_PIN);         // 0-1023 arası / between 0 and 1023
10  float volt = ham * (5.0 / 1023.0);     // sayıyı gerilime çevir / convert the reading to volts
11  analogWrite(LED_PIN, ham / 4);         // 0-1023 -> 0-255 PWM parlaklığı / 0-1023 -> 0-255 PWM brightness
12
13  Serial.print(F("Ham / raw: "));
14  Serial.print(ham);
15  Serial.print(F("  Gerilim / voltage: "));
16  Serial.print(volt, 2);                 // 2 ondalık basamak / 2 decimal places
17  Serial.println(F(" V"));
18  delay(200);
19}
Op een pin zonder PWM kan analogWrite() geen tussenwaarden maken: het zet de pin LOW voor waarden onder 128 en HIGH voor 128 en hoger. De pins A0–A5 van de Uno hebben ook geen PWM, en de klassieke Uno R3 heeft geen echte analoge uitgang (DAC); analogWrite(A0, 100) geeft dus geen 2 V. Heb je een echte analoge spanning nodig, gebruik dan een board met een DAC (zoals de Uno R4, die een DAC op A0 heeft) of voeg een RC-filter toe aan een PWM-uitgang.

delay(), millis() en micros(): tijdcommando's

delay(ms) wacht het opgegeven aantal milliseconden, en in die tijd wordt geen enkele andere regel in loop() uitgevoerd; delay(1000) is een volle pauze van een seconde. Voor korte wachttijden in het microsecondenbereik is er delayMicroseconds(), dat nauwkeurig is tussen 3 en 16383 µs. millis() wacht daarentegen niet; het geeft de tijd sinds het opstarten van het board terug, in milliseconden. Sla het resultaat altijd op in een unsigned long-variabele: gebruik je int, dan loopt de waarde op de Uno over zodra hij 32.767 passeert, na ongeveer 33 seconden, en gaat je timing stuk. millis() begint ongeveer elke 49,7 dagen weer bij nul; de onderstaande aftrekmethode blijft ook over die overgang heen correct werken.

C++ (Arduino IDE)
1const int LED_PIN = 13;
2const unsigned long ARALIK = 500;   // yanıp sönme aralığı (ms) / blink interval (ms)
3unsigned long oncekiZaman = 0;      // son değişim anı / time of the last toggle
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7}
8
9void loop() {
10  unsigned long simdi = millis();
11  if (simdi - oncekiZaman >= ARALIK) {               // taşmada da doğru çalışır / safe across overflow
12    oncekiZaman = simdi;
13    digitalWrite(LED_PIN, !digitalRead(LED_PIN));    // LED'i tersine çevir / toggle the LED
14  }
15  // Burada buton, sensör ve ekran işleri de yapılabilir / button, sensor and display tasks can run here
16}

Met dit patroon stopt loop() nooit; terwijl de LED blijft knipperen kun je in dezelfde lus een knop lezen, een sensor meten en een display bijwerken. micros() werkt op dezelfde manier in microseconden; op de Uno loopt het op in stappen van 4 µs en begint het na ongeveer 70 minuten weer bij nul. Meerdere taken tegelijk uitvoeren behandelen we uitgebreid in Arduino millis() vs delay().

Serial.begin(), Serial.print() en Serial.read(): seriële communicatie

Met de Serial-commando's praat de Arduino via de USB-kabel met je computer, en ze zijn je belangrijkste hulpmiddel bij het opsporen van fouten. Serial.begin(9600) opent de seriële poort met 9600 bits per seconde; komt de snelheid in de Serial Monitor niet overeen, dan zie je rare tekens op het scherm. Serial.print() stuurt data en blijft op dezelfde regel, terwijl Serial.println() na het sturen naar een nieuwe regel gaat. Met een tweede parameter kies je het formaat: Serial.print(78, HEX) toont "4E", Serial.print(78, BIN) toont "1001110" en Serial.print(3.14159, 3) toont "3.142" (floats hebben standaard 2 decimalen). Vaste tekst in F("...") zetten bespaart ruimte in de 2 KB RAM van de Uno.

Om data te lezen controleer je eerst met Serial.available() of er bytes in de buffer wachten; de ontvangstbuffer van de Uno is 64 bytes. Serial.read() haalt één byte uit die buffer en geeft -1 terug als er niets te lezen is. De onderstaande code zet de LED aan en uit met de tekens 1 en 0 die je vanuit de Serial Monitor verstuurt:

C++ (Arduino IDE)
1const int LED_PIN = 13;
2
3void setup() {
4  Serial.begin(9600);                    // Seri Monitör de 9600 olmalı / Serial Monitor must be 9600 too
5  pinMode(LED_PIN, OUTPUT);
6  Serial.println(F("1: LED açık / on, 0: LED kapalı / off"));
7}
8
9void loop() {
10  if (Serial.available() > 0) {          // tamponda bayt var mı? / any bytes waiting?
11    char c = Serial.read();              // ilk baytı al / read the first byte
12    if (c == '1') {                      // '1' karakteri, 1 sayısı değil / the character '1', not the number 1
13      digitalWrite(LED_PIN, HIGH);
14      Serial.println(F("LED açık / on"));
15    } else if (c == '0') {
16      digitalWrite(LED_PIN, LOW);
17      Serial.println(F("LED kapalı / off"));
18    }
19    // '\n' ve '\r' gibi diğer karakterler atlanır / other characters such as '\n' and '\r' are ignored
20  }
21}

Merk op dat de vergelijking met '1' gebeurt (enkele aanhalingstekens, dus een teken): de 1 die je op het toetsenbord typt komt overeen met het getal 49 in de ASCII-tabel, dus de voorwaarde c == 1 is nooit waar. Voor getallen met meerdere cijfers kun je Serial.parseInt() gebruiken, en om een hele regel op te pakken Serial.readStringUntil('\n'). Voor de instellingen voor regeleinde, de baudrate en de plotter van de Serial Monitor, zie De Arduino Serial Monitor gebruiken.

map() en constrain(): waarden schalen en begrenzen

map(value, fromLow, fromHigh, toLow, toHigh) verplaatst een getal proportioneel van het ene bereik naar het andere. De formule erachter is: (x − fromLow) × (toHigh − toLow) / (fromHigh − fromLow) + toLow. Zo geeft map(512, 0, 1023, 0, 255) 127 terug in plaats van 127,6, omdat map() alleen met gehele getallen werkt en het deel achter de komma weglaat. Een omgekeerde relatie maak je door het doelbereik om te draaien: map(x, 0, 1023, 255, 0). map() begrenst het resultaat niet; als de invoer buiten het opgegeven bereik komt, komt de uitvoer er ook buiten. Daarom combineer je het meestal met constrain(x, low, high).

C++ (Arduino IDE)
1const int LDR_PIN = A0;   // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
2const int LED_PIN = 9;    // ~9 PWM pini / ~9 PWM pin
3
4void setup() {
5  pinMode(LED_PIN, OUTPUT);
6}
7
8void loop() {
9  int isik = analogRead(LDR_PIN);           // odada ölçülen aralık ~200-800 / measured range in the room ~200-800
10  int pwm = map(isik, 200, 800, 255, 0);    // karanlıkta parlak, aydınlıkta sönük / bright in the dark, dim in the light
11  pwm = constrain(pwm, 0, 255);             // aralık dışı değerleri kes / clip out-of-range values
12  analogWrite(LED_PIN, pwm);
13  delay(20);
14}

In dit voorbeeld geeft de LDR in de kamer waarden tussen 200 en 800. Zakt de meting 's nachts naar 100, dan berekent map() 297; zonder constrain() zou analogWrite() deze waarde buiten het bereik 0–255 krijgen. Op de Uno geeft zo'n waarde afhankelijk van de pin verschillende, onverwachte resultaten: op pins 3, 5, 6 en 11, die 8-bits timers gebruiken, loopt 297 over en gedraagt zich als 41, waardoor de LED in volledig donker bijna uitgaat in plaats van fel te branden. Omdat constrain(), min(), max() en abs() op de Uno als macro's zijn gedefinieerd, moet je geen x++ of andere functieaanroep tussen de haakjes zetten; de expressie kan meer dan eens worden geëvalueerd en onverwachte resultaten geven. Voor de bedrading van de LDR, zie LDR-lichtsensor.

tone() en noTone(): geluid maken met een buzzer

tone(pin, frequency, duration) genereert op een pin een blokgolf met een duty cycle van 50% en laat een passieve buzzer of een kleine luidspreker op die frequentie klinken. De duur is in milliseconden en optioneel; zonder duur gaat het geluid door tot je noTone(pin) aanroept. Een belangrijk detail: tone() wacht niet; het start het geluid en gaat direct door naar de volgende regel. Speel je dus noten na elkaar af, dan heb je na elke tone()-aanroep een delay() nodig die minstens zo lang is als de noot, anders hoor je alleen de laatste noot.

C++ (Arduino IDE)
1const int BUZZER_PIN = 8;   // pasif buzzer'ın + ucu / passive buzzer + leg
2
3void setup() {
4  int notalar[] = {262, 294, 330, 349, 392};   // Do Re Mi Fa Sol (Hz) / C D E F G (Hz)
5  for (int i = 0; i < 5; i++) {
6    tone(BUZZER_PIN, notalar[i], 200);         // 200 ms çal / play for 200 ms
7    delay(250);                                // tone() beklemez, sen bekle / tone() does not wait, so you do
8  }
9  noTone(BUZZER_PIN);                          // sesi kapat / stop the sound
10}
11
12void loop() {
13}
  • Frequentiegrenzen: Op de Uno kunnen tonen onder 31 Hz niet worden gemaakt en is de bovengrens 65.535 Hz; het bruikbare bereik met een buzzer is grofweg 100–5000 Hz.
  • Eén geluid tegelijk: Er kan maar één pin tegelijk een toon afspelen; om op een andere pin geluid te maken moet je eerst de vorige stoppen met noTone().
  • PWM-conflict: Op de Uno gebruikt tone() Timer2, dus analogWrite() op pins 3 en 11 wordt verstoord terwijl er geluid klinkt.
  • Actieve buzzer: Omdat die een eigen oscillator heeft, kan de frequentie niet met tone() worden veranderd; schakel een actieve buzzer gewoon aan en uit met digitalWrite(). Voor de verschillen, zie Wat is een buzzer?.

pulseIn(): pulslengte meten

pulseIn(pin, HIGH) wacht tot de pin HIGH wordt, meet hoe lang hij HIGH blijft en geeft het resultaat terug in microseconden; het kan pulsen meten van 10 µs tot 3 minuten lang. De bekendste toepassing is de HC-SR04-ultrasone afstandssensor: de sensor geeft een puls af die zo lang duurt als het geluid nodig heeft om heen en terug te reizen. Geluid reist door lucht met ongeveer 343 m/s, oftewel 0,0343 cm/µs; omdat de weg heen en terug is, geldt afstand = duur × 0,0343 / 2.

C++ (Arduino IDE)
1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3
4void setup() {
5  Serial.begin(9600);
6  pinMode(TRIG_PIN, OUTPUT);
7  pinMode(ECHO_PIN, INPUT);
8}
9
10void loop() {
11  digitalWrite(TRIG_PIN, LOW);
12  delayMicroseconds(2);
13  digitalWrite(TRIG_PIN, HIGH);            // 10 µs tetik darbesi / 10 µs trigger pulse
14  delayMicroseconds(10);
15  digitalWrite(TRIG_PIN, LOW);
16
17  unsigned long sure = pulseIn(ECHO_PIN, HIGH, 30000UL);   // en fazla 30 ms bekle / wait at most 30 ms
18  if (sure == 0) {
19    Serial.println(F("Menzil dışı / out of range"));
20  } else {
21    float mesafe = sure * 0.0343 / 2.0;    // ses hızı 343 m/s, gidiş-dönüş / speed of sound 343 m/s, round trip
22    Serial.print(mesafe, 1);
23    Serial.println(F(" cm"));
24  }
25  delay(100);
26}

De derde parameter, de timeout, is erg belangrijk. Zonder timeout wacht pulseIn() 1 seconde als er geen puls komt en geeft het 0 terug; komt de sensordraad los, dan staat het hele programma bij elke lus een seconde stil. Een timeout van 30000 µs komt overeen met ongeveer 5 meter, wat genoeg is voor het bereik van 4 meter van de HC-SR04. Voor de bedrading en nauwkeurigheid van de sensor, zie HC-SR04-afstandssensor.

attachInterrupt(): direct reageren met interrupts

attachInterrupt(digitalPinToInterrupt(pin), function, mode) voert de functie die je opgeeft uit op het moment dat een pin verandert, ongeacht wat loop() op dat moment doet. Deze functie heet een interruptserviceroutine (ISR). De modus kan vier waarden hebben: RISING triggert bij een overgang van LOW naar HIGH, FALLING bij een overgang van HIGH naar LOW, CHANGE bij elke verandering en LOW zolang de pin LOW blijft. Op de Uno en Nano kunnen alleen de pins D2 en D3 op deze manier interrupts triggeren; op de Mega kun je pins 2, 3, 18, 19, 20 en 21 gebruiken. Het is ideaal om geen snel draaiende encoder, de pulsen van een anemometer of een heel korte knopdruk te missen.

C++ (Arduino IDE)
1const int BUTON_PIN = 2;            // Uno'da kesme pinleri: 2 ve 3 / interrupt pins on the Uno: 2 and 3
2volatile unsigned long sayac = 0;   // ISR'de değişen değişken volatile olmalı / variables changed in an ISR must be volatile
3
4void say() {                        // kesme fonksiyonu (ISR): kısa tut / interrupt service routine: keep it short
5  sayac++;
6}
7
8void setup() {
9  Serial.begin(9600);
10  pinMode(BUTON_PIN, INPUT_PULLUP);
11  attachInterrupt(digitalPinToInterrupt(BUTON_PIN), say, FALLING);   // HIGH'dan LOW'a geçişte / on a HIGH-to-LOW edge
12}
13
14void loop() {
15  noInterrupts();                   // 4 baytlık değeri güvenle kopyala / copy the 4-byte value safely
16  unsigned long kopya = sayac;
17  interrupts();
18
19  Serial.print(F("Basma sayısı / presses: "));
20  Serial.println(kopya);
21  delay(500);
22}
Declareer elke variabele die je in een ISR wijzigt als volatile en houd de functie zo kort mogelijk. In een ISR werkt delay() niet, loopt millis() niet door en kan Serial.print() het programma laten vastlopen; werk alleen een vlag of teller bij en doe het echte werk in loop(). Mechanische knoppen denderen, dus de teller kan bij één druk meerdere keren oplopen; de oplossing voor dender en alle details over interrupts staan in Arduino-interrupts.

random() en randomSeed(): willekeurige getallen genereren

random(max) geeft een willekeurig geheel getal tussen 0 en max−1 terug en random(min, max) een getal tussen min en max−1; de bovengrens is niet inbegrepen in het resultaat. Daarom schrijf je random(1, 7) voor een dobbelsteen van 1 tot 6. De Arduino produceert geen echte willekeur; hij berekent met een vaste formule een reeks getallen, dus als je randomSeed() niet aanroept, zie je elke keer dat het board opstart dezelfde getallen in dezelfde volgorde. De ruis van een niet-aangesloten analoge pin als seed gebruiken lost dit in de praktijk op:

C++ (Arduino IDE)
1void setup() {
2  Serial.begin(9600);
3  randomSeed(analogRead(A3));     // boştaki A3 pininin gürültüsü / noise from the unconnected A3 pin
4}
5
6void loop() {
7  int zar = random(1, 7);         // 1-6 arası; üst sınır dahil değil / 1 to 6; the upper bound is exclusive
8  Serial.print(F("Zar / dice: "));
9  Serial.println(zar);
10  delay(1000);
11}

Arduino-commando's op de ESP32: waar je op moet letten

De ESP32 programmeer je in de Arduino IDE met dezelfde commando's, en het grootste deel van de code in dit artikel werkt direct zodra je de pinnummers aanpast. Omdat de hardware anders is, gedragen sommige commando's zich toch anders. Het belangrijkste verschil is de spanning: de pins van de ESP32 werken op 3,3 V, digitalWrite(pin, HIGH) geeft 3,3 V af en 5 V-signalen mogen niet rechtstreeks op de pins worden aangesloten. Om het board beter te leren kennen, zie Wat is de ESP32?.

CommandoArduino UnoESP32
digitalWrite(pin, HIGH)5 V3,3 V
analogRead()10 bits, 0–1023, A0–A512 bits, 0–4095; met Wi-Fi aan alleen de ADC1-pins (GPIO 32–39)
analogWrite()Alleen de ~-pins (3, 5, 6, 9, 10, 11), 490/980 HzBijna elke GPIO die als uitgang kan dienen; stel de frequentie in met ledcAttach(pin, freq, resolution)
attachInterrupt()Alleen D2 en D3Alle GPIO's; voeg IRAM_ATTR toe aan de ISR
tone()Gebruikt Timer2, verstoort PWM op 3 en 11Draait op de LEDC-hardware
Serial.begin()Meestal 9600Meestal 115200 (de bootmeldingen gebruiken ook deze snelheid)
delay()Houdt de processor tijdens het wachten volledig bezigGeeft de tijd door aan FreeRTOS; Wi-Fi blijft op de achtergrond draaien
C++ (Arduino IDE)
1const int POT_PIN = 34;     // ADC1 pini, Wi-Fi açıkken de okur / ADC1 pin, works with Wi-Fi on
2const int LED_PIN = 2;      // çoğu DevKit'te dahili LED / onboard LED on most DevKits
3const int BUTON_PIN = 4;    // butonun diğer ucu GND / other button leg to GND
4
5volatile bool basildi = false;
6
7void IRAM_ATTR butonISR() { // ESP32'de ISR IRAM'e yerleşmeli / on the ESP32 the ISR should live in IRAM
8  basildi = true;
9}
10
11void setup() {
12  Serial.begin(115200);
13  pinMode(BUTON_PIN, INPUT_PULLUP);
14  attachInterrupt(digitalPinToInterrupt(BUTON_PIN), butonISR, FALLING);   // her GPIO kesme destekler / every GPIO supports interrupts
15}
16
17void loop() {
18  int ham = analogRead(POT_PIN);                     // 0-4095 (12 bit)
19  analogWrite(LED_PIN, map(ham, 0, 4095, 0, 255));   // 8 bit PWM / 8-bit PWM
20  if (basildi) {
21    basildi = false;
22    Serial.println("Butona basıldı / button pressed");
23  }
24  Serial.println(ham);
25  delay(200);
26}

Omdat analogRead() op de ESP32 0–4095 teruggeeft, verandert het bereik in map() mee. Het IRAM_ATTR voor de ISR plaatst de code in snel intern geheugen; zonder dit kan het board in sommige situaties herstarten met een "Guru Meditation Error". De analoge metingen van de ESP32 zijn niet lineair aan de uiteinden van het bereik (rond 0 V en 3,3 V); heb je een nauwkeurigere meting nodig, dan geeft de functie analogReadMilliVolts() een gekalibreerde waarde in millivolt terug.

Raspberry Pi Pico: MicroPython-equivalenten van Arduino-commando's

Programmeer je de Raspberry Pi Pico met de Arduino IDE (de arduino-pico-core), dan werkt elk commando uit dit artikel onder dezelfde naam; analogRead() geeft standaard 10 bits terug en analogWrite() produceert 1 kHz PWM. De meeste mensen gebruiken de Pico echter met MicroPython. Daar schrijf je de commando's met objecten uit de modules machine en time; de logica is hetzelfde, alleen de syntaxis verandert. De pins van de Pico zijn ook 3,3 V en zijn analoge ingangen zijn pins GP26, GP27 en GP28. Om te beginnen, zie Wat is de Raspberry Pi Pico?.

Arduino-commandoMicroPython-equivalentOpmerking
pinMode(15, OUTPUT)led = Pin(15, Pin.OUT)Het Pin-object maak je één keer aan
pinMode(14, INPUT_PULLUP)btn = Pin(14, Pin.IN, Pin.PULL_UP)Interne pull-upweerstand
digitalWrite(15, HIGH)led.value(1)led.on() werkt ook
digitalRead(14)btn.value()Geeft 0 of 1 terug
analogRead(A0)ADC(26).read_u16()Geeft 0–65535 terug
analogWrite(15, 128)PWM(Pin(15)).duty_u16(32768)Duty van 0 tot 65535
delay(500)time.sleep_ms(500)time.sleep(0.5) werkt ook
millis()time.ticks_ms()Gebruik time.ticks_diff() voor verschillen
Serial.println(x)print(x)Verschijnt in de Thonny-shell
tone(pin, 440)pwm.freq(440) en pwm.duty_u16(32768)Maak het stil met duty_u16(0)
pulseIn(pin, HIGH, 30000)machine.time_pulse_us(pin, 1, 30000)Geeft bij een timeout een negatieve waarde terug
attachInterrupt(...)btn.irq(trigger=Pin.IRQ_FALLING, handler=f)f krijgt het pin-object als parameter
random(1, 7)random.randint(1, 6)Bovengrens is inbegrepen
map() / constrain()Niet ingebouwd, je schrijft ze zelfVoor constrain: min(max(x, 0), 255)
MicroPython
1from machine import Pin, ADC, PWM
2import time
3
4led = PWM(Pin(15))                       # pinMode + analogWrite karşılığı / pinMode + analogWrite equivalent
5led.freq(1000)                           # 1 kHz PWM
6buton = Pin(14, Pin.IN, Pin.PULL_UP)     # INPUT_PULLUP karşılığı / INPUT_PULLUP equivalent
7pot = ADC(26)                            # GP26 = ADC0
8
9def map_deger(x, giris_min, giris_max, cikis_min, cikis_max):   # Arduino map() karşılığı / Arduino map() equivalent
10    return (x - giris_min) * (cikis_max - cikis_min) // (giris_max - giris_min) + cikis_min
11
12onceki = time.ticks_ms()                 # millis() karşılığı / millis() equivalent
13while True:
14    ham = pot.read_u16()                 # 0-65535 (analogRead)
15    led.duty_u16(ham)                    # parlaklık / brightness (analogWrite)
16    if buton.value() == 0:               # digitalRead; basılı = 0 / pressed = 0
17        print("Butona basıldı / button pressed")
18    if time.ticks_diff(time.ticks_ms(), onceki) >= 1000:   # saniyede bir / once a second
19        onceki = time.ticks_ms()
20        print("Yüzde / percent:", map_deger(ham, 0, 65535, 0, 100))
21    time.sleep_ms(50)                    # delay(50)

Zoals de tabel laat zien, neemt random.randint(1, 6) in MicroPython de bovengrens mee en geeft het hetzelfde resultaat als random(1, 7) op de Arduino; time.ticks_diff() biedt dezelfde veiligheid bij overgang naar nul als de millis()-aftrekking. Juist deze kleine verschillen zorgen het meest voor verwarring bij het wisselen tussen de twee platforms. Voor de andere basiscommando's van MicroPython, zie MicroPython-basis.

Projectideeën die je met deze commando's kunt bouwen

  • Stoplicht: Laat drie LED's na elkaar branden met pinMode(), digitalWrite() en delay(); we leggen het stap voor stap uit in Arduino-stoplicht.
  • Digitale dobbelsteen: Genereer met random() een getal van 1 tot 6 en toon het resultaat bij een druk op de knop met LED's of op een 7-segmentdisplay.
  • Parkeersensor: Meet de afstand met pulseIn(), zet die met map() om in een pieptussenpoos en laat met tone() een waarschuwing klinken.
  • Automatisch nachtlampje: Lees het lichtniveau met analogRead() en stel de helderheid van analogWrite() in met map() en constrain().
  • Afstandsbediening via de seriële poort: Bestuur een LED, een relais of een servomotor met commando's vanaf je computer via Serial.read().
  • Reactietest: Laat met random() op een willekeurig moment een LED branden en meet je reactietijd op de knop tot op de milliseconde met attachInterrupt() en millis().

Veelgemaakte fouten en hoe je ze oplost

FoutSymptoomOplossing
pinMode() vergetenDe LED is erg zwak of brandt helemaal nietSchrijf pinMode(pin, OUTPUT) in setup()
Knop zonder weerstand in INPUT-modusdigitalRead() geeft willekeurige 0'en en 1'enGebruik INPUT_PULLUP; ingedrukt leest LOW
Typefout in een commandonaam'digitalwrite' was not declared in this scopeLet op hoofdletters en kleine letters: digitalWrite
Baudrate komt niet overeenRare tekens in de Serial MonitorZet de snelheid van de Serial Monitor gelijk aan Serial.begin()
analogWrite() op een pin zonder PWMDe LED is alleen volledig aan of volledig uitGebruik een pin met ~ (3, 5, 6, 9, 10, 11)
millis() opgeslagen in een intDe timing gaat na ongeveer 33 seconden stukGebruik unsigned long
Dobbelsteen met random(1, 6)Er komt nooit een 6Schrijf random(1, 7); de bovengrens is niet inbegrepen
Decimalen verwachten van map()Het resultaat is altijd een geheel getal, kleine veranderingen gaan verlorenSchrijf indien nodig je eigen float-formule
pulseIn() zonder timeoutElke lus staat 1 seconde stil als de sensor ontbreektGeef 30000 mee als derde parameter
delay() of Serial in een ISRHet programma loopt vast of gedraagt zich vreemdWijzig in de ISR alleen een volatile vlag
Weet je niet precies wat een commando doet, schrijf dan een kleine testsketch en toon het resultaat met Serial.println(); in Arduino IDE 2 kun je ook met de rechtermuisknop op de commandonaam klikken en "Go to Definition" kiezen om de broncode te zien. Wil je code niet compileren, dan wijst de eerste regel van de foutmelding meestal naar het probleem; de meest voorkomende meldingen en hun oplossingen staan in Arduino-compileerfouten.

De commando's in dit artikel zijn de bouwstenen van de meeste projecten die je met een Arduino maakt; de rest zijn vooral extra functies uit bibliotheken. Elk commando één keer uitproberen in een eigen kleine schakeling en het resultaat in de Serial Monitor bekijken, beklijft veel beter dan ze uit je hoofd leren. In de BlueGrays-app vind je projecten die deze commando's gebruiken, zoals een LED laten branden, een LED met een knop bedienen, licht meten met een LDR, de frequentie van een buzzer instellen, afstand meten met een HC-SR04 en een dobbelsteenproject, stap voor stap met schakelschema's en code met commentaar.

Veelgestelde vragen

Wat zijn de meestgebruikte Arduino-commando's?

Het vaakst gebruikt worden pinMode(), digitalWrite(), digitalRead(), analogRead(), analogWrite(), delay(), millis(), Serial.begin() en Serial.println(). Voeg daar map() aan toe voor het schalen van waarden, tone() voor geluid, pulseIn() voor afstandssensoren en attachInterrupt() voor interrupts, en je kunt bijna al je beginnersprojecten schrijven.

In welke taal worden Arduino-commando's geschreven?

Arduino-code is gebouwd op C en C++; de Arduino-core voegt kant-en-klare functies zoals pinMode() en digitalWrite() aan de taal toe. De commando's zijn in het Engels, ze zijn hoofdlettergevoelig en elke instructie eindigt met een puntkomma. De ESP32 en de Raspberry Pi Pico kun je als je dat liever hebt ook in MicroPython programmeren.

Wat is het verschil tussen digitalWrite en analogWrite?

digitalWrite() zet een pin in een van maar twee toestanden: HIGH (5 V op de Uno) of LOW (0 V). analogWrite() schakelt de pin heel snel aan en uit om een PWM-signaal van 0 tot 255 te maken, zodat je de helderheid van een LED of de snelheid van een motor kunt regelen. Op de Uno werkt analogWrite() alleen op de pins die met ~ zijn gemarkeerd.

Wat betekenen void setup en void loop?

setup() is de functie die één keer wordt uitgevoerd wanneer het board wordt gevoed of gereset; voorbereidingen zoals pinMode() en Serial.begin() horen hier. loop() is de functie die zich eindeloos herhaalt nadat setup() klaar is. De void ervoor betekent dat deze functies geen waarde teruggeven.

Wat is het verschil tussen Serial.print en Serial.println?

Serial.print() stuurt de data en laat de cursor op dezelfde regel staan, dus de volgende data komt er direct achter. Serial.println() stuurt na het versturen de regeleindetekens (\r\n), dus de volgende data begint op een nieuwe regel. Om meerdere waarden naast elkaar op één regel te tonen, gebruik je eerst print() en aan het eind println().

Wat doet de Arduino-functie map?

map() rekent een getal proportioneel om van het ene bereik naar het andere; het zet bijvoorbeeld de waarde 0–1023 van analogRead() om naar het bereik 0–255 voor analogWrite() of naar 0–180 graden voor een servo. Het werkt alleen met gehele getallen en begrenst het resultaat niet, dus het wordt aangeraden het te combineren met constrain() om invoer buiten het bereik af te vangen.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

LED laten knipperen

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

4.6(197)
1240
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)
252
Lichtsterkte meten met een LDR
AR-11Beginner

Lichtsterkte meten met een LDR

Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

4.6(83)
143
Frequentie instellen met een buzzer
AR-14Gemiddeld

Frequentie instellen met een buzzer

Met vier knoppen bestuur je het geluid van een buzzer: één start het geluid, één stopt het en de andere twee maken het hoger of lager.

4.6(69)
120
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
Knight Rider-ledeffect met instelbare snelheid
AR-8Gemiddeld

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.

4.5(60)
124
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

Servomotor aansturen met een potentiometer

Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

4.6(37)
53
Dobbelsteenproject
AR-79Gemiddeld
Premium

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.

5.0(48)
67