Basis · 13 min leestijd

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.

Arduino Uno-board: digitale pins, PWM-pins gemarkeerd met ~ en de analoge ingangen A0–A5
De eerste vijf kaarten van de Arduino C++-leerlijn behandelen de drie pingroepen van dit board: digitale pins, PWM-pins gemarkeerd met ~ en de analoge ingangen A0–A5.

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.

OnderdeelWat het behandeltOp de millis-kaart
Wat doet het?De taak van het commando in één zinVertelt je hoeveel milliseconden er voorbij zijn sinds het board is gestart.
Waarom?Waarom je het nodig hebt, via een alledaagse vergelijkingAlsof je een cake in de oven zet en af en toe op de klok kijkt: je doet andere dingen terwijl je wacht.
SyntaxisHoe het commando wordt geschrevenunsigned long now = millis();
VoorbeeldEen kort werkend programma; tabbladen Blokken, Arduino en MicroPythonCode die elke 500 ms een led laat wisselen; op de Pico dezelfde taak met time.ticks_ms
Veelgemaakte foutDe valkuil waar beginners het vaakst in trappenmillis in een int bewaren: het getal loopt na ongeveer 33 seconden fout.
TipEen kleine regel die het leven makkelijker maaktSchrijf de controle altijd als now - previous >= interval.
Zie het in projectenProjecten die het commando gebruiken, van makkelijk naar moeilijkMeer dan 50 projecten; de lijst begint met een gratis ESP32-knopproject
Mini testTwee vragen, na elk antwoord een korte uitlegWat 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.KaartWat doet het?MicroPython-equivalent
1pinModeVertelt het board of een pin een uitgang (led, buzzer) of een ingang (knop, sensor) isPin(15, Pin.OUT) · Pin(14, Pin.IN, Pin.PULL_UP)
2digitalWriteZet een uitgangspin aan (HIGH, 5 V) of uit (LOW, 0 V)led.value(1) · led.on() · led.off()
3digitalReadLeest of een ingangspin HIGH of LOW isbutton.value() → 1 of 0
4analogReadZet de spanning op A0–A5 om in een getal van 0 tot 1023ADC(26).read_u16() → 0–65535
5analogWrite (PWM)Dimt een led of vertraagt een motor met een waarde van 0 tot 255 op een ~-pinPWM(Pin(15)) · freq(1000) · duty_u16(0–65535)
6delayPauzeert de code voor het opgegeven aantal millisecondentime.sleep(0.5) · time.sleep_ms(500)
7millisMilliseconden sinds het opstarten; timen zonder de code te stoppentime.ticks_ms() · time.ticks_diff()
8Variabelen en typenBewaart waarden met typen zoals int, float, bool, unsigned longEr wordt geen type geschreven: count = 0, volts = 3.3
9if / else if / elseVoert andere code uit afhankelijk van een voorwaardeif / elif / else
10Vergelijkings- en logische operatorenBouwt voorwaarden met ==, !=, <, >, &&, ||, !==, !=, <, > · and, or, not
11for-lusHerhaalt een taak een vast aantal keerfor i in range(10):
12while-lusHerhaalt zolang een voorwaarde waar iswhile condition:
13Functies (void, parameters, return)Verdeelt code in herbruikbare stukken met een naamdef blink(times): … return
14ArraysBewaart waarden van hetzelfde type op volgorde onder één naamLijst: pins = [2, 3, 4] · len(pins)
15Serial.begin / print / printlnStuurt tekst en waarden naar de computer (Serial Monitor)print(x) · f-string; Serial.begin is niet nodig
16mapSchaalt het ene getalbereik naar het andereGeen ingebouwd commando: raw * 255 // 1023 of je eigen functie
17random / randomSeedGenereert willekeurige getallenimport random · random.randint(1, 6)
18tone / noToneSpeelt een toon met een bepaalde frequentie op een buzzer en stopt hem weerPWM: freq(440) · duty_u16(32768); duty_u16(0) om het stil te zetten
De equivalenten zijn niet één-op-één, en het grootste verschil zit in de getalbereiken. Op de Uno geeft analogRead 0–1023 terug en verwacht analogWrite 0–255; op de Pico gebruiken zowel ADC.read_u16 als PWM.duty_u16 0–65535. Alleen GP26, GP27 en GP28 kunnen op de Pico analoge waarden lezen, en ze meten maximaal 3,3 V, dus sluit een potmeter aan op 3V3 (OUT), niet op 5 V. MicroPython heeft ook geen kant-en-klaar map- of tone-commando: je schaalt met een eenvoudige vermenigvuldiging en deling, en maakt geluid met de PWM-instelling freq.

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.KaartWat doet het?Arduino-equivalent
1import en from … importVoegt modules zoals machine en time toe aan het programma#include voor bibliotheken; basiscommando's zoals pinMode en delay zijn ingebouwd
2print en f-stringsToont tekst en waarden in de Thonny-shellSerial.begin(9600) + Serial.println()
3Pin-uitgang: Pin(15, Pin.OUT)Maakt van een GP-pin een uitgang; value(), on(), off(), toggle()pinMode(13, OUTPUT) + digitalWrite()
4Pin-ingang: Pin.IN, PULL_UP, PULL_DOWNMaakt van een pin een ingang, kiest de interne weerstand, leest met value()pinMode(2, INPUT_PULLUP) + digitalRead()
5time.sleep en sleep_msPauzeert het programma in seconden of millisecondendelay()
6while True: de eindeloze lusHerhaalt de regels eronder zolang de Pico aanstaatloop()
7Inspringen en de dubbele punt (:)Bepaalt welke regel bij welk blok hoortAccolades { } en de puntkomma ;
8Variabelen: int, float, str, boolBewaart waarden; het type wordt automatisch bepaaldint, float, String, bool
9if / elif / else, and / or / notVertakt op een voorwaarde en combineert voorwaardenif / else if / else · &&, ||, !
10for en rangeHerhaalt een vast aantal keer; range(0, 10) telt van 0 tot 9for (int i = 0; i < 10; i++)
11Lijsten: [ ], index, lenBevat meerdere waarden op volgorde; het eerste item staat op index 0Arrays: int pins[] = {2, 3, 4};
12def en return (functies)Geeft herbruikbare code een naam en geeft een resultaat terugvoid- of getypeerde functies, return
13ADC: analoog lezen met read_u16Leest de spanning op GP26, GP27, GP28 als 0–65535analogRead() → 0–1023
14PWM: freq en duty_u16Dimt een led, speelt noten op een buzzeranalogWrite() en tone()
15time.ticks_ms en ticks_diffMeet verstreken tijd zonder de code te stoppenmillis()
16Pin.irq: knoppen met interruptsVoert een functie uit op het moment dat een knop wordt ingedruktattachInterrupt()
17try / except (fouten opvangen)Voorkomt dat het programma stopt als er een fout optreedtGeen gangbaar equivalent in Arduino; je controleert teruggegeven waarden
18I2C en scan()Vindt de adressen van apparaten op de I2C-busWire.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.

C++ (Arduino IDE)
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}
MicroPython
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 ms

Het 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.

C++ (Arduino IDE)
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}
MicroPython
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 pause

Het 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.

C++ (Arduino IDE)
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}
MicroPython
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)
ConceptArduino C++MicroPython (Pico)
Wordt één keer uitgevoerdvoid setup() { … }De regels vóór while True:
Herhaalt eeuwigvoid loop() { … }while True: en de ingesprongen regels eronder
CodeblokAccolades { } en ; aan het eind van een regel: aan het eind van een regel en een inspringing van 4 spaties
Opmerking// opmerking# opmerking
UitgangspinpinMode(13, OUTPUT); digitalWrite(13, HIGH);led = Pin(15, Pin.OUT) · led.value(1)
IngangspinpinMode(2, INPUT_PULLUP); digitalRead(2)Pin(14, Pin.IN, Pin.PULL_UP) · button.value()
Analoog lezenanalogRead(A0) → 0–1023ADC(26).read_u16() → 0–65535
PWM-uitganganalogWrite(9, 0–255)PWM(Pin(15)).duty_u16(0–65535)
Wachtendelay(500)time.sleep_ms(500) of time.sleep(0.5)
Tekst tonenSerial.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.

WeekArduino C++-kaartenMicroPython-kaartenGratis projecten van de weekWat je aan het eind van de week kunt
11–5: pinMode, digitalWrite, digitalRead, analogRead, analogWrite1–5: import, print, Pin-uitgang, Pin-ingang, time.sleepLed 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
26–10: delay, millis, variabelen, if / else, operatoren6–9: while True, inspringen, variabelen, if / elif / elseNachtlampje 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
311–14: for, while, functies, arrays10–13: for en range, lijsten, def, ADCKnight 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
415–18: Serial, map, random, tone14–18: PWM, ticks_ms, Pin.irq, try / except, I2CEen 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

  1. 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.
  2. 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. 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.
  4. 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.
  5. 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.
  6. 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

FoutSymptoomOplossingKaart
pinMode vergetenDe led gaat helemaal niet aan of brandt heel zwakSchrijf 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 voorwaardeif (x = 5) is altijd waar, dus het programma voert altijd dezelfde tak uitGebruik == om te vergelijken; in Python geeft if x = 5 meteen een SyntaxErrorif / else · operatoren
De code vastzetten met een lange delayJe drukt op de knop, maar de reactie komt laat of helemaal nietDoe het wachten met millis; gebruik op de Pico time.ticks_ms en ticks_diffdelay · millis · ticks_ms
Het bereik van analogRead door elkaar halenEen drempel die je van Arduino hebt overgenomen, wordt op de Pico nooit bereiktanalogRead geeft 0–1023 op de Uno, read_u16 geeft 0–65535 op de Pico; reken de drempel opnieuw uit voor het nieuwe bereikanalogRead · ADC
Een analogWrite-waarde overnemen voor duty_u16Op de Pico laat duty_u16(255) de led bijna donkerduty_u16 verwacht 0–65535: halve helderheid is 32768, volle helderheid 65535analogWrite · PWM
millis in een int bewarenOp de Uno loopt de timing na ongeveer 33 seconden foutMaak tijdvariabelen unsigned long en schrijf de controle als now - previous >= intervalmillis
De INPUT_PULLUP-logica andersom verwachtenJe verwacht HIGH of 1 als je de knop indrukt, maar krijgt LOW of 0Met een pull-up is ingedrukt LOW (0) en losgelaten HIGH (1)digitalRead · Pin-ingang
sleep(500) schrijven op de PicoDe Pico wacht 500 seconden, meer dan 8 minuten, in plaats van een halve secondesleep rekent in seconden: schrijf sleep(0.5) of sleep_ms(500)time.sleep

Het tabblad Blokken: een commando begrijpen door het te zien

Nederlandse blokken van het project Led laten knipperen: zet pin 9 als OUTPUT, schrijf daarna in de eindeloze lus HIGH naar pin 9, wacht 100 ms, schrijf LOW naar pin 9, wacht 100 ms
Blokken van het gratis project Led laten knipperen: het blok "setup (één keer uitvoeren)" komt overeen met setup() en het blok "herhaal voor altijd" met loop().

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.

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(198)
1242
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
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

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

4.7(105)
224
ESP32-ledbesturing met drukknop (Toggle)
ES-3Beginner

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.

4.6(39)
59
Knight Rider-ledeffect
AR-6Gemiddeld

Knight Rider-ledeffect

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

4.8(107)
213
Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
PI-1Beginner

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.

5.0(1)
10
Raspberry Pi Pico twee LED's om en om laten knipperen (blink-flip-patroon)
PI-3Beginner

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.

5.0(2)
19
Raspberry Pi Pico-stoplicht (3 leds na elkaar)
PI-4Beginner

Raspberry Pi Pico-stoplicht (3 leds na elkaar)

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

4.0(1)
12