VAN START MET DWENGUINO VIA C++

VAN START MET
DWENGUINO VIA C++
Francis Wyffels, Dirk De Muynck en Peter Bertels
geïllustreerd door Manon De Ridder
Copyright © 2016 Dwengo vzw
ISBN 978-90-819917-2-8
D/2016/Dwengo/1
NUR 257, 980
We willen graag dat zoveel mogelijk mensen kennis kunnen maken met microcontrollers of leren
programmeren met Dwengo.
Daarom brengen we dit boek uit onder Creative Commons:
De gebruiker mag:
•  het werk kopiëren, verspreiden en doorgeven
•  remixen – afgeleide werken maken
Onder de volgende voorwaarden:
•  Naamsvermelding: de gebruiker dient bij het werk steeds Dwengo vzw te vermelden (maar zonder de
indruk te wekken dat Dwengo vzw instemt met je werk of jouw gebruik van het werk).
[email protected]
http://www.dwengo.org
VOORWOORD
Vandaag de dag zijn elektronische apparaten niet meer weg te
denken uit onze maatschappij. Veel van die apparaten worden
aangestuurd door microcontrollers. In dit boekje verkennen we
stap voor stap de prachtige wereld van de microcontrollers. En we
zetten jou aan het werk, zodat je op het einde van dit boekje je
eigen digitale piano kan programmeren! Als je hierin slaagt, heb je
zelf een ingebed systeem ontwikkeld: een digitaal systeem dat
interageert met zijn omgeving.
Je zal dit doen met behulp van de Dwenguino. Dit eenvoudige,
multifunctionele microcontroller-platform is voorzien van tal van
handigheidjes om je op weg te zetten. Dankzij zijn compatibiliteit
met Arduino IDE kan je bovendien rekenen op weldoordachte tools
om grafisch en tekstueel te programmeren.
Experimenteren met microcontrollers kan zowel thuis als in de
klas. Dit boekje is in de eerste plaats bedoeld voor leerkrachten die
in hun lessen aandacht besteden aan informatica, elektronica of
techniek. Maar jongeren kunnen het ook perfect zelfstandig
ontdekken. Dat maakt hun leerervaring nog intenser.
Veel succes!
OVERAL MICROCONTROLLERS
De voorbije decennia nam het aantal digitale apparaten in huis, in
de tuin en op de werkvloer exponentieel toe. Het begon eenvoudig,
met kleine toestellen als wekkerradio's en elektrische
tandenborstels. Maar ondertussen is zo goed als elk apparaat
intelligent. Misschien heb je thuis wel een stofzuigrobot, en ook
zelfrijdende auto's zijn allang geen sciencefiction meer.
En dat is nog niet alles. Deze apparaten staan steeds vaker in
verbinding met het internet en vormen zo samen het Internet of
Things. Experts voorspellen dat tegen 2020 meer dan 50 miljard
apparaten verbonden zullen zijn met het internet. Ze doelen
daarmee niet alleen op smartphones en tablets, maar bijvoorbeeld
ook op slimme rookmelders, intelligente koelkasten en robots.
De basis van al deze apparaten zijn digitale rekensystemen die
instaan voor de noodzakelijke intelligentie. De microcontroller is
hiervan een mooi voorbeeld. Hij bevat alles wat nodig is om
sensorgegevens te verwerken, berekeningen uit te voeren en de
gepaste acties te ondernemen.
MOGEN WE JE VOORSTELLEN
AAN DE DWENGUINO…
In dit boekje duiken we de wondere wereld van de microcontrollers in, geholpen door de Dwenguino. Dit microcontrollerplatform bevat heel wat extra’s waarmee je snel je eigen apparaat
kan bouwen, zoals handige drukknoppen, analoge ingangen, een
2x16 lcd-scherm, een zoemer, alles om motoren aan te sturen,
enzovoort.
Verder zijn er nog de uitbreidingsconnector en het uitbreidingsbord. Met die eerste kan je contact maken met elke pin. Zo’n pin
verbindt de microcontroller met de buitenwereld en stuurt
apparaten aan (bijvoorbeeld een led). Dankzij het uitbreidingsbord
kan je de Dwenguino dan weer uitbreiden met je eigen circuit of
een van de vele Arduino shields.
De Dwenguino is compatibel met de Arduino en kan dus
geprogrammeerd worden in Arduino IDE, ArduBlock, Google
Blockly en Scratch4Arduino. Dankzij alle handige voorzieningen
op de Dwenguino en het gebruiksgemak van de software, kan jij
eenvoudig leren programmeren. Kortom: de Dwenguino is de
perfecte tool voor starters – hobbyisten, leraren en leerlingen.
1
uitbreidingsconnector
2
led op pin 13
3
contrast aanpassen van lcd-scherm
4
4
USB-connector
5
UART-connector
6
zoemer
7
batterij-connector
8
power led
9
aan- en uitschakelaar
10
motor-connector
11
servo-connector
12
vijf drukknoppen
13
acht leds
14
resetknop
15
lcd-scherm
16
bevestingsgaten
5
3
7
6
8
2
9
1
10
11
15
16
14
13
12
De Dwenguino is volledig open source:
alle schema's, alle ontwerpbestanden
en de softwarebibliotheek staan online.
Zo kan je de Dwenguino-hardware tot in het
kleinste detail bestuderen, jouw eigen
uitbreidingsbord in elkaar steken of zelf
een Dwenguino-variant maken.
DE MICROCONTROLLER ONTLEED
De microcontroller is het kloppende hart van elk digitaal apparaat.
Om te begrijpen wat hem zo speciaal maakt, vergelijk je hem het
best met een klassieke processor, zoals er bijvoorbeeld eentje in
jouw pc zit. Zo’n processor doet beroep op een extern geheugen,
een externe bus of chip, en externe ingangs- en uitgangspinnen (I/
O) om te kunnen interageren met andere componenten. De
microcontroller daarentegen bundelt alles wat hij nodig heeft om
te kunnen functioneren op één chip. Hierdoor kunnen compacte en
zuinige digitale systemen gebouwd worden. Terwijl de klassieke
processor een gespecialiseerde component is met veel meer
rekenkracht dan de microcontroller, is de microcontroller eerder
een manusje-van-alles.
Om de microcontroller te laten functioneren, moet je hem
programmeren. Jouw programma kan bijvoorbeeld vertellen dat
de microcontroller twee motoren moet aansturen wanneer de
knopjes ingedrukt zijn. In dit boekje gebruiken we hiervoor de
tekstuele programmeertaal C++. Maar ook andere talen zijn
mogelijk, zoals de grafische programmeertalen Google Blockly en
Ardublock.
klok
timers
interrupts
I/O
I/O
adres-, data- en controlebus
CPU
watchdog
RAM
ROM
de microcontroller
Wist je dat jouw programma in de praktijk wordt omgezet naar een sequentie van
instructies die de microcontroller begrijpt? Elke instructie wordt voorgesteld door
een getal, waardoor jouw programma eigenlijk neerkomt op een opeenvolging van nullen
en enen. Bij elke tik van zijn interne klok zal de microcontroller deze nullen en enen
overlopen, omzetten naar een gekende instructie en ze uitvoeren.
De microcontroller op de Dwenguino kent in totaal 135 instructies. Sommige daarvan zijn
verantwoordelijk voor berekeningen zoals optellen, aftrekken, vermenigvuldigen en delen.
Andere sturen dan weer de ingangs- en uitgangspinnen van de microcontroller aan, de
timers of de communicatie met andere apparaten.
DIGITALE INPUT & OUTPUT
Een microcontroller heeft een heel aantal ingangs- en
uitgangspinnen (I/O). Hierdoor kan je hem verbinden met externe
componenten zoals leds (Light Emitting Diodes) en knopjes. Het is
dus dankzij deze pinnen dat de microcontroller in staat is om te
interageren met de fysieke wereld. De meeste van deze pinnen zijn
digitaal. Dat wil zeggen dat ze de toestand '0' of '1' kunnen
aannemen. Op het Dwenguino-bord komt een '0' overeen met 0
Volt en een '1' met 5 Volt.
I/O-pinnen krijgen een functie toegekend: in- of uitgang. Als een I/
O-pin geconfigureerd is als digitale uitgang, dan kan hij externe
componenten aansturen. Een voorbeeld van zo'n component is
een led die oplicht wanneer een spanning aangelegd wordt.
I/O-pinnen kunnen ook geconfigureerd worden als digitale ingang.
Dan kunnen ze de toestand van een externe component lezen,
zoals bijvoorbeeld een knopje. Een knop is meestal via een pull-up
weerstand verbonden met de pin. Als de knop niet ingedrukt is, zal
de pin op 5 V staan (de pin wordt als het ware omhoog getrokken
door de weerstand) en dus een '1' lezen. Als je de knop indrukt,
leest de pin een '0'.
afbeelding
platte zijde
symbool
anode (+)
anode (+)
kathode (-)
kathode (-)
schematisch
grond (-)
weerstand (R)
5V-spanning (+)
De stroom die zo'n pin
kan leveren, is beperkt tot
20 mA. Een grotere
hoeveelheid stroom (bijvoorbeeld
door een kortsluiting) kan de
microcontroller beschadigen.
Om de stroom te beperken, wordt
tussen de uitgangspin van de
microcontroller en de anode van
de led een weerstand gezet. Op
het Dwenguino-bord plaatsten we
een weerstand van 470 Ω. De wet
van Ohm (U=R · I) vertelt ons dat
de stroom die de pin moet leveren
gelijk is aan
7 mA (I = (U5 - ULED)/R met
U5 = 5 V, R = 480 Ω, ULED = 1,6 V).
HET LCD-SCHERM
De Dwenguino geeft je niet alleen feedback via leds, maar ook via
een Liquid Crystal Display of lcd-scherm. Hierop verschijnen
letters of cijfers. Op het lcd van de Dwenguino passen maximaal
32 karakters, verspreid over twee lijnen.
Voor het aansturen van het lcd zijn er in totaal 16 pinnen nodig.
Een aantal van die pinnen zijn verbonden met dezelfde microcontroller-pinnen als de leds. Hierdoor zullen de leds flikkeren als
je iets naar het lcd schrijft. Het omgekeerde geldt niet: als je de
leds verandert, heeft dit geen invloed op het lcd. Hoe dit komt? Het
lcd luistert alleen naar de datapinnen (de I/O-pinnen die
informatie van de microcontroller naar het scherm sturen, zoals de
karakters die erop moeten verschijnen) als de controlepinnen
(R/W, E en RS) goed staan (de I/O-pinnen waarmee de
microcontroller aangeeft dat het scherm moet luisteren).
Wist je dat elk karakter dat je naar het scherm schrijft (Latijnse letters, cijfers en
leestekens), wordt voorgesteld door een unieke ASCII-code? Naast de standaard
letters met een ASCII-code kan je ook zelf symbolen toevoegen. Elk karakter op het
scherm bestaat immers uit een rechthoek van 40 pixels die je aan en uit kan zetten.
Hiermee kan je in alle vrijheid bijvoorbeeld gepersonaliseerde smileys maken.
Als je aandachtig naar het schema van de
Dwenguino kijkt, zie je hoe het scherm die
16 pinnen precies gebruikt:
• 
2 als voeding (VSS en VCC),
• 
2 om de achtergrondverlichting aan te
schakelen (LDCK en LCDA),
• 
1 om het contrast te regelen,
• 
8 om karakters te verzenden
(de datapinnen DB0 t.e.m. DB7),
• 
En 3 om te controleren of die karakters toch
wel geldig zijn (R/W, E en RS)
DE ZOEMER
Geluid is eigenlijk een luchtdrukgolf die veroorzaakt wordt door
een trillend object, zoals een instrument of een luidspreker. De
amplitude van deze golf bepaalt de sterkte van het geluid, terwijl
de frequentie van de trillingen de toonhoogte beïnvloedt. Als mens
kan je alleen geluiden horen waarvan het aantal trillingen tussen
de 20 Hz en 20.000 Hz ligt. Een zuivere toon ontstaat wanneer de
luchtverplaatsing verloopt volgens een sinus-signaal (met andere
woorden: wanneer de luchtdruk sinusoïdaal varieert).
Om geluid te maken, moet je een luidspreker kunnen aansturen
met een sinusgolf. Maar microcontrollers hebben geen analoge
uitgangen: de pinnen kunnen alleen de toestand ‘0’ of ‘1’
aannemen. Je omzeilt dit probleem door een sinusgolf na te
bootsen met de digitale uitgangen van de Dwenguino. Dit doe je
met een blokgolf, een signaal dat typisch aan of afstaat en
waarvan je de frequentie kan wijzigen. Hiermee kan je eenvoudige
geluiden genereren. Let op: de amplitude van het geluidssignaal
kan je niet wijzigen: de blokgolf alterneert steeds tussen 0 en 5 V.
De eenvoudige piëzo-elektrische zoemer van de Dwenguino zet de
blokgolf om in hoorbaar geluid.
In de methode die we hiernaast beschreven, pas je enkel de frequentie van de
blokgolf aan. Er zijn echter nog betere methodes om geluid te genereren. Door
continu de breedte van de blokgolf te wijzigen, kan je een geluidssignaal (dat in feite
bestaat uit een samenstelling van verschillende sinussignalen) heel dicht benaderen.
Zeker als je er nog een aantal elektronische filters achter plaatst om ruis weg te
filteren.
PROGRAMMEREN:
DRIE-TWEE-EEN… START!
De Dwenguino is compatibel met de Arduino. Dit betekent dat je
de vele mogelijkheden van je microcontroller-platform kan
programmeren met behulp van Arduino IDE en andere beschikbare
hulpmiddelen zoals Google Blockly en ArduBlock. Standaard
gebruik je de tekstuele programmeertaal C++, waarmee je meteen
aan de slag kan na het installeren van Arduino IDE.
Probeer het zelf! Installeer Arduino IDE en de bijbehorende Dwenguinobibliotheken via http://www.dwengo.org/nl/install
Is de installatie voltooid? Dan kan je beginnen schrijven aan je
eigen programma. Hiervoor vertrek je het best vanuit een bepaald
probleem dat je wil oplossen. Vervolgens bedenk je een algoritme
voor dat probleem: een reeks van stappen die in de juiste volgorde
moeten uitgevoerd worden om vanuit de begintoestand tot het
gewenste eindresultaat te komen.
Het bedenken van een goed algoritme is niet altijd even evident. Twijfel je
hieraan? Kijk dan eens naar het beroemde filmpje ’How to program your
teacher to make a jam sandwich’. Je vindt het door via Google te zoeken
naar ’Sandwich Bot’.
Tijdens het programmeren zet je jouw algoritme om in code. Dit
zijn tekstuele (of grafische) opdrachten die eenduidig beschrijven
wat jouw programma moet doen.
De microcontroller van de Dwenguino kent slechts 135
eenvoudige instructies.
Jouw code is uiteraard
veel complexer. Daarom is
nog een tussenstap
nodig: compileren. Dit
proces dankt zijn naam
aan de compiler die zorgt
voor het omzetten van
jouw code in een
sequentie van instructies
die verstaanbaar zijn voor
de microcontroller. Deze
instructies worden
opgeslagen in een binair
bestand, waarin elke
instructie wordt voorgesteld
door een uniek getal.
In dit boekje ga je aan de slag met de tekstuele programmeertaal C++. Als je je
onzeker voelt over leren programmeren, kan je eventueel ook ons boekje ’Van start
met Dwenguino via Google Blockly’ bekijken. Daarin gebruiken we de grafische
programmeertaal Google Blockly om de Dwenguino te programmeren.
1-2-3 PIANO
Aan de basis van heel wat muziek ligt een pentatoniek, een
toonreeks van vijf tonen. Met een beetje programmeerkennis kan
je je Dwenguino-bord omtoveren tot een heus pentatonisch
instrument. Hiervoor koppel je elk van de vijf drukknoppen (N, E, S,
W en C) aan een bepaalde toon. Voor de tonen kiezen we C, D, E, G
en A (met als toonnamen do, re, mi, sol en la).
Zoals je net las, zijn geluiden hoorbare trillingen in de lucht. Om
muziek te spelen, komt het er dan ook op aan om een instrument
te laten trillen met bepaalde goedgekozen frequenties. De tonen C,
D, E, G en A van onze pentatoniek komen overeen met sinusoïdale
trillingen met een frequentie van respectievelijk 262, 294, 330, 392
en 440 Hz.
Probeer het zelf! Er bestaan heel veel pentatonieken. Zoek er een paar op en
probeer ook de frequenties van de geluidsgolven te weten te komen. Straks,
wanneer jouw instrument af is, kan je ze uitproberen.
toonnaam (BE)
toonnaam (NL)
frequentie (Hz)
drukknop
STAP 1: 1-2-3 PIANO
Je eerste taak is het opzetten van een raamwerk voor alle
toekomstige Dwenguino-projecten. In C++ bestaat zo’n raamwerk
altijd uit drie delen:
(1) het inladen van de nodige bibliotheken,
(2) het setup-blok,
(3) en de oneindige lus (of de loop in het Engels).
Belangrijk om te weten: alles in het setup-blok wordt maar één
keer uitgevoerd, namelijk bij het opstarten of aanzetten van de
Dwenguino. De I/O-pinnen van de Dwenguino moeten juist
geconfigureerd worden om het lcd-scherm, de leds, … correct te
laten werken. Hiervoor roepen we de initDwenguino-functie op.
Daarnaast zetten we nog de boodschap ‘1-2-3 piano’ op het
scherm door de print-functie op te roepen op het
dwenguinoLCD-object. Nu kan je het programma beginnen
uittesten!
Wie tekstueel programmeert moet oog hebben voor detail!
Ieder haakje, hoofdletter en puntkomma telt. Indien je je
vergist dan zal de compiler een foutmelding geven.
#include <LiquidCrystal.h>
#include <Wire.h>
#include <Dwenguino.h>
Inladen van bibliotheken:
hiermee voegen we specifieke
functies toe aan C++ voor de
Dwenguino.
void setup() {
initDwenguino();
dwenguinoLCD.setCursor(0,0);
dwenguinoLCD.print("1-2-3 piano");
}
Het setup-blok:
wordt slechts 1x uitgevoerd,
bij het opstarten van de
Dwenguino.
void loop() {
De oneindige lus:
wordt na het setup-blok
uitgevoerd, alle code in dit
blok zal herhaaldelijk
opgeroepen worden.
}
Probeer het zelf! Begin met het ontcijferen van het programma en probeer
te voorspellen wat het zal doen. Doe de test:
1. 
Sluit de Dwenguino aan
2. 
Open Arduino IDE en typ het programma in de lege sketch
3. 
Selecteer de Dwenguino in het menu Hulpmiddelen > Bord
4. 
Selecteer de poort waarop de Dwenguino is aangesloten in het menu
Hulpmiddelen > Poort
5. 
Klik op het upload-icoontje
in Arduino IDE en kijk wat er gebeurt!
Breid het programma uit. Kan je op de tweede lijn van de lcd ’Daar gaan we!’
schrijven? Experimenteer met de tekst en de andere argumenten van de lcd-functies
(met ’argumenten’ bedoelen we: getallen, letters, zinnetjes… die je kan meegeven aan
een functie en die je dus – in dit geval – op het scherm laat verschijnen).
STAP 2: DE EERSTE TOETS
Tijd voor de eerste echte uitdaging, namelijk: de Dwenguino zo
programmeren dat de toon C (de do-toon met frequentie 262 Hz)
wordt afgespeeld én dat led 0 oplicht wanneer je knop N indrukt.
Om te beginnen moet de Dwenguino kunnen detecteren of knop N
ingedrukt is of niet. Hiervoor heb je een keuzestructuur nodig, de
if-clausule, waaraan je een voorwaarde toekent. Als (if) de
voorwaarde voldaan is, dan wordt de code in de if-clausule
uitgevoerd. De conditie die je in dit geval meegeeft, gaat over de
toestand van de knop N (SW_N), die je kan uitlezen met de functie
digitalRead.
Als je wil dat een toon weerklinkt en led 0 oplicht, dan moet je dit
als een actie meegeven aan je if-clausule. Daarom stel je de leds
in op 0b00000001 en roep je de functie tone op. Deze functie
heeft drie argumenten:
1.  de pin waarop de zoemer is aangesloten (aangeduid met het
Engelse BUZZER),
2.  de toonhoogte (262 Hz),
3.  de tijdsduur (in milliseconden).
Deze if-clausule zet je vervolgens in de loop. In tegenstelling tot
bij de setup zal alle code in de loop steeds opnieuw uitgevoerd
worden. Met andere woorden, je programma zal altijd opnieuw
gaan kijken naar de toestand van knop N en – als hij ingedrukt is
– een toon afspelen en een led laten branden.
#include <Wire.h>
#include <Dwenguino.h>
#include <LiquidCrystal.h>
void setup(){
initDwenguino();
dwenguinoLCD.setCursor(0,0);
dwenguinoLCD.print("1-2-3 piano");
}
void loop(){
if (digitalRead(SW_N) == PRESSED)
{
LEDS=0b00000001;
tone(BUZZER, 262, 100);
}
}
De if-clausule: de code binnen
de haakjes wordt uitgevoerd als
de voorwaarde is voldaan. In dit
geval: de knop SW_N is
ingedrukt.
Probeer het zelf! Ga de volgende uitdagingen aan om de Dwenguino
beter te leren kennen:
1. 
Pas de code aan zodat led 7 brandt in de plaats van led 0.
2. 
Verklaar waarom de led niet uitgaat als je de knop loslaat.
3. 
Zorg ervoor dat de led uitgaat wanneer de knop niet meer ingedrukt is.
STAP 3: EEN PENTATONIEK
Nu heb je natuurlijk nog geen volwaardig pentatonisch instrument
gemaakt. Om dit voor elkaar te krijgen, moet je de tonenreeks C, D,
E, G en A (262, 294, 330, 392 en 440 Hz) koppelen aan de vijf
drukknoppen op de Dwenguino (N, E, S, W en C). Je kan dit
eenvoudigweg doen door vijf if-clausules te implementeren,
waarbij je aan elke drukknop de juiste conditie meegeeft (je kan
kiezen uit SW_N, SW_E, SW_S, SW_W en SW_C) terwijl je ook de
acties aanpast.
Analyseer de voorbeeldcode, programmeer de code op de
Dwenguino en test
ze uit! Herken jij het
volgende deuntje van
Edvard Grieg? Elke
letter staat voor een
knop, de vlaggetjes aan
de noten geven het
tempo aan: hoe meer
lijnen hoe sneller.
#include <Wire.h>
#include <Dwenguino.h>
#include <LiquidCrystal.h>
void setup(){
initDwenguino();
dwenguinoLCD.setCursor(0,0);
dwenguinoLCD.print("1,2,3 piano");
}
void loop(){
if (digitalRead(SW_N) == PRESSED){
LEDS=0b00000001;
tone(BUZZER, 262, 100);
}
if (digitalRead(SW_E) == PRESSED){
LEDS=0b00000010;
tone(BUZZER, 294, 100);
}
if (digitalRead(SW_S) == PRESSED){
LEDS=0b00000100;
tone(BUZZER, 330, 100);
}
if (digitalRead(SW_W) == PRESSED){
LEDS=0b00001000;
tone(BUZZER, 392, 100);
}
if (digitalRead(SW_C) == PRESSED){
LEDS=0b00001111;
tone(BUZZER, 440, 100);
}
}
Meerdere if-clausules: de
toon die afgespeeld wordt,
hangt af van de toets die je
indrukt.
Probeer het zelf!
Verander de
argumenten van de
tone-functie eens. Zoek
bijvoorbeeld de
frequenties op van
andere pentatonische
reeksen en gebruik die
in de code. Een ander
interessant experiment
is de tijdsduur van de
tonen te laten variëren.
VAN PIANO TOT THEREMIN
Een Theremin, genoemd naar zijn uitvinder Léon Theremin, is een
elektronisch instrument dat je kan bespelen zonder het aan te
raken.
Om zelf zo’n Theremin te maken, heb je een sonar-sensor nodig.
Een sonar-sensor meet de afstand tot aan een object. Hoe hij dat
doet? De sensor stuurt een ultrasoon geluidssignaal uit. Als er een
voorwerp binnen bereik is, dan zal deze ultrasone geluidsgolf
hierop weerkaatsen. Door de tijd te meten tussen het verzenden
van het geluidssignaal en het ontvangen van een ‘antwoord’, kan
de sensor de afstand tot het object nauwkeurig bepalen. Met
andere woorden, de sonar-sensor detecteert obstakels zoals
vleermuizen en walvissen dat doen.
Vooraleer je de Theremin programmeert, moet je dus een sonarsensor aansluiten. Dit gaat het makkelijkst via het
uitbreidingsbord, ook wel breadboard, dat in de Dwenguino past.
De afstand Δ (in meter) tussen het obstakel en de sonar-sensor kan je
bepalen met een eenvoudige formule: Δ = 340 · (δt/2), met δt de gemeten
tijd (in seconden) tussen het uitsturen en het ontvangen van het ultrasoon signaal,
waarbij we veronderstellen dat de geluidssnelheid gelijk is aan 340 m/s.
DE SONAR-SENSOR AANSLUITEN
De sonar-sensor kan je het gemakkelijkste aansluiten via het
breadboard. Op dit breadboard vind je gaatjes die in twee
kolommen met elkaar verbonden zijn, zoals aangegeven op de
figuur. Daarnaast vind je er ook de connector van de Dwenguino
terug met onder meer:
• 
aansluitingen voor de referentiespanning of de grond
(aangeduid met GND of -),
• 
3.3 V (3.3) of 5 V-spanning (5 of +),
• 
digitale in- en uitgangen (aangeduid met een nummer),
• 
analoge ingangen (aangeduid met A<x>).
De sonar-sensor heeft vier pinnen:
1.  VCC: de 5 V-voeding, soms ook aangeduid met een +;
2.  Trigger: deze pin geeft aan wanneer de ultrasone sensor moet
beginnen meten;
3.  Echo: deze pin geeft aan wanneer het weerkaatste ultrasone
signaal ontvangen is;
4.  Ground: de referentiespanning of de grond, soms ook
aangeduid met een -.
Connecteer de 5 V- en de GND-pin van de sonar-sensor met
respectievelijk de + en de - op het uitbreidingsbord. Je volgt het
best de conventie om een rode draad te gebruiken voor de 5 V en
een zwarte draad voor de grond.
Vcc
TRIG
ECHO
GND
Tot slot kan je de trigger- en de echo-pin connecteren met eender
welke beschikbare digitale I/O-pin (aangeduid met een nummer).
In dit voorbeeld sluiten we de trigger-pin
aan op pin 11 en de echo-pin op pin 12.
De gaatjes van elke rij zijn
met elkaar verbonden
Om te vermijden dat
er iets stukgaat, is het een
goed idee om de elektronica
los te koppelen van je computer
en/of de batterij wanneer je de
sensoren gaat aansluiten.
Daarnaast controleer je jouw
schakeling best grondig voordat
je de Dwenguino terug aanzet (via
de computer of de batterij). Zijn
alle pinnen wel aangesloten zoals
op het schema? Kijk bovendien
heel goed na of er nergens een
kortsluiting is: de 5 V (de +) mag
nooit rechtstreeks verbonden zijn
met de grond (de -).
MEETWAARDE UITLEZEN EN OPSLAAN
Nu heb je de sonar-sensor aangesloten, maar je kan hem nog niet
uitlezen. Hiervoor moet je eerst nog een nieuwe bibliotheek
toevoegen, NewPing. Vervolgens creëer je een nieuw NewPingobject dat je sonar noemt (je kan eventueel ook een andere naam
kiezen). Als je dit object aanmaakt, geef je mee op welke pinnummers de sonar-sensor is aangesloten en wat het
maximumbereik van de sensor is (meestal 200 cm). In ons
voorbeeld zijn de trigger- en echo-pinnen respectievelijk
aangesloten op de pinnen 11 en 12.
Hierna voer je op dit object een meting uit door de functie
ping_cm op te roepen: sonar.ping_cm. Zo krijg je de afstand tot
het object in centimeter. Om deze meting te gebruiken (om hem te
tonen op het scherm, om er wiskundige bewerkingen mee te
doen, ...) sla je haar op in een variabele van het type integer
(afgekort als int) waarin je gehele getallen kan opslaan.
Tot slot toon je de meting op het scherm. Dit doe je simpelweg
door de variabele afstand naar het scherm te schrijven met de
print-functie.
#include <Wire.h>
#include <Dwenguino.h>
#include <LiquidCrystal.h>
#include <NewPing.h>
#define TRIGGER_PIN 11
#define ECHO_PIN
12
#define MAX_AFSTAND 200
Macro’s: definiëren een aantal
waarden die in het programma
gebruikt kunnen worden (maakt de
code leesbaarder).
NewPing sonar(TRIGGER_PIN,
ECHO_PIN, MAX_AFSTAND);
Het sonar-object: definieert de
functionaliteit van de sonar-sensor
die we aansloten op pinnen 11 en 12.
int afstand = 0;
De variabele afstand: een stukje
geheugen waarin je gehele
getallen (integers) kan opslaan.
void setup(){
initDwenguino();
}
void loop(){
afstand = sonar.ping_cm();
dwenguinoLCD.clear();
dwenguinoLCD.print("Sonar = ");
dwenguinoLCD.print(afstand);
dwenguinoLCD.print(" cm");
delay(100);
}
De afstandsmeting: we meten de
afstand tot een object en slaan het
op in de variabele afstand.
De wachtfunctie: met de functie
delay kunnen we bepalen om de
hoeveel tijd de lus doorlopen
wordt.
Een variabele kan je beschouwen als een plek in het geheugen waaraan je een
naam (in ons voorbeeld de naam afstand) kan toekennen, zodat je dit
geheugen later in jouw programma kan gebruiken. Merk op dat je de variabele moet
declareren voordat je haar kan gebruiken. In onze code declareren we de variabele
afstand tussen het inladen van de bibliotheken en de setup. Hierdoor wordt hij
beschikbaar in zowel het setup- als het loop-blok. Achteraf kan je de variabele
gebruiken door er een nieuwe waarde aan toe te kennen met de toekenningsoperator
’=’. Daarnaast kan je hem bijvoorbeeld in een conditie of functie oproepen. In ons
voorbeeld kennen we de meetwaarden (via de functie sonar.ping_cm) toe aan de
variabele afstand.
Probeer het zelf! De
’Dwenguino Starterskit+’
bevat heel wat extra
sensoren om zelf een Theremin
te maken. In dit boekje gebruik
je de sonar-sensor, maar
waarom ga je ook eens niet aan
de slag met de lichtsensor, de
temperatuur-sensor…? Meer
uitleg over de verschillende
sensoren vind je op
www.dwengo.org/nl/sensors
VAN AFSTAND NAAR GELUID
Als je de sonar-sensor wil gebruiken om de frequentie van het
geluidssignaal te bepalen, dan moet je deze eerst uitlezen en
vervolgens herschalen naar een bereik dat voor de mens hoorbaar
is. De afstand die de sonar-sensor uitleest (tussen 0 en 200 cm),
moet met andere woorden worden omgezet naar een hoorbare
frequentie (tussen 200 en 20.000 Hz).
De sonar zal dus een waarde tussen 0 en 200 teruggeven, terwijl
geluidssignalen tussen 200 Hz en 12000 Hz afspeelbaar zijn op de
buzzer. Je moet er daarom voor zorgen dat een 0 wordt afgebeeld
op 200, en dat 200 wordt afgebeeld op 12.000. Hiervoor
programmeer je de volgende formule: frequentie = a · afstand + b.
Hierin is a = 11800/200 en b = 200.
Merk op dat je nu twee variabelen van het type integer gaat
gebruiken:
1.  De variabele afstand waarin de sonar-meting wordt
opgeslagen.
2.  De variabele frequentie die de afspeelbare frequentie zal
bevatten (na omrekening van de afstand).
Een variabele van het type integer kan, zoals je ondertussen weet,
gebruikt worden om gehele getallen op te slaan. De Dwenguino slaat
integers op in geheugenplaatsen van 16 bit. Hierdoor kunnen integers waarden
aannemen van -32768 (215) tot 32767 (215 - 1): er worden 15 bits gebruikt voor het
getalbereik en 1 bit om aan te duiden of een getal al dan niet negatief is. Wanneer
je enkel positieve getallen gebruikt, kan je het getalbereik vergroten van 0 tot en
met 65535 (216 - 1) door het type unsigned int te gebruiken in plaats van int.
Je hebt het misschien al gehoord: als er geen object voor de sonarsensor staat, klinkt er een lage bromtoon. Dit komt omdat de sonarsensor een 0 teruggeeft als hij geen obstakel ziet. Wijzig het programma
zodat het stil blijft wanneer er geen obstakel gedetecteerd wordt (tip: je zal
hiervoor de if-clausule moeten gebruiken).
Verschillen in lage frequenties zijn voor de mens makkelijker waar te nemen dan
verschillen in hogere frequenties. Vervang in de code de lineaire omzetting door
een kwadratische omzetting: frequentie = a’ · afstand2 + b’. Merk je verschil bij
het testen?
KUNST IN DE KLAS?
Het Theremin-project kan je op verschillende manieren gebruiken
in de klas: als integraal STE(A)M-project (Science, Technology,
Engineering, Art en Mathematics) of als losstaand project om de
beginselen van programmeren en elektronica uit te leggen.
In dit project voor beginners legden we bewust de link met kunst.
Op school kan je deze link versterken door het project te koppelen
aan vakken zoals plastische opvoeding, tekenen, architecturale
vorming of esthetica. De ervaring leert dat veel meer leerlingen
zich dan aangesproken voelen. Bovendien leidt het project tot een
resultaat dat je bijvoorbeeld op een opendeurdag kan
tentoonstellen.
Een mogelijke didactische aanpak bestaat erin om de leerlingen
per 2 à 3 te laten samenwerken en hen elk lesuur een nieuwe
uitdaging voor te schotelen, gekoppeld aan een specifieke
leerdoelstelling. Door deze opdrachten stap voor stap te
doorlopen, komen de leerlingen steeds dichter bij de realisatie. Het
is motiverend en ontroerend om te zien hoe ze hun successen
vieren.
De grootste uitdaging voor de leerkracht? Die ligt misschien wel in
het opzoeken van de grens waarop je de leerlingen net genoeg
informatie geeft om hen toch zo zelfstandig mogelijk tot een
oplossing te laten komen. Te veel informatie geven is verleidelijk,
maar zo hou je de leerlingen niet voldoende gemotiveerd en
intellectueel geprikkeld.
Hoewel je voor dit boekje in principe geen programmeerervaring
nodig hebt, is een zekere basiskennis wel handig (bijvoorbeeld van
een grafische programmeertaal). Mocht C++ een te grote drempel
zijn, kan je bijvoorbeeld de ‘Google Blockly’-versie van dit boekje
uitproberen.
Dit boekje kwam tot stand in samenwerking met de leerlingen van de tweede
graad van het Secundair Kunstinstituut Gent. Een filmpje van het volledige
proces vind je op http://www.dwengo.org/nl/theremin
SPIEKBRIEFJE
// Dit is een eenvoudig programma
// dat de LEDS laat knipperen
Een standaard programma
#include <Wire.h>
#include <LiquidCrystal.h>
#include <Dwenguino.h>
Inladen van bibliotheken:
hiermee voegen we
specifieke functies toe aan
C++ voor de Dwenguino.
void setup(){
initDwenguino();
}
Het setup-blok:
wordt slechts 1x uitgevoerd,
bij het opstarten van de
Dwenguino.
void loop(){
LEDS = 0b01010101;
delay(50);
LEDS = 0b10101010;
delay(50);
}
De oneindige lus:
wordt na het setup-blok
uitgevoerd, alle code in
dit blok zal herhaaldelijk
opgeroepen worden.
delay(t);
Pauzeren van de code:
pauzeer jouw code voor
t milliseconden.
// zo zet je commentaar in jouw code
Commentaar:
door uitleg aan jouw code
toe te voegen wordt de
code leesbaarder.
// wissen van het LCD-scherm:
dwenguinoLCD.clear();
LCD-functies:
wissen en afbeelden van
tekst en variabelen op het
LCD-scherm.
// de cursor verplaatsen:
dwenguinoLCD.setCursor(0,0);
// afbeelden van de tekst “hallo”:
dwenguinoLCD.print(“hallo”);
// de variabele var tonen op het LCD:
dwenguinoLCD.print(var);
tone(BUZZER,440,100);
Geluid maken:
een toon afspelen met
als frequentie 440 Hz
gedurende 100
milliseconden. Uiteraard
kan je de frequentie en
duur naar wens
aanpassen.
if(conditie) {
// code die uitgevoerd wordt als de
// conditie waar is
} else {
// code die uitgevoerd moet worden
// als de conditie onwaar is
}
Keuzes maken:
if…else...
int variabele = 0;
Variabelen gebruiken:
stap 1: declareren van de
variabele. Vergeet niet om
het juiste type mee te
geven, bijv. int voor
gehele getallen.
Door de variabele te
declareren wordt er een
stukje geheugen
gereserveerd.
variabele = variabele + 1;
stap 2: gebruiken van de
variabele. Je kan een
waarde toekennen aan de
variabele met de
toekenningsoperatie ‘=’.
Daarnaast kan je
bijvoorbeeld wiskundige
bewerkingen +-/*
toepassen of de variabele
gebruiken in een conditie
(bijv. d.m.v. de operatoren
< > == !=).
#include
#include
#include
#include
<Wire.h>
<LiquidCrystal.h>
<NewPing.h>
<Dwenguino.h>
De sonar-sensor gebruiken
Inladen van bibliotheken:
de bibliotheek NewPing is
nodig voor de sonarfunctionaliteit.
int afstand1, afstand2;
Aanmaken variabelen:
hierin kan je de meetwaarden
opslaan.
NewPing sonar1(11,12,200);
NewPing sonar2(13,14,200);
Aanmaken sonar-object:
geef de juiste pin-nummers
mee: het 1ste getal geef de
TRIG-pin aan, het 2e getal
de ECHO-in. Je moet ook
een maximaal bereik
meegeven (hier 200 cm).
void setup(){
initDwenguino();
}
void loop(){
afstand1 = sonar1.ping_cm();
afstand1 = sonar1.ping_cm();
}
dwenguinoLCD.clear();
dwenguinoLCD.setCursor(0,0);
dwenguinoLCD.print(afstand1);
dwenguinoLCD.setCursor(0,1);
dwenguinoLCD.print(afstand2);
delay(100);
Sonar-sensor uitlezen:
de metingen sla je best op
in een variabele zoals hier.
Afprinten meetwaarden:
met behulp van deze code
kan je de meetwaarden
onder elkaar afprinten op
het LCD-scherm.
Werken met Dwenguino is leuk omdat het erg praktisch gericht is.
Het opent ook mogelijkheden om technologie in de kunst te
verwerken.
– Britt, 4de middelbaar
Mijn collega ICT verraste mij met zijn vraag om samen te werken
aan een project; nooit gedacht dat de symbiose ICT en Beeldende
Vorming tot zo'n mooie, krachtige ontwerpen zou leiden!
– Grietje Vandaele, leerkracht Beeldende Vorming,
Secundair Kunstinstituut Gent
Je maakt iets praktisch, je leert werken met hardware en je kan
zelf iets nieuws creëren.
– Matthias en Bruno, 4de middelbaar
Bekijk alle boeken van Dwengo op htttp://dwengo.org/nl/books