IVM corona hebben we het onderdeel embedded systems gemist, om die reden gaan we embedded systems dus de eerste periode in jullie examenjaar doen. Onderstaande opdracht is voor je PET4 cijfer!

Presentatie Schema

Als je aan het programmeren bent wil je zo af en toe iets op het scherm printen. Misschien wil je de waarde van een variabele op een specifiek moment zien? Dit is vooral handig als je een bug hebt in je programma en je wilt weten wat de waarde van een variabele is op het moment dat de bug optreedt. In Python zeg je dan iets als:

for i in range(10):
  print (i)

Maar als een programma wordt geüpload naar een Arduino, dan is het niet vanzelfsprekend dat je met een print-functie iets op het scherm van je computer krijgt. Het programma wordt immers op de Arduino uitgevoerd en niet op je computer. Nu kun je wel een LCD-scherm op je Arduino aansluiting en vervolgens daar de gewenste informatie naartoe schrijven, maar niet elke Arduino hoeft per se een LCD-scherm te hebben. En het vereist natuurlijk wel wat moeite om een LCD-scherm aan te sluiten op een Arduino. Gelukkig is hier een betere oplossing voor!

Zoals je je hopelijk hebt gerealiseerd is de communicatie tussen jouw computer en de Arduino middels de USB-verbinding. Deze verbinding gebruiken we om programma's te uploaden naar de Arduino. Deze zelfde verbinding kunnen we ook gebruiken om tekst te communiceren tussen het programma op de Arduino en een programma op je computer.

Door middel van Serial.print() kunnen we tekst van de Arduino naar je computer sturen. Er moet dan op je computer een programma draaien dat iets met deze tekst doet. Een voorbeeld hiervan is het Seriële Monitor-venster van de Arduino IDE: daarin kun je de tekst zien die de host computer van de Arduino ontvangt. Dit venster kunnen we ook gebruiken om tekst naar de Arduino te sturen: dat zullen we in een latere les behandelen.

Bij de programma's die we tot nu toe gezien hebben weten we niet wat het programma precies doet. We zien alleen het resultaat via de analoge en digitale uitvoer. In sommige gevallen We kunnen alleen zien wat het invoer/uitvoer-gedrag is, via de analoge en di

Opdracht 1

• Gebruik de hardware-opstelling van de vorige les. Gebruik ook het programma van de vorige les. (Gebruik het programma Voorbeelden->02. Digital->Button)

• Verander het programma zodat het er als volgt uitziet:

const int buttonPin = 2;      // the number of the pushbutton pin
const int ledPin =  13;       // the number of the LED pin
 
int buttonState = 0;          // variable for reading button status
 
void setup() {
  pinMode(ledPin, OUTPUT);      // initialize LED pin as output 
  pinMode(buttonPin, INPUT);    // initialize button pin as input 
  Serial.begin(9600)
}
 
void loop() {
  buttonState = digitalRead(buttonPin);   // read the button state
  Serial.println(buttonState);
  if (buttonState == HIGH) {         // pushbutton is pressed.
    digitalWrite(ledPin, HIGH);      // turn LED on    
  } 
  else {
    digitalWrite(ledPin, LOW);       // turn LED off
  }
}

• Zoals je wellicht is opgevallen hebben we in de setup-functie iets toegevoegd. Namelijk Serial.begin(9600) (9600 bit/s of ook bps).

• Ook in de loop functie hebben we iets toegevoegd om iets te schrijven naar de Seriële monitor. Namelijk Serial.println(buttonState);.

• Om de uitvoer van het programma op je computer te kunnen zien, gebruik je het Seriële Monitor venster van de Arduino IDE (menu Extra->Seriële-Monitor).

• De communicatie werkt alleen als de snelheid van de communicatie (bitsnelheid) van de Arduino en van je computer gelijk zijn. Dit stel je in door de selectieknop (rechts onder) in het Seriële Monitor venster.

• Start nu het programma op en controleer of je in de Seriele monitor continu de waarde van de knop te zien krijgt. Druk ook zo af en toe op de knop.

Opdracht 2

Verander nu het programma zodat je in de Seriële monitor alleen de tekst "Je hebt op het knopje gedrukt" te zien krijgt wanneer je op het knopje drukt.

Opmerkingen:

• Serial.print(x) stuurt x als tekst naar de computer. Als x een getal is, dat wordt dit eerst in tekst-vorm omgezet. je kunt er daarbij voor kiezen of je een decimale vorm wilt hebben, of een vorm met een ander grondgetal. Bijvoorbeeld: hexadecimaal, via Serial.print(x, HEX);.

In deze module ga je aan de slag met Arduino. Je gaat met electronica aan de slag en gaat met breadboards aan de slag om o.a. knopjes, displays, ledjes, motoren e.d. te programmeren.

Programma's

De Arduino ontwikkelomgeving download je hier

Onderwerpen die aan bod komen:

• Wat zit er op een Arduino Uno?

  • https://www.arduino.cc/ voor info en ideeen

  • Ophalen datasheet Arduino Uno, processor datasheet (Atmel ATmega328P), bespreken, alternatieven (introduceren zelf bouwen Arduino!)

• Werking breadboard

  • Toelichten van rol breadboard, prototyping, alternatieven (eiland-printjes etc)

• Gebruik verschillende analoge en digitale sensoren

  • temperatuur

  • afstand (ultrasoon)

  • tast (schakelaar/button)

  • licht

  • geluid

• Eenvoudige actuatoren zoals LED's, servo-motoren etc.

  • Ook LCD's (eventueel kant-en-klaar)

• Gebruik (externe) Libraries

  • neopixels/ledstrips

  • lcd's

• Nabouwen van gegeven opstellingen (fritzing)

  • Simulator (tinkercad)

  • Het is leuk om Fritzing, Tinkercad en zelf bouwen in dezelfde opdrachten te gebruiken, bouw een Fritzing tekening na in Tinkercad en in het echt.

• Elementair idee over de functie van een weerstand (kunnen herkennen)

  • Ook hier weer leuk om Tinkercad te gebruiken, Tinkercad geeft het duidelijk aan als een weerstand te klein is gekozen en daardoor een LED stuk gaat. In Tinkercad kun je ook een Ampere- en Volt-meter aansluiten, dat ook te gebruiken is in voorbeelden/les.

• Seriële monitor

  • als communicatiemiddel (voor waarden in van PC naar Arduino, of lees gemeten waarden af in PC)

  • voor debug doeleinden (laat een programma aan de PC doorgeven waar het is, in welke regel)

• Debuggen van een embedded systeem

  • Naast debuggen via seriële monitor kun je ook LEDs of LCD gebruiken, zelf geluid (denk aan piep-toontjes bij het opstarten van een PC!)

  • inklemmen probleem

• State diagrams

• Programmeren in C.

  • Arduino Cheat Sheet (Mark Liffition is een hele goede)

  • Arduino Language Reference (https://www.arduino.cc/reference/en/)

  • plaats van declaraties ((globale) variabelen, gebruikte libraries), setup en loop functies.

  • Getypeerde taal.

  • Gecompileerde taal versus Geїnterpreteerde taal

Planner

De eerste opdracht is "Blink". Voor een Arduino is dit wat "Hello World" is voor andere programmeeromgevingen. Dit is het eenvoudigste programma waarmee je kunt laten zien dat de hele keten werkt - van het invoeren van het programma (op de hostcomputer: je PC/laptop/Raspberry Pi), het vertalen van het programma (op de host), het laden van de code van de host naar de Arduino, tot het uitvoeren van het programma op de Arduino. In het geval van "Blink" gaat er dan een LED knipperen - een LED op het Arduino bordje, of een LED die je op het breadboard gemonteerd hebt.

Opdracht 1a. Blink - met ingebouwde LED

1. Open in de Arduino IDE het programma "Blink": Bestand->Voorbelden->01.Basic->Blink.

2. Vertaal dit op de host (knop met "vinkje"),

3. Laad het naar de Arduino (knop met ->, "upload").

Als alles goed is start het programma dan automatisch op het Arduino-bordje. Dit programma (of "sketch" in Arduino-termen) gebruikt een LED die op het bordje ingebouwd is. Deze is via een serieweerstand aangesloten op pin 13.

int led = 13;

void setup() {                
  pinMode(led, OUTPUT);   // initialize the digital pin as an output.
}

void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by (LOW level)
  delay(1000);               // wait for a second
}

Uitleg bij deze code:

1. een Arduino-programma ("sketch") bestaat uit 3 vaste onderdelen:

   1. declaraties en definities van constanten, variabele, functies

2. declaratie van de functie setup: deze functie wordt bij een reset van de Arduino één keer uitgevoerd, vóór de uitvoering van de loop.

   1. deze functie gebruik je voor allerlei initialisaties; in dit voorbeeld, om pin 13 te initialiseren als uitvoer-pin. Een Arduino-pin kun je meestal op meerdere manieren gebruiken (de pin is "programmeerbaar"); je moet dan van tevoren aangeven hoe je die pin gebruikt.

3. declaratie van de functie loop: deze functie wordt herhaaldelijk aangeroepen (tot de volgende reset).

4. de functie-aanroep digitalWrite(led, HIGH); heeft als resultaat dat er een spanning van 5V verschijnt op pin 13.

   1. de hardware-schakeling is zo dat hiermee de LED gaat branden

5. de functie-aanroep digitalWrite(led, LOW); heeft als resultaat dat er een spanning van 0V verschijnt op pin 13.

   1. hierdoor gaat de LED uit.

Opmerking: een functie-declaratie begint met het type van het resultaat van de functie. Als de functie geen resultaat heeft, zoals in het voorbeeld van de setup en loop, dan is het resultaat void, ofwel "leeg".

Opmerking: we kunnen ook een hardware-schakeling maken zodat de LED brandt als er 0V op een pin staat, en deze uit is bij 5V.

Dit Arduino-programma werkt ook los van de "host"computer. Je sluit de Arduino dan aan op een aparte voeding (USB of batterij). Zodra de Arduino spanning krijgt, start het programma.

Variaties

1. verander in de sketch de periode waarin de LED aan en uit is - bijvoorbeeld naar 500 msec, of naar 2000 msec.

Opdracht 1b. Blink - met LED op breadboard

De volgende opdrachten zijn bedoeld om te leren werken met het breadboard. Hierop kun je je eigen schakelingen opbouwen, om te besturen vanuit de Arduino.

1. lees /Breadboard om te begrijpen hoe de verbindingen op het breadboard lopen, en hoe je de voeding aansluit.

2. zorg ervoor dat je Arduino geen spanning krijgt als je een schakeling opbouwt of verandert.

3. bouw de eenvoudige schakeling met een LED en een serieweerstand. Gebruik een serieweerstand van 220 Ohm (rood-rood-bruin (goud)). Lees /Weerstand om te begrijpen wat weerstanden zijn en waarom je ze moet gebruken.

   1. denk erom dat je de LED in de juiste richting aansluit: langste pootje en/of ronde kant: Anode, aansluiten op Arduino pin 13; de andere pin sluit je aan op de weerstand.

   2. de weerstand plaats je tussen de Kathode van de LED (kortste pootje, vlakke kant behuizing) en de GND (0V, "aarde") op het breadboard. Een weerstand is een symmetrische component: het maakt niet uit in welke richting je deze aansluit.

4. Sluit de Arduino aan op de spanning (bijv. via USB), en voer de "Blink" sketch uit.

In de bijgaande figuur zie je hoe je deze onderdelen op het breadboard kunt plaatsen en verbinden. Je krijgt een grotere versie van deze figuur door erop te klikken.

Opdracht 1c. Blink met 2 LEDs

Als volgende stap:

1. verwijder de spanning van de Arduino (USB kabel los);

2. voeg op het breadboard nog een LED toe met een serieweerstand; sluit deze aan op een andere pin, bijvoorbeeld pin 12.

3. pas je eigen versie van "Blink" zo aan dat deze LED uit is terwijl de andere aan is, en omgekeerd.

4. sluit de Arduino weer aan, en vertaal en laad deze aangepaste versie naar de Arduino.

Extra opdrachten

1. (*) bij welke periode aan en uit zie je de LED net niet meer knipperen? Waardoor komt het dat je een knipperende LED niet meer ziet knipperen?

   1. Hint: met welke frequentie wordt een televisiebeeld ververst? Wat is de snelheid van de beeldjes van een film?

   2. Zie ook: http://en.wikipedia.org/wiki/Persistence_of_vision

   3. je kunt laten zien dat de LED echt knippert door het bordje zelf (snel) heen en weer te bewegen. Wat zie je dan?

   4. Zie bijvoorbeeld: http://www.youtube.com/watch?v=2hASOre63Nk,

Een servo-motor, of kortweg servo, gebruik je voor besturing. Dit in tegenstelling tot motoren die je gebruikt voor aandrijving. Enkele voorbeelden:

• besturing van een robot,

• speelgoedauto,

• modelvliegtuig, enz.

De servo is dan verbonden aan het stuur of aan een roer. Meestal kan een servo draaien over een beperkte hoek, bijvoorbeeld 180 graden. Voor besturing is dat voldoende.

Vanuit de Arduino kunnen we de servo aansturen, zodat deze in een bepaalde stand komt. In deze opstelling voeren we de gewenste stand van de servo in met een potmeter.

Voor het aansturen van de servo maken we gebruik van de Servo-library. Het uiteindelijke programma is daardoor erg eenvoudig.

Ook het opbouwen van de hardware is eenvoudig:

• we hebben nodig: een servo-motor, een potmeter, en een breadboard met draadjes;

• de aansluitdraden van de servo zijn voorzien van een connector; daarop passen breadboard-draadjes voor aansluiting op het breadboard of op de Arduino.

• de servo heeft 3 aansluitingen: (i) GND (bruin of zwart), (ii) voeding - bijv. 5V (rood); (iii) data (oranje, geel, of wit).

  • sluit GND en 5V aan op de voedingslijnen op het breadboard.

  • sluit de data-verbinding aan op D9 van de Arduino

• sluit de potmeter aan: uiteinden aan 0V en 5V, loper aan A0 van de Arduino

Als sketch gebruik je: Bestand->Voorbeelden->Servo->Knob

Uitleg bij dit programma:

• #include Servo.h: we gebruiken de Servo library; Servo.h bevat het interface daarvoor
• de potmeter is aangesloten op A0

• de map-functie kun je gebruiken om een waarde in een ander bereik te schalen. Dit gebruik je vaak om een analoge invoerwaarde om te zetten in het bereik dat je nodig hebt voor uitvoer.

  • in dit geval willen we voor de servo een bereik van 180 graden.

• delay: de servo is een mechanische constructie: deze is veel trager dan een computer, zelfs een eenvoudige computer als een Arduino.

Zie ook:

• • hier vind je ook een schema en een figuur met draden.

• • hier vind je ook meer informatie over de werking en de aansturing van servo's.

Als de servo zich "misdraagt" kan dat liggen aan de grote stroom die de servo gebruikt als deze begint te bewegen. Hierdoor kan de spanning inzakken, waardoor de elektronica niet meer goed werkt. Dit kun je oplossen door een grote condensator (470 uF of meer) over de voedingslijnen op het breadboard te plaatsen, dicht bij de aansluiting van de servo.

• Meestal gebruik je hiervoor een elektrolytische condensator. Deze moet je wel op de juiste manier aansluiten (anders loop je het risico dat deze ontploft...): de plus en/of min-aansluiting zijn duidelijk aangegeven.

Variaties

1. Stuur de waarde van de hoek die je naar de servo stuurt, ook naar de host (seriële output)

2. (Voor gevorderden): stuur de waarde voor de hoek vanuit de host naar de Arduino (seriële input)

Vragen

1. Geef een aantal (andere) voorbeelden van toepassingen van een servo;

2. Heb je een (of meer) servo's nodig voor je droomproject?

Arduino

Een Arduino is een klein bordje met elektronica, met als belangrijkste onderdeel een microcontroller. Dit is een complete computer op een chip voor het aansturen van een apparaat. Je kunt de microcontroller op het Arduino-bordje eenvoudig programmeren via een laptop/computer. Op de Arduino kun je allerlei hardware aansluiten:

• invoerelementen ("sensoren") zoals schakelaars, temperatuursensors, infrarood-ontvangers, 3D versnellingsopnemers, enz.;

• en uitvoerelementen ("actuators") zoals lampjes, motoren, of andere apparaten.

Hiermee kun je allerlei "physical computing" toepassingen mogelijk maken, van een eenvoudig reactiespelletje tot een robot of een 3D printer.

Arduino's worden onder andere door industrieel ontwerpers gebruikt om unieke opstellingen of prototypes te maken. Op het web vind je hiervan allerlei voorbeelden, van erg eenvoudig tot spectaculair. Je kunt een Arduino ook gebruiken om meer te leren over computers, hardware, en de besturing van systemen en machines met computers ("embedded systems").

Opdrachten

• Lees het onderstaande goed door. Bekijk ook de filmpjes.

• Download en installeer de Arduino software vanaf

• Vraag je docent om een Arduino-kit

Wat kun je met een Arduino?

Hier een leuk en handig filmpje:

Hoe begin je?

• Vraag je docent om een Arduino-kit. Wees er zuinig op!

• In elke les moet je eerst een opstelling nabouwen. Het is belangrijk om klein te beginnen, en om steeds kleine stappen te nemen. Het loont de moeite om te proberen de voorbeelden te begrijpen. Als je zelf iets wilt bouwen, zul je goed moeten begrijpen wat je doet. Puur "copy & paste" werkt zelden bij software, en helemaal niet bij complexere Arduino-projecten.

• In het begin kan het werken met een Arduino wat overweldigend zijn. Je moet zowel programmeren als een hardware-opstelling maken. De software en de hardware moet ook nog precies op elkaar afgestemd zijn. En als het niet werkt, heb je vaak maak weinig houvast om uit te zoeken wat er aan de hand is.

• Een belangrijke regel is: volhouden - ook als het niet direct werkt. Door uit te zoeken waar het probleem zit, kun je ook veel leren.

Wat maakt het werken met Arduino zo bijzonder?

Op de microcontroller van de Arduino draait alleen de software die je zelf daarvoor geschreven hebt, in combinatie met een bibliotheek met ondersteunende functies. Er is geen Operating System aanwezig, er is geen filesysteem, enz. Dit betekent dat de afstand tussen je eigen programma en de hardware erg klein is, waardoor je een goed gevoel kunt krijgen voor de hardware en voor de mogelijkheden en de onmogelijkheden daarvan. Door met de Arduino te werken begrijp je ook beter hoe een computer werkt, en wat er op andere computers door het Operating System en andere software voor je gedaan wordt.

Arduino UNO, Arduino IDE

In het onderstaande gaan we uit van de Arduino Uno, als versie van het elektronica-bordje, en van versie 1.0 en hoger van de software-ontwikkelomgeving (IDE). Sommige details kunnen verschillen voor andere versies. Raadpleeg daarom altijd de officiële documentatie op de Arduino-website.

• • dit is een speciale versie van C++

Ontwikkelomgeving

De software-ontwikkelomgeving (IDE) van de Arduino werkt op een "gewone" computer (desktop, laptop), die we hier de "host" noemen. Op de host bewerk je de source files (bronbestanden) met programma's en vertaal je deze programma's in machinecode. Via een USB-kabel kun je deze machinecode "uploaden" naar je Arduino-bordje.

Begin met een ontwerpcanvas:

Kies uit een van de volgende opdrachten

Geheugenspel

Je hebt vier led-lampjes van verschillende kleuren en vier drukknopjes. Het programma kiest een willekeurige volgorde van lampjes die moeten branden. Die volgorde moet de speler onthouden. Vervolgens krijgt de speler de kans om dezelfde volgorde met de knopjes in te drukken.

1. Als het goed is, dan geeft het Arduino programma dat aan (wees hierin creatief, je kunt de Seriële monitor gebruiken, maar ook een LCD-display of de lampjes in een bepaalde volgorde laten branden).

2. Als het fout is, geef dan een foutmelding (wees creatief).

3. Het spel wordt steeds moeilijker door een langere reeks lampjes te laten memoriseren.

Bewegingsdetector

Maak een bewegingsdetector voor je kamer die een STOP bord laat zien zodra er iemand naar binnenkomt (met een servo motor)

Rijdende robot

We hebben Arduino-robots waarmee je lijnvolgers kan maken of andere leuke dingetjes. Doe hier een project mee.

Lichtkrant

Zorg ervoor dat via de Seriële monitor een stuk tekst ingevoerd kan worden. En laat dat stukje tekst scrollen door je LCD-scherm. Zet er ook twee knopjes bij waarmee je de richting van de tekst kunt bepalen.

Een afstandsbediening voor senioren

Access control met RFID

Beoordelingsmodel

Kies je een van deze opdrachten hierboven is de beoordeling heel simpel. Voldoet je opdracht exact aan de opdracht dan heb je een '7'. Heb je 'meer' features toegevoegd dan krijg je bonus punten. Zijn er minder funcionaliteiten dan daalt je cijfer. Heb je zelf een idee voor een project, dan spreken we samen de functionaliteiten af voor het betreffende cijfer. Succes!

De eenvoudigste vorm van invoer voor een computer is een schakelaar - bijvoorbeeld een druktoets. In deze les behandelen we het aansluiten en gebruik van druktoetsen.

Opdracht 1 - elementaire schakeling met drukknopschakelaar

1. Begin met een breadboard met daarop een LED (met serieweerstand, 220 Ohm, rood-rood-bruin) aangesloten op pin 13. Plaats op het breadboard een schakelaar (druktoets) met een "pull down weerstand" van 10kOhm (bruin-zwart-oranje), volgens bijgaande figuur. Sluit een draad van het contactpunt van de schakelaar en de "pull down" weerstand aan op pin 2 van de Arduino. Als de schakelaar gemonteerd is als op de figuur aangegeven, dan verbind je door het indrukken de punten in de linkerkolom met de punten in de rechterkolom van de schakelaar.

2. Gebruik het programma Voorbeelden->02. Digital->Button waarmee je de LED op pin 13 laat branden als de schakelaar ingedrukt is.

Opmerking: het if-statement hierboven kun je korter schrijven als:

Opdracht 2: twee knoppen: aan en uit

In de vorige opdracht moesten we de knop ingedrukt houden zolang we de LED willen laten branden. Dat is geen praktische oplossing. We gebruiken nu twee knoppen: één om de LED aan te doen, en één om deze weer uit te schakelen. (Later zullen we zien dat dit ook met één drukknopschakelaar kan).

Voeg eerst aan de schakeling op het breadboard een tweede drukknop toe, met een pull-down weerstand. Sluit deze aan op pin D3.

Vraag: wat gebeurt er als je beide knoppen tegelijk indrukt? Dit kun je controleren voor elke digitalRead een delay(200); toe te voegen.

In alle toepassingen van de Arduino speelt de interactie met de buitenwereld een grote rol. Voor interactie zijn er twee zaken nodig:

• invoer, bij de Arduino in de vorm van sensoren;

• en uitvoer, in de vorm van actuatoren.

Een sensor is eigenlijk een kunstmatige vorm van wat we in de biologie zintuigen noemen. Voorbeelden van sensoren zijn:

• druksensor

• lichtsensor

• kleurensensor

• ultrasone sensor

• temperatuursensor

• etc

Je kunt sensoren grofweg in twee categorieën onderscheiden: analoge sensoren en digitale sensoren. Maar wat is analoog en wat is digitaal? In het onderstaande kader worden deze begrippen nader toegelicht.

Veel sensoren zijn gericht op het meten van een analoge waarden; deze wordt door een zogenaamde analoog/digitaal omzetter van de Arduino omgezet in een digitale waarde. We zullen in een volgende les ook digitale sensoren zien, waar de analoog/digitaal-omzetting al deel uitmaakt van de sensor.

Opdracht 1: meten van licht met LDR

Voor dit experiment kun je de sketch Voorbeelden->0.1Basics->AnalogReadSerial gebruiken, om te kijken of de lichtsensor (LDR) werkt.

Een samenvatting van AnalogReadSerial:

Opdracht 1 LDR

Opdracht 1a. Met dit programma kun je de waarde van de analoge invoer te zien krijgen in het Seriële Monitor-venster van de IDE (denk om de bitsnelheid). Je kunt daarmee ook controleren of de LDR inderdaad reageert op licht en donker. "Donker" betekent in dit geval echt donker, bijvoorbeeld door er een zwart doosje overheen te schuiven; de hand erop leggen levert niet zo'n groot effect.

• Wat zijn de waarden die je meet voor "licht" en "donker"?

• (**) Reken uit wat de bijbehorende weerstand is.

Opdracht 1b. Een volgende stap is om met de uitgelezen waarde een LED aan te sturen. Het programma Voorbeelden->Analog->AnalogInOutSerial laat de LED feller branden als er meer licht op de LDR valt.

• Pas het programma zo aan dat de LED feller brandt als er minder licht op de LDR valt. (Een "nachtlichtschakelaar", bijvoorbeeld voor een fietslamp.)

AnalogInOutSerial

Opdracht 2: meten van temperatuur

De temperatuursensor LM35DZ geeft direct een spanning af. Deze spanning kun je meten met een analoge ingang van de Arduino. De relatie tussen de spanning U (in V) en de temperatuur is: T = U * 100 (C). Met andere woorden: de spanning 0V komt overeen met 0 graad Celcius; elke 10mV hoger komt overeen met een graad hoger.

De variant LM35DZ werkt van 0 graad C tot 100 graad C, met 10mV per graad Celcius; andere varianten werken ook voor negatieve temperaturen, en/of in graden Fahrenheit.De precisie bedraagt bij kamertemperatuur ongeveer +/- 0,25C.

Opdracht a. Test eerst de temperatuursensor met het programma AnalogSerial (analoge invoer naar Seriële Monitor). Controleer of de temperatuur verandert als je de sensor vastpakt, of als je erop blaast. Klopt de aanwijzing van de temperatuur met je verwachtingen?

Het genoemde programma heeft voor het meten van de temperatuur twee tekortkomingen:

1. het programma geeft een digitale waarde, niet een temperatuur.

2. de maximale spanning van de sensor (1V, voor 100'C) is veel minder dan de maximale spanning van de analoog-digitaal-omzetter (in dit geval: 5V). Je gebruikt niet het volledige bereik van de A/D-omzetter, en dus niet de volledige precisie van de A/D-omzetter.

Opdracht b. Verander het programma zo dat de temperatuur afgedrukt wordt, in plaats van de digitale waarde die uitgelezen wordt. Doe dit in twee stappen:

1. geef eerst de temperatuur weer als een geheel getal, in 1/10 van graden Celcius. 21,3 geeft je dan weer als 213.

2. geef de temperatuur weer als een komma-getal. Gebruik hiervoor een float!

Met een eenvoudig 16x2 character-display kun je je Arduino-schakeling voor veel toepassingen "autonoom" maken: je kunt dit dan zonder computer laten werken, terwijl je toch de nodige informatie kunt laten zien.

• Een nadeel van een display is dat je hiervoor zoveel Arduino-pinnen nodig hebt. Je kunt ook een I2C-display-aansturing gebruiken: door deze extra elektronica heb je dan maar een paar pinnen van de Arduino nodig voor het display. We hebben op school ook een paar van dit soort modules. Vraag je docent hiernaar als je liever dat gepriegel met draadjes wil ontwijken. We behandelen hier alleen de directe aansturing, zonder I2C.

Voor het aansturen van het display gebruik je een library: dit neemt je alle lastige programmeerwerk uit handen.

Opbouwen van de schakeling

Voor het aansluiten van een dergelijk display moet je veel verbindingen maken. Dit is niet moeilijk, maar wel een precies werkje.

Plaats de potmeter en sluit deze aan (loper aan display pin3; links aan 0V, rechts aan 5V).

• voor het gebruik op een breadboard heb je een klein formaat instelpotmeter nodig. Deze is bij de meeste displays meegeleverd.

NB: als het display niet lijkt te werken, kan het helpen om het contrast van het display aan te passen, via de potmeter.

Programma

Uitleg van het programma

Het eerste programma dat we voor het display gebruiken is een variant van "Hello World".

1. #include <LiquidCrystal.h> - invoegen van de definities van de display-library

2. LiquidCrystal lcd(rs, en, d4, d5, d6, d7); - maken van een LiquiCrystal (display)-object lcd, met de pinnummers van het interface

3. lcd.begin(16, 2); - geef aantal kolommen en rijen op

4. lcd.print("Hello World"); - stuur tekst naar display

5. lcd.display(); - zet display aan

6. lcd.nodisplay; - zet display uit

Voor het tonen van tekst op het display gebruik je dezelfde print-functie als voor het tonen van tekst in de seriële monitor.

Er zijn ook varianten van deze library waarmee je het display van I2C enz. kunt aansturen.

Opdracht 1

Sluit een LCD-display aan en upload de bovenstaande code naar je Arduino. Controleer of je echt Hello World op het scherm krijgt.

Opdracht 2

Sluit een LDR, temperatuur of een andere sensor aan op je Arduino. Toon de waardes van je sensor op de LCD-display. Zorg er wel voor dat ze steeds ververst worden!