Arduino-commandolijst: 36 kaarten, C++ en MicroPython naast elkaar
Arduino-commandolijst in leervolgorde: 18 kaarten van pinMode tot tone, de MicroPython-equivalenten, code naast elkaar, een plan voor 4 weken en 8 veelgemaakte fouten.
De betrouwbaarste manier om Arduino-commando's te leren is niet een lange lijst uit je hoofd te leren, maar ze op volgorde door te nemen, elk met een klein voorbeeld en een echt project. De BlueGrays-app heeft hiervoor een Codegids in het onderdeel Lessen van het tabblad Leren: 18 kaarten in de leerlijn Arduino C++, van pinMode tot tone, en 18 kaarten in de leerlijn MicroPython, van import tot I2C, samen 36 kaarten. Elke kaart heeft dezelfde opzet: Wat doet het?, Waarom?, Syntaxis, Voorbeeld (met de tabbladen Blokken, Arduino en MicroPython), Veelgemaakte fout, Tip, Zie het in projecten en een Minitoets van twee vragen. Ook de volgorde ligt vast: eerst pins (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), dan tijd (delay, millis), dan variabelen, voorwaarden, lussen en functies, en tot slot Serial, map, random en tone. Gebruik je een Raspberry Pi Pico, dan leer je dezelfde ideeën in de MicroPython-leerlijn met Pin, Pin.value, time.sleep, ADC.read_u16 en PWM.
Dit artikel is een kaart van de gids. Eerst zie je wat er in een kaart staat, daarna de 18 kaarten van elke leerlijn in hun echte volgorde in de app, met het equivalent in de andere taal. Daarna volgen drie korte voorbeelden waarin de C++- en MicroPython-versie van hetzelfde programma naast elkaar staan, hoe de minitoets en de voortgang werken, een leervolgorde van 4 weken, een dagelijkse routine van 20 minuten en de 8 meest gemaakte fouten met deze commando's. Zoek je een uitgebreide uitleg per commando? Het artikel Arduino-commandolijst met voorbeelden geeft elk commando een eigen onderdeel; dit artikel gaat over de volgorde waarin je ze leert en hoe je oefent.

Waar vind je de Codegids en hoe werkt hij?
Je opent de gids via het tabblad Leren onderaan: tik in het onderdeel Lessen bovenaan op de tegel Codegids. Als de gids opent, zie je bovenaan twee tabbladen: Arduino C++ en MicroPython; de app onthoudt welke leerlijn je het laatst hebt geopend. Onder de tabbladen staat een teller Wat je hebt geleerd en een regel Volgende kaart, zodat je nooit hoeft te zoeken waar je was gebleven. De kaarten zijn gegroepeerd per onderwerp: Pins, Tijd, Variabelen, Voorwaarden, Lussen, Functies, Seriële poort, Rekenen en Geluid; de MicroPython-leerlijn voegt Basisstructuur en Foutafhandeling toe. De Codegids is gratis: je hebt geen Premium nodig om de kaarten te lezen, de voorbeelden te bekijken of de minitoetsen te maken. De kaarten zijn beschikbaar in 10 talen, dus je leest de uitleg in de taal waarin je de app gebruikt.
Wat staat er in een kaart?
Elke kaart gebruikt hetzelfde skelet, dus na de derde kaart weet je precies waar je moet kijken. De tabel hieronder toont de onderdelen aan de hand van de 7e kaart van de Arduino-leerlijn, millis; de rechterkolom is een korte samenvatting van wat de kaart echt zegt. De volgorde van de onderdelen is zelf al een leervolgorde: eerst hoor je in één zin wat het commando doet, dan begrijp je via een alledaagse vergelijking waarom je het nodig hebt, je ziet hoe het wordt geschreven, leest een werkend voorbeeld, leert de meest voorkomende valkuil kennen en test jezelf met twee vragen.
| Onderdeel | Wat het behandelt | Op de millis-kaart |
|---|---|---|
| Wat doet het? | De taak van het commando in één zin | Vertelt je hoeveel milliseconden er voorbij zijn sinds het board is gestart. |
| Waarom? | Waarom je het nodig hebt, via een alledaagse vergelijking | Alsof je een cake in de oven zet en af en toe op de klok kijkt: je doet andere dingen terwijl je wacht. |
| Syntaxis | Hoe het commando wordt geschreven | unsigned long now = millis(); |
| Voorbeeld | Een kort werkend programma; tabbladen Blokken, Arduino en MicroPython | Code die elke 500 ms een led laat wisselen; op de Pico dezelfde taak met time.ticks_ms |
| Veelgemaakte fout | De valkuil waar beginners het vaakst in trappen | millis in een int bewaren: het getal loopt na ongeveer 33 seconden fout. |
| Tip | Een kleine regel die het leven makkelijker maakt | Schrijf de controle altijd als now - previous >= interval. |
| Zie het in projecten | Projecten die het commando gebruiken, van makkelijk naar moeilijk | Meer dan 50 projecten; de lijst begint met een gratis ESP32-knopproject |
| Mini test | Twee vragen, na elk antwoord een korte uitleg | Wat geeft millis() terug? In welk type moet je millis bewaren? |
Het onderdeel Voorbeeld opent in de eigen leerlijn van de kaart: bij een Arduino-kaart staat het tabblad Arduino voorop, bij een MicroPython-kaart het tabblad MicroPython. Maar het andere tabblad is er altijd ook, en dat maakt van de gids een woordenboek. Op de kaart Pin-uitgang: Pin(15, Pin.OUT) van de MicroPython-leerlijn bevat het tabblad Arduino bijvoorbeeld code die hetzelfde doet met pinMode en digitalWrite, en de opmerkingen vertellen welke regel waarmee overeenkomt (zoals de regel die voor led.toggle() staat). Bijna elke kaart heeft ook een derde tabblad, Blokken, dat het voorbeeldprogramma als blokken toont. Stap je over van Arduino naar de Pico, dan is dit de snelste methode: open een kaart die je kent, wissel van tabblad en leg de twee programma's regel voor regel naast elkaar.
Arduino C++-leerlijn: 18 kaarten en hun MicroPython-equivalenten
De tabel hieronder is de echte volgorde van de Arduino-leerlijn in de app; de laatste kolom laat zien hoe dezelfde taak in MicroPython op een Raspberry Pi Pico gaat. De pinnummers komen overeen met de voorbeelden op de kaarten: voor een led 13 of 9 op de Uno en GP15 op de Pico; voor een knop 2 op de Uno en GP14 op de Pico; voor analoog lezen A0 op de Uno en GP26 op de Pico. De eerste vijf kaarten gaan over pins, 6 en 7 over tijd, 8 tot en met 14 over programmeerbasis, en de laatste vier over de seriële poort, schalen, willekeurige getallen en geluid. De volgorde is bewust gekozen: eerst leer je hoe het board de buitenwereld aanraakt, daarna stuur je die aanrakingen aan met variabelen, voorwaarden en lussen.
| Nr. | Kaart | Wat doet het? | MicroPython-equivalent |
|---|---|---|---|
| 1 | pinMode | Vertelt het board of een pin een uitgang (led, buzzer) of een ingang (knop, sensor) is | Pin(15, Pin.OUT) · Pin(14, Pin.IN, Pin.PULL_UP) |
| 2 | digitalWrite | Zet een uitgangspin aan (HIGH, 5 V) of uit (LOW, 0 V) | led.value(1) · led.on() · led.off() |
| 3 | digitalRead | Leest of een ingangspin HIGH of LOW is | button.value() → 1 of 0 |
| 4 | analogRead | Zet de spanning op A0–A5 om in een getal van 0 tot 1023 | ADC(26).read_u16() → 0–65535 |
| 5 | analogWrite (PWM) | Dimt een led of vertraagt een motor met een waarde van 0 tot 255 op een ~-pin | PWM(Pin(15)) · freq(1000) · duty_u16(0–65535) |
| 6 | delay | Pauzeert de code voor het opgegeven aantal milliseconden | time.sleep(0.5) · time.sleep_ms(500) |
| 7 | millis | Milliseconden sinds het opstarten; timen zonder de code te stoppen | time.ticks_ms() · time.ticks_diff() |
| 8 | Variabelen en typen | Bewaart waarden met typen zoals int, float, bool, unsigned long | Er wordt geen type geschreven: count = 0, volts = 3.3 |
| 9 | if / else if / else | Voert andere code uit afhankelijk van een voorwaarde | if / elif / else |
| 10 | Vergelijkings- en logische operatoren | Bouwt voorwaarden met ==, !=, <, >, &&, ||, ! | ==, !=, <, > · and, or, not |
| 11 | for-lus | Herhaalt een taak een vast aantal keer | for i in range(10): |
| 12 | while-lus | Herhaalt zolang een voorwaarde waar is | while condition: |
| 13 | Functies (void, parameters, return) | Verdeelt code in herbruikbare stukken met een naam | def blink(times): … return |
| 14 | Arrays | Bewaart waarden van hetzelfde type op volgorde onder één naam | Lijst: pins = [2, 3, 4] · len(pins) |
| 15 | Serial.begin / print / println | Stuurt tekst en waarden naar de computer (Serial Monitor) | print(x) · f-string; Serial.begin is niet nodig |
| 16 | map | Schaalt het ene getalbereik naar het andere | Geen ingebouwd commando: raw * 255 // 1023 of je eigen functie |
| 17 | random / randomSeed | Genereert willekeurige getallen | import random · random.randint(1, 6) |
| 18 | tone / noTone | Speelt een toon met een bepaalde frequentie op een buzzer en stopt hem weer | PWM: freq(440) · duty_u16(32768); duty_u16(0) om het stil te zetten |
MicroPython-leerlijn: 18 kaarten en hun Arduino-equivalenten
De MicroPython-leerlijn is geschreven met de Raspberry Pi Pico in gedachten; de voorbeelden op de kaarten zijn korte programma's die je op een Pico kunt uitvoeren, bijvoorbeeld met Thonny. De volgorde wijkt een beetje af van de Arduino-leerlijn, omdat je in Python eerst moet wennen aan de eigen regels van de taal: modules toevoegen met import, tekst tonen met print, en de regel over inspringen en de dubbele punt. Op het tabblad Arduino van elke MicroPython-kaart staat ook de C++-versie van hetzelfde programma, dus als je Arduino al kent, kun je de tabel van rechts naar links lezen. Gebruik je een Pico voor het eerst, dan is het artikel wat is een Raspberry Pi Pico een goede voorbereiding op de opzet en de pins.
| Nr. | Kaart | Wat doet het? | Arduino-equivalent |
|---|---|---|---|
| 1 | import en from … import | Voegt modules zoals machine en time toe aan het programma | #include voor bibliotheken; basiscommando's zoals pinMode en delay zijn ingebouwd |
| 2 | print en f-strings | Toont tekst en waarden in de Thonny-shell | Serial.begin(9600) + Serial.println() |
| 3 | Pin-uitgang: Pin(15, Pin.OUT) | Maakt van een GP-pin een uitgang; value(), on(), off(), toggle() | pinMode(13, OUTPUT) + digitalWrite() |
| 4 | Pin-ingang: Pin.IN, PULL_UP, PULL_DOWN | Maakt van een pin een ingang, kiest de interne weerstand, leest met value() | pinMode(2, INPUT_PULLUP) + digitalRead() |
| 5 | time.sleep en sleep_ms | Pauzeert het programma in seconden of milliseconden | delay() |
| 6 | while True: de eindeloze lus | Herhaalt de regels eronder zolang de Pico aanstaat | loop() |
| 7 | Inspringen en de dubbele punt (:) | Bepaalt welke regel bij welk blok hoort | Accolades { } en de puntkomma ; |
| 8 | Variabelen: int, float, str, bool | Bewaart waarden; het type wordt automatisch bepaald | int, float, String, bool |
| 9 | if / elif / else, and / or / not | Vertakt op een voorwaarde en combineert voorwaarden | if / else if / else · &&, ||, ! |
| 10 | for en range | Herhaalt een vast aantal keer; range(0, 10) telt van 0 tot 9 | for (int i = 0; i < 10; i++) |
| 11 | Lijsten: [ ], index, len | Bevat meerdere waarden op volgorde; het eerste item staat op index 0 | Arrays: int pins[] = {2, 3, 4}; |
| 12 | def en return (functies) | Geeft herbruikbare code een naam en geeft een resultaat terug | void- of getypeerde functies, return |
| 13 | ADC: analoog lezen met read_u16 | Leest de spanning op GP26, GP27, GP28 als 0–65535 | analogRead() → 0–1023 |
| 14 | PWM: freq en duty_u16 | Dimt een led, speelt noten op een buzzer | analogWrite() en tone() |
| 15 | time.ticks_ms en ticks_diff | Meet verstreken tijd zonder de code te stoppen | millis() |
| 16 | Pin.irq: knoppen met interrupts | Voert een functie uit op het moment dat een knop wordt ingedrukt | attachInterrupt() |
| 17 | try / except (fouten opvangen) | Voorkomt dat het programma stopt als er een fout optreedt | Geen gangbaar equivalent in Arduino; je controleert teruggegeven waarden |
| 18 | I2C en scan() | Vindt de adressen van apparaten op de I2C-bus | Wire.begin() + I2C-scannercode |
Hetzelfde programma in twee talen: 3 voorbeelden naast elkaar
Het eerste voorbeeld is de "hello world" van elke taal: de led op het board elke halve seconde laten knipperen. Op de Uno zit de ingebouwde led aan pin 13, dus je hoeft geen schakeling te bouwen. De Pico is iets anders: op de gewone Pico zit de ingebouwde led op GP25, maar op de Pico W zit de led aan de draadloze chip en laat Pin(25) hem niet oplichten. Daarom is het veiliger om in MicroPython Pin("LED", Pin.OUT) te schrijven; in actuele MicroPython-versies vindt deze naam de ingebouwde led op zowel de Pico als de Pico W. Herkent de firmware op je board de naam "LED" niet, installeer dan een actuele MicroPython op de Pico. Het gratis project Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W) legt precies dit verschil uit.
1// Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the built-in LED
2void setup() {
3 pinMode(13, OUTPUT); // Uno'da dahili LED 13. pinde / built-in LED is on pin 13 on the Uno
4}
5
6void loop() {
7 digitalWrite(13, HIGH); // LED yanar / LED on
8 delay(500); // 500 ms bekle / wait 500 ms
9 digitalWrite(13, LOW); // LED söner / LED off
10 delay(500); // 500 ms bekle / wait 500 ms
11}1# Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT) # Pico ve Pico W'de dahili LED / onboard LED on Pico and Pico W
6# Pin(25, Pin.OUT) yalnız düz Pico'da çalışır / Pin(25, Pin.OUT) works only on the plain Pico
7
8while True: # Arduino'daki loop() gibi / like loop() in Arduino
9 led.on() # LED yanar / LED on
10 time.sleep_ms(500) # 500 ms bekle / wait 500 ms
11 led.off() # LED söner / LED off
12 time.sleep_ms(500) # 500 ms bekle / wait 500 msHet tweede voorbeeld voegt een ingang toe: de led brandt zolang de knop is ingedrukt. De knop komt op de Uno tussen pin 2 en GND, en op de Pico tussen GP14 en GND. Op de Uno gebruiken we weer de ingebouwde led op pin 13; sluit op de Pico een externe led aan op GP15 via een weerstand van 220 Ω (de tool Ledweerstand berekent deze waarde voor je eigen led). Beide talen schakelen de interne pull-upweerstand in: INPUT_PULLUP in Arduino, Pin.PULL_UP in MicroPython. Met deze bedrading is de logica omgekeerd: als je de knop indrukt, wordt de pin naar GND getrokken, dus Arduino leest LOW en de Pico leest 0. De pauze van 20 ms aan het einde lost de mechanische contactdender van de knop niet volledig op, maar vermindert wel heel korte flikkeringen. De details over het aansluiten van een knop staan in het artikel een knop aansluiten op Arduino.
1// Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2const int BUTTON_PIN = 2; // buton: 2. pin ile GND arasında / button between pin 2 and GND
3const int LED_PIN = 13; // dahili LED / built-in LED
4
5void setup() {
6 pinMode(BUTTON_PIN, INPUT_PULLUP); // iç pull-up direnci açık / internal pull-up on
7 pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11 if (digitalRead(BUTTON_PIN) == LOW) { // basılıyken LOW okunur / reads LOW while pressed
12 digitalWrite(LED_PIN, HIGH);
13 } else {
14 digitalWrite(LED_PIN, LOW);
15 }
16 delay(20); // kısa bekleme / short pause
17}1# Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2from machine import Pin
3import time
4
5button = Pin(14, Pin.IN, Pin.PULL_UP) # buton: GP14 ile GND arasında / button between GP14 and GND
6led = Pin(15, Pin.OUT) # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7
8while True:
9 if button.value() == 0: # basılıyken 0 okunur / reads 0 while pressed
10 led.value(1)
11 else:
12 led.value(0)
13 time.sleep_ms(20) # kısa bekleme / short pauseHet derde voorbeeld toont het belangrijkste verschil tussen de twee talen: getalbereiken. De middelste pin van de potmeter gaat naar A0 op de Uno en GP26 op de Pico; de buitenste pinnen gaan naar 5V en GND op de Uno, en naar 3V3 (OUT) en GND op de Pico. De led komt op pin 9 (gemarkeerd met ~) op de Uno en op GP15 op de Pico, elk met een weerstand van 220 Ω. In Arduino geeft analogRead 0–1023 terug, maar verwacht analogWrite 0–255, daarom staat map(raw, 0, 1023, 0, 255) ertussen. Op de Pico gebruiken zowel read_u16 als duty_u16 0–65535, dus je kunt de meting rechtstreeks aan PWM doorgeven. Hoe PWM werkt lees je in het artikel wat is PWM, en hoe je waarden live volgt in de gids over de Serial Monitor.
1// Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2const int POT_PIN = A0; // potansiyometrenin orta ucu / potentiometer wiper
3const int LED_PIN = 9; // ~ işaretli PWM pini / PWM pin marked with ~
4
5void setup() {
6 pinMode(LED_PIN, OUTPUT);
7 Serial.begin(9600);
8}
9
10void loop() {
11 int raw = analogRead(POT_PIN); // 0-1023
12 int brightness = map(raw, 0, 1023, 0, 255); // 0-255 aralığına ölçekle / scale to 0-255
13 analogWrite(LED_PIN, brightness);
14 Serial.println(raw); // Seri Monitör'de izle / watch in the Serial Monitor
15 delay(50);
16}1# Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26) # GP26 = ADC0, orta uç / wiper on GP26 (ADC0)
6led = PWM(Pin(15)) # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7led.freq(1000) # saniyede 1000 aç-kapa / 1000 cycles per second
8
9while True:
10 raw = pot.read_u16() # 0-65535
11 led.duty_u16(raw) # aynı aralık, ölçekleme gerekmez / same range, no scaling needed
12 print(raw) # Thonny kabuğunda izle / watch in the Thonny shell
13 time.sleep_ms(50)| Concept | Arduino C++ | MicroPython (Pico) |
|---|---|---|
| Wordt één keer uitgevoerd | void setup() { … } | De regels vóór while True: |
| Herhaalt eeuwig | void loop() { … } | while True: en de ingesprongen regels eronder |
| Codeblok | Accolades { } en ; aan het eind van een regel | : aan het eind van een regel en een inspringing van 4 spaties |
| Opmerking | // opmerking | # opmerking |
| Uitgangspin | pinMode(13, OUTPUT); digitalWrite(13, HIGH); | led = Pin(15, Pin.OUT) · led.value(1) |
| Ingangspin | pinMode(2, INPUT_PULLUP); digitalRead(2) | Pin(14, Pin.IN, Pin.PULL_UP) · button.value() |
| Analoog lezen | analogRead(A0) → 0–1023 | ADC(26).read_u16() → 0–65535 |
| PWM-uitgang | analogWrite(9, 0–255) | PWM(Pin(15)).duty_u16(0–65535) |
| Wachten | delay(500) | time.sleep_ms(500) of time.sleep(0.5) |
| Tekst tonen | Serial.begin(9600); Serial.println(x); | print(x) |
Minitoets, "Begrepen" en je voortgang in Mijn niveau
- Minitoets: Elke kaart eindigt met twee vragen, en de kop luidt Minitoets · 1 / 2. Als je op een antwoord tikt, krijg je meteen Goed. of Niet helemaal. met een korte uitleg; met Volgende vraag ga je verder.
- Score: Als beide vragen klaar zijn, zie je een score zoals 2 / 2 goed. De kaart kan niet worden afgerond zonder de toets; in plaats van de knop staat er Los de minitoets op om deze kaart af te ronden.
- Begrepen: Zodra de toets klaar is, verschijnt de knop Begrepen, volgende kaart (op de laatste kaart van een leerlijn alleen Begrepen). Als je erop tikt, wordt de kaart in je account opgeslagen als geleerd, laat een korte felicitatie je voortgang zien, zoals Mooi! 5 / 18 kaarten, en opent de volgende kaart.
- Badge en teller: Kaarten die je hebt geleerd, krijgen in de lijst het label Geleerd, en de teller Wat je hebt geleerd bovenaan de gids loopt op. Als je elke kaart van een leerlijn hebt afgerond, zie je Je hebt elke kaart van deze leerlijn geleerd.
- Mijn niveau: Op het scherm Mijn niveau in het onderdeel Leren staan onder de kop Codegids en de opmerking Kaarten die je hebt geleerd twee aparte balken: Arduino C++ x/18 en MicroPython x/18. Deze balken tellen alleen de kaarten van de codegids.
- Een eerlijke regel voor jezelf: De app houdt je niet tegen na een fout antwoord; de knop Begrepen verschijnt zodra de toets klaar is. Zorg er dus voor dat je hardop kunt uitleggen waarom beide antwoorden goed zijn voordat je erop tikt; lukt dat niet, ga dan terug naar het onderdeel Voorbeeld en lees de code nog een keer regel voor regel.
Zie het in projecten: het commando herkennen in echte code
De laatste stap bij het leren van een commando is het herkennen ervan in een werkend project dat iemand anders heeft geschreven. Het onderdeel Zie het in projecten op een kaart toont een paar geselecteerde projecten met eronder een zin die zegt hoeveel projecten het commando in hun code gebruiken; de link Alles opent de volledige lijst. De lijst is gesorteerd van makkelijk naar moeilijk en kun je beperken met de filters Alles, Gratis en Premium. millis staat bijvoorbeeld in de code van meer dan 50 projecten: de lijst begint met het gratis ESP32-ledbediening met drukknop (toggle), gaat verder met Pico-projecten voor beginners zoals Raspberry Pi Pico-knoppenpiano (5 knoppen + buzzer + melodierecorder) en Raspberry Pi Pico-parkeersensor (HC-SR04 + 3 leds + buzzer), en loopt op naar projecten van gemiddeld niveau zoals Raspberry Pi Pico-stoplicht met knop voor 4 standen (toestandsmachine, GP11-13 + GP4), die een knop combineren met timing. Ons advies: open een gratis project uit de lijst, zoek het commando in de code, verander één waarde en voorspel eerst het resultaat. Om te zien wat elke regel van de code doet, is het tabblad Code uitgelegd van het project de logische volgende stap.
Aanbevolen leervolgorde: een plan voor 4 weken
Stel dat je ongeveer 20 minuten per dag kunt besteden, 5 dagen per week. Om één leerlijn in 4 weken af te ronden, is op de meeste dagen één kaart genoeg; op de andere dagen herhaal je en werk je aan een project in plaats van aan een nieuwe kaart. Heb je een Arduino, volg dan alleen de Arduino-kolom; heb je een Pico, volg dan de MicroPython-kolom. Heb je beide, rond dan eerst de Arduino-leerlijn af en ga in de tweede maand naar MicroPython; de concepten zijn hetzelfde, dus de tweede leerlijn gaat veel sneller. Alle projecten in de tabel zijn gratis in BlueGrays. Wil je een breder plan, dan werkt de routekaart van 30 dagen in het artikel app om Arduino te leren goed naast deze tabel; geef je les met de Pico, dan verdeelt het lesplan voor de Raspberry Pi Pico de MicroPython-kaarten over 6 lesweken.
| Week | Arduino C++-kaarten | MicroPython-kaarten | Gratis projecten van de week | Wat je aan het eind van de week kunt |
|---|---|---|---|---|
| 1 | 1–5: pinMode, digitalWrite, digitalRead, analogRead, analogWrite | 1–5: import, print, Pin-uitgang, Pin-ingang, time.sleep | Led laten knipperen, Led bedienen met een drukknop (push); Pico: Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W) | Een led laten knipperen, een knop lezen; op Arduino een analoge waarde zien |
| 2 | 6–10: delay, millis, variabelen, if / else, operatoren | 6–9: while True, inspringen, variabelen, if / elif / else | Nachtlampje met LDR, ESP32-ledbediening met drukknop (toggle); Pico: Raspberry Pi Pico twee leds afwisselend (wisselpatroon, GP14 + GP13) | Beslissingen nemen op basis van een meting, dingen timen zonder het programma te stoppen |
| 3 | 11–14: for, while, functies, arrays | 10–13: for en range, lijsten, def, ADC | Knight Rider-ledeffect, Looplicht; Pico: Raspberry Pi Pico-stoplichtsimulator (3 leds na elkaar, GP11/GP12/GP13) | Herhaling in lussen zetten, pins in arrays en taken in functies |
| 4 | 15–18: Serial, map, random, tone | 14–18: PWM, ticks_ms, Pin.irq, try / except, I2C | Een buzzer gebruiken, Lichtsterkte meten met een LDR; Pico: Raspberry Pi Pico-stoplicht met knop voor 4 standen (toestandsmachine, GP11-13 + GP4) | Waarden tonen, geluid en helderheid regelen, een klein project helemaal zelf bouwen |
Een dagelijkse routine van 20 minuten
- 3 minuten, opwarmen: Maak de vragen van de dag in het onderdeel Leren of doe de minitoets van gisteren opnieuw. Het doel is te controleren of je het commando van gisteren vandaag nog weet.
- 5 minuten, nieuwe kaart: Lees de onderdelen Wat doet het?, Waarom? en Syntaxis. Schrijf de syntaxis met de hand over op papier; door het uit te schrijven slaan je ogen haakjes en puntkomma's minder snel over.
- 3 minuten, voorbeeld: Leg het voorbeeld aan jezelf uit, regel voor regel, en wissel dan van tabblad. Kijk bij een Arduino-kaart naar het tabblad MicroPython, bij een MicroPython-kaart naar het tabblad Arduino, en koppel de regels die in beide programma's hetzelfde doen.
- 2 minuten, minitoets: Beantwoord beide vragen en lees de uitleg bij de vragen die je fout had. Kijk op dit moment nog een keer naar de vakken Veelgemaakte fout en Tip.
- 6 minuten, project: Open een gratis, makkelijk project uit de lijst Zie het in projecten, zoek het commando in de code en verander één waarde: een delay, een pinnummer of een drempel. Is je schakeling klaar, upload dan naar het board; zo niet, voorspel dan het resultaat en controleer het met Code uitgelegd.
- 1 minuut, notitie: Schrijf één regel in je schrift: de naam van het commando, de betekenis in één zin en het equivalent in de andere taal. Na vier weken is die pagina je eigen commandowoordenboek.
8 veelgemaakte fouten met deze commando's
| Fout | Symptoom | Oplossing | Kaart |
|---|---|---|---|
| pinMode vergeten | De led gaat helemaal niet aan of brandt heel zwak | Schrijf pinMode(pin, OUTPUT) in setup(); maak op de Pico de pin aan met Pin(15, Pin.OUT) | pinMode · Pin-uitgang |
| = schrijven in plaats van == in een voorwaarde | if (x = 5) is altijd waar, dus het programma voert altijd dezelfde tak uit | Gebruik == om te vergelijken; in Python geeft if x = 5 meteen een SyntaxError | if / else · operatoren |
| De code vastzetten met een lange delay | Je drukt op de knop, maar de reactie komt laat of helemaal niet | Doe het wachten met millis; gebruik op de Pico time.ticks_ms en ticks_diff | delay · millis · ticks_ms |
| Het bereik van analogRead door elkaar halen | Een drempel die je van Arduino hebt overgenomen, wordt op de Pico nooit bereikt | analogRead geeft 0–1023 op de Uno, read_u16 geeft 0–65535 op de Pico; reken de drempel opnieuw uit voor het nieuwe bereik | analogRead · ADC |
| Een analogWrite-waarde overnemen voor duty_u16 | Op de Pico laat duty_u16(255) de led bijna donker | duty_u16 verwacht 0–65535: halve helderheid is 32768, volle helderheid 65535 | analogWrite · PWM |
| millis in een int bewaren | Op de Uno loopt de timing na ongeveer 33 seconden fout | Maak tijdvariabelen unsigned long en schrijf de controle als now - previous >= interval | millis |
| De INPUT_PULLUP-logica andersom verwachten | Je verwacht HIGH of 1 als je de knop indrukt, maar krijgt LOW of 0 | Met een pull-up is ingedrukt LOW (0) en losgelaten HIGH (1) | digitalRead · Pin-ingang |
| sleep(500) schrijven op de Pico | De Pico wacht 500 seconden, meer dan 8 minuten, in plaats van een halve seconde | sleep rekent in seconden: schrijf sleep(0.5) of sleep_ms(500) | time.sleep |
Het tabblad Blokken: een commando begrijpen door het te zien

Op het tabblad Blokken zie je wat een commando doet zonder code te schrijven, vooral op de eerste kaarten van een leerlijn. In de afbeelding hierboven wordt pinMode het blok "zet pin 9 als OUTPUT", digitalWrite het blok "schrijf HIGH naar pin 9" en delay het blok "wacht 100 ms"; op de pinMode-kaart staan onder de blokweergave ook de opties van het uitklapmenu: OUTPUT, INPUT en INPUT_PULLUP. Blokken worden getoond in de taal van de app en zijn bedoeld om te lezen: je sleept in de app geen blokken om een programma te schrijven, en het board krijgt altijd de echte code. De aanbevolen aanpak: voorspel eerst wat het programma doet op het tabblad Blokken, wissel dan naar het tabblad Arduino en zoek welke regel bij elk blok hoort. Bij projecten met een blokweergave kun je met de schakelaar Tonen als blokken op de projectpagina hetzelfde doen voor een heel project; de basis staat in het artikel wat is programmeren met blokken.
Kortom: om Arduino-commando's te leren heb je geen lange lijst nodig: de juiste volgorde, een klein werkend voorbeeld per commando, een controle van twee vragen en een echt project dat het commando gebruikt, zijn genoeg. Als je vandaag met de pinMode-kaart begint, heb je over vier weken alle 18 kaarten afgerond en elk commando in minstens één project met eigen ogen gezien; als je overstapt naar de Pico, werk je dezelfde concepten in de MicroPython-leerlijn veel sneller door. Wil je de kaarten en de projecten erin uitproberen, installeer dan BlueGrays op je telefoon en open de eerste kaart in het onderdeel Leren.
Veelgestelde vragen
Wat zijn de basiscommando's van Arduino?
De meest gebruikte Arduino-commando's zijn de pincommando's (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), de tijdcommando's (delay, millis), de commando's voor de seriële poort onder Serial, en hulpfuncties zoals map, random en tone. Daarnaast bouwen C++-structuren zoals if, for en while, plus functies, de loop van het programma op. De Arduino C++-leerlijn van de BlueGrays-Codegids behandelt deze onderwerpen op volgorde in 18 kaarten.
Welk Arduino-commando moet ik als eerste leren?
Begin met pinMode en digitalWrite, want met die twee kun je al een led laten branden en zie je meteen het resultaat. Voeg daarna timing toe met delay en het lezen van een knop met digitalRead. analogRead, millis, if en for bouwen allemaal voort op deze vier commando's.
Wat is het verschil tussen Arduino- en MicroPython-commando's?
De concepten zijn hetzelfde, de schrijfwijze is anders: Pin(15, Pin.OUT) en led.value(1) vervangen pinMode en digitalWrite, time.sleep_ms vervangt delay en while True vervangt loop(). Ook de getalbereiken veranderen; analogRead geeft 0–1023 op de Uno, terwijl read_u16 0–65535 geeft op de Pico. In Python nemen inspringen en de dubbele punt de plaats in van de accolades en puntkomma's van C++.
Is er een delay-commando in MicroPython?
Er is geen commando met de naam delay; sleep (seconden), sleep_ms (milliseconden) en sleep_us (microseconden) uit de module time doen hetzelfde. delay(500) in Arduino wordt op de Pico time.sleep_ms(500) of time.sleep(0.5). Voor timing zonder de code te stoppen vervangen time.ticks_ms en time.ticks_diff millis.
Op welke pin zit de ingebouwde led van de Raspberry Pi Pico?
Op de gewone Pico zit de ingebouwde led aan GP25. Op de Pico W zit de led aan de draadloze chip, dus Pin(25) laat hem niet oplichten. In actuele MicroPython-versies vindt Pin("LED", Pin.OUT) de ingebouwde led op beide boards.
Is de BlueGrays-Codegids gratis?
Ja, de Codegids is gratis: je kunt alle 36 kaarten lezen, de voorbeelden bekijken en de minitoetsen maken. De lijsten Zie het in projecten op de kaarten bevatten zowel gratis als Premium-projecten; het filter Gratis toont alleen de gratis projecten.
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.

Nachtlampje met LDR
Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

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

Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
Het openingsproject van de Raspberry Pi Pico-serie! We laten de groene ingebouwde led van de Pico knipperen om te controleren of het board werkt: het klassieke "Hello World" als eerste experiment. Je hebt geen externe onderdelen nodig, alleen de Pico en een USB-kabel. De code is geschreven in MicroPython, de taal die officieel door de Raspberry Pi Foundation wordt ondersteund.

Raspberry Pi Pico twee LED's om en om laten knipperen (blink-flip-patroon)
De volgende stap na de enkele led van de Pico: de klassieke flipflop-animatie, waarbij twee LED's om de beurt knipperen. De ene led gaat uit als de andere aan gaat, het meest basale voorbeeld van het aansturen van meerdere GPIO's. Twee LED's in verschillende kleuren (rood op GP14, groen op GP13) wisselen elke 500 ms. Met de methode Pin.toggle() van MicroPython blijft de code kort en leesbaar.

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

