In deze serie opdrachten ga je leren werken met de Arduino. Wat is dat voor ding, wat zijn de mogelijkheden, maar vooral: wat kun jij er nou zelf mee doen?
Het doel is om een aantal vaardigheden aan te leren, zodat je de Arduino na deze module kunt gebruiken bij practica van de andere vakken. Daarvoor moet je met de Arduino kunnen meten en regelen, daarom is het einddoel om een basis meet-regelsysteem te kunnen bouwen.
Aansluiten van de Arduino
Deze handleiding bestaat uit 9 stappen die je moet doorlopen om met de Arduino te kunnen werken. De laatste stap is een test om te controleren of je alles goed hebt gedaan.
Leg een Arduino, een USB-kabel en een LED-lampje klaar
Sluit de Arduino aan op de computer met de USB-kabel aan op de computer.
Een groen LED-lampje (ON) op de Arduino zal gaan branden.
Installeer de Driver
Na stap 3 zal de computer zelf beginnen met de installatie van de driver software. De computer kan dit echter niet helemaal zelfstandig, je moet nu achtereenvolgens het volgende doen:
Klik op het Start menu en open het Control Panel.
In het Control Panel ga je naar ‘System and Security’.
Vervolgens selecteer je ‘System’.
Open tenslotte de ‘Device Manager’.
Klik in de Device Manager op ‘Ports (COM & LPT)’, hier moet nu de Arduino Uno (COM3) zichtbaar zijn.
Als de Arduino hier NIET bijstaat, zoek dan in ‘Other Devices’ naar ‘Unknown Device’.
Klik met de rechter muisknop op ‘Arduino Uno (COM3)’ en selecteer de optie ‘Update Driver Software’.
Selecteer nu de optie ‘Browse my computer for Driver software’.
Je moet nu aangeven in welk mapje de Driver Software gezocht moet worden. Hiervoor klik je op ‘Browse’ en blader je via de map ‘Program Files’ naar de map met de naam ‘Arduino’, hierin staat de map ‘drivers’. Deze map moet je selecteren en vervolgens klik je op OK.
LET OP: Selecteer NIET de map ‘FTDI USB Drivers’.
In het volgende scherm klik je op ‘Next’.
Windows zal de installatie nu afmaken.
Open de Arduino applicatie.
Je krijgt nu het volgende scherm.
Open het voorbeeld van het knipperende LED-lampje.
Ga in het ‘File’ menu naar ‘Examples’, kies vervolgens ’01. Basics’ en selecteer tenslotte ‘Blink’. Maximaliseer het gekregen scherm
Selecteer het juiste type Arduino
Ga in het 'Tools' menu naar 'Board' en selecteer nu 'Arduino Uno'
Selecteer de juiste poort.
Ga in het ‘Tools’ menu naar ‘Port’ en selecteer nu ‘COM3’ (of hoger).
Upload het programma
Plaats het LED-lampje met de lange pin in poort 13 en de korte pin in de poort ernaast met de naam GND (afkorting van Ground).
Upload het programma ‘Blink’ naar de Arduino door in de balk bovenaan op de tweede knop van links te klikken:
Als je alle stappen goed hebt doorlopen heb je nu een knipperend LED-lampje.
De Arduino maakt gebruik van codes. Als je codes lastig vindt om mee te werken kun je gebruik maken van het programma ArduBlocks.
Uiteindelijk is het de bedoeling dat je programmeert in het Arduino programma.
Om aan het werken met codes te wennen kun je beginnen met ArduBlocks.
Een korte introductie van ArduBlocks vind je op de deze pagina.
Je mag natuurlijk ook gelijk beginnen met de codes. Lees dan verder op de volgende pagina.
Aan de slag met ArduBlocks
ArduBlocks is geen standaard Arduino onderdeel. Je kunt ArduBlocks downloaden via deze link.
Op deze site staat hoe je het moet installeren, je docent kan je hierbij helpen.
Na het installeren kun je ArduBlocks openen via het Arduino programma door naar Tools te gaan en vervolgens te kiezen voor ArduBlocks (zie onderstaande afbeelding)
Als je ArduBlocks geopend hebt kun je allerlei opdrachten naar het werkvlak slepen om een werkende 'code' te creëren.
Je gaat nu met behulp van ArduBlocks een code samenstellen om een LED lampje te laten knipperen.
De code zelf krijg je niet te zien in ArduBlocks, maar deze kun je vervolgens wel naar het Arduino programma uploaden.
Dit kun je doen door op de knop 'Upload' te drukken bovenaan in het scherm.
Maak nu het onderstaande programma door vanuit het linker menu opdrachten te slepen naar het werkvlak en eventuele waarden aan te passen in de blokken.
Met bovenstaande 'code' is de LED steeds één seconde aan en één seconde uit.
Deze code kun je uploaden naar de Arduino door bovenin het scherm op de knop 'Upload' te klikken.
Kijk eens in het Arduino programma hoe de code eruit ziet en of je de overeenkomsten ziet met de code in blokken.
Ga zelf eens proberen hoe je de 'code' aan kunt passen zodat de LED met andere aan/uit tijden gaat knipperen.
Door de waarden in de blokken aan te passen kun je de LED met andere aan/uit tijden laten knipperen.
Blokken uitbreiden
Programmeer codes kun je eindeloos uitbreiden. De bovenstaande 'code' kun je verder uitbreiden door de LED een S-O-S signaal te laten uitzenden.
Om dit te kunnen doen moet je waarden in de huidige blokken aanpassen, maar ook blokken toevoegen.
Deze extra blokken heb je in de huidige 'code' ook al gebruikt om de LED te laten knipperen.
Ga eens verder experimenteren met de huidige 'code'.
Vergelijk de codes die je maakt eens met het volgende blokje in de introductie.
Knipperend LED-lampje
In het eerste stukje van de introductie heb je na het aansluiten van de Arduino een code geselecteerd waardoor er een LED lampje ging knipperen.
Hieronder staat die code en het aansluitschema nog een keer.
/* Het programma Blink laat een LED knipperen met 1 seconde aan en 1 seconde uit. Dit voorbeeld mag door iedereen gebruikt worden en is vrij toegankelijk. */
// Pin 13 is bij de meeste Arduino's standaard aangesloten op het LED lampje van de Arduino zelf.
// Geef de variabele een naam (nu led): int led = 13;
// De 'setup' opdracht wordt één keer uitgevoerd als op reset drukt: void setup() {
// Definieer de digitale punt als uitgang signaal. pinMode(led, OUTPUT); }
// De 'loop' opdracht zorgt ervoor dat de onderdelen steeds opnieuw worden herhaald: void loop() { digitalWrite(led, HIGH);
// Zet de LED aan (HIGH is het spannings niveau) delay(1000);
// Wacht één seconde digitalWrite(led, LOW);
// Zet de LED uit door het spanningsniveau op laag (LOW) te zetten delay(1000);
// Wacht één seconde
}
Met bovenstaande code is de LED steeds één seconde aan en één seconde uit.
Door de code aan te passen kun je de led met andere aan/uit tijden laten knipperen.
Ga zelf eens proberen hoe je de code aan kunt passen zodat de LED met andere aan/uit tijden gaat knipperen.
Code uitbreiden
Programmeer codes kun je eindeloos uitbreiden. De bovenstaande code kun je verder uitbreiden door de LED een S-O-S signaal te laten uitzenden.
Om dit te kunnen doen moet je dingen in de huidige code aanpassen, maar ook stukjes extra code toevoegen.
Deze extra stukjes code kun je uit de huidige code halen om de LED te laten knipperen.
Ga eens verder experimenteren met de huidige code.
Sensoren
Sensoren zijn de zintuigen van een apparaat. Hiermee kunnen dingen uit de 'echte wereld' worden gevoeld en door de sensor omgezet worden in elektrische signalen die de Arduino kan verwerken.
In dit blok leer je een aantal sensoren kennen en gebruiken met de Arduino.
Zintuigen van de Arduino
Een sensor is dus een zintuig voor een apparaat. Voor de door mensen waar te nemen grootheden bestaan dus ook sensoren:
Je ogen zien licht en kunnen onderscheiden of dit fel is of juist niet, en welke kleur het licht heeft. Voor de Arduino bestaan bijvoorbeeld lichtsensoren die de hoeveelheid licht meten dat op de sensor valt.
Fotoresistor
Licht-frequentie sensor
Je oren kunnen geluid horen in verschillende frequenties variërend van ongeveer 20 Hz tot 20.000 Hz, en kunnen ook onderscheiden of het om hard of zacht geluid gaat. Voor de apparaten bestaat een decibelmeter, waarmee je kunt bepalen hoe hard het geluid is, maar je kunt ook een microfoon gebruiken om geluid op te nemen.
Geluidsensor
Zo bestaan er dus voor alle zintuigen ook sensoren die hetzelfde kunnen 'voelen'. Maar er bestaan ook sensoren die meer kunnen voelen dan mensen. Denk bijvoorbeeld aan een infraroodsensor die warmte kan 'zien' of waarmee je het signaal van een afstandsbediening kunt detecteren. Of een ultrasoonsensor om afstand te bepalen tot een voorwerp, of juist de dichtheid zoals bij een echo.
Infraroodsensor
Ultrasoonsensor
Temperatuur bepalen
Sluit de temperatuursensor aan op de Arduino, met behulp van een breadboard. De middelste pin geeft de uitgangsspanning, die je omrekent naar temperatuur. Sluit die aan op analoge input 1 (A1). De andere twee pinnen voorzien de sensor van stroom, en worden aangesloten op 5V en GND (= ground = 0V). Let op, als je deze verkeerd aansluit brandt de sensor door!
De gebruikte temperatuursensor is de LM35, hieronder staat een plaatje uit de datasheet waarop je ziet hoe de pinnen moeten worden aangesloten.
Nu je de schakeling gebouwd hebt kun je verder met het computerprogramma naar de Arduino te uploaden.
int val;
int tempPin = 1;
void setup()
{ Serial.begin(9600);
}
void loop()
{
val = analogRead(tempPin); float mv = ( val/1024.0)*5000; float cel = mv/10;
Upload het programma en open de Seriële monitor (onder Hulpmiddelen in het Arduino programma op de computer). Nu krijg je als alles goed gegaan is elke seconde de actuele waarde van de temperatuur die de sensor meet.
Nu heb je net je eerste sensor aangesloten en de code daarvan beter bekeken. Om nu een andere sensor te gebruiken die net als de temperatuursensor een analoge waarde (spanning) geeft is min om meer de zelfde code nodig.
Kopiëer de code van net en sla deze op als een nieuw bestand met de naam ultrasoon_afstand.
Sluit nu de sensor als hieronder aan.
Probeer de oude code zo aan te passen dat je de spanning van de twee ultrasoon-sensors kunt weergeven op de Serial Monitor. De afstand berekenen uit die spanning komt daarna.
Gebruikersinput
Wat is gebruikersinput
Als je een systeem gaat ontwikkelen, dan wil je dat het systeem uiteindelijk de dingen doet die jij instelt. Dit noem je gebruikersinput. Er zijn verschillende manieren waarop je een systeem kan laten doen wat je wil. Enkele voorbeelden hiervan zijn het gebruik van schakelaars, knoppen of een numerieke waarde.
Drukschakelaar
Als je een systeem gaat ontwikkelen, dan wil je dat het systeem uiteindelijk de dingen doet die jij instelt. Dit noem je gebruikersinput.
Er zijn verschillende manieren waarop je een systeem kan laten doen wat je wil.
Enkele voorbeelden hiervan zijn het gebruik van schakelaars, knoppen of een numerieke waarde.
De Arduino maakt gebruik van codes.
Om een LED (of ander apparaat) aan te laten gaan door het drukken op een knop (een knop zonder geheugen in dit voorbeeld) kun je onderstaande code gebruiken:
// start de code void setup() { pinMode(12,OUTPUT); // Dit is de uitgang waarop de LED of het apparaat is aangesloten pinMode(4,INPUT); // Dit is de ingang waarop de drukknop is aangesloten } // door het instellen van een loop blijven de volgende stappen zich eindeloos herhalen void loop() { // Als er een hoog signaal van de knop is treed de LED of het andere apparaat in werking, anders blijft hij uit. if(digitalRead(4) ==HIGH) { digitalWrite(12,HIGH); }else { digitalWrite(12,LOW); } }
Ga zelf eens uitzoeken wat er gebeurt als je een waarde ( bijvoorbeeld HIGH/LOW) in de code verandert.
Code uitbreiden
Programmeer codes kun je eindeloos uitbreiden. De bovenstaande code kun je verder uitbreiden door de LED langer te laten branden dan dat je de knop indrukt.
Om dit te kunnen doen moet je dingen uit een vorige code toevoegen.
Ga eens verder experimenteren met de huidige code.
POT-meter
Je kunt een POT-meter gebruiken om waarden in te stellen.
In onderstaande code wordt de spanning uitgelezen die als gevolg van het draaien aan een POT-meter verandert.
Deze spanning kun je vervolgens gebruiken om je systeem de dingen te laten doen die je wil.
// start de code void setup() {
// maak verbinding met de computer met een gegeven snelheid. Serial.begin(9600); }
// door het instellen van een loop blijven de volgende stappen zich eindeloos herhalen void loop() {
// vanaf de POT-meter uitgang komt er een draad op de analoge input 0. int sensor = analogRead(A0);
// de input spanning is 5 volt en het wordt afgelezen in 2^10 stappen. float voltage = sensor * 5 / 1023;
// de spanning na de POT-meter wordt doorgegeven aan de computer Serial.println(voltage);
// wacht een halve seconde voor de volgende meting delay(500);
}
Ga zelf eens uitzoeken wat er gebeurt als je een waarde in de code verandert.
Code uitbreiden
Programmeer codes kun je eindeloos uitbreiden. De bovenstaande code kun je verder uitbreiden.
Probeer de code eens zodanig te veranderen dat de 'output' op je scherm het percentage doorgelaten spanning is (hoe ver de POT-meter dus gedraaid is).
Om dit te kunnen doen moet je dingen in de huidige code aanpassen, maar ook stukjes extra code toevoegen.
Deze extra stukjes code kun je maken door achter het float commando een berekening te maken.
Ga eens verder experimenteren met de huidige code.
Numerieke waarden
Soms wil je geen schakelaar, (draai)knop of een andere externe bron gebruiken om iets in te stellen, dan kun je ook een code gebruiken om een numerieke waarde in te vullen als gebruikersinput.
Hiervoor gebruik je de volgende coderegel in je bestaande programma:
int waarde = 999;
De naam 'waarde' kun je veranderen voor iets wat je zelf wil, bijvoorbeeld 'lichtsterkte'.
Dit is de naam van de variabele.
De waarde van de variabele (999 in dit voorbeeld) kun je naar je eigen wil veranderen.
Je kunt alleen gehele waarden instellen.
Decimale getallen gebruiken
Als je een decimaal getal in wil vullen kun je een andere code invoegen in je bestaande programma, namelijk de volgende:
float waarde = 10.5;
Ook hier kun je de naam van de variabele en de waarde weer veranderen.
Code verder uitbreiden
Dit soort codes kun je niet alleen gebruiken om input te geven aan het programma, maar ook om berekeningen uit te voeren, op dezelfde manier als beschreven bij de POT-meter.
Zo is het mogelijk om een nieuwe waarde te berekenen aan de hand van gegevens uit je gebruikersinput in combinatie met iets wat je Arduino meet met een sensor.
Een voorbeeld van een dergelijke code om toe te voegen aan je huidige programma staat hieronder:
int waarde = 12; int sensor = analogRead(A0); float factor = 10.5; float uitkomst = waarde * factor * sensor;
Belangrijke opmerking bij het schrijven van een code
Let bij het gebruik van dit soort codes op het maken van typfouten.
Je vergeet snel een puntkomma of gebruikt een kleine letter in plaats van een hoofdletter.
Als je dat doet werkt je code niet meer. Een dergelijke fout heet een syntax fout.
De software van de Arduino kan zulke fouten vinden en benoemen als je de code checkt met de 'verify' knop (zie onderstaande afbeelding).
Actuatoren
Een actuator zet elektrische energie om in andere vormen van energie. Dit kan bijvoorbeeld licht, warmte, beweging of geluid zijn. Als de actuator hiervoor een commando krijgt zal hij overgaan tot actie. Je stuurt de actuator aan met behulp van de code, waarbij je eventueel gebruik maakt van een sensor.
Een actuator is de laatste schakel in je circuit, het zorgt voor een waarneembare output. Een lamp, een sirene, een beeldscherm, een luidspreker, een ventilator en een elektromotor zijn allemaal voorbeelden van actuatoren.
LED-lampjes
LED-lampjes zetten elektrische stroom om in licht, en zijn dus ook actuatoren.
Benodigdheden:
- Jumper draden: Rood, zwart en nog een willekeurige draad
- Een LED-lampje
- Een 220 Ohm weerstandje (voor een overzicht van de kleurcodering kun je de volgende link gebruiken: http://www.esdsite.nl/elektronica/kleurcode.html)
Maak nu het volgende circuit:
Plaats de rode draad in de 5V uitgang op de Arduino en in de + kolom op het broodbord.
Plaats de zwarte draad in de Ground uitgang op de Arduino en in de - kolom op het broodbord.
Plaats het LED-lampje in het broodbord met de poten in 2 verschillende rijen van het broodbord. Plaats de lange poot in de rij boven de korte poot.
Verbind nu de lange poot van het LED-lampje met poort 2 met de draad die nog over is.
Plaats hiervoor het ene uiteinde van de draad in poort 2, het andere uiteinde plaats je op het broodbord in de rij waar ook de lange poot van het LED-lampje in zit.
Tenslotte plaats je de 220 Ohm weerstand op het broodbord. Het ene uiteinde van de weerstand plaats je in de rij waar ook de korte poot van het LED-lampje in zit.
Het andere uiteinde plaats je in de - kolom. Het circuit is nu rond.
Code:
void setup() {
// declare the LED pins as outputs: pinMode(2,OUTPUT);
} void loop() { digitalWrite(2, HIGH);// turn the LED on pin 2 on delay(1000);//wait for a second digitalWrite(2,LOW);//turn the LED on pin 2 on delay(1000);//wait for a second }
Je hebt nu weer een knipperend LED-lampje, zoals je al eerder hebt gezien. Nu hebben we het LED-lampje niet via poort 13 op de Arduino zelf ingeplugd, maar hebben we gebruik gemaakt van het breadboard.
Op deze manier kun je meer lampjes toevoegen. Je gaat hier in volgende oefening zelf mee experimenteren.
Een Piezo element kan gebruikt worden als een sensor, omdat het vibraties kan detecteren. Een Piezo element kan echter zelf ook geluid maken, je kunt het dus ook als actuator gebruiken. Het piezo element zet elektrische stroom dan om in geluid. Je kunt de toon bepalen door het opgeven van een frequentie.
Benodigdheden:
- Jumper draden: Rood, zwart, 2 lange en 2 korte draden.
- Piezo element
- 10 kilo Ohm weerstandje
- Drukknopje
Je maakt hiermee het volgende circuit:
Code:
void setup() {
//start serial communication Serial.begin(9600);
} void loop(){
// create a local variable to hold the input on pin A0 int keyVal = analogRead(A0);
// send the value from A0 to the Serial Monitor Serial.println(keyVal);
// play the note corresponding to each value on A0 if (keyVal == 1023) {
// play the first frequency in the array on pin 8
tone(2, 262);
} else if (keyVal == 0) {
// play the second frequency in the array on pin 8 noTone(2);
}
}
Als je op de knop indrukt zal het Piezo element een toon produceren.
Een motor zet elektriche stroom om in beweging. Bij een servomotor is deze beweging een rotatie tot maximaal 180 graden.
Servomotoren worden gebruikt in machines om bijvoorbeeld machine-onderdelen of producten in de juiste positie te brengen. Een bewakingscamera kan met behulp van een servomotor ook in verschillende posities gebracht worden.
We gaan nu bekijken hoe je de servomotor kunt aansluiten op de Arduino en hoe je de servomotor vervolgens kunt aansturen.
Benodigdheden:
- Jumper draden: Rood, zwart, nog 1 andere draad
- Servomotor
- 3 male header pins (zie plaatje hieronder)
Maak hiermee het volgende circuit:
Met de rode draad zorg je ervoor dat het breadboard voorzien wordt van 5V, de zwarte draad verbindt het breadboard weer met Ground.
De drie male header pins zijn de verbinding tussen de servomotor en het breadboard.
Let goed op dat je de zwarte draad van de servomotor met de - kolom (Ground) verbindt en de rode draad van de servomotor met de + kolom (5V) verbindt.
De witte draad van de servomotor verbind je met poort 9 op de Arduino.
Code:
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{ for(pos = 0; pos <= 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position
} for(pos = 180; pos>=0; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position
}
}
Met deze code laat je de servomotor een rotatie van 0 tot 180 graden en weer terug maken.
Je kunt de positie van de arm van de servomotor ook zelf bepalen met behulp van een pot-meter.
Hiervoor gaan we de pot-meter toevoegen aan het eerder opgestelde circuit.
Extra benodigdheden:
- POT-meter
- 3 lange jumper draden, 2 korte jumper draden
Je zet de pot-meter er op de volgende manier tussen:
Let erop dat de twee buitenste pinnetjes van de pot-meter met 5V en Ground verbonden zijn.
Zorg dat je de middelste pin kunt laten aflezen door hem met een jumper draad te verbinden met analoge poort A0.
Code:
#include <Servo.h>
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the potentiometer int val; // variable to read the value from the analog pin
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object Serial.begin(9600);
}
void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023) Serial.print(val);
val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value between 0 and 180) myservo.write(val); // sets the servo position according to the scaled value delay(15); // waits for the servo to get there
}
De POT-meter fungeert nu als een draaiknop waarmee je de positie van de arm kunt bepalen.
LCD scherm
Aan sluiten van een standaard LCD scherm.
Het aansluiten van een LCD display
Het aansluiten van een LCD display was vroeger erg ingewikkeld, maar tegenwoordig is dat een fluitje van een cent. De Arduino software kent een flink aantal libraries (bibliotheken) die al het moelijke werk uit handen nemen.
Kijk maar eens naar het onderstaande programma. Je ziet in het programma bovenin het commando #include <LiquidCrystal.h> Dat betekent niets anders dan dat de software straks een beetje extra code mee upload naar de Arduino, zodat je alleen nog maar de tekst hoeft in te typen die je wilt laten zien na het commando lcd.print("Elektrotechniek!");
Je gebruikt een normaal 4 bits (geen seriëel) display zodat zodat het commando LiquidCrystal wil weten waar de pennen rs, rw, d4 t/m d7 zijn aangesloten. Wil je meer weten van displays bekijk dan eens een datasheet.
Het commando lcd.setCursor(0, 1); zorgt er voor dat de nieuw te plaatsen tekst op de tweede regel komt. Zou je een display hebben met vier regels dan zou de start van de derde regel dus plaats vinden op regel 0,2. Dat klinkt vreemd, maar de positie 0,0 is namelijk de eerste positie op de eerste regel.
Als je ook nog een video wil zien over hoe je het LCD scherm aansluit op een Arduino, kijk volgende video:
Combineren van LCD met Sensor
Het koppelen van de temperatuur sensor aan een Arduino met een LCD scherm, waarbij de temperatuur wordt weergegeven in graden Fahrenheit.
Deze les laat op een interessante manier zien hoe je met de Arduino de temperatuur van de omgeving kunt meten en zichtbaar kunt maken op een LCD 16X2 scherm in graden Fahrenheit door gebruik te maken van delen van de programmatuur en de LM35DZ temperatuursensor.
Hiervoor zijn de volgende componenten nodig:
- 1 Arduino board
- 1 LCD 16x2 scherm
- 1 10K potentiometer
- 1 Temperature LM35 sensor
- Jumpers
Deze sensor meet de externe temperatuur en converteert deze in een bijbehoorende spannings waarde. In deze schakeling koppelen we de output V0 van de sensor aan de Arduino pin A0, die verandert het in de floatwaarde van de temperatuur, daarna, laten we het zien op het LCD scherm. De 10K potentiometer kan het contrast van het scherm aanpassen.
Maak de onderstaande schakeling met de Arduino en de benodigde componenten:
Open de Arduino's IDE en voeg de volgende code toe:
#include <LiquidCrystal.h> // Include the library to use a LCD display
#define sensor 0 // Define the A0 pin as “sensor”
int Vin; // Variable to read the value from the Arduino’s pin
float Temperature; // Variable that receives the converted voltage value to temperature
float TF; // Variable to receive the converted value from ºC to ºF
LiquidCrystal lcd (12, 11, 5, 4, 3, 2);
/* The function above declares which Arduino’s pins will be used for controlling the LCD */
void setup()
{
lcd.begin(16, 2); // It tells the Arduino that the display is a 16x2 type
lcd.print("Temperature: "); // Send the text to the screen of the display.
}
void loop()
{
Vin = analogRead (sensor); /* Tells the Arduino to read the pin and stores the value in “Vin” */
Temperature=(500*Vin)/1023; /* Converts the voltage value into temperature and stores it into the “Temperature” variable (in ºC)*/
TF = ((9*Temperature)/5)+32; // Converts ºC to ºF
lcd.setCursor(0, 1); // Moves the cursor of the display to the next line
lcd.print(TF); // Exhibits the value of the temperature on the display
lcd.print(" F"); // Writes “F” to indicate that it is in Fahrenheit scale.
delay(1000); // Waits for a second to read the pin again
}
Als laatste stap laad je de code naar je Arduino.
Je project om de temperatuur te laten zien is bijna klaar. De temperatuur wordt op het scherm getoond in graden Farenheit. Kijk in je code om dit te veranderen naar graden Celcius.
Note: de LM35DZ sensor heeft een temperatuur range van waarde van tussen -55ºC to 150ºC.
Als je geineresseerd bent in de uitleg hoe de programmatuur dit om rekent van spanning naar temperatuur lees dan het volgende door:
In deze sensor, voor elke 1 graden Celcius ontvangen, de V0 output is verhoogt met 10mV, in de range van 0 tot 5V, met 10 bits resolutie voor Analoog/Digitaal conversie (1024 verschillende waardes om de temperatuur te presenteren).
Dus de maximum waarde (1023, omdat het is van 0 tot 1023) is dan 5V. De helft komt dan overeen met 511 of 2,5V en zo voort.
Voor de berekening, is het 5V output van de sensor overeenkomen met 5000C (Wat verschillend is van de realiteit).
Alhoewel, dit voorbeeld geeft het ons de volgende generieke relatie:
Temperatuur ----- Vin
500ºC ----- 1023 (maximale waarde)
Dit geeft ons:
Temperatuur = (500*Vin)/1023, maar omdat het in ºC is en we het in ºF willen, zullen we het converteren:
TF = ((9*Temperatuur)/5)+32, en dit is de waarde die getoond wordt op het LCD scherm.
Met deze uitleg zou je ook in staat moeten zijn om de temperatuur in Kelvin op het scherm te laten komen.
Tenslotte: maak de oefening af zodanig dat de temperatuur in Kelvin op het scherm komt te staan.
Je kunt ook nog de volgende video bekijken:
Meet- en regelsysteem
Eindopdrachten
In de eindopdracht ga je sensoren, gebruikersinput en actuatoren combineren tot een meet- en regelsysteem.
Je kunt hierbij gebruik maken van de gegeven codes in de modules.
Als het eindproduct af is geef je hierover een presentatie aan de rest van de groep waarin je jouw eindproduct presenteert en laat je zien hoe je hebt gezorgd dat het werkt. In de beoordeling worden ook originaliteit en de moeilijkheidsgraad van het door jou gemaakte eindproduct meegewogen.
Je mag zelf een project bedenken dat je wilt maken, je mag ook kiezen voor een van de hieronder omschreven eindopdrachten.
Weerstation
Maak een weerstation dat van de volgende grootheden de gemeten waarden laat zien:
- Temperatuur
- Luchtvochtigheid
Je kunt deze waarden op een computerscherm laten zien of op een LCD-scherm. Als je nog andere dingen wilt toevoegen (bijvoorbeeld de tijd), dan mag dit natuurlijk ook.
Verkeerslicht(en)
Maak een werkend verkeerslicht waarbij je door middel van een sensor of een drukknop zorgt dat het verkeerslicht op groen springt. Breidt de opdracht eventueel uit tot het maken van een functionerend kruispunt.
Automatische fietsverlichting
Een automatische fietsverlichting heeft een lichtsensor en een bewegingssensor. Wordt het donker en beweegt de fiets, dan gaat het achterlicht vanzelf branden. In het achterlicht zelf bevinden zich drie LED-lampjes. De lichtsensor geeft een spanning van 1,5V af als het donker begint te worden. De bewegingssensor geeft een tweewaardig signaal af. Het signaal is hoog als de fiets beweegt en laag als de fiets stilstaat.
Binaire klok
Maak een binaire klok met de Arduino. Maak gebruik van het web om ideeën op te doen om tot een creatief prototype te komen. Er zijn veel varianten mogelijk.
Stopwatch
Een stopwatch bevat drie drukschakelaars. Elke drukschakelaar geeft een hoog signaal aan de teller als de knop even wordt ingedrukt. De eerste drukschakelaar zorgt voor het starten van de stopwatch. De tweede stopt de stopwatch. De derde zet de stopwatch op nul.
Lichtautomaat
In een lokaal is een automatisch systeem om de lampen aan en uit te schakelen.
De lampen zijn aan als tegelijkertijd aan de volgende twee voorwaarden is voldaan: er is weinig licht in het lokaal en er is beweging, of er is beweging geweest gedurdende de laatste 8 minuten terwijl er weinig licht was. Zo niet, dan zijn de lampen uit.
Het signaal van de lichtsensor wordt groter als er meer licht op valt.
De bewegingssensor geeft een hoog signaal als er iemand beweegt in het lokaal.
De pulsgenerator geeft één puls per minuut. De LED stelt de verlichting in het lokaal voor.
Plantenwatermachine
Met de Arduino, een bodemvochtigheidssensor en een pompje kun je eenvoudig een 'plantenwatermachine' maken. De spullen die je zou kunnen gebruiken zijn goedkoop op internet te krijgen:
Je kunt er zelfs zoiets van maken als je een echte uitdaging wilt.
Docenten Handleiding
Docentenhandleiding Arduino
Handleiding voor bij de lessenserie Kennismaken met Arduino.
De Arduino is ruim 10 jaar geleden ontwikkeld en wordt tegenwoordig steeds vaker ingezet in het onderwijs. De orginele Arduino UNO komt uit Italie als handig applicatie device dat kan omgaan met output- en inputsignalen. Met een Arduino kun je eenvoudig een meet- en regelsysteem bouwen. Het kan LED's laten knipperen of reageren op temperauur, licht en/of beweging, maar dat is nog maar het begin. De mogelijkheden zijn onbeperkt en het is nog goedkoop ook.
De Arduino-community is sterk aan het groeien. Voor bijna iedere applicatie kun je wel een voorbeeld of tutorial vinden. Google je op "Applicatie's met Arduino" vind je ongetwijfeld iets van instructables.com. Niet alles wat je vindt kun je direct gebruiken, maar onderschat de leerlingen niet.
Om met een Arduino te kunnen werken moeten de leerlingen twee dingen kennen. Een stukje basiselectronica en programmeren. Van basiskennis over electronica is nodig: Stroomkring, spanning, schakelaar, plus/minpool, weerstanden en LED's aansluiten. Indien je met de analoge ingangssignalen wilt werken, is kennis van het principe van spanningsverdeler nodig. Inzake programmeren is er een standaard Arduino IDE software dat werkt via tekstregels, de in te voeren tekst regels lijken veel op de C++ programmeer taal. Ook kun je gebruik maken van de modulaire programmeer taal Ardu-blocks. Communicatie van PC naar de Arduino wordt met software geregeld en loopt via een USB poort.
Betadidactische benadering
We hebben geprobeerd deze lesmodule zo veel mogelijk constructivistisch in te richten. Wij willen de leerlingen onderzoekend laten leren door codes aan ze te presenteren, waarmee ze zelf kunnen experimenteren. Op die manier kunnen ze leren omgaan met programmeren, zonder dat het aanvoelt als een cursus programmeren.
Daarnaast hebben we geprobeerd de stukken tekst zo kort mogelijk te houden, zodat leerlingen zelf op zoek moeten als ze nog meer informatie nodig hebben.
De eindopdracht zullen we probleemgestuurd inrichten. Leerlingen moeten zelf onderzoeken welke codes uit het lesmateriaal ze nodig hebben, ze moeten deze codes nu zelf gaan aanpassen en hun eigen opstelling maken.
Hoe ga je van start?
Na wat uitleg over het lessen pakket en de opbouw er van, kunnen de leerlingen aan de slag met de eerste oprachten.
Naast de Arduino-lessen kunnen de leerlingen het geheel afsluiten met een eigen gekozen project. Aan het einde zijn verschillende project ideeën geformuleerd. Hieruit kan gekozen worden of een van de aantal goede Nederlandstalige voorbeelden, die de komende tijd zeker ontworpen zullen gaan worden.
Voor de gehele module is ongeveer 12 uur nodig. De bedoeling is dat de leerlingen homogene groepjes van twee gaan formeren. Het project bestaat uit een applicatie systeem ontwerp, een concrete proto-type toepassing naar aanleiding van het ontwerp, de bijbehorende documentatie/beschrijving en een presentatie. Voor de beoordeling van het project kan gebruik gemaakt worden van het volgende beoordelingsschema. Uiterard kan ook een eigen matrix/rubriks gebruikt/gemaakt worden.
Lessen
De modules zijn gemaakt om leerlingen zelfstandig op een constructivistische manier te laten werken. Zorg dat u een aantal van de oefeningen zelf ook al eens gedaan hebt.
Als leerlingen eenmaal begrijpen dat er digitale en analoge pinnen zijn welke als input of output gedefinieerd kunnen worden om waardes naar toe te schrijven of mee uit te lezen, kunnen ze op een cognitivistische leerstyle heel veel leuke projecten uitvoeren. He is de bedoeling dat het project met twee-tallen gedaan wordt zoals eerder beschreven.
Niveau
De module is geschikt voor HAVO en VWO leerjaar 4 (voor DNS ontworpen op niveau VWO 4). Het is niet noodzakelijk dat leerlingen basis programmeer concepten al kennen. Het Arduino platform is zeker heel geschikt om basis programmeer vaardigheden aan te leren.
Talen zoals Python, Pascal, C# of C++ zijn erg geschikt als basis voor deze module, hoewel het met Visual Basic of eventueel iets als PHP ook al wel zou moeten kunnen.
Een Arduino is....
een platform bestaande uit:
- Een Atmel AVR microcontroller
- Een Arduino bordje waarmee je de chip kunt gebruiken
- Een programmeertool + taal waarmee de Arduino wat kan doen!
- Het ‘shield’ concept zodat extra functionaliteit in een handomdraai toegevoegd wordt aan de Arduino basis
Leveranciers en hardware
Een paar tips over leveranciers e.d. Ten eerste staat op arduino.cc een lijst van hardware leveranciers (ook voor Nederland). Freeduino.eu heeft kits gemaakt voor een Hogeschool en daar zijn positieve ervaringen mee.
A-blocks.org heeft handige kits om zonder solderen (of alleen éénmalig solderen) sensoren en actuatoren meerdere malen toe te kunnen passen. Bij andere kits zullen LED’s e.d. bij verkeerd gebruik soms vervangen moeten worden.
Het is ook handig om voldoende breadboard draadjes in voorraad te hebben. Deze raken in de praktijk snel op bij opdrachten zoals het verkeerslicht.
Soms is het handig als leerlingen bepaalde sensoren (bijv. voor de bumper) solderen. Dit kunt u natuurlijk ook als docent doen.
Zorg ook dat u wat tangetjes, schoevendraaiers e.d. in de klas heeft zodat leerlingen snel aan de gang kunnen.
Op Arduino.cc is de Arduino omgeving als Open Source te downloaden. Deze is op zich prima als netwerkversie te installeren. Leerlingen moeten soms wel bij de libraries map kunnen als zij bepaalde sensoren willen gebruiken of zelf de bibliotheek willen uitbreiden. Eventueel kunt u ook zelf eerst zo veel mogelijk uitbreidingen doen aan de bibliotheek en deze aan systeembeheer leveren. Arduino is overigens platform onafhankelijk en het uitpakken van de ZIP naar een USB stick is ook al voldoende om Arduino aan de praat te krijgen.
Bij de eindopdrachten
Stimuleer leerlingen in twee tallen zo veel mogelijk om zelf een eindopdracht te verzinnen. Er worden (in de eerste fase) twee eindopdrachten aangedragen:
Er zijn tal van andere toepassingen mogelijk, zo bedachten leerlingen uit de testgroep een kubus (gemaakt in een zogenaamd FabLab met Plexiglas) met een acceleratiesensor welke verandert van kleur bij het detecteren van beweging.(Tip: Google: “resistor color code calculator”)
Veel voorkomende syntax errors
Fout bij uploaden
avrdude: ser_open(): can't open device "\\.\COM6": Het systeem kan het opgegeven bestand niet vinden.
De Arduino is waarschijnlijk niet goed aangeloten op de PC. Kijk of de USB kabel is aangesloten.
Kies onder Hulpmiddelen > Poort de COM poort waar (Arduino) achter staat.
Fout bij compileren link.ino: In function 'void loop()': Blink.ino:29:1: error: expected ';' before '}' token Fout bij compileren.
Waarschijnlijk is dit de meest voorkomende syntax fout, de vergeten puntkomma na een functie.
Er staat bij in de hoeveelste regel van de code (hier29).
NVON.tk/fun-electro voor lespakk1etten en cursussen
NVON.tk/beta-steun cursus en DOT over de Arduino ban Betasteunpunt Zuid-Holland
NVON.tk/verdiep Cursussen beginners en gevorderen van de Verdiep (Be).
NVON.tk/ardui-forum forum voor als je er niet uit komt.
Beoordelingsmodel
Voor de praktisch opdracht kan het volgende model gebruikt worden.
De beoordeling ( kan gebeuren) gebeurt op basis van een groot aantal punten, die hierna vermeld worden. Zij wordt mede bepaald door de vorm van je toepassing/ applicatie. Onder elk punt worden een aantal criteria vermeld, waarop (indien van toepassing) de beoordeling voornamelijk gebaseerd is. Achter elk beoordelingscriterium is tussen haakjes de bijbehorende mogelijke score vermeld. De score wordt per onderdeel vermeld en levert een maximale totaalscore van 100 op. Het cijfer wordt berekend door het totaal aantal behaalde punten te delen door 10.
Het niet op tijd inleveren van onderdelen, zoals aangegeven een vooraf afgesproken het tijdpad, betekent per te laat ingeleverd onderdeel 5 punten in mindering op het totaal van 100 punten.
Beoordelingssysteem
Keuze applicatie (1-3)
Hoort de applicatie bij het thema?
Past de applicatie bij de gekozen vakken ?
Duidelijkheid
Uitvoerbaarheid
Deelactiviteiten
Geeft het antwoord op de onderzoeksvraag ?
Tijdsplanning
Maken van afspraken met docent en TOA
Veiligheid
Verzamelde gegevens (informatiebronnen) (1-5)
Voldoende
Variatie
Relevant
Betrouwbaar
Mate van zelfstandigheid (1-7)
Bij het verzamelen van gegevens
Bij keuze van de applicatie
Bij opstellen van het systeem ontwerp
Bij problemen oplossen
Bij nemen van (juiste) beslissingen
Bij meedenken
Creativiteit, inventiviteit
Kwaliteit van het logboek(1-5)
Soort informatie
Overzichtelijkheid
Uitvoering van het systeem ontwerp (in relatie met plan van aanpak) (1-8)
Tijdsplanning
Afwijken van aanpak
Veiligheid
Gegevens(verwerking)(1-8)
Voldoende relevante informatie/waarnemingen/metingen
Leesbaarheid
Relatie met theorie
Kwaliteit
Afwerking (1-5)
Op basis gegevens
complexiteit
Mate van zelfstandigheid(1-8)
Bij het verwerken van de gegevens
Bij opstellen conclusie
Bij het oplossen van problemen
Bij het nemen van (juiste) beslissingen
Bij meedenken
Creativitet, inventiviteit
Evt. functioneren in de groep
Inzet(1-8)
Werkverdeling onder de team leden
Betrokkenheid van de team leden
Logboek(1-5)
Soort informatie
Overzichtelijkheid
Volledigheid
Inhoudelijke keuzes en motivering
Diepgang
Bronvermelding(1-4)
Aanwezig
Notatie
Presentatie(1-3)
Educatie gehalte
Creativiteit
Detailering
Structuur / Opbouw (1-4)
Introductie / inleiding
Logische vervolg van presentatie
Afsluiting / afronding
Vormgeving (1-3)
Duur van de presentatie
Consistentie van het verhaal
Gebruik van audiovisuele middelen
Taalgebruik (1-4)
Correct Nederlands
Gericht op doelgroep
Woordenschat
Creativiteit
Stemgebruik (1-3)
Verstaanbaarheid
Stemgebruik / intonatie / muziek
Vlotheid van de spreker
Het arrangement Kennismaken met de Arduino is gemaakt met
Wikiwijs van
Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt,
maakt en deelt.
Auteurs
Hans Kolk
Je moet eerst inloggen om feedback aan de auteur te kunnen geven.
Laatst gewijzigd
2015-06-24 13:48:39
Licentie
Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 3.0 Nederlands licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:
het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
voor alle doeleinden, inclusief commerciële doeleinden.
Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:
Toelichting
Deze opdracht volgt uit de evaluatie van het NLT-thema ‘meten en
regelen’. In dit thema hebben de leerlingen van 5VWO de arduino
toegepast bij een zelfgebouwde klimaatkamer. In de evaluatie geven de
leerlingen aan dat zij enorm geholpen zouden zijn (te beginnen in het
2
de
semester van klas 4) met een overzichtelijk, beknopt, lesprogramma
over de arduino, eenvoudig programmeren in C+, en enkele duidelijke
toepassingen met uitwerkingen. Zij willen hun ervaringen dan ook graag
delen met de ESoE-studenten en het project ook verder ondersteunen.
Eindgebruiker
leerling/student
Moeilijkheidsgraad
gemiddeld
Kennismaken met de Arduino
nl
Hans Kolk
2015-06-24 13:48:39
Deze opdracht volgt uit de evaluatie van het NLT-thema ‘meten en
regelen’. In dit thema hebben de leerlingen van 5VWO de arduino
toegepast bij een zelfgebouwde klimaatkamer. In de evaluatie geven de
leerlingen aan dat zij enorm geholpen zouden zijn (te beginnen in het
2
de
semester van klas 4) met een overzichtelijk, beknopt, lesprogramma
over de arduino, eenvoudig programmeren in C+, en enkele duidelijke
toepassingen met uitwerkingen. Zij willen hun ervaringen dan ook graag
delen met de ESoE-studenten en het project ook verder ondersteunen.
Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten
terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI
koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI
koppeling aan te gaan.
Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.
Arrangement
Oefeningen en toetsen
De code leren kennen
LED-lampjes toevoegen
Deurbel
IMSCC package
Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.
Oefeningen en toetsen van dit arrangement kun je ook downloaden als QTI. Dit bestaat uit een ZIP bestand dat
alle
informatie bevat over de specifieke oefening of toets; volgorde van de vragen, afbeeldingen, te behalen
punten,
etc. Omgevingen met een QTI player kunnen QTI afspelen.
Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en
het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op
onze Developers Wiki.
