Arduino-code stap voor stap uitgelegd: begrijp hem en pas hem dan aan
Arduino-code stap voor stap uitgelegd met BlueGrays: de samenvatting, de stappen, Kom je er niet uit, Probeer het zelf-opdrachten, een routine van 15 minuten en een echt knopproject.
Code uitgelegd is het tabblad in het onderdeel Broncode op elke BlueGrays-projectpagina dat de kant-en-klare Arduino-code stap voor stap uitlegt. Om te begrijpen wat de code die je hebt gekopieerd en geüpload echt doet, volg je deze volgorde: lees eerst de samenvatting Wat doet deze code?, zoek dan elk codefragment uit Stap voor stap op in de volledige code samen met de uitleg, kijk bij Kom je er niet uit als de schakeling zich niet gedraagt zoals verwacht, en gebruik ten slotte de opdracht Probeer het zelf om één ding in de code te veranderen en het resultaat op het board te zien. Deze vier onderdelen zijn de kortste weg van "het werkt, maar ik weet niet waarom" naar "ik weet wat er gebeurt als ik deze regel verander".
In dit bericht bespreken we het tabblad Code uitgelegd van begin tot eind met de echte inhoud van een echt project: project nummer 10, Een led schakelen met een knop (aan/uit). Het is gratis, heeft niveau Beginner en heeft ook een blokweergave, dus iedereen kan de uitleg openen voor zowel de code als de blokken. Je vindt hier de onderdelen van het tabblad, een methode om de code aan de uitleg te koppelen, een studieroutine van 15 minuten, een aanpak voor Probeer het zelf-opdrachten, welke aanpassing welk concept leert, de weergave Blokken uitgelegd, het verschil tussen Kom je er niet uit en Problemen oplossen, en ideeën voor docenten die het in de klas gebruiken.
Waar vind je het tabblad Code uitgelegd en wie kan het gebruiken?
Als je een project opent en naar het onderdeel Broncode scrolt, zie je bovenaan een selector met twee tabbladen: Code en Code uitgelegd. Het tabblad Code toont het volledige programma, en daar staan ook de knoppen Kopiëren en Link kopiëren. Schakel je over naar Code uitgelegd, dan opent de geannoteerde versie van hetzelfde programma. Elk van de meer dan 200 projecten heeft dit tabblad, en het werkt hetzelfde voor Arduino-, ESP32- en Raspberry Pi Pico-projecten. De toegang is eenvoudig: in de 60 gratis projecten (20 per platform) is Code uitgelegd voor iedereen open, dus ook met een gratis account zie je de samenvatting, alle stappen, Kom je er niet uit en de Probeer het zelf-opdracht met oplossing. In Premium-projecten staat in plaats van het tabblad een slotkaart: "Ontgrendel de stapsgewijze code-uitleg met Premium." Je kunt de methode uit dit bericht dus zonder te betalen gebruiken op LED-knipperlicht, Verkeerslicht, LED-politielichten en de knopprojecten.
De onderdelen: waar elk voor dient
| Onderdeel | Wat het toont | Hoe je het gebruikt |
|---|---|---|
| Wat doet deze code? | Een samenvatting van 2–3 zinnen: wat het programma doet, in welke volgorde en waarom het zich blijft herhalen | Leg het programma na het lezen zonder te kijken in één zin uit; lukt dat niet, lees het dan opnieuw |
| Stap voor stap | Genummerde stappen, elk met een titel, een kort codefragment en een uitleg (in de meeste projecten 5–6 stappen) | Lees de stappen op volgorde en zoek elk fragment op in de volledige code |
| Codefragment | Alleen de regels waar die stap over gaat, zonder de rest van het programma | Kijk naar de getallen en pinnummers erin; dat zijn meestal de onderdelen die je kunt aanpassen |
| Kom je er niet uit | Veelvoorkomende verschijnselen in dat project en hun oplossingen (meestal 4–5) | Als de schakeling zich niet gedraagt zoals verwacht, zoek je verschijnsel eerst hier |
| Probeer het zelf | Een korte opdracht waarin je één wijziging in de code aanbrengt | Voorspel eerst het resultaat, voer dan de wijziging door en upload |
| Hint | Eén zin direct onder de opdracht die zegt waar je moet kijken | Lees hem als je voorspelling niet klopt; hij wijst de weg zonder het antwoord te geven |
| Oplossing tonen | Een OPLOSSING-vak dat opent als je tikt: welke regel wat wordt, en het resultaat | Open het als laatste en vergelijk met je eigen werk; sluit het weer met Oplossing verbergen |
De volgorde van de onderdelen is bewust gekozen: eerst het grote geheel, dan de onderdelen, dan de fouten en ten slotte je eigen experiment. Codefragmenten zijn niet het hele programma, alleen de regels die die stap uitlegt; de sluitaccolade van een blok dat in de ene stap is geopend, kan in de volgende staan. Daarom werkt het beter om alle stappen op volgorde te lezen dan er maar één te bekijken. De hint staat direct onder de opdrachttekst, terwijl de oplossing verborgen blijft totdat je op Oplossing tonen tikt. Door deze opzet heb je ruimte om na te denken voordat je het antwoord ziet.
Voorbeeld: Code uitgelegd in het project Een led schakelen met een knop
Het project gebruikt één drukknop en één led. Eén kant van de knop gaat naar 5V en de andere kant naar pin 13 van het board; dezelfde pin wordt via een weerstand van 10 kΩ naar GND getrokken. Het lange pootje van de led gaat naar pin 7 en het korte pootje via een weerstand van 330 Ω naar GND. De samenvatting in Code uitgelegd beschrijft het programma zo: elke keer dat je op de knop drukt, wisselt de led één keer van stand, hij gaat aan als hij uit was en uit als hij aan was; ook als je de knop ingedrukt houdt, verandert de led maar één keer, en een wachttijd van 50 ms negeert het contactdender van de knop. Hier is het volledige programma, met opmerkingen in twee talen.
1int ledState = 0; // LED durumu: 0 sönük, 1 yanık / LED state: 0 = off, 1 = on
2int lastButton = 0; // Butonun önceki okuması / Previous button reading
3
4void setup() {
5 pinMode(13, INPUT); // Buton girişi, harici pull-down / Button input, external pull-down
6 pinMode(7, OUTPUT); // LED çıkışı / LED output
7}
8
9void loop() {
10 int button = digitalRead(13); // Butonu oku / Read the button
11 if (button != lastButton) { // Buton durumu değişti / Button state changed
12 if (button == 1) { // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13 ledState = !ledState; // Durumu tersine çevir / Flip the state
14 digitalWrite(7, ledState); // Yeni durumu LED'e yaz / Write the new state to the LED
15 }
16 delay(50); // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17 lastButton = button; // Bu okumayı sakla / Store this reading
18 }
19}| Stap | Codefragment | Kern van de uitleg | Concept dat het leert |
|---|---|---|---|
| 1. Variabelen die de led en de knop onthouden | int ledState = 0; int lastButton = 0; | ledState bevat de huidige stand van de led en lastButton de vorige knopwaarde; omdat ze buiten de functies zijn gedeclareerd, behouden ze hun waarde bij elke doorgang van de lus | Globale variabele |
| 2. setup(): de pins voorbereiden | pinMode(13, INPUT); pinMode(7, OUTPUT); | D13 is een ingang, D7 een uitgang; INPUT is genoeg omdat de schakeling een externe pull-downweerstand van 10 kΩ heeft, anders zou de pin zweven | Ingang, uitgang, pull-down |
| 3. loop(): de knop lezen, de verandering opvangen | int button = digitalRead(13); if (button != lastButton) { if (button == 1) { | Als de waarde gelijk is aan de vorige gebeurt er niets; als hij is veranderd en nu 1 is, is de knop net ingedrukt | Flankdetectie (overgang van LOW naar HIGH) |
| 4. De stand omdraaien, naar de led schrijven | ledState = !ledState; digitalWrite(7, ledState); | De operator ! maakt van 0 een 1 en van 1 een 0; de nieuwe waarde wordt naar de led geschreven | Toggle (aan/uit) |
| 5. 50 ms wachten en de laatste waarde opslaan | delay(50); lastButton = button; | Een mechanische knop dendert een paar milliseconden; 50 ms wachten negeert dat, daarna wordt de waarde opgeslagen voor de volgende doorgang | Debounce |
Let tijdens het lezen van de stappen vooral op dat de uitleg niet alleen vertelt wat er gebeurt, maar ook wat er zonder die regel zou gebeuren. Stap 1 wijst erop dat ledState begint op 0, dus de led is uit als het board wordt ingeschakeld. Dat leidt tot een goede vraag: als je het op 1 zet, begint de led dan aan? Nee, want die regel verandert alleen de variabele; setup() schrijft niets naar de led, dus hij begint uit, en bij de eerste druk gaat ledState terug naar 0, zodat hij uit blijft. De waarde van een variabele en de echte toestand van een pin zijn twee verschillende dingen. Stap 2 koppelt het gebruik van INPUT bij de knop aan de weerstand van 10 kΩ in de schakeling: als de knop niet is ingedrukt, trekt de weerstand de pin naar GND en lees je 0. Haal je de weerstand weg, dan zweeft de pin en lees je willekeurige waarden; het verschijnsel "de led gaat uit zichzelf aan en uit" bij Kom je er niet uit komt daar precies mee overeen.
Stap 3 en 5 lees je het best samen. De vergelijking in stap 3 werkt alleen als lastButton na elke verandering wordt bijgewerkt, en die update is de regel lastButton = button in stap 5. Als je de twee stappen aan elkaar koppelt, wordt het kernidee van het programma duidelijk: de code controleert niet of de knop is ingedrukt, maar of zijn toestand is veranderd. Terwijl je hem ingedrukt houdt, leest elke doorgang 1, maar lastButton is ook 1, dus de vergelijking is onwaar en de led verandert niet. De operator ! in stap 4 is een aan/uit-schakelaar in twee regels. Stap 5 eindigt met een waarschuwing: als de wachttijd te kort is, kan de led soms meer dan één keer per druk wisselen. Dat suggereert je eerste experiment vóór de opdracht: verlaag 50 naar 5, druk een paar keer en kijk of de led af en toe twee keer wisselt; het resultaat hangt af van de kwaliteit van de knop. Meer over debouncing lees je in hoe sluit je een knop aan op Arduino.

Het onderdeel Kom je er niet uit van dit project noemt vijf verschijnselen: de led gaat nooit branden; de led verandert uit zichzelf zonder dat je de knop aanraakt; er gebeurt niets als je op de knop drukt; de knop gedraagt zich alsof hij altijd is ingedrukt; de code wordt niet geüpload. Bij elk verschijnsel hoort een concrete controle. Bij "altijd ingedrukt" wordt bijvoorbeeld uitgelegd dat D13 de hele tijd met 5V verbonden blijft als de pootjes van de knop verkeerd zijn geplaatst, en dat je de knop 90 graden moet draaien. De Probeer het zelf-opdracht is deze: laat de led veranderen als je de knop loslaat in plaats van als je hem indrukt. De hint herinnert je eraan dat de variabele button 1 wordt op het moment van indrukken en 0 op het moment van loslaten. De oplossing is een wijziging van één teken: de regel if (button == 1) wordt if (button == 0). Deze kleine opdracht toetst of je het idee van flankdetectie uit stap 3 echt hebt begrepen.
Hoe je het leest: samenvatting, koppelen, testen
- Lees de samenvatting, schrijf hem in één zin: Lees Wat doet deze code? en schrijf het programma dan in één zin in je schrift zonder naar je telefoon te kijken. Voor het knopproject: "Elke druk zet de led één keer aan of uit."
- Koppel de code van boven naar beneden aan de stappen: Open de code in de Arduino IDE (met Link kopiëren in Broncode gaat dat makkelijk), zoek het fragment van elke stap in de volledige code en zet het stapnummer als opmerking naast de regel. De stappen volgen de volgorde van de code: globale variabelen, setup(), loop().
- Markeer regels zonder koppeling: Als een regel door geen enkele stap wordt behandeld (meestal blijven alleen sluitaccolades over), bedenk dan waarom hij niet wordt uitgelegd; als het geen accolade is, zoek hem dan opnieuw in de uitleg.
- Test het op de schakeling: Upload de code en test het gedrag uit de samenvatting stuk voor stap. Drie tests zijn genoeg voor het knopproject: één enkele druk, ingedrukt houden en snel herhaald drukken. Zeg voor elke test hardop wat er gaat gebeuren.
De koppelstap wordt het vaakst overgeslagen, maar levert het meeste op. Als je stapnummers naast de regels schrijft, wordt het skelet van de code zichtbaar: welke regel eenmalig draait en welke continu, waar elke variabele wordt gelezen en waar hij wordt geschreven. In het knopproject komt lastButton op twee plaatsen voor: hij wordt gedeclareerd in stap 1 en bijgewerkt in stap 5. Dat met eigen ogen zien blijft veel beter hangen dan lezen dat "een variabele een doosje is". Wil je variabelen, lussen en functies apart bestuderen, lees dan Arduino-programmeerbasis.
Een routine van 15 minuten voor Code uitgelegd
| Minuten | Wat je doet | Waar |
|---|---|---|
| 0–2 | Lees de samenvatting Wat doet deze code? en schrijf het programma in één zin op | Telefoon, Code uitgelegd |
| 2–6 | Zoek elk fragment uit Stap voor stap op in de volledige code en zet de stapnummers als opmerkingen bij de regels | Telefoon + Arduino IDE |
| 6–8 | Upload de code en test het gedrag uit de samenvatting stuk voor stuk | Computer + schakeling |
| 8–9 | Lees de Probeer het zelf-opdracht, voorspel het resultaat en schrijf het op | Telefoon + schrift |
| 9–12 | Voer de ene wijziging door, upload en bekijk het resultaat | Arduino IDE + schakeling |
| 12–13 | Als je voorspelling niet klopte, lees dan de Hint en probeer het nog eens | Telefoon |
| 13–15 | Vergelijk met Oplossing tonen en probeer dan een tweede wijziging naar eigen keuze | Telefoon + Arduino IDE |
Deze routine is bedoeld voor een project waarvan de schakeling al is gebouwd. Bouw je de schakeling voor het eerst, geef er dan 10–15 minuten extra bij of bewaar de routine Code uitgelegd voor de volgende dag. De laatste twee minuten zijn het waardevolst: na het zien van de oplossing zelf een kleine wijziging maken toetst het idee dat je hebt begrepen, niet het antwoord dat je uit je hoofd hebt geleerd. In het knopproject kun je bijvoorbeeld de led naar een andere pin verplaatsen of de wachttijd van 50 ms verhogen naar 300 ms en kijken wat er gebeurt bij snel drukken. Eén project per dag in dit tempo betekent vijf gratis projecten per week afronden en ze echt begrijpen. Voor een langer plan, zie de Arduino-roadmap van 30 dagen.
Een aanpak voor Probeer het zelf-opdrachten
Probeer het zelf-opdrachten zijn kort maar zorgvuldig gekozen: elke vraagt om één wijziging, en het resultaat kun je zien of horen. Als je deze volgorde aanhoudt, leer je er het dubbele van:
- Voorspel: Lees de opdracht en zeg welke regel van de code je aanpast en wat je na de wijziging gaat zien. Je voorspelling opschrijven voorkomt later de illusie van "dat wist ik al".
- Verander: Verander maar één ding. Als je twee regels tegelijk verandert, weet je niet welke wijziging wat veroorzaakte.
- Upload: Upload de code naar het board en wacht op de melding dat het uploaden klaar is. Krijg je een compileerfout, controleer dan de puntkomma's en haakjes in de regel die je hebt gewijzigd.
- Observeer: Vergelijk het resultaat met je voorspelling. Tel bij timingopdrachten de seconden; luister bij geluidsopdrachten naar het oude en het nieuwe geluid na elkaar.
- Bekijk de hint: Als je voorspelling niet klopte of je niet kon vinden welke regel je moest aanpassen, lees dan de hint. Omdat de hint direct onder de opdracht staat, helpt het om hem bij de eerste keer lezen met je hand af te dekken.
- Open de oplossing als laatste: Tik pas op Oplossing tonen nadat je het zelf hebt geprobeerd. Komt de oplossing overeen met die van jou, bedenk dan waarom hij goed is; wijkt hij af, bedenk dan waarom de twee aanpakken een ander resultaat geven.
Een ander voordeel van deze volgorde is dat fouten er nuttig door worden. Stel dat je bij de opdracht van Verkeerslicht het gele licht na groen wilt verlengen naar 1,5 seconde, maar per ongeluk de eerste regel delay(300) aanpast. In plaats van wat je verwachtte, wordt het gele licht na rood langer. Die fout leert je veel beter dan de oplossing dat de code twee aparte gele fasen heeft en dat loop() regel voor regel wordt uitgevoerd. De oplossing van de opdracht zegt precies dat: de regel delay(300) helemaal aan het eind van loop() wordt delay(1500), terwijl het gele licht na rood op 0,3 seconden blijft.
Soorten wijzigingen: welke leert welk concept?
Als je naar de opdrachten in de gratis projecten kijkt, zie je dat ze onder een paar soorten vallen. Het soort herkennen maakt het ook makkelijker om zelf een opdracht te bedenken in een nieuw project. De voorbeelden in de tabel komen uit echte Probeer het zelf-opdrachten in gratis projecten; de rij over een pin wijzigen is een experiment dat je zelf in hetzelfde project kunt doen.
| Soort wijziging | Voorbeeld | Concept dat het leert | Let op |
|---|---|---|---|
| Een getal veranderen | LED-knipperlicht: zet beide delay-regels op delay(1000); Een buzzer gebruiken: verhoog de frequentie van 400 Hz naar 1000 Hz | Eenheden (ms, Hz) en hoe één waarde het gedrag bepaalt | Tijden zijn in milliseconden: 1500 = 1,5 s. Voor de frequentieopdracht heb je een passieve buzzer nodig |
| Een pin veranderen | In het knopproject verplaats je de led van D7 naar D8: wijzig de draad en de regels pinMode(7, OUTPUT) en digitalWrite(7, ledState) | De link tussen code en schakeling; een pinnummer dat op meer dan één plek voorkomt | Verplaats de draad terwijl de USB-kabel los is; pas het nummer overal in de code aan |
| Een voorwaarde veranderen | Knop-toggle: button == 0 in plaats van button == 1; Nachtlampje met LDR: drempel van 50 naar 300 | Vergelijking, drempel, flankdetectie | Als de drempel verandert, verschuift het gedrag niet geleidelijk maar schakelt het op een bepaald punt om |
| Het gedrag omkeren | LED bedienen met een drukknop (push): de led is normaal aan en gaat uit als je indrukt | HIGH- en LOW-logica, een voorwaarde omkeren | Verander de voorwaarde of de geschreven waarden, niet allebei |
| Lusgrens | LED-politielichten: de rode led knippert 5 keer in plaats van 3, for (int i = 0; i < 5; i++) | for-lus, teller, aantal herhalingen | Verander alleen de eerste for-regel; blauw blijft 3 keer knipperen |
| Een ondergrens aan een uitdrukking toevoegen | Looplicht met instelbare snelheid: delay(potValue + 50) in plaats van delay(potValue) | Een meetwaarde in een berekening gebruiken, ondergrens | De wachttijd loopt nu van 50 tot 1073 ms, zodat het licht zelfs op topsnelheid goed te volgen blijft |
Blokken uitgelegd: dezelfde uitleg met blokken
Projecten met een blokweergave hebben in het onderdeel Broncode een schakelaar Tonen als blokken. Zet je hem aan, dan verschijnt hetzelfde programma als blokken in de taal van de app in plaats van als code, en het tabblad ernaast verandert van Code uitgelegd in Blokken uitgelegd. In deze weergave blijven de samenvatting, Kom je er niet uit en de opdracht hetzelfde; wat verandert is het onderdeel Stap voor stap: elke stap toont zijn eigen blokken in plaats van het codefragment, en als je op de afbeelding tikt, opent die op volledig scherm. Meer dan 100 projecten hebben een blokweergave, waaronder meer dan 30 van de gratis projecten. De blokken zijn alleen om te lezen; ze kunnen niet in de app worden bewerkt of naar het board worden geüpload, en wat op het board komt is altijd de echte code.
De beste manier om Blokken uitgelegd te gebruiken is heen en weer schakelen tussen de twee weergaven. In het knopproject zijn de blokken van stap 3 een blok "zet button op lees pin 13" plus twee geneste "als"-blokken; in code is dat de regel int button = digitalRead(13); en twee geneste if's. Het blok "zet ledState op niet ledState" in stap 4 is precies de regel ledState = !ledState;. Lees eerst het blok en zeg wat het doet, zet dan de schakelaar uit en bekijk het codefragment van dezelfde stap. Blokken zo aan code koppelen is de stevigste manier om van programmeren met blokken over te stappen naar tekstcode; om het onderwerp vanaf het begin te beginnen, zie wat is programmeren met blokken en het als-blok.
Kom je er niet uit versus Problemen oplossen
| Kenmerk | Kom je er niet uit | Problemen oplossen |
|---|---|---|
| Waar? | In het tabblad Code uitgelegd, na Stap voor stap | Een apart onderdeel op de projectpagina |
| Vorm | Paren van verschijnsel en oplossing; 5 in het knopproject | Een geordende checklist die begint met "Als je project niet werkt, controleer dan de onderstaande stappen."; 10 stappen in het knopproject |
| Wanneer? | Je kent het verschijnsel: "de led verandert uit zichzelf" | Je weet niet wat er mis is en wilt alles vanaf het begin controleren |
| Focus | Typische fouten die bij de code en schakeling van dat project horen | Algemene controles zoals voeding, uploaden, pinnummers, aansluitingen en GND |
| Toegang | Open voor iedereen in gratis projecten, met Premium in Premium-projecten | Beschikbaar in meer dan 170 projecten, te ontgrendelen met Premium |
In de praktijk is de volgorde deze: als de schakeling niet werkt, beschrijf je het verschijnsel in één zin en zoek je het op in Kom je er niet uit. Staat je verschijnsel erbij, dan is de oplossing meestal één draad, weerstand of regel. Staat het er niet bij, of hielp de voorgestelde oplossing niet, loop dan de stappen van Problemen oplossen op volgorde door; je vangt waarschijnlijk een basiscontrole die je hebt overgeslagen (voeding van het board, de juiste poort, een gemeenschappelijke GND). Zit je vast bij het uploaden, dan helpt Arduino-code wordt niet geüpload, en voor compileerfouten is er Arduino-compileerfouten.
Voor docenten: Code uitgelegd gebruiken in de klas
- Samen lezen op de beamer: Spiegel aan het begin van de les je telefoonscherm, lees samen de samenvatting Wat doet deze code? en laat de klas het programma in één zin samenvatten. Laat daarna dezelfde stappen als blokken zien met Tonen als blokken aan; voor leerlingen die met blokken zijn begonnen is dit een brug.
- Eén groep per stap: Verdeel de klas bij een project met 5 stappen in 5 groepen; elke groep leest één stap, zoekt het fragment op in de volledige code en legt het in twee minuten aan de klas uit. Terwijl een groep uitlegt, vragen de anderen: "wat zou er gebeuren zonder deze regel?".
- Voorspellingsbriefje: Schrijf de Probeer het zelf-opdracht op het bord; elke groep schrijft zijn voorspelling op een briefje voordat de wijziging wordt gemaakt, past dan de code aan en uploadt. Het verschil tussen voorspelling en resultaat bespreken leert meer dan de opdracht zelf uitvoeren.
- Afsluitende vraag: Beantwoordt in de laatste twee minuten van de les iedereen één vraag. Voorbeelden voor het knopproject: wat zou er gebeuren als je de knop ingedrukt houdt als lastButton er niet was? Wat verandert er als je delay(50) verwijdert? Waarom kan de led uit zichzelf veranderen als je de weerstand van 10 kΩ weghaalt?
Houd bij het plannen van de toegang rekening met dit: omdat Code uitgelegd in gratis projecten voor iedereen open is, kunnen je leerlingen deze methode zonder te betalen gebruiken met LED-knipperlicht, Verkeerslicht, LED-politielichten en de twee knopprojecten. In Premium-projecten wordt Code uitgelegd ontgrendeld met Premium; wil je je klas naar Premium-projecten laten doorstromen, dan kun je codes uit de docentenpakketten uitdelen in plaats van dat elke leerling een abonnement neemt, zoals uitgelegd in een Arduino-app voor de klas. Wil je een schakeling delen die je zelf hebt ontworpen, dan kun je in het Forum een Tutorial-topic openen; dat komt niet met stappen van Code uitgelegd of een blokweergave, dus je schrijft de uitleg zelf in de topictekst en voegt de code toe met Code toevoegen (lesgeven met je eigen project). De app heeft ook geen paneel dat laat zien welke opdrachten elke leerling heeft opgelost; je controleert de opdracht in de klas, door naar de werkende schakeling te kijken of via een foto.
Veelgemaakte fouten en eenvoudige oplossingen
- De oplossing meteen openen: Als je op Oplossing tonen tikt zodra je de opdracht hebt gelezen, leer je het antwoord maar niet het idee. De regel: eerst voorspellen, dan proberen, dan de hint en de oplossing als laatste.
- Kopiëren zonder de stappen te lezen: De code pakken met Kopiëren en uploaden werkt, maar als je naar het volgende project gaat zonder Stap voor stap te lezen, begin je elke keer opnieuw. Lees na het uploaden in elk geval de samenvatting en de stappen.
- Een codefragment zien als het hele programma: Fragmenten zijn alleen de regels van die stap; plak je er één los in de IDE, dan compileert het niet. Voer wijzigingen altijd door in de volledige code.
- Meerdere dingen tegelijk veranderen: Als je twee regels samen verandert en een onverwacht resultaat krijgt, weet je niet welke verantwoordelijk is. Eén wijziging per upload.
- Een pinnummer maar op één plek veranderen: pinMode wijzigen en digitalWrite of de draad vergeten is een van de meest voorkomende fouten. Markeer vóór het wijzigen elke plek waar het nummer in de code voorkomt.
- Kom je er niet uit overslaan en meteen op het forum vragen: Het antwoord staat vaak al in de lijst Kom je er niet uit van dat project. Kijk daar eerst, dan bij Problemen oplossen; is het dan nog niet opgelost, vraag het dan op het forum met een foto van je schakeling en je code.
- De opdracht afmaken en dan stoppen: Als je na het vergelijken met de oplossing geen eigen kleine wijziging maakt, blijft wat je hebt geleerd verbonden aan die ene opdracht. Kies zelf een getal, een pin of een voorwaarde.
Als je Code uitgelegd in deze volgorde op een paar projecten hebt gebruikt, is kant-en-klare code geen gesloten doos meer: je kunt van tevoren zeggen welke regel wat bestuurt en wat er gebeurt als je hem verandert. Een led schakelen met een knop is een goede plek om deze gewoonte op te bouwen, omdat een kort stukje code een globale variabele, flankdetectie, een toggle en debouncing tegelijk laat zien. Wil je het proberen, open dan dit project in de BlueGrays-app en begin met de opdracht in het tabblad Code uitgelegd; dezelfde onderdelen staan in alle 60 gratis projecten.
Veelgestelde vragen
Wat is Code uitgelegd in BlueGrays?
Code uitgelegd is het tabblad in het onderdeel Broncode van een BlueGrays-projectpagina dat de code van het project stap voor stap uitlegt. Het heeft een samenvatting, genummerde stappen (elk met een codefragment en een uitleg), een onderdeel Kom je er niet uit en een Probeer het zelf-opdracht met een hint en een oplossing. Elk project heeft het.
Is Code uitgelegd gratis?
In de 60 gratis projecten (20 per platform) is Code uitgelegd voor iedereen open; met een gratis account zie je de samenvatting, de stappen, Kom je er niet uit en de opdracht met oplossing. In Premium-projecten wordt het tabblad ontgrendeld met Premium.
Hoe begrijp ik kant-en-klare Arduino-code stap voor stap?
Vat eerst in één zin samen wat de code doet, verdeel hem dan van boven naar beneden en noteer wat elk deel doet: globale variabelen, setup() en loop(). Let op getallen en pinnummers, verander dan één waarde en bekijk het resultaat op het board. Code uitgelegd geeft je deze volgorde kant-en-klaar bij elk project.
Hoe zie ik de oplossing van een Probeer het zelf-opdracht?
Tik op de knop Oplossing tonen onder de opdracht; er opent een OPLOSSING-vak dat vertelt welke regel wat wordt. Je kunt het weer sluiten met Oplossing verbergen. Eerst zelf proberen en de oplossing als laatste openen leert je meer.
Wat is Blokken uitgelegd?
In projecten met een blokweergave verandert de naam van het tabblad Code uitgelegd in Blokken uitgelegd als je de schakelaar Tonen als blokken aanzet. In het onderdeel Stap voor stap toont dan elke stap zijn eigen blokken in plaats van het codefragment. Meer dan 100 projecten hebben een blokweergave.
Zijn Kom je er niet uit en Problemen oplossen hetzelfde?
Nee. Kom je er niet uit is een lijst met paren van verschijnsel en oplossing die specifiek is voor het project, binnen Code uitgelegd; Problemen oplossen is een aparte, geordende checklist op de projectpagina. Problemen oplossen is beschikbaar in meer dan 170 projecten en wordt ontgrendeld met Premium.
Projecten om hierna te bouwen
Alle projecten bekijken
LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

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

Verkeerslicht
Een kleine kopie van het verkeerslicht dat je elke dag op straat ziet. Rood brandt twee seconden, geel knippert even, groen brandt twee seconden en daarna gaat het via geel weer naar rood, steeds…

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-politielichten
Net als de lichten van een politieauto: de rode LED knippert drie keer snel achter elkaar, daarna knippert de blauwe LED drie keer, en dit patroon herhaalt zich zonder pauze.

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

Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

LED-looplicht met instelbare snelheid
Zes LED's gaan na elkaar aan, zodat het licht van het ene uiteinde naar het andere lijkt te rennen.
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

