FFundamental · deel F6 · Programmeren en automatiseren

Handboek · hoofdstuk 24De microcontroller

Een computer van een paar euro die leds, knoppen en later de hele meetkas bestuurt

Een wasmachine, een verwarmingsketel, een speelgoedrobot: overal zit een kleine computer die één taak eindeloos herhaalt. Zo'n microcontroller leest ingangen (een knop, een sensor) en stuurt uitgangen (een led, een relais). In dit hoofdstuk leer je de Arduino Uno en de micro:bit kennen, je berekent de weerstand voor een led met wat je in hoofdstuk 19 en 20 leerde, je leest een drukknop in, en je schrijft je eerste programma's in blokken en in Arduino-code. Voor de meetkas bouw je een statuslampje.

6× uitleg3× uitgewerkt voorbeeld1× proef1× ontleed1× naslag1× verhaal1× het geheel4× code15 opdrachten in het werkboek± 8 lestijden

PProgrammeren en computationeel denken LElektriciteit en elektronica RRegelen en robotica

Een Arduino, een breadboard, twee leds en een knop: het begin van de automatische meetkas.

Na dit hoofdstuk

Je kan uitleggen wat een microcontroller is, waarin hij verschilt van een computer en in welke toestellen hij zit.
Je kan bij een toestel de input, de verwerking en de output aanwijzen.
Je kan de onderdelen van een Arduino Uno aanwijzen: USB, voeding, microcontroller, digitale en analoge pinnen, GND en 5V.
Je kan de voorschakelweerstand van een led berekenen, een waarde uit de E12-reeks kiezen en de stroom narekenen.
Je kan een led en een drukknop correct aansluiten, als schema en op een breadboard, met een pull-down of met INPUT_PULLUP.
Je kan een knipperlicht en een verkeerslicht programmeren in blokken en in Arduino-code (setup, loop, pinMode, digitalWrite, digitalRead, delay).
Je kan een programma uploaden en systematisch testen, en een schakeling die niet werkt stap voor stap nakijken.

Verhaal · 24.1

Een computer in alles

1/18

Tel de computers in je huis. De laptop en de smartphone, dat weet je. Maar ook de wasmachine heeft er een (welk programma, hoe lang, hoe warm), net als de microgolfoven, de thermostaat, de afstandsbediening, de elektrische tandenborstel en de fietscomputer. Een moderne auto bevat er tientallen. Het zijn geen laptops in het klein, maar microcontrollers: goedkope chips die één taak doen, dag en nacht, met heel weinig energie.

Wie zelf met microcontrollers wilde werken, had lang dure apparatuur nodig. Dat veranderde in 2005 in het Italiaanse stadje Ivrea. Aan het Interaction Design Institute zocht een groep docenten, onder wie Massimo Banzi, een goedkoop bordje waarmee hun studenten (ontwerpers, geen ingenieurs) snel iets konden laten bewegen of oplichten. Ze noemden het naar het café waar ze samenkwamen: Arduino. Het ontwerp werd vrij gegeven, iedereen mag het namaken. Vandaag gebruiken scholen, kunstenaars, wetenschappers en hobbyisten wereldwijd Arduino-bordjes, en de BBC micro:bit (2016) maakte programmeerbare elektronica nog toegankelijker.

Waarom dit voor de meetkas telt

Tot nu toe zette jij de ledstrip en de pomp aan met een schakelaar. Een microcontroller kan dat zelf, op basis van metingen. Hij is het 'brein' van de meetkas, en hij gebruikt maar ongeveer 1,5 W (hoofdstuk 21).

Achter de draaiknop van een wasmachine zit een printplaat met een microcontroller die het programma uitvoert.

Uitleg · 24.2

Wat is een microcontroller?

2/18

Een microcontroller is een volledige computer op één chip: een processor die instructies uitvoert, flashgeheugen waarin het programma bewaard blijft (ook zonder stroom), een klein werkgeheugen voor variabelen, en pinnen: aansluitingen die de chip met de buitenwereld verbinden. Hij heeft geen scherm, geen toetsenbord en geen besturingssysteem. Hij start meteen zijn ene programma en herhaalt dat tot de stroom uitvalt.

	Arduino Uno R3	BBC micro:bit V2	laptop (ter vergelijking)
processor	ATmega328P, 16 MHz, 8 bit	nRF52833, 64 MHz, 32 bit	enkele GHz, 64 bit, meerdere kernen
programmageheugen	32 KB flash	512 KB flash	honderden GB (schijf)
werkgeheugen	2 KB	128 KB	8 tot 32 GB
werkspanning pinnen	5 V	3,3 V	(geen losse pinnen)
ingebouwd	één led (L op pin 13)	25 leds, 2 knoppen, sensoren, luidspreker	scherm, toetsenbord
programmeren	Arduino IDE (C++), mBlock (blokken)	MakeCode (blokken, JavaScript, Python)	alles
vermogen	ongeveer 0,25 W	minder dan 0,5 W	tientallen watt

Een laptop heeft ongeveer acht miljoen keer zoveel werkgeheugen als een Arduino Uno. Toch is de Uno ruim genoeg om een kas te besturen: het programma 'water geven' past met gemak in 32 KB. In dit hoofdstuk werk je met de Arduino Uno R3; alles werkt ook op een micro:bit, met MakeCode en 3,3 V in plaats van 5 V.

Een Arduino Uno en een micro:bit, met een munt van 1 euro om de grootte te vergelijken.

Ontleed · 24.3

De Arduino Uno

3/18

Het bordje heet Uno, maar er zit veel op. Leer vooral de pinnen kennen: daar sluit je alles op aan.

Schematisch bovenaanzicht van een Arduino Uno R3 (68,6 × 53,4 mm). Bovenaan de digitale pinnen, onderaan voeding en analoge ingangen.

Wijs een nummer aan: de figuur zoomt in. Klik om vast te zetten.

1
USB-aansluiting
Voor het uploaden van het programma, voor communicatie met de computer en als voeding (5 V). Een herstelbare zekering van 500 mA beschermt de USB-poort van je computer.
2
Voedingsbus
Voor een adapter of batterij van 7 tot 12 V als de Uno zonder computer werkt. Een spanningsregelaar op het bord maakt er 5 V van.
3
Microcontroller ATmega328P
De eigenlijke computer: 16 MHz, 32 KB flash voor het programma, 2 KB werkgeheugen. Al de rest op het bord is voeding en aansluitingen.
4
Digitale pinnen 0 tot 13
In- of uitgang, HIGH (5 V) of LOW (0 V). Pinnen met een ~ kunnen ook PWM (Intermediate, hoofdstuk 25). Pin 0 en 1 gebruikt de USB-verbinding: laat ze vrij.
5
Ingebouwde led L
Hangt aan pin 13, met een eigen weerstand. Handig om een eerste programma te testen zonder iets aan te sluiten.
6
Analoge ingangen A0 tot A5
Lezen een spanning tussen 0 en 5 V als een getal van 0 tot 1023: hier komen de sensoren van hoofdstuk 25.
7
Voedingspinnen
5V en 3.3V leveren spanning aan kleine schakelingen; GND is de massa (0 V). Elke schakeling moet met GND verbonden zijn.
8
Resetknop
Start het programma opnieuw vanaf het begin. Het programma blijft bewaard.

Uitleg · 24.4

Input, verwerking, output

4/18

Elk systeem met een microcontroller volgt hetzelfde schema, dat je in hoofdstuk 1 als systeemdenken leerde:

Input: wat de microcontroller leest. Een drukknop, een schakelaar, een vlotter, een sensor.
Verwerking: het programma. Het vergelijkt, telt, beslist.
Output: wat de microcontroller stuurt. Een led, een zoemer, een display, of via een relais een pomp of een ledstrip.

De microcontroller levert zelf maar kleine stromen: genoeg voor een led, veel te weinig voor een pomp van 0,65 A. Grote verbruikers schakel je met een tussenstap: een relais (hoofdstuk 25) of een transistor (Intermediate, hoofdstuk 23). Zo kwam in hoofdstuk 18 het relaiscontact K1 in het schema van de kasverlichting.

Een pin is geen stopcontact

Een pin van een Uno R3 levert hoogstens 20 mA (40 mA is het absolute maximum: daarboven gaat de chip stuk), en alle pinnen samen hoogstens 200 mA. Sluit nooit een motor, pomp of lamp rechtstreeks aan op een pin, en verbind nooit een pin rechtstreeks met GND of 5V als ze een uitgang is: dat is een kortsluiting.

Wat binnenkomt, wordt verwerkt tot wat iets doet. Grote verbruikers gaan via een relais.

Uitleg · 24.5

Digitale pinnen: HIGH of LOW

5/18

Een digitale pin kent maar twee toestanden: HIGH (1) en LOW (0). Bij een Uno betekent HIGH ongeveer 5 V en LOW 0 V, gemeten ten opzichte van GND. Voor je een pin gebruikt, zeg je in het programma of ze een ingang of een uitgang is:

Arduino-code	betekenis
`pinMode(10, OUTPUT);`	pin 10 is een uitgang
`digitalWrite(10, HIGH);`	zet 5 V op pin 10
`digitalWrite(10, LOW);`	zet 0 V op pin 10
`pinMode(2, INPUT_PULLUP);`	pin 2 is een ingang met de interne pull-up
`digitalRead(2)`	geeft HIGH of LOW terug: wat ligt er op pin 2?
`delay(500);`	wacht 500 ms (0,5 s)

Een ingang leest HIGH als de spanning boven ongeveer 3 V ligt en LOW onder ongeveer 1,5 V. Wat ertussen ligt, is onzeker: vermijd het.

Hoofdletters tellen

C++ maakt verschil tussen hoofdletters en kleine letters: digitalWrite werkt, digitalwrite niet. En elke opdracht eindigt op een puntkomma.

Een knipperlicht in spanning: 0,5 s HIGH (5 V), 0,5 s LOW (0 V), en zo verder.

Uitgewerkt voorbeeld · 24.6

De voorschakelweerstand berekenen

6/18

Een rode led moet branden op pin 10 van een Arduino Uno. Volgens het gegevensblad krijgt de led 2,0 V bij 20 mA. Welke weerstand zet je in serie? Kies een weerstand die je echt kan kopen en reken de stroom na.

De 5 V van de pin verdeelt zich: 3,0 V over de weerstand, 2,0 V over de led, en door beide loopt 13,6 mA.

Gegeven

pin HIGH: $U = 5, 0 V$
led: $U_{led} = 2, 0 V$ bij $I = 20 mA$
weerstanden te koop in de E12-reeks: 10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82 (maal 10, 100, ...)

Gevraagd

$R$
een E12-waarde
de stroom met die weerstand

Oplossing

1
Spanning over de weerstand (in serie tellen de spanningen op, hoofdstuk 20): $U_{R} = 5, 0 - 2, 0 = 3, 0 V$ .
2
Wet van Ohm (hoofdstuk 19) voor de weerstand, met dezelfde stroom als door de led: $R = \frac{U _{R}}{I} = \frac{3 , 0 V}{0 , 020 A} = 150 Ω$ .
3
Kiezen. 150 Ω staat in de E12-reeks, maar geeft precies 20 mA: de bovengrens van de led én de aanbevolen grens van de pin. Neem een grotere waarde voor wat marge. De waarde die in elke starterskit zit, is 220 Ω (rood-rood-bruin-goud).
4
Narekenen. $I = \frac{U _{R}}{R} = \frac{3 , 0 V}{220 Ω} = 0, 0136 A = 13, 6 mA$ . De led brandt nog duidelijk; het verschil in helderheid met 20 mA zie je nauwelijks.
5
Vermogen in de weerstand (hoofdstuk 21): $P = U_{R} \cdot I = 3, 0 \times 0, 0136 = 0, 041 W$ . Een gewone weerstand kan 0,25 W aan: ruim genoeg.

Antwoord

Minstens 150 Ω; gekozen: 220 Ω. De stroom is dan 13,6 mA.

Klopt dit? Omgekeerd:

13, 6 mA \times 220 Ω = 3, 0 V

, plus 2,0 V over de led is 5,0 V. Voor een groene led (ongeveer 2,2 V) geeft 220 Ω 12,7 mA, voor een blauwe of witte (ongeveer 3,0 V) 9,1 mA: één waarde voor alle kleuren is dus prima. Pas op met een Uno R4: die pinnen mogen maar 8 mA leveren; kies daar minstens 375 Ω, bijvoorbeeld 470 Ω (6,4 mA).

Uitleg · 24.7

Van schema naar breadboard

7/18

Op een breadboard bouw je zonder solderen. Onder elk gaatje zit een metalen klem. De vijf gaatjes van een kolom (a tot e, of f tot j) zijn met elkaar verbonden; over de gleuf in het midden niet. De lange rijen aan de rand (de rails, rood + en blauw −) zijn over de hele lengte verbonden: daar komen 5V en GND.

Zo volg je het schema: pin 10 → kolom 6 → weerstand van kolom 6 naar kolom 10 → lange poot van de led in kolom 10 → korte poot in kolom 11 → kabeltje van kolom 11 naar de blauwe rail → GND van de Arduino.

Een led heeft een richting

De lange poot is de anode (+, naar de weerstand en de pin), de korte poot de kathode (−, naar GND). Ook de rand van de led is aan de kathodekant plat. Andersom brandt ze niet (maar gaat ze bij 5 V ook niet stuk).

Twee pootjes in dezelfde kolom

Steek je beide pootjes van een weerstand in dezelfde kolom, dan is ze kortgesloten: de klem verbindt ze al. Een onderdeel moet altijd over twee verschillende kolommen staan.

Dezelfde schakeling als het schema, op een breadboard: blauw is het signaal van pin 10, paars is GND.

Code · 24.8

Het eerste programma: een knipperlicht

8/18

Elk Arduino-programma (een sketch) heeft twee delen. setup() loopt één keer als het bord stroom krijgt: daar zeg je welke pinnen uitgangen zijn. loop() loopt daarna eindeloos. Het is precies het blok 'bij opstarten' en de eindeloze lus 'herhaal' uit hoofdstuk 23. Alles na // is commentaar: uitleg voor mensen, de computer slaat het over.

C++ (Arduino)knipperlicht.ino13 regelsDownload

// Knipperlicht: de led op pin 10 gaat elke halve seconde aan of uitconst int LED = 10;          // rode led met 220 ohm naar GND void setup() {  pinMode(LED, OUTPUT);      // pin 10 is een uitgang (gebeurt 1 keer)} void loop() {                // herhaalt eindeloos  digitalWrite(LED, HIGH);   // pin op 5 V: led aan  delay(500);                // 500 ms wachten  digitalWrite(LED, LOW);    // pin op 0 V: led uit  delay(500);}

Het knipperlicht in blokken (mBlock-stijl). 'wacht 0.5 sec.' is delay(500).

In blokken is het hetzelfde programma: een hoedblok, een eindeloze lus en vier blokken. In mBlock hoef je geen pinMode te schrijven: het blok 'zet digitale pin' doet het voor je. Op de micro:bit gebruik je pin P0 en schrijf je 1 en 0 in plaats van HIGH en LOW. Wil je het sneller laten knipperen, dan verklein je de twee wachttijden: met delay(100) knippert de led vijf keer per seconde.

Hetzelfde op een micro:bit in MakeCode: 'de hele tijd' is loop(), 'pauzeer (ms) 500' is delay(500).

Proef · 24.9

Knipperlicht bouwen en meten

9/18

Onderzoeksvraag

Klopt de berekende stroom van 13,6 mA met wat er echt door de led loopt?

Materiaal

Arduino Uno met USB-kabel en computer
breadboard, 3 kabeltjes
rode led, weerstand 220 Ω
multimeter

VeiligheidBouw en verander de schakeling alleen als de USB-kabel los is. Controleer voor je de kabel insteekt dat geen draad van 5V of een pin rechtstreeks naar GND loopt.

Meten over de weerstand: met de wet van Ohm vind je de stroom zonder de kring te openen.

Werkwijze

1Bouw de schakeling van het breadboard. Upload het knipperlicht, maar maak de wachttijden 5000 ms, zodat je rustig kan meten.
2Meet met de multimeter (V⎓) de spanning tussen pin 10 en GND als de led brandt, en de spanning over de led en over de weerstand.
3Neem de USB-kabel los, meet de weerstand zelf (Ω).
4Bereken de stroom met de wet van Ohm uit de spanning over de weerstand. Of meet ze: zet de multimeter (mA) in serie tussen de weerstand en de led.
5Controleer: tellen de spanningen over weerstand en led op tot de spanning op de pin?

Waarneming

Een meting: pin 10 geeft 4,86 V (niet precies 5 V: de pin zakt een beetje als hij stroom levert). Over de led 1,93 V, over de weerstand 2,93 V; samen 4,86 V. De weerstand meet 218 Ω (binnen de tolerantie van 5 %). Stroom: $2, 93/218 = 0, 0134 A = 13, 4 mA$ ; de multimeter in serie geeft 13,3 mA.

Verklaring

De meting ligt binnen 2 % van de berekening. De kleine verschillen komen van de pin (4,86 V in plaats van 5,00 V), de led (1,93 V in plaats van 2,0 V) en de tolerantie van de weerstand. Dat is precies waarom je een weerstand met wat marge kiest: de werkelijkheid wijkt altijd een beetje af van het gegevensblad. De spanningen tellen op zoals in elke serieschakeling (hoofdstuk 20).

Uitleg · 24.10

Uploaden en testen

10/18

Een programma in tekst of blokken kan de chip niet lezen. De computer compileert het eerst: hij vertaalt het naar machinecode (enen en nullen). Staat er een fout in de schrijfwijze, dan stopt hij hier met een foutmelding en een regelnummer. Daarna upload je: via USB schrijft een klein hulpprogramma op de chip (de bootloader) de machinecode in het flashgeheugen. Het programma start meteen en blijft bewaard.

In de Arduino IDE kies je eerst het bord (Arduino Uno) en de poort (de USB-verbinding), dan klik je op Verifiëren (compileren) en Uploaden. Daarna test je, volgens een plan:

test	verwacht	gezien
bord krijgt stroom	ON-led brandt	ja
na het uploaden	led op pin 10 knippert 1 keer per seconde	ja
resetknop	knipperen begint opnieuw	ja
USB los en weer in	programma start vanzelf	ja

Werkt het niet? Van programma naar draad

Test eerst het programma zonder schakeling: laat de ingebouwde led L (pin 13) knipperen. Knippert L, dan werken bord, upload en programma, en zit de fout in de schakeling: led omgekeerd, weerstand in één kolom, verkeerde pin, GND vergeten, kabeltje los. Kijk ze één voor één na, en meet met de multimeter.

Compileren vertaalt, uploaden schrijft het in het flashgeheugen; daarna start het programma vanzelf.

Uitleg · 24.11

Een drukknop inlezen: pull-down of pull-up

11/18

Een drukknop is een maakcontact (hoofdstuk 18): ingedrukt verbindt hij twee pootjes. Verbind je hem alleen tussen 5V en een ingang, dan ligt de ingang op 5 V als je drukt. Maar als je loslaat, is de ingang met niets verbonden. Zo'n zwevende ingang werkt als een antenne: ze leest willekeurig HIGH of LOW, soms al als je je hand in de buurt houdt.

De oplossing is een weerstand die de ingang in rust naar een vaste spanning trekt:

Pull-down: 10 kΩ van de ingang naar GND, knop naar 5V. Losgelaten leest de pin LOW, ingedrukt HIGH. Ingedrukt loopt er $5/10 000 = 0, 5 mA$ door de weerstand: verwaarloosbaar. Zonder die weerstand zou de knop 5V rechtstreeks met GND verbinden: kortsluiting.
Interne pull-up: de Uno heeft in de chip bij elke pin een weerstand van 20 à 50 kΩ naar 5 V, die je aanzet met pinMode(2, INPUT_PULLUP). De knop komt dan tussen de pin en GND. Losgelaten leest de pin HIGH, ingedrukt LOW: omgekeerd.

De pull-up is eenvoudiger (geen extra weerstand, één draad minder), daarom gebruik je hem in dit hoofdstuk. Onthoud wel dat 'ingedrukt' dan LOW betekent.

Een knop met vier pootjes

Een drukknop voor het breadboard heeft vier pootjes, per twee altijd verbonden. Zet hem over de gleuf en gebruik twee diagonaal tegenover elkaar liggende pootjes: dan werkt hij, hoe je hem ook draait.

Links trekt een weerstand de ingang naar 0 V, rechts trekt de interne weerstand haar naar 5 V. De knop doet het omgekeerde.

Code · 24.12

Knop en led: lezen en beslissen

12/18

Nu komt er een keuze in het programma (hoofdstuk 23): de led brandt zolang de knop ingedrukt is. Omdat de knop met INPUT_PULLUP werkt, betekent 'ingedrukt' dat de pin LOW leest. In C++ vergelijk je met twee gelijktekens: ==. Eén gelijkteken (=) geeft een waarde aan een variabele, zoals 'maak' in Scratch.

C++ (Arduino)knop_led.ino16 regelsDownload

// Led op pin 10 brandt zolang de drukknop op pin 2 ingedrukt isconst int KNOP = 2;          // knop tussen pin 2 en GNDconst int LED = 10; void setup() {  pinMode(KNOP, INPUT_PULLUP);   // interne weerstand naar 5 V: losgelaten = HIGH  pinMode(LED, OUTPUT);} void loop() {  if (digitalRead(KNOP) == LOW) {    // ingedrukt: de knop verbindt pin 2 met GND    digitalWrite(LED, HIGH);  } else {    digitalWrite(LED, LOW);  }}

In blokken: 'lees digitale pin 2' geeft 0 als de knop ingedrukt is (pull-up).

loop() loopt duizenden keren per seconde. Elke ronde leest ze de knop en zet ze de led juist. Daarom lijkt de led meteen te reageren. De schakeling op het breadboard: de led van het vorige blad, plus een knop over de gleuf, met één pootje naar pin 2 en het diagonale pootje naar GND.

De knop staat over de gleuf: oranje van pin 2 naar kolom 18, paars van kolom 20 naar GND. Een draadje rechts verbindt de twee GND-rails.

Uitgewerkt voorbeeld · 24.13

Een verkeerslicht

13/18

Bouw een verkeerslicht met drie leds: groen 5 s, oranje 2 s, rood 5 s, en zo verder. Teken het tijdsdiagram, het schema en het programma. Hoe lang duurt één volledige cyclus?

Groen 5 s, oranje 2 s, rood 5 s: na 12 s begint alles opnieuw.

Gegeven

leds rood, oranje, groen op de pinnen 11, 12 en 13
elke led met een eigen weerstand van 220 Ω
volgorde in België: groen → oranje → rood → groen

Gevraagd

tijdsdiagram
schema
programma
duur van een cyclus

Oplossing

1
Decompositie. Drie toestanden na elkaar: groen, oranje, rood. In elke toestand brandt precies één led.
2
Tijdsdiagram. Zet per led een lijn die hoog is als de led brandt. Tel op: $5 + 2 + 5 = 12 s$ per cyclus.
3
Schema. Elke led krijgt een eigen weerstand. Eén gemeenschappelijke weerstand voor de drie leds zou werken zolang er maar één tegelijk brandt, maar met eigen weerstanden is elke led onafhankelijk.
4
Programma. In setup() drie uitgangen. In loop(): groen aan, 5000 ms, groen uit; oranje aan, 2000 ms, oranje uit; rood aan, 5000 ms, rood uit. Dan begint loop opnieuw.
5
Testen. Brandt er ooit geen of meer dan één led? Kijk vooral naar de overgangen: zet je 'uit' vóór 'aan', dan is er even geen licht (een paar microseconden, onzichtbaar); vergeet je 'uit', dan branden er twee.

Antwoord

Een cyclus duurt 12 s. Zie het tijdsdiagram, het schema en de code hieronder.

Klopt dit? Echte verkeerslichten staan langer op oranje (meestal enkele seconden, afhankelijk van de toegelaten snelheid) en hebben een korte tijd waarin alle richtingen rood hebben. Een echt kruispunt heeft ook meerdere lichten die samen moeten werken: dan wordt het een toestandsmachine (Intermediate, hoofdstuk 32).

Drie leds op drie pinnen, elk met een eigen weerstand, samen naar GND.

Het verkeerslicht in blokken.

Code · 24.14

Het verkeerslicht in Arduino-code

14/18

De code volgt het tijdsdiagram regel per regel. Constanten met een naam (ROOD, ORANJE, GROEN) maken het programma leesbaar: wil je andere pinnen, dan pas je één regel aan.

C++ (Arduino)verkeerslicht.ino22 regelsDownload

// Verkeerslicht: groen, oranje, rood, en opnieuwconst int ROOD = 11;const int ORANJE = 12;const int GROEN = 13; void setup() {  pinMode(ROOD, OUTPUT);  pinMode(ORANJE, OUTPUT);  pinMode(GROEN, OUTPUT);} void loop() {  digitalWrite(GROEN, HIGH);    // groen  delay(5000);  digitalWrite(GROEN, LOW);  digitalWrite(ORANJE, HIGH);   // oranje  delay(2000);  digitalWrite(ORANJE, LOW);  digitalWrite(ROOD, HIGH);     // rood  delay(5000);  digitalWrite(ROOD, LOW);}

Een nadeel van delay(): tijdens het wachten doet de microcontroller niets anders. Een knop die je in die 12 s indrukt, wordt niet opgemerkt. Voor een voetgangersknop die altijd reageert, heb je een andere techniek nodig (millis(), Intermediate, hoofdstuk 29). Opdracht 24.13 toont een eenvoudige oplossing die de knop alleen tussen twee cycli leest.

Uitgewerkt voorbeeld · 24.15

Habitat: het statuslampje van de meetkas

15/18

De meetkas krijgt een statuslampje: groen als alles goed is, rood als de planten water nodig hebben. De bodemvochtsensor komt pas in hoofdstuk 25; tot dan speelt een drukknop voor 'de grond is droog'. Ontwerp de schakeling en het programma, en controleer het stroomverbruik.

Het statuslampje: een knop als stand-in voor de sensor, twee leds met elk een weerstand.

Gegeven

Arduino Uno op de 5 V-omvormer van de meetkas (hoofdstuk 20)
rode en groene led, elk 220 Ω
drukknop 'droog' met INPUT_PULLUP
pinnen: knop D2, rood D10, groen D11

Gevraagd

schema
programma in blokken en in code
stroom van de leds en vergelijking met het budget

Oplossing

1
Input, verwerking, output. Input: de knop op D2 (later de sensor). Verwerking: 'droog?' Output: de rode led op D10 of de groene op D11.
2
Schema. Twee keer het schema led + 220 Ω, op D10 en D11; de knop tussen D2 en GND.
3
Programma. Eindeloze lus met een keuze: als D2 LOW leest (ingedrukt = droog), rood aan en groen uit; anders rood uit en groen aan. Er brandt altijd precies één led: zo zie je ook dat de microcontroller werkt.
4
Stroom. Rood: $3, 0/220 = 13, 6 mA$ . Groen (ongeveer 2,2 V): $2, 8/220 = 12, 7 mA$ . Er brandt er één tegelijk: hoogstens 13,6 mA, of $5 \times 0, 0136 = 0, 07 W$ . Aan de 5 V-kant van de omvormer is 0,30 A beschikbaar (hoofdstuk 21): het lampje gebruikt minder dan 5 % daarvan.

Antwoord

Knop op D2 (INPUT_PULLUP), rode led op D10 en groene op D11, elk met 220 Ω; hoogstens 13,6 mA extra.

Klopt dit? Test beide toestanden: knop los → groen; knop ingedrukt → rood. Test ook de overgang: rood en groen branden nooit samen en nooit allebei niet. In opdracht 24.12 laat je rood knipperen als het reservoir leeg is.

In blokken: als D2 0 leest, rood aan en groen uit; anders omgekeerd.

Op een micro:bit kan het ook met de ingebouwde leds: 'DROOG' of 'OK' schuift over het schermpje van 5 × 5 lampjes.

Code · 24.16

Het statuslampje in Arduino-code

16/18

De code is die van 'knop en led', met een tweede uitgang. Het commentaar bovenaan zegt wat er later verandert: in hoofdstuk 25 vervang je digitalRead(DROOG) == LOW door een vergelijking met de bodemvochtsensor.

C++ (Arduino)statuslampje.ino21 regelsDownload

// Statuslampje van de meetkas: rood = water nodig, groen = alles goed.// Tot hoofdstuk 25 speelt een drukknop voor de bodemvochtsensor: ingedrukt = de grond is droog.const int DROOG = 2;      // drukknop naar GND (INPUT_PULLUP)const int ROOD = 10;      // rode led, 220 ohmconst int GROEN = 11;     // groene led, 220 ohm void setup() {  pinMode(DROOG, INPUT_PULLUP);  pinMode(ROOD, OUTPUT);  pinMode(GROEN, OUTPUT);} void loop() {  if (digitalRead(DROOG) == LOW) {   // 'droog'    digitalWrite(ROOD, HIGH);    digitalWrite(GROEN, LOW);  } else {                           // 'vochtig genoeg'    digitalWrite(ROOD, LOW);    digitalWrite(GROEN, HIGH);  }}

Het bord hangt in de meetkas aan de 5 V-omvormer, niet aan de computer. Upload dus eerst via USB, en sluit daarna de voeding aan. Het programma blijft in het flashgeheugen en start vanzelf.

Naslag · 24.17

Overzicht: pinnen, code en weerstanden

17/18

voorschakelweerstand van een led

R = \frac{U _{bron} - U _{led}}{I}

symbool	betekenis	eenheid
$R$	weerstand	ohm (Ω)
$U_{bron}$	spanning van de pin of de bron	volt (V)
$U_{led}$	spanning over de led (gegevensblad)	volt (V)
$I$	gewenste stroom	ampère (A)

led-kleur	spanning (ongeveer)	stroom met 220 Ω op 5 V
rood	2,0 V	13,6 mA
oranje, geel	2,1 V	13,2 mA
groen	2,2 V (felgroen tot 3,0 V)	12,7 mA (9,1 mA)
blauw, wit	3,0 V	9,1 mA

blok (mBlock-stijl)	Arduino-code	MakeCode (micro:bit)
wanneer Arduino Uno opstart	`void setup() { ... }`	bij opstarten
herhaal (eindeloos)	`void loop() { ... }`	de hele tijd
zet digitale pin 10 op hoog	`digitalWrite(10, HIGH);`	schrijf digitaal pin P0 naar 1
lees digitale pin 2	`digitalRead(2)`	lees digitaal pin P1
wacht 0.5 sec.	`delay(500);`	pauzeer (ms) 500
als ... dan ... anders	`if (...) { ... } else { ... }`	als ... dan ... anders
(ingang met pull-up)	`pinMode(2, INPUT_PULLUP);`	zet pull pin P1 op omhoog

Uno R3: grens	waarde
stroom per pin	20 mA aanbevolen, 40 mA absoluut maximum
alle pinnen samen	200 mA
HIGH / LOW	ongeveer 5 V / 0 V; ingang: boven ±3 V HIGH, onder ±1,5 V LOW
interne pull-up	20 à 50 kΩ
E12-reeks	10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82 (maal 1, 10, 100, 1000 ...)
Uno R4	hoogstens 8 mA per pin: gebruik 470 Ω of meer voor een led

Het geheel · 24.18

Waar de microcontroller vandaan komt en naartoe gaat

18/18

De microcontroller is het kruispunt van drie leerlijnen: programmeren (het programma), elektriciteit en elektronica (de schakeling rond de pinnen) en regelen en robotica (een systeem dat zelf reageert). Wat je hier doet met leds en knoppen, doe je in hoofdstuk 25 met sensoren en relais.

F18 De elektrische kring

Maakcontact, schakelaar en relaiscontact K1: de drukknop is de ingang van de microcontroller.

F19 Spanning, stroom en weerstand

De wet van Ohm voor de voorschakelweerstand, en de multimeter om na te meten.

F20 Serie- en parallelschakeling

Led en weerstand in serie: de spanningen tellen op, de stroom is overal gelijk.

F23 Programmeren met blokken

Dezelfde blokken: bij opstarten, eindeloze lus, als ... dan ... anders.

F25 Sensoren en automatisch regelen

De drukknop wordt een sensor, de led een relais met een pomp: automatisch water geven.

I23 Halfgeleiders: diode, led en transistor

Waarom een led een vaste spanning heeft, en hoe een transistor een pomp schakelt.

I24 Condensatoren en de RC-tijd

Een drukknop 'dendert': hij maakt en verbreekt een paar keer contact. Ontdenderen met een RC-kring.

I29 Microcontrollers programmeren in C++

Meer C++: variabelen en types, millis() in plaats van delay(), de seriële monitor.

E37 Embedded systemen en IoT

Interrupts, slaapstanden en draadloze sensornetwerken.

HabitatDe meetkas heeft nu een brein: een Arduino Uno op de 5 V-omvormer. Het statuslampje gebruikt D2 (knop), D10 (rood) en D11 (groen), elk met 220 Ω. In hoofdstuk 25 komt de bodemvochtsensor op A0 in plaats van de knop, en schakelt een relais op D6 het pompje. Opdracht 24.12 voegt het reservoiralarm toe.

Samenvatting

In het kort

Een microcontroller is een computer op één chip (processor, flashgeheugen, werkgeheugen, pinnen) die één programma eindeloos uitvoert.
Elk systeem met een microcontroller heeft input (knop, sensor), verwerking (programma) en output (led, via een relais: pomp).
Een digitale pin is HIGH (ongeveer 5 V) of LOW (0 V); een Uno R3-pin levert hoogstens 20 mA (absoluut maximum 40 mA).
Voorschakelweerstand: R = (U_bron − U_led) / I. Voor 5 V en een rode led: minstens 150 Ω; 220 Ω geeft 13,6 mA.
Een drukknop heeft een pull-down (knop naar 5V, 10 kΩ naar GND) of de interne pull-up (knop naar GND, INPUT_PULLUP: ingedrukt = LOW) nodig.
Een Arduino-programma heeft setup() (één keer) en loop() (eindeloos); pinMode, digitalWrite, digitalRead en delay doen het werk.
Compileren vertaalt, uploaden schrijft het programma in het flashgeheugen; test daarna volgens een plan, eerst met de ingebouwde led.
Het statuslampje van de meetkas: D2 knop 'droog', D10 rode led, D11 groene led, elk 220 Ω.

Begrippen

Wat je nu kent

microcontroller: Een kleine computer op één chip, met processor, geheugen en in- en uitgangspinnen, die één programma eindeloos uitvoert.
pin: Aansluiting van een microcontroller die als ingang (lezen) of als uitgang (schrijven) werkt.
digitaal signaal: Een signaal met maar twee toestanden: HIGH (1, bij de Uno ongeveer 5 V) en LOW (0, 0 V).
GND: De massa of min van de schakeling (0 V); alle spanningen worden ten opzichte van GND gemeten.
voorschakelweerstand: Weerstand in serie met een led die de stroom beperkt tot een veilige waarde.
E12-reeks: De twaalf standaardwaarden per decade waarin weerstanden te koop zijn: 10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82 (maal 1, 10, 100, ...).
pull-down / pull-up: Weerstand die een ingang naar 0 V (pull-down) of naar 5 V (pull-up) trekt zolang de knop los is, zodat de ingang nooit zweeft.
breadboard: Insteekbord om zonder solderen te bouwen: de vijf gaatjes van een kolom (a-e of f-j) zijn verbonden, net als de gaatjes van een voedingsrail.
setup() en loop(): In een Arduino-programma loopt setup() één keer bij het opstarten, loop() daarna eindeloos.
uploaden: Het vertaalde programma via USB in het flashgeheugen van de microcontroller schrijven.

Aan de slag in het werkboek15 opdrachten, van oefenen tot uitdagen