arduino programmeerboek Davy Wolfs

Transcriptie

1 arduino programmeerboek - Davy Wolfs

2 arduino programmeerboek herwerkt door Davy Wolfs gebaseerd op: Arduino Programming Notebook door Brian W. Evans (2007) Arduino Programmeer Manual door A. Kompanje (2009) bijkomende informatie verkregen van: Uitgave: versie februari 2017 Dit werk valt onder de Creative Common licentie Attribution--ShareAlike 4.0 International (CC BY-SA 4.0) Een kopie van de licentie staat op:

3 inhoud opbouw 1 void setup() 1 void loop() 2 functies 2 accolades (gekrulde haakjes) 3 ; puntkomma 4 // regelcommentaar 4 /* */ blokcommentaar 4 variabelen 6 variabelen declareren 7 het bereik van een variabele 7 data types 9 byte 9 int 9 long 9 float 9 double 10 char 10 Overflow 10 arrays 10 wiskunde 12 wiskundige bewerkingen 12 samengestelde toekenning 13 vergelijkende bewerkingen 13 logische bewerkingen 14 constanten 15 true/false 15

4 input/output 15 high/low 15 controle elementen 16 if 16 if else 17 switch case 18 for 19 while 20 do while 21 digitale I/O 22 pinmode(pin, mode) 22 digitalread(pin) 22 digitalwrite(pin, waarde) 23 analoge I/O 24 analogread(pin) 24 analogwrite(pin, waarde) 24 tijd 25 delay() 25 millis() 25 seriële communicatie 26 Serial.begin(baudrate) 26 Serial.println(data) 26 Serial.read() 27 Serial.available() 27 Serial.parseInt() 27 Hulpfuncties 28 map( ) 28 min( ) 28 max( ) 28

5 constrain( ) 29

6 voorwoord Dit boek dient als een eenvoudig en makkelijk te gebruiken referentie om een Arduino (Uno) microcontrollerbordje te programmeren. Om het eenvoudig te houden werden hier en daar wat complexere begrippen en commando s weggelaten. Het resultaat is een beginnershandleiding en bijkomende informatie vindt men genoeg op het internet. We beginnen met de basis opbouw van een Sketch, de Arduino versie van een programma afgeleid van de programmeertaal C++. Daarna komen de basiselementen van de taal aanbod, geïllustreerd met voorbeelden. Mijn dank aan CVO De Verdieping, die het voor mij mogelijk maakte om het Arduino-gebeuren aan anderen te leren. Verder ook nog de cursisten die de tijd namen om alles eens na te lezen. Maar bovenal dank aan de community en de bedenkers van Arduino. Zonder de overvloed aan informatie van hun was dit zakboek niet mogelijk geweest. Het originele materiaal is terug te vinden op

7 opbouw De basis van de Arduino programmeertaal is een Sketch. Een tekstversie op het scherm dat beschrijft wat de Arduino moet gaan doen. Een Sketch wordt eerst gecompileerd naar een programma dat de Arduino microcontroller kan uitvoeren. De basis opbouw van een Sketch is vrij eenvoudig en bestaat steeds uit minstens twee delen. Deze twee delen, of beter functies, groeperen een aantal opdrachten (Engels: statements). void setup() opdrachten; void loop() opdrachten; Zowel setup() als loop() zijn verplichte functies, zonder zal een Sketch niet compileren. De setup() functie doet het voorbereidende werk. Deze functie wordt als eerste uitgevoerd, wordt slechts een keer uitgevoerd en wordt gebruikt om de pinmode en/of seriële communicatie in te stellen. De loop() functie volgt op setup() en bevat de code die de Arduino continue (in een lus) moet uitvoeren. Hier worden ingangen uitgelezen, eventueel beslissingen genomen om vervolgens de uitgangen aan te sturen. De loop() functie is de motor van de Sketch waarin al het werk gebeurt. void setup() De setup functie wordt slechts één keer uitgevoerd, namelijk wanneer de Arduino opstart (of reset). setup() wordt gebruikt om de richting (in- of uitgang) van pinnen in te stellen en/of om seriële communicatie te initialiseren. Deze functie moet in de Sketch aanwezig zijn, zelfs als er geen opdrachten in staan. opbouw 1

8 void setup() pinmode(13, OUTPUT); // maak pin 13 een uitgang void loop() Nadat de setup functie eenmaal is uitgevoerd, volgt de loop functie. De loop functie voert alle opdrachten uit in een oneindige lus (Engels: loop). Hier worden de eventuele ingangen ingelezen, beslissingen genomen om tot slot de uitgangen aan te sturen. void loop() digitalwrite(13, HIGH); // zet pin 13 aan delay(1000); // wacht 1 seconde digitalwrite(pin, LOW); // zet pin 13 uit delay(1000); // wacht 1 seconde functies Een functie is een stukje code met een naam die een groep van opdrachten bevat. Deze opdrachten worden uitgevoerd telkens de functie wordt aangeroepen. De functies void setup() en void loop() zijn reeds besproken en andere Arduino specifieke functies komen later aan bod. In een Sketch kan men ook zelf geschreven functies toevoegen om opdrachten, die steeds in dezelfde volgorde en meerdere keren in de loop() functie moeten worden uitgevoerd, te groeperen. Zo blijft de Sketch overzichtelijk en moeten eventuele wijzingen maar op één plaats in de code worden gedaan. Om een functie te kunnen gebruiken, moet je hem onderaan in de Sketch eerst declaren. type functienaam (parameters) opdrachten; opbouw 2

9 Eerst wordt het type van de functie benoemd. Dit is het type van de waarde die die functie teruggeeft zoals int voor een geheel getal (Engels: integer). Als er geen waarde wordt teruggegeven, zoals bij de functies setup() en loop(), is de functie van het type void. Na het type declareer je de naam van de functie. Tot slot volgen, tussen ronde haakjes, de parameters die je aan de functie wilt meegeven. Een voorbeeld: We lezen een analoge ingang in maar willen de waarde van de ingang (tussen 0 en 1023) herleiden tot een waarde tussen 0 en 255. Hiervoor moeten we de analoge waarde delen door 4. int delayval() int v; // maak een tijdelijke variabele 'v' v = analogread(a0); // lees de analoge ingang // A0 en plaats de waarde // in v v /= 4; // converteer van naar return v; // geef de aangepaste waarde terug Als eerste wordt een lokale variabele v gedeclareerd. Daarna lezen we de analoge ingang op pin A0 in en kennen we de waarde (tussen 0 en 1023) toe aan de variabele v. Vervolgens delen we de variabele v door 4 om een definitieve waarde tussen 0 en 255 te bekomen en kennen we de waarde opnieuw toe aan v. De opdracht v/=4; is een verkorte vorm voor v=v/4;. Tot slot gebruiken we de return opdracht om de waarde van v terug te geven aan het hoofdprogramma. accolades (gekrulde haakjes) Accolades geven het begin () en einde () aan van functies declaraties (setup() en loop()) of opdracht blokken zoals bij if en for. type functienaam (parameters) opdrachten; Iedere beginnende accolade moet altijd gesloten worden door een eindigende accolade. Het totaal aantal accolades is dus steeds een opbouw 3

10 even getal en er zijn steeds evenveel als accolades. Indien dit niet het geval is, compileert het programma niet en is het soms moeilijk te achterhalen waar er juist een accolade ontbreekt. ; puntkomma Iedere opdracht moet met een puntkomma worden afgesloten. De puntkomma wordt ook gebruik om de verschillende elementen in de for lus van elkaar de scheiden. int som = 0; // opdracht: declareer een integer // variabele som met waarde 0 for (int i = 0; i < 10; i++) // scheid de elementen som /= i; // opdracht: tel i op bij de som Als een puntkomma ontbreekt op het einde van een opdracht, compileert het programma (meestal) niet. De fout die de compiler toont staat echter niet noodzakelijk op de regel van de ontbrekende puntkomma. // regelcommentaar Regelcommentaar begint met de dubbele slash // en eindigt automatisch op het einde van de regel. De compiler negeert commentaar en commentaar neemt geen programmageheugen in beslag. // Dit is een regel met commentaar Regelcommentaar wordt vaak gebruikt achter een opdracht om bijkomende informatie te verschaffen. Dit kan een woordje uitleg van de opdracht zijn of een herinnering dat er nog iets moet aangepast worden. /* */ blokcommentaar Blokcommentaar, of commentaar over meerdere regels, zijn stukjes tekst die niet worden uitgevoerd door het programma en die uitgebreide informatie verschaffen. Blokcommentaar begint met /* en wordt afgesloten met */, waarbij het over meerdere regels kan verspreid zijn. opbouw 4

11 /* Dit is een stukje blokcommentaar dat over meerdere regels verspreid staat. Vergeet niet de blok ook terug te sluiten */ Blokcommentaar wordt gebruikt om een header te voorzien bovenaan de code met daarin uitleg over de Sketch. Blokcommentaar wordt ook gebruikt om stukjes code uit te commentariëren als men de code wilt testen of fouten opsporen. Het is perfect mogelijk om regelcommentaar te gebruiken in blokcommentaar. Een tweede blok commentaar starten in een eerste gaat echter niet. /* Blokcommentaar met //een regel regelcommentaar - dit gaat */ /* Blokcommentaar met /* nog een stukje blokcommentaar */ - werkt niet: deze en de volgende regels staan niet meer in commentaar */ Het is daarom aangeraden om in de code enkel regelcommentaar te gebruiken voor bijkomende informatie en blokcommentaar om stukken code uit te commentariëren. opbouw 5

12 variabelen Een variabele is een manier om een waarde (bv. een getal of een karakter) te bewaren voor later gebruik in het programma. Zoals de naam variabele al aangeeft, kan de waarde van een variabele regelmatig veranderen. Dit in tegenstelling tot constanten, wiens waarde nooit kan veranderen. Een variabele moet gedeclareerd worden voordat hij gebruikt kan worden. Optioneel kan je bij de declaratie ook al een waarde toekennen. De onderstaande code declareert een variabele met als naam inputwaarde met als initiële waarde 0. Daarna wordt er de waarde van de analoge input pin 2 aan toegekend. int inputwaarde = 0; // declareer een // variabele en ken // de waarde toe inputwaarde = analogread(a2); // geef de variabele // de waarde van // analoge pin 2 inputwaarde is de variabele. De eerste lijn declareert hem als type int (integer), een geheel getal. De tweede opdracht kent de waarde van analoge pin 2 toe aan de variabele. Nu kan deze waarde overal in de code gebruikt worden. Eenmaal een variabele (opnieuw) een waarde heeft gekregen, kan men testen of deze waarde voldoet aan bepaalde condities. Men kan de variabele natuurlijk ook rechtstreeks gebruiken. Onderstaand voorbeeld toont drie mogelijkheden om een variabele nuttig te gebruiken. De code test of de waarde van de variabele inputwaarde kleiner is dan 100 en indien zo, zet de waarde op 100. Daarna wordt een delay() gebruikt met deze variabele, waarbij de waarde nu 100 is. if (inputwaarde < 100) // test of kleiner dan 100 inputwaarde =100; // indien waar: zet op 100 delay(inputwaarde); // gebruik de variabele als // vertraging Variabelen krijgen best omschrijvende namen, waardoor de code leesbaarder wordt. Variabelen zoals drukknop en lichtsensor zorgen ervoor dat men beter begrijpt waarvoor de variabele dient. Variabelen variabelen 6

13 zoals var en waarde zeggen weinig of niks. Een variabele kan eender welke naam krijgen, zolang het maar geen keyword van de Arduino programmeertaal is. variabelen declareren Iedere variabele moet gedeclareerd worden voordat hij gebruikt kan worden. Declareren betekent dat we een type, zoals int, long, float, etc definiëren, een naam specifiëren en optioneel een initiële waarde toekennen. De declaratie moet (en kan) slechts een keer gebeuren in de Sketch, maar de waarde van de variabele kan eender wanneer wijzigen. Onderstaand voorbeeld declareert inputwaarde als type int, of geheel getal, en geeft hem als initiële warde nul. int inputwaarde = 0; Een variabele kan men op verschillende plaatsen in de Sketch declareren. De plaats waar men dit doet bepaald in welk deel van de Sketch de variabele gebruikt kan worden. het bereik van een variabele De scope, of bereik, van een variabele vertelt waar in de Sketch de variabele gebruikt kan worden. Variabelen worden meestal gedeclareerd: in het begin van de Sketch, voor setup(), lokaal in een functie en soms in een code blok zoals bijvoorbeeld de for() lus. De plaats waar men dit doet bepaalt in welk deel van de Sketch de variabele gebruikt kan worden. Een globale variabele is een variabele die overal gebruikt kan worden: in iedere functie en opdracht van de Sketch. Deze variabelen worden in het begin van de Sketch gedeclareerd, voor de setup() functie. Een lokale variabele is een variabele die gedeclareerd wordt in een functie (dus tussen de accolades en ). Deze variabelen zijn enkel zichtbaar en bruikbaar in de functie waarin ze gedeclareerd zijn. Hierdoor is het mogelijk dat je twee of zelfs meer variabelen hebt met dezelfde naam maar met mogelijks verschillende waarde. De enige voorwaarde is dat geen enkele van deze variabelen globaal is en dat ze elk afzonderlijk in hun eigen bereik staan. Door een variabele variabelen 7

14 lokaal te declareren, zorg je ervoor dat enkel in dat stukje code de variabele kan gebruikt worden, wat de leesbaarheid verhoogd en de kansen op fouten verkleint. Het volgend voorbeeld toont hoe je de globale en lokale variabelen kunt declareren en waar ze zichtbaar zijn. int waarde; void setup() char karakter; // waarde is zichtbaar // in iedere functie // karakter is enkel // zichtbaar in setup() void loop() for(int i=0; i<20;) // i is enkel zichtbaar // in de for loop i++; float f; // f is enkel zichtbaar in // loop(), maar niet in de // for lus variabelen 8

15 data types De data types die gebruik worden voor een variabele of constante binnen een Sketch bepalen niet enkel welke waarden we er kunnen insteken, maar ook hoeveel geheugen ze innemen. byte Een byte is een 8-bit geheel getal (zonder komma). Ze hebben een bereik van 0 tot 255. byte waarde = 180; // declareer de variabele // waarde met als type byte int Integer (of gehele getal) is het basis type zonder decimalen bij Arduino. Ze zijn 16-bit groot en hebben een bereik van tot int waarde = 1500; // declareer de variabele // waarde met als type int long Een long is een langere int en wordt ook gebruikt voor gehele getallen. Ze zijn 32-bit groot en hebben een bereik van tot long waarde = 90000; // declareer de variabele // waarde met als type long float Een float is een datatype voor rationele of komma getallen met decimalen. Ze zijn 32-bit groot en hebben een bereik van -3, tot 3, Hun bereik is veel groter dan een int, maar ze hebben hierdoor wel afrondingsfouten. Hierdoor kan men vreemde resultaten krijgen als men ze vergelijkt. Het vraagt ook meer tijd om met een float te rekenen. float waarde = 3.14; // declareer de variabele // waarde met als type float data types 9

16 double Een double is nauwkeuriger dan een float. Ze zijn 64-bit groot en hebben hetzelfde bereik als een float. De extra bits worden gebruikt om een kleinere afrondingsfout te verkrijgen. Door de verdubbeling van het aantal bits, is de rekentijd nog groter. double waarde = 6.5; // declareer de variabele // waarde met als type double char Een char is een type dat bedoeld is om karakters in op te slaan. Het type is 8-bit groot en breed genoeg om alle karakters uit de extended ASCII-tabel in op te slaan. char karakter = A ; // declareer de variabele // karakter met als type char Overflow In C en C++ kan bij de types byte, int en long een overflow optreden. Dit gebeurt zodra we maximum (of minimum) waarde van het bereik overschrijden. Bijvoorbeeld: de integer x = Vervolgens wordt hier 1 bij op geteld, x= x + 1. x zal dan niet de waarde hebben, maar er treedt een overflow op waardoor de waarde van x gelijk is aan arrays Een array (of reeks) is een verzameling van waarden met hetzelfde type die we kunnen benaderen met een indexnummer of kortweg index. We kunnen eender welke waarde uit de array bereiken door middel van de naam van de array en de index van die gewenste waarde. Een array heeft een index met als basis 0. Dit wil zeggen dat het eerste element in de array de index 0 heeft. Een array moet eerst gedeclareerd worden met de gewenste grootte voordat je hem kunt gebruiken. Eens gedeclareerd, kan je de array vullen met de gewenste waarde op de gewenste index. int mijnarray[5]; // declareer een array van // integers met 5 plaatsen mijnarray[3] = 10; // plaats 4 krijgt als waarde 10 data types 10

17 Om een waarde uit de array te bekomen, gebruik je de array naam en index om de waarde aan een variabele toe te kennen. x = mijnarray[3]; // x heeft nu als waarde 10 Optioneel kan je ook al waarden toekennen tijden de declaratie. Bij het toekennen van waarden tijdens de declaratie is het niet verplicht om de grootte op te geven: de array is even groot als het aantal toegekende waarden. int haararray[] = 1, waardea, 8, waardeb; // haararray heeft 4 plaatsen (van 0 tot 3) Arrays worden vaak gebruikt in lussen, waarbij de teller van de lus gebruikt wordt als index van de array. In het volgend voorbeeld gebruiken we een array om een LED te laten flikkeren zoals een kaars. Met behulp van een for-lus, die begint bij waarde 0, schrijven we verschillende waarde naar een PWM-uitgang waaraan de LED hangt. Hierdoor flikkert de intensiteit van de LED. const int PIN_LED = 10; // de LED hangt op een PWM // uitgang byte flikker[] = 180, 30, 255, 200, 10, 90,150, 60; // een array met 8 verschillende waarden om het // flikkeren van een kaars na te bootsen void setup() pinmode(pin_led, OUTPUT); void loop() for(int i=0, i<8; i++)// Een lus over al de // waarde van array flikker analogwrite(pin_led, flikker[i]); // zet PWM delay(200); // wacht even data types 11

18 wiskunde wiskundige bewerkingen Wiskundige bewerkingen, zoals optellen, aftrekken, vermenigvuldigen en delen geven respectievelijk de som, het verschil, het product of het quotiënt terug van 2 getallen. y = y + 3; x = x 7; i = j * 6; r = r / 5; De wiskundige bewerking gebruikt het data type van de getallen. Met andere woorden 9 delen door 4 resulteert in 2 en niet 2,25 aangezien 9 en 4 beide gehele getallen (integers) zijn. Gehele getallen hebben nu eenmaal geen decimalen. Dit betekend ook dat we een overflow kunnen krijgen als het resultaat groter is dan de maximale waarde die we aan een bepaald type kunnen toekennen. Als de twee getallen van een verschillend type zijn, wordt het grotere type gebruikt voor de bewerking. Bijvoorbeeld: als één van de getallen van het type float is en de andere van het type integer, is het resultaat ook een float. 9.0 delen door 4 resulteert dus wel in 2,25 (net zoals 9 delen door 4.0 of 9.0 delen door 4.0). Gebruik dus steeds een type dat groot genoeg is om het resultaat in te stockeren anders treedt er een overflow op. Overdimensioneer wel niet alle variabelen. Grote variabelen nemen meer plaats in het geheugen in en de berekeningen gebeuren trager. Je kan het type van een getal tijdelijk veranderen door het te casten naar een ander type. Dit doe je door het gewenste type tussen ronde haakjes vlak voor het getal te zetten. Bijvoorbeeld, (float)9 / 4; resulteert in 2.25 omdat de geheel getal 9 eventjes wordt omgezet in een kommagetal 9.0 voor de deling. wiskunde 12

19 samengestelde toekenning Een samengestelde toekenning (Engels: compound assignment), combineert een wiskundige bewerking met een variabele toekenning. Een samengestelde toekenning wordt vooral gebruikt in lussen. De meest voorkomende samengestelde toekenningen zijn: x++ // x = x + 1 x-- // x = x 1 x += y // x = x + y x -= y // x = x y x *= y // x = x * y x /= y // x = x / y Stel x = 5, dan is na x *= 3 de waarde van x gelijk aan 15, of drie keer de waarde die x had. vergelijkende bewerkingen Het vergelijken van de waarden van een variabele met de waarde van een andere variabele of constante wordt vaak gebruikt bij een ifstatement om te kijken of een bepaalde conditie waar (true) is. x == y // test of x gelijk is aan y x!= y // test of x niet gelijk is aan y x < y // test of x kleiner is dan y x > y // test of x groter is dan y x <= y // test of x kleiner of gelijk is aan y x >= y // test of x groter of gelijk is aan y Merk op dat voor data types met decimalen (float en double) de test om te zien of iets gelijk is, niet zinvol is omwille van de afrondingsfouten. Ook de vergelijkingen x <= y en x >= y herwerk je beter in de overeenkomstige alternatieve vorm y > x en y < x respectievelijk. wiskunde 13

20 logische bewerkingen Logische bewerkingen worden meestal gebruikt om twee (of meer) resultaten van vergelijkingen met elkaar te combineren. Het resultaat is opnieuw true of false. Er zijn drie logische bewerkingen, die vaak gebruikt worden bij de if-statement. Logische EN (AND) if ( x > 0 && x < 5) // waar (true) indien x groter // dan 0 en x kleiner dan 5 if ( x > 0 y > 0) // waar (true) indien x groter // dan 0 of y groter dan 0 if (!x > 0 ) // waar (true) indien x niet // groter dan 0. Er bestaat ook een alternatieve schrijfwijze, in leesbaar Engels, voor de drie logische operatoren && (and), (or) en! (not). Deze kunnen ook beruik worden in de code. if ( x > 0 and x < 5) // alternatief voor && if ( x > 0 or y > 0) // alternatief voor if ( not x > 0 ) // alternatief voor! wiskunde 14

21 constanten De Arduino programmeertaal heeft enkele voorgedefinieerde constanten. Ze worden gebruikt om de code leesbaarder te maken en hebben geen invloed op de grootte of snelheid van de Sketch. We kunnen deze constanten onderverdelen in verschillende groepen. true/false Dit zijn Booleaanse constanten die overeenkomen met een logische toestand. false is gedefinieerd als 0 terwijl true vaak als 1 wordt gedefinieerd. Eender welke waarde behalve nul komt in aanmerking voor true. if ( b == true) doeiets(); input/output Deze constanten worden gebruikt samen met de pinmode() functie en bepalen of een digitale pin een INPUT (ingang) of OUTPUT (uitgang) is. pinmode(13, OUTPUT); high/low Deze constanten definiëren de niveaus voor de in- en outputpinnen als HIGH of LOW. HIGH of hoog komt overeen met een waarde van 1, aan of een spanning van 5 volt aan de pin. LOW of laag komt overeen met een waarde van 0, uit of een spanning van 0 volt. digitalwrite(13, HIGH); // zet pin 13 aan (5V) constanten 15

22 controle elementen Soms moet er in een Sketch enkel iets uitgevoerd worden als aan bepaalde voorwaarden voldaan wordt. In andere gevallen moeten we een stukje code een aantal keer uitvoeren. Hiervoor kunnen we controle elementen gebruiken. if if vergelijkt als een bepaalde voorwaarde bereikt is en indien dit zo is, voert het de opdrachten tussen de gekrulde haakjes uit. Indien de voorwaarde niet waar is, worden de opdrachten tussen de gekrulde haakjes genegeerd. if (eenvariabele?? eenwaarde) doiets(); De variabele kan eender welk type hebben en de waarde kan een variabele of constante zijn. In onderstaand voorbeeld vergelijken we of de analogewaarde groter is dan de grenswaarde. Als de vergelijking tussen de ronde haakjes waar is, dan wordt de opdracht doiets() uitgevoerd. if (analogewaarde > grenswaarde) doiets(); Let op Een veelvoorkomende vergissing is per ongeluk = in plaats van == te gebruiken in de vergelijking. Bij if (x = 10) wordt in plaats van te testen of x gelijk is aan 10, de waarde 10 toegekend aan x. Dit is altijd waar waardoor de opdrachten tussen de gekrulde haakjes van de if altijd worden uitgevoerd. Als if (x == 10) wordt gebruikt, dan worden de opdrachten tussen de gekrulde haakjes uitgevoerd als x gelijk is aan 10. Lees = als is en == als is gelijk aan. Een andere veel voorkomende vergissing is om ; te plaatsen vlak na de ronde haakjes if (x == 10);. Dit betekend dat als x gelijk is aan 10, de lege opdracht ; wordt uitgevoerd. Hierna wordt altijd de controle elementen 16

23 opdrachten tussen de gekrulde haakjes uitgevoerd omdat deze haakjes niet meer bij de if horen. if else if else laat toe om een als-en-anders beslissing te maken. Bijvoorbeeld, als de waarde van een inputpin HIGH is, moeten we iets doen. Anders, als de waarde van de inputpin LOW is, doen we iets anders: if (inputpin == HIGH) doiets(); else doietsanders(); else kan onmiddellijk gevolgd worden door een nieuwe if test. Op deze manier kunnen we meerdere testen uitvoeren, waarbij er uiteindelijk steeds slechts één stukje code wordt uitgevoerd. if (analogewaarde < 500) doietsbijlagewaarde(); else if (analogewaarde > 1000) doietsbijhogewaarde(); else doietsbijtussenliggendewaarde(); controle elementen 17

24 switch case Net zoals if en if else, laat een switch case toe om beslissingen te maken over welk stuk code uitgevoerd moet worden afhankelijk van een bepaalde voorwaarde. In dit geval wordt de waarde van een variabele, gespecifieerd in de switch, vergeleken met de waarde die in iedere case wordt gespecifieerd. Zodra de waarde van de case overeenkomt, worden de opdrachten in deze case uitgevoerd. Via de break; -opdracht kan men een case verlaten nadat al de gewenste opdrachten werden uitgevoerd. Zonder de break; - opdracht, zullen de opdrachten van de volgende case(s) ook uitgevoerd worden totdat een break; -opdracht wordt gevonden of het einde van de switch wordt bereikt. Dit wordt falling-through genoemd, wat vrij vertaalt als verder tuimelen. Op het einde wordt vaak ook default: gebruikt als case (zonder het case ervoor.) Deze case vangt alle andere gevallen op indien er geen overeenkomende case erboven was. Het gebruik hiervan is optioneel. switch(eenvariabele) case 1: doietsindien1(); break; case 2: doietsindien2(); case 3: doietsindien2of3(); break default: doietsinalleanderegevallen(); break; //optioneel controle elementen 18

25 for De for-lus wordt gebruikt om een blok van opdrachten, omsloten met gekrulde haakjes, een exact aantal keren uit te voeren. Een teller wordt hierbij vaak gebruikt om bij te houden welke iteratie uitgevoerd wordt en wanneer de for-lus moet stoppen. Vlak na for volgen ronde haakjes met daarin drie delen, gescheiden door een puntkomma (;): for (initialisatie; voorwaarde; update) doiets(); De initialisatie wordt exact één keer uitgevoerd voor dat de lus begint. Hier initialiseren we de teller als een lokale variabele. Iedere keer voordat de lus begint met het uitvoeren van de opdrachten tussen de gekrulde haakjes, wordt de voorwaarde gecontroleerd. De voorwaarde wordt gebruikt om te kijken of de teller zijn gewenste waarde heeft bereikt. Als deze voorwaarde true is, wordt eerst de update uitgevoerd en daarna de lus. Indien de voorwaarde false is, eindigt de for-lus. De update dient om de waarde van de teller te verhogen. Het volgende voorbeeld start met een integer i op waarde 0, test dan of i kleiner is dan 20 en indien dit true is, wordt i met 1 verhoogd en worden de opdrachten tussen de gekrulde haakjes uitgevoerd. for (int i = 0; i < 20; i++) digitalwrite(13, LOW); delay(250); digitalwrite(13, HIGH); delay(250); controle elementen 19

26 while Een while-lus loopt onafgebroken oneindig door, totdat de voorwaarde tussen de ronde haakjes false wordt. Hiervoor moet de geteste variabele binnen de lus (tussen de gekrulde haakjes) ook veranderen, anders stopt de while-lus nooit. while (eenvariabele?? eenwaarde) doeiets(); Het volgende voorbeeld test of eenvariabele kleiner is dan 200 en indien dit zo is, worden de opdrachten binnen de gekrulde haakjes uitgevoerd. De while-lus blijft zich herhalen tot eenvariabele niet meer kleiner is dan 200. while (eenvariabele < 200) doiets() eenvariabele++; // verhoog de variabele met 1 Let op Een veel voorkomende vergissing is om ; te plaatsen vlak na de ronde haakjes: while (eenvariabele < 200);. Hierdoor wordt een variabele niet meer verhoogd met 1 en zal de while-lus oneindig blijven lussen. controle elementen 20

27 do while De do-while-lus werkt identiek als de while-lus, met uitzondering dat de voorwaarde op het einde getest wordt. Hierdoor zal de dowhile-lus altijd minstens één keer uitgevoerd worden. do doiets(); while (eenvariabele?? eenwaarde); In het volgend voorbeeld wordt er in de lus een sensor uitgelezen en 50 milliseconden gewacht. Zolang de uitgelezen waarde kleiner is dan 100, wordt de lus herhaald. Do x = leessensor(); // lees een sensor in x delay(50); // wacht 50 ms while (x < 100); // lus als x kleiner is dan 100 controle elementen 21

28 digitale I/O pinmode(pin, mode) pinmode() wordt in void setup() gebruikt om een pin als INPUT of als OUTPUT te configureren. pinmode(pin, OUTPUT); // stel pin in als output Standaard staan al de pinnen van een Arduino ingesteld als input pinnen. Deze moeten dus niet expliciet nog als INPUT geconfigureerd worden. Een pin die als INPUT is geconfigureerd bevindt zich in een hoog ohmige toestand, met andere woorden, deze pin heeft een zeer grote ingangsweerstand. De ingangspinnen op een Arduino hebben ook een ingebouwde weerstand die als pull-up weerstand gebruikt kan worden. De waarde van deze weerstand ligt ergens tussen de 20K en de 150K, afhankelijk van de gebruikte microcontroller. pinmode(pin, INPUT_PULLUP); Aan een pin met een interne pull-up weerstand kan men eenvoudig een schakelaar verbinden die, wanneer ingedrukt, de massa met de ingangspin verbindt. Pinnen die als OUTPUT geconfigureerd zijn, zijn laag ohmig en kunnen 40 ma stroom leveren aan andere componenten. Dit is genoeg om een LED helder te laten op lichten, maar te weinig om bijvoorbeeld een motor te laten draaien. Let op dat je geen kortsluiting maakt met een OUTPUT pin. Hierdoor kan de pin beschadigd raken. Daarom wordt er vaak een weerstand van 470R of 1K in serie geplaatst als men andere componenten met de pin verbindt. digitalread(pin) Leest de waarde van een digitale input pin, het resultaat is HIGH of LOW. De gewenste pin wordt gekozen door zijn nummer (0 13) als variabele of als constante mee te geven aan de functie. waarde = digitalread(pin); // lees de waarde van de // input pin en ken deze // toe aan waarde. digitale I/O 22

29 digitalwrite(pin, waarde) Zet de toestand van een digitale uitgangspin op de logische waarde HIGH (aan of 5V op de pin) of op de logische waarde LOW (uit of 0V op de pin). De gewenste pin wordt gekozen door zijn nummer (0 13) als variabele of als constante mee te geven aan de functie. digitalwrite(pin, HIGH); // zet pin aan In het volgend voorbeeld wordt de waarde van een drukknop, verbonden aan een digitale ingangspin, uitgelezen en gebruikt om een LED, verbonden aan een digitale uitgangspin, aan te schakelen. const int PIN_LED = 13; // LED op pin 13 const int PIN_KNOP = 7; // drukknop op pin 7 int waarde = 0; // variabele om de waarde // van de drukknop te void setup() //bewaren pinmode(pin_led, OUTPUT); // pin 13 als uitgang pinmode(pin_knop, INPUT); // pin 7 als ingang void loop() waarde = digitalread(pin_knop); // lees de waarde // van de knop digitalwrite(pin_led, waarde); // schrijf de // waarde van de // knop naar de // LED digitale I/O 23

30 analoge I/O analogread(pin) Leest de waarde van een analoge pin met een 10-bit resolutie (waarde tussen 0 en 1023). Deze functie werkt alleen bij analoge ingangspinnen (A0 A5). waarde = analogread(pin); // lees de waarde van de // input pin en ken deze // toe aan waarde. analogwrite(pin, waarde) Schrijft een pseudo-analoge waarde, gebruik makend van hardware gestuurde puls breedte modulatie (PWM), naar een uitgangspin die hier geschikt voor is (gemarkeerd met PWM of ~). Voor de Arduino UNO werkt dit op pinnen 3, 5, 6, 9, 10 en 11. De waarde die geschreven kan worden is een variabele of constante van 0 tot en met 255. analogwrite(pin, waarde); // schrijf waarde naar // analoge pin Een waarde van 0 genereert een constante 0 volt op de uitgangspin. En waarde van 255 genereert een constante 5 volt op de uitgangspin Voor waardes tussen 0 en 255 schakelt de uitgangspin snel tussen 0 en 5 volt. Hoe hoger de waarde, hoe langer de pin HIGH (5 volt) is. Bijvoorbeeld: bij een waarde van 64 is de uitganspin drie vierde van de tijd LOW en één vierde van de tijd HIGH. Bij een waarde van 128 is de uitgangspin de helft van de tijd HIGH en de helft van de tijd LOW. Bij een waarde van 192 is de uitgangspin één vierde van de tijd LOW en drie vierde van de tijd HIGH. Doordat de PWM door hardware gestuurd wordt, zal de PWM op de uitganspin blijven na een analogwrite() en dit tot de pin opnieuw wordt gebruikt voor een analogwrite(), digitalread() of digitalwrite(). opmerking: voor analogread() of analogwrite() moet de pin niet eerst als INPUT worden gedefinieerd met de pinmode() functie. Het volgend voorbeeld leest een analoge waarde van een analoge ingangspin, deelt deze waarde door 4 en zet het resultaat als PWMsignaal op een PWM pin. We moeten de waarde door 4 delen omdat analoge I/O 24

31 analogread() een waarde van 0 tot en met 1023 kan teruggeven, terwijl analogwrite() een waarde van 0 tot en met 255 verwacht. const int PIN_LED = 10; // LED met 220R weerstand // op pin 10 const int PIN_POT = A0; // potentiometer op pin A0 int waarde = 0; // variabele om de analoge // waarde op te bewaren void setup() // geen pinmode nodig void loop() waarde = analogread(pin_pot);// lees de waarde // van potentiometer waarde /= 4; // deel door 4 analogwrite(pin_led, waarde);// schrijf een PWM // signaal naar de // LED tijd delay() Pauzeert het programma voor het aantal milliseconden dat je mee geeft aan de functie. De waarde die je meegeeft kan een variabele of constante zijn, waarbij 1000 milliseconden overeenkomt met 1 seconde. delay(1000); // wacht 1 seconde millis() Deze functie geeft het aantal milliseconden sinds de Arduino is begonnen met het huidige programma uit te voeren. De waarde is een unsigned long. waarde = millis(); // aantal ms sinds start opmerking: De waarde krijgt een overflow (start terug van 0) na ongeveer 9 uren. tijd 25

32 seriële communicatie Serial.begin(baudrate) Opent een seriële poort en zet de baudrate voor seriële communicatie. Als baudrate voor seriële communicatie met een computer wordt typisch 9600 gekozen, hoewel andere snelheden ook ondersteund worden. void setup() Serial.begin(9600); // open seriële poort // zet de baudrate op 9600 opmerking: Wanneer de seriële communicatie gebruikt wordt, zijn digitale pinnen 0 (RX) en 1 (TX) niet bruikbaar voor andere doeleinde. Serial.println(data) Verstuurt data naar de seriële poort en voegt automatisch het carriage return en line feed karakter toe zodat de seriële monitor automatisch op een nieuwe regel staat. Serial.print() werkt identiek, maar zonder de automatische nieuwe regel. Serial.println("hallo"); // verstuur de tekst // "hallo" Je kan ook variabelen en constanten versturen. Serial.println() zorgt er dan voor dat de waarde omgezet wordt in de juiste karakters. opmerking: Voor variabelen van het type float en double kan je een bijkomend argument meegeven aan de functie namelijk het aantal decimalen na de komma(punt). Standaard worden er twee decimalen getoond. const float pi = Serial.println(pi); // 3.14 Serial.println(pi, 1); // 3.1 Serial.println(pi, 5); // seriële communicatie 26

33 Serial.read() Leest een byte (karakter) van de seriële poort. Indien er geen seriële data ontvangen is, geeft de functie de waarde -1 terug. char rxkar = Serial.read(); Serial.available() Geeft het aantal bytes (karakters) terug die in de leesbuffer zitten. Deze functie wordt gebruikt om te voorkomen dat we ongeldige karakters zouden lezen als er nog niks verstuurd werd. opmerking: de leesbuffer kan tot 64 bytes bevatten. Als daarna nog een byte wordt ontvangen zonder uit te lezen, wordt de eerst ontvangen byte overschreven. void setup() Serial.begin(9600); // open seriële poort // zet de baudrate op 9600 void loop() // controleer of er data ontvangen is if(serial.available() > 0) // lees een ontvangen byte char rxkar = Serial.read(); // verstuur wat je ontvangen hebt Serial.print("Ontvangen data: "); Serial.println(rxKar); Serial.parseInt() Probeert volgende seriële ontvangen bytes te lezen als een geheel getal: Beginnende karakters die geen cijfer of - teken zijn worden genegeerd. De functie stopt zodra er geen karakters meer ontvangen worden na een zeker tijd (time-out) of als het ontvangen karakter geen cijfer meer is. Indien er geen cijfers ontvangen worden gedurende de timeout periode, geeft de functie 0 terug. seriële communicatie 27

34 Hulpfuncties map( ) Herrekent een geheel getal (int, long) van een bereik naar een ander. ledpwm = map(potwaarde, 0, 1023, 0, 255); De potwaarde van 0 tot en met 1023 wordt herrekend naar een waarde van 0 tot en met 255 voor een PWM-signaal. opmerkingen: map() is niet begrensd. Als in het voorbeeld de potwaarde groter zou zijn dan 1023, dan is de berekende ledpwm groter dan 255. Indien men een variabele moet beperken, gebruik je constrain(). Als ledpwm moet dalen naarmate potwaarde groter wordt, kan men de grenzen omwisselen ledpwm = map(potwaarde, 0, 1023, 255, 0); De functie werkt met negatieve getallen, maar geen komma getallen. Het deel na de komma wordt afgekapt, er vindt met andere woorden geen afronding plaats. min( ) Berekent het minimum van twee getallen van eender welk data type en geeft het kleinste getal terug. waarde = min(waarde, 100); // waarde kan nooit // groter zijn dan 100 max( ) Berekent het maximum van twee getallen van eender welk data type en geeft het grootste getal terug. waarde = max(waarde, 20); // waarde kan nooit // kleiner zijn dan 20 Hulpfuncties 28

35 constrain( ) Begrenst een getal binnen een gekozen bereik. Ieder type van variabele wordt ondersteund. x = constrain(x, ondergrens, bovengrens); x wordt in bovenstaand voorbeeld begrensd tussen ondergrens en bovengrens. Als ondergrens x bovengrens is het resultaat x. Als x < ondergrens is het resultaat ondergrens. Als x > bovengrens is het resultaat bovengrens. // begrens de sensorwaarde tussen 10 en 150 sensorwaarde = constrain(sensorwaarde, 10, 150); Hulpfuncties 29