Het Programmeren van Lego Robots met NXC Leerlingenboek

Het Programmeren van Lego Robots met NXC Leerlingenboek 2011 - 2012

School Vak Klas Docent

: : : :

Cartesius Lyceum Informatica 5H en 5V Ron Klaver

Inhoudsopgave Het Programmeren van Lego Robots met NXC .................................. 1 Inhoudsopgave ................................................................................ 2 Inleiding .......................................................................................... 4 Robots ..................................................................................................................... 4 De programmeertaal NXC .......................................................................................... 4 Het Bricx commando centrum .................................................................................... 4 Het starten van het Bricx commando centrum ............................................................. 4

Hoofdstuk 1 ..................................................................................... 7 Het schrijven van een eerste programma .................................................................... 7 Veranderen van de snelheid ....................................................................................... 8 Samenvatting............................................................................................................ 8

Opdrachten bij hoofdstuk 1 ............................................................... 9

Hoofdstuk 2 ....................................................................................10 Een interessanter programma .................................................................................. 10 Draaien .................................................................................................................. 10 Herhalingscommando’s ............................................................................................ 11 Commentaar toevoegen ........................................................................................... 12 Variabelen en Constanten: ....................................................................................... 13 Samenvatting.......................................................................................................... 13

Opdrachten bij hoofdstuk 2 ..............................................................14

Hoofdstuk 3 ....................................................................................15 Variabelen gebruiken ............................................................................................... 15 Een spiraal maken. .................................................................................................. 15 Random (= toevals-) getallen ................................................................................... 16 Samenvatting.......................................................................................................... 17


Hoofdstuk 4 ....................................................................................20 Controlestructuren................................................................................................... 20 De if-opdracht ......................................................................................................... 20 De do-opdracht ....................................................................................................... 21 Samenvatting.......................................................................................................... 22

Opdrachten bij hoofdstuk 4 ..............................................................22 2

Hoofdstuk 5 ....................................................................................23 Sensoren ................................................................................................................ 23 Wachten op een sensor ........................................................................................... 23 Werken met een druksensor..................................................................................... 24 Lichtsensoren.......................................................................................................... 24 Geluidssensor ......................................................................................................... 25 Ultrasone sensor ..................................................................................................... 26 Samenvatting.......................................................................................................... 27


Hoofdstuk 6 ....................................................................................28 Taken en subroutines .............................................................................................. 28 Taken..................................................................................................................... 28 Subroutines ............................................................................................................ 29 Inline functies ......................................................................................................... 30 Macro’s .................................................................................................................. 32 Samenvatting.......................................................................................................... 33


Hoofdstuk 7 ....................................................................................35 Parallelle taken ....................................................................................................... 35 Een programma met fouten ..................................................................................... 35 Het stoppen en weer starten van taken ..................................................................... 36 Het gebruik van semaforen (signalen) ....................................................................... 37 Samenvatting.......................................................................................................... 38


Bijlage A .........................................................................................40 Het Het Het Het

bouwen van een Lego Mindstorms robot ............................................................. 40 aansluiten van sensoren op de NXT .................................................................... 40 verzenden van programma’s van de computer naar de robot ................................ 41 compileren van een programma ......................................................................... 41

3

Inleiding Robots Robots spreken sterk tot de verbeelding van mensen. Men denkt daarbij vaak aan science fiction films: enigszins mensachtige apparaten die regelmatig op hol slaan. De werkelijkheid is minder spectaculair. Robots worden al vele jaren in de industrie gebruikt. Ze lijken echter in de verste verte niet op mensen. In de auto-industrie doen bijv. robotarmen een aanzienlijk deel van het werk. In sommige ziekenhuizen rijden robots die medicijnen rondbrengen. Sinds enige tijd worden ook robots gemaakt als speelgoed. Eén ervan is de Lego Mindstorms Robotic Invention System. In de VS is dit ‘speelgoed’ al een groot succes geworden. Met Mindstorms kun je robots maken die een bepaald gedrag hebben. Ze kunnen rondrijden, obstakels vermijden, objecten oppakken en ergens anders weer neerzetten en, als er meerdere robots zijn, met elkaar communiceren.

De programmeertaal NXC Om een robot een bepaalde taak te laten uitvoeren, moet deze geprogrammeerd worden. De programmeertaal die hoort bij de Lego Mindstorms Robotics Invention System ziet er aantrekkelijk uit, maar is helaas nogal beperkt in zijn mogelijkheden. Gelukkig bestaat er een alternatieve programmeeromgeving in de taal NXC die speciaal geschreven is voor het programmeren van Lego robots. Deze letters staan voor “Not Exactly C”. Zoals de naam al suggereert (niet precies C) is NXC afgeleid van de (hogere programmeer-)taal C.

Het Bricx commando centrum De programmeerbare Legosteen NXT vormt de kern van het Mindstorms RIS. Om het programmeren van de robots nog makkelijker te maken, maken we gebruik van het “Bricx Command Center”. Dit is een bijzonder handig en nuttig hulpmiddel bij het schrijven van NXC programma’s; ook wordt het gebruikt voor het verzenden van programma’s naar de robot en voor het starten en stoppen van de robot. Het Bricx Command Center is te downloaden van: http://bricxcc.sourceforge.net/

Het starten van het Bricx commando centrum Bij het starten van het BCC verschijnt eerst een scherm dat controleert of de robot op de computer is aangesloten. Aangezien we voorlopig eerst programma’s gaan maken zonder daarbij de robot te gebruiken, kun je deze schermpjes negeren door op Cancel (of: Annuleren) of OK te klikken.

4

Het volgende dat je te zien krijgt is het onderstaande BCC-scherm. Het ziet eruit als een gewone tekstverwerker met de gebruikelijke menu’s en knoppen. Er zijn ook speciale menu’s voor het compileren en verzenden van programma’s naar de robot. Compileren is het omzetten van de hogere taal NXC naar machinetaal die de robot (de NXT-steen) “begrijpt”.

5

Als je later besluit met de NXT-robot te gaan werken en je programma’s naar de NXT wil verzenden, kun je via → het Bricx Command Center contact laten maken met de robot.

Als dat is gebeurd, zijn er meer knoppen en menukeuzes beschikbaar, zoals in het onderstaande scherm is te zien.

6

Hoofdstuk 1 Het schrijven van een eerste programma Bij het schrijven van de programma’s voor de robot gaan we uit van het model zoals dat is afgebeeld in bijlage A. We beginnen met een eenvoudig programma. Dit programma start de robot; laat hem gedurende 4 seconden vooruit rijden en daarna 4 seconden achteruit; vervolgens stopt de robot weer: #include "NXCDefs.h" task main() { OnFwd(OUT_B,75); OnFwd(OUT_C,75); Wait(4000); OnRev(OUT_BC,75); Wait(4000); Off(OUT_BC); } Het ziet er wellicht ingewikkeld uit, dus laten we het eens bekijken. Programma’s in NXC bestaan uit taken (tasks). Ons programma heeft slechts 1 taak, genaamd ‘main’. Ieder programma moet een taak ‘main’ hebben, want die wordt uitgevoerd door de robot. Dit komt in hoofdstuk 4 nog eens terug. Een taak (task) bestaat uit een aantal commando’s, oftewel ‘opdrachten’ (‘statements’). Om deze statements heen staan accolades { }, om aan te geven dat ze allemaal bij dezelfde task horen. Elk statement eindigt met een puntkomma (;). Dan is duidelijk waar het ene statement eindigt en het volgende begint. Een task ziet er dus in het algemeen als volgt uit: task main() { statement1; statement2; statement3; … } Ons programma heeft 6 statements. We bekijken ze één voor één: OnFwd(OUT_B,75); Dit statement vertelt de robot om output B te starten, dat wil zeggen, de motor die via output B is aangesloten op de NXT. Hij rijdt niet op de maximale snelheid (deze is in te stellen, maar dat komt later). OnFwd(OUT_C,75); Hetzelfde statement, maar nu voor het starten van motor C. Na deze 2 statements draaien beide motoren en rijdt de robot naar voren.

7

Wait(4000); Nu komt het wachten. Dit statement laat het programma 4 seconden wachten. Het argument (ook wel parameter of variabele genoemd) is het getal tussen haakjes en geeft het aantal ”tikken” weer. Elke tik duurt 1/1000 seconde. Je kunt dus zeer nauwkeurig aangeven hoe lang het programma moet wachten. Dus het programma doet 4 seconden lang niets, terwijl de robot vooruit rijdt. Een argument (of parameter/variabele) is dus een middel om informatie aan een statement door te geven. OnRev(OUT_BC,75); De robot is nu ver genoeg doorgereden en we vertellen hem om in tegengestelde richting, dus achteruit, verder te gaan. Let er op dat beide motoren in 1 statement kunnen worden gestopt (OUT_BC,75); dat was dus bij het starten hierboven ook mogelijk geweest. Wait(4000); Wederom doet het programma “niets” gedurende 4 seconden. Off(OUT_BC); Tenslotte schakelen we beide motoren uit. Als je het programma in de NXT-editor (Bricxcc) intypt, zul je ontdekken dat bepaalde gedeelten van de tekst gekleurd worden. Dit gebeurt automatisch. Alles in blauw is een commando voor de robot, of een indicatie van een motor of iets anders waar de robot mee bekend is. Het woord task is vetgedrukt omdat het een belangrijk (gereserveerd) woord is in NXC. Andere belangrijke woorden verschijnen eveneens vetgedrukt (zien we later nog). De kleuren zijn ook nog handig om fouten te ontdekken in je typewerk.

Veranderen van de snelheid De snelheid kan aangepast worden door een komma gevolgd door een getal te typen achter het commando waarmee de motor wordt aangezet. De kracht is een nummer tussen 0 (langzaamst) en 100 (snelst). Hier is een nieuwe versie van ons programma waarin de robot langzamer beweegt: #include "NXCDefs.h" task main() { OnFwd(OUT_B,15); OnFwd(OUT_C,15); Wait(4000); OnRev(OUT_BC,15); Wait(4000); Off(OUT_BC); }

Samenvatting Wat betreft programmeren hebben we een aantal belangrijke aspecten van de taal NXC geleerd. Ten eerste, dat elk programma een task heeft die main heet en die altijd uitgevoerd wordt door de robot. Ook hebben we de vier belangrijkste statements gezien: OnFwd(), OnRev(), en Off(). Tenslotte hebben we iets over het Wait() statement geleerd.

8

Opdrachten bij hoofdstuk 1 (4 pt) Opdracht 1 (2 pt): Open een nieuw bestand en type de volgende code: #include "NXCDefs.h" task main() { OnFwd(OUT_D,75); OnFwd(OUT_C,75); Wait(4000); OnRev(OUT_BC,75); Wait(4000); Of(OUT_BC); } In de code zitten twee fouten. Misschien heb je ze bij het typen al ontdekt. De NXCcompiler zal deze fouten ook ontdekken en zelf de foutieve regel selecteren. Onder aan het scherm zie je niet alleen in welke regel de fout zit, maar ook de aard van de fout. Trek je er maar niets van aan als je de foutmelding niet begrijpt. Voorlopig gaat het erom dat je leert dat de NXC-compiler fouten in een programma kan opsporen. Om de compiler de fouten te laten ontdekken, gaan we het bovenstaande programma compileren. Klik op ‘Compile’ in de menubalk of druk op functietoets F5. 1a: Welke foutmelding geeft de compiler? 1b: Beschrijf in je eigen woorden waarom de compiler deze fout niet accepteert. De compiler gaat pas verder als de fout hersteld is. Doe dit eerst en druk daarna weer op F5. 1c: Wat is de volgende foutmelding? Herstel ook deze fout voordat je aan opdracht 2 begint. Opdracht 2 (2 pt): 2a: Beschrijf wat er gebeurt als in het (gecorrigeerde) programma van opdracht 1 de opdracht Wait(4000); in regel 7 weggelaten wordt. Test daarna je “theorie” door dit programma door de robot te laten uitvoeren. In bijlage A staat hoe je een programma van de computer naar de NXT-steen kunt verzenden. Vraag hulp aan je docent als het niet lukt. 2b: Kun je nu voorspellen wat er gebeurt als je beide Wait() statements uit het bovenstaande programma weglaat?

9

Hoofdstuk 2 Een interessanter programma We gaan nu stapsgewijs een interessanter programma maken, waarbij een aantal belangrijke onderdelen van de programmeertaal NXC naar voren komt.

Draaien Je kunt de robot laten draaien door een van de twee motoren te laten stoppen of in tegengestelde richting te laten draaien. Het onderstaande programma moet de robot een stukje laten rijden en dan een bocht van 90° laten maken. #include "NXCDefs.h" task main() { OnFwd(OUT_AC,75); Wait(1000); OnFwd(OUT_C,50); Wait(450); Off(OUT_AC); } Misschien moet je een iets ander getal dan de 450 bij het tweede Wait()-commando invullen om een bocht van precies 90° te maken. Dat hangt af van het type oppervlak waarover de robot rijdt en de snelheid van de motor. Slimmer dan dit in het programma steeds te moeten veranderen is om een naam voor dit aantal te gebruiken. Dat heet dan een CONSTANTE. Het is gebruikelijk in veel programmeertalen om constanten met hoofdletters te schrijven. In NXC kun je constanten (dat zijn dus constante waarden) definiëren zoals in het volgende voorbeeldprogramma: #include "NXCDefs.h" #define MOVE_TIME #define TURN_TIME

1000 450

task main() { OnFwd(OUT_AC,75); Wait(MOVE_TIME); OnRev(OUT_C,50); Wait(TURN_TIME); Off(OUT_AC); } De eerste 2 regels, na #include "NXCDefs.h", definiëren twee constanten. Deze kunnen nu het hele programma door gebruikt worden. Het definiëren van constanten is handig om 2 redenen: het maakt het programma leesbaarder en het is makkelijker om de waarde van de constanten in een keer te veranderen; vooral in lange programma’s waarin vaak dezelfde waarde gebruikt wordt. Ook deze constanten krijgen van het Bricxcc weer een eigen kleur.

10

Herhalingscommando’s Laten we nu proberen een programma te schrijven waarbij de robot een vierkant maakt. Een vierkant maken betekent: naar voren rijden, 90°draaien, weer vooruit rijden, 90° draaien, enz. We kunnen het stuk code van hiervoor vier maal gebruiken, maar het kan eenvoudiger met een herhalingscommando: repeat #include "NXCDefs.h" #define MOVE_TIME #define TURN_TIME

1000 450

task main() { repeat(4) { OnFwd(OUT_AC,75); Wait(MOVE_TIME); OnRev(OUT_C,50); Wait(TURN_TIME); } Off(OUT_AC); } Het getal achter repeat tussen haakjes geeft aan hoe vaak iets moet worden herhaald. De commando’s die herhaald moeten worden staan, net als de commando’s in een task, altijd tussen haakjes. Let er ook op dat we in het bovenstaande programma steeds inspringen. Dit is niet verplicht, maar het staat veel netter en het maakt het programma beter leesbaar. Als laatste voorbeeld laten we de robot 10 keer een vierkant rijden. Hier is het programma: #include "NXCDefs.h" #define MOVE_TIME #define TURN_TIME

1000 450

task main() { repeat(10) { repeat(4) { OnFwd(OUT_AC,75); Wait(MOVE_TIME); OnRev(OUT_C,50); Wait(TURN_TIME); } } Off(OUT_AC); }

11

Nu staat het ene herhalingscommando in het andere. Dit heet een ‘genest’ herhalingscommando. Je kunt herhalingscommando’s zoveel als je wilt ‘nesten’. Let goed op de accolades en het inspringen in het programma. De task start bij de eerste accolade en eindigt bij de laatste. Het eerste herhalingscommando start bij de tweede accolade en eindigt bij de vijfde. Het tweede, geneste, herhalingscommando begint bij de derde accolade en eindigt bij de vierde. De accolades staan dus altijd in paren in het programma en het stuk ertussen springt in.

Commentaar toevoegen Om het programma begrijpelijker te maken, is het verstandig om af en toe commentaar toe te voegen. Als je // op een regel zet, wordt de rest van die regel door het programma genegeerd en kan hij gebruikt worden voor commentaar. Een langer commentaar kan tussen /* en */ gezet worden. Commentaar wordt cursief en zwart weergegeven in het Brixcc. Het volledige programma zou er als volgt uit kunnen zien:

#include "NXCDefs.h" /* 10 VIERKANTEN door Leo Eerling Dit programma laat de robot 10 vierkanten rijden */ #define MOVE_TIME #define TURN_TIME

1000 //Tijd voor vooruit gaan 450 //Tijd voor 90° draaien

task main() { repeat(10) { repeat(4) { OnFwd(OUT_AC,50); Wait(MOVE_TIME); OnRev(OUT_C,80); Wait(TURN_TIME); } } Off(OUT_AC); }

//Maak 10 vierkanten

// // // //

rij vooruit gedurende de MOVE_TIME rij achteruit met mtr C gedurende de TURN_TIME

//Zet de motoren uit

12

Variabelen en Constanten: In computerprogramma’s wordt heel vaak gebruik gemaakt van variabelen. Een variabele is feitelijk een plaats in het (werk)geheugen van een computer om een bepaalde waarde in op te bergen. In ons geval dus in het geheugen van de NXT. Een voorbeeld van een variabele is het getal achter het commando Wait (). Door de waarde te wijzigen wordt de tijd die het programma wacht langer of korter; daardoor wordt de afstand die de robot aflegt langer of korter of de hoek die een robot maakt bij het draaien groter of kleiner. Als een variabele met dezelfde waarde vaak voorkomt in een programma is het handiger om een constante te gebruiken. De waarde van een constante kan niet veranderd worden; vandaar de naam. In hoofdstuk 3 leer je meer over het gebruik van variabelen.

Samenvatting In dit hoofdstuk leerden we het repeat commando en het gebruik van commentaar. Ook zag je de functie van geneste accolades en van het inspringen. Met de kennis die je nu hebt, kun je de robot in allerlei richtingen laten bewegen.

13

Opdrachten bij hoofdstuk 2 (12 pt) Opdracht 1 (1 pt): Wat is er mis met het volgende programma: #include "NXCDefs.h" # MOVE_TIME # TURN_TIME

1000 450

task main() { repeat(10) { repeat(4) { OnFwd(OUT_AC,60); Wait(MOVE_TIME); OnRev(OUT_C,40); } Off(OUT_AC); } Beantwoordt deze vraag zonder gebruik te maken van de compiler. Aanwijzing: er zitten vier fouten in. Opdracht 2 (2 pt): Schrijf een programma dat de NXT robot een eindje vooruit laat rijden; dan 180° laat draaien en daarna weer terug naar het startpunt laat gaan. Opdracht 3 (2 pt): Schrijf in gewoon Nederlands een programma dat de robot drie vierkantjes van ca. 50 centimeter laat afleggen. Aanwijzing: er komt een geneste herhaling in voor. Maak een schatting voor de tijd die nodig is om de gevraagde afstand af te leggen. De details komen in opdracht 4 aan de orde. Opdracht 4 (4 pt): Schrijf nu het programma aan de hand van het Nederlandse programma van opdracht 3. In dit programma moet je gebruik maken van constanten. Als het programma klaar is moet je het testen met de robot. Je zult ongetwijfeld wat moeten experimenteren met de waarden van de constanten om de robot de voorgeschreven afstand te laten afleggen. Opdracht 5 (3 pt): Schrijf een programma dat de robot in een cirkel van plusminus een meter doorsnee laat rijden. Een meter is ongeveer van je vingertoppen van je linkerhand tot aan je schouder van je rechterarm.

14

Hoofdstuk 3 Variabelen gebruiken Variabelen zijn in elke programmeertaal zeer belangrijk. Variabelen zijn geheugenplaatsen waarin we een waarde kunnen opslaan. We kunnen die waarde op verschillende plaatsen in een programma gebruiken en we kunnen de waarde veranderen. We gaan het bekijken aan de hand van een voorbeeld.

Een spiraal maken. Stel dat we het bovenstaande programma willen wijzigen, zodanig dat de robot een spiraal gaat maken. Dit kan, door de ‘wachttijd’ bij iedere beweging recht vooruit iets langer te maken. D.w.z. dat we de waarde van MOVE_TIME elke keer willen verhogen. Maar hoe kunnen we dit doen? MOVE_TIME is een constante en constanten kunnen we niet wijzigen. We hebben daarom een variabele nodig. Variabelen kunnen in NXC eenvoudig worden gedefinieerd. Je kunt er 32 van hebben en ze kunnen elk een andere naam krijgen. Hier is het programma van de spiraal:

#include "NXCDefs.h" #define TURN_TIME

450// definieer een constante

int move_time; task main() { move_time = 20; repeat(50) { OnFwd(OUT_AC,80); Wait(move_time);

// definieer een variabele

// geef de beginwaarde

// gebruik van variabele // voor wachten

OnRev(OUT_C,60); Wait(TURN_TIME);

move_time += 5;

// gebruik van constante // verhoog de variabele

} Off(OUT_AC); }

De belangrijke zaken staan in het commentaar. Eerst definiëren we een variabele via het keyword int, gevolgd door een naam die we kiezen. De naam moet met een letter beginnen, maar kan daarna ook cijfers bevatten en het onderstreepteken (_). Andere symbolen zijn niet toegestaan. ditzelfde geldt voor constanten, task namen, enz. De afkorting int staat voor integer; dit zijn gehele getallen zonder komma. Alleen deze getallen mogen hier staan.

15

In de tweede commentaarregel geven we de variabele de waarde 20. Nu volgt de herhalingslus waarin we de variabele gebruiken om de wachttijd aan te geven, en aan het einde van de lus verhogen we de waarde met 5. Zo wacht de robot eerst 20 tikken, de tweede keer 25, de derde keer 30, enz. Bij een variabele kun je naast optellen, zoals hierboven, ook vermenigvuldigen (met *=), aftrekken (met -=) en delen (met /=). (N.B. bij delen wordt de uitkomst afgerond op de dichtstbijliggende integer) Je kunt ook de ene variabele bij de andere optellen, en meer gecompliceerde expressies gebruiken. Hieronder een paar voorbeelden: int aaa, bbb, ccc; task main() { aaa = 10; bbb = 20 * 5; ccc = bbb; ccc /= aaa; ccc -= 5; aaa = 10 * (ccc + 3); }

// aaa is nu gelijk aan waarde 80

Let erop dat we op de eerste regel meerdere variabelen in één regel definiëren.

Random (= toevals-) getallen Tot nu toe hebben we de robot precies verteld wat hij doen moest. Het kan interessant zijn als de robot dingen gaat doen die wij niet van tevoren kennen. We willen wat toeval (randomness) in de acties. In NXC kun je random getallen gebruiken. Het volgende programma gebruikt deze om de robot rond te laten rijden op een random-manier. Hij rijdt steeds een bepaalde random-tijd vooruit en maakt dan een random-draai.

#include "NXCDefs.h" int move_time, turn_time; task main() { while(true) { move_time = Random(3000); turn_time = Random(1000); OnFwd(OUT_AC,50); Wait(move_time); OnRev(OUT_A,50); Wait(turn_time); } }

16

Het programma kent twee variabelen met random nummers. Random(3000); betekent een willekeurig getal tussen 0 en 3000 (maar ook 0 en 3000 zelf kunnen). Telkens zijn de getallen verschillend. Let erop dat we het gebruik van een variabele hadden kunnen vermijden door te schrijven Wait (Random(3000). Je ziet hier ook een nieuwe soort lus. Dit komt door de while(true) herhalingsopdracht. De while-opdracht herhaalt de opdrachten eronder net zo lang als de uitdrukking tussen haakjes waar is. Het woord tussen haakjes (true) is altijd waar, en dus wordt het commando tussen haakjes eindeloos herhaald. En dat is juist wat we willen. In hoofdstuk 4 komt de while-opdracht nog terug.

Samenvatting In dit hoofdstuk hebben we het gebruik van variabelen geleerd. Variabelen zijn nuttig, maar ook, door de beperkingen van de robots, begrensd in hun gebruik. Je kunt er slechts 32 definiëren en ze kunnen alleen werken met integers. Maar voor veel robottaken is dit voldoende. Ook leerde je nog om met random getallen te werken, zodat je de robot onvoorspelbaar gedrag kunt laten vertonen. Tenslotte zagen we het gebruik van de while-opdracht om een oneindige loop te maken.

17

Opdrachten bij hoofdstuk 3 (12 pt) Opdracht 1 (2 pt): Schrijf een programma dat de robot een bepaalde afstand rechtdoor laat rijden, bijv. 5 cm; laat hem vervolgens 2 seconden wachten en daarna weer verder rijden, maar nu het dubbele van de vorige afstand, dus 10 cm. Laat de robot dit vier keer doen, dus vier keer rijden afgewisseld met vier keer wachten. Aanwijzing: je moet een variabele (rij_tijd) en een constante (wacht_tijd) definiëren, waarvan de waarde van (rij_tijd) tijdens het uitvoeren van het programma steeds verdubbeld wordt.

Opdracht 2 (2 pt): Bestudeer het onderstaande programma. Teken vervolgens in je verslag in Word de weg die je denkt dat de robot volgens dit programma aflegt.

Het programma luidt als volgt:

#include “NXCDefs.h” #define RIJ_TIJD 1000 #define DRAAI_TIJD 750 int snelheid; task main() { snelheid = 50; OnFwd(OUT_AC, snelheid); Wait(RIJ_TIJD); OnRev(OUT_A, snelheid); Wait(DRAAI_TIJD); repeat(2) { OnFwd(OUT_AC, snelheid); Wait(RIJ_TIJD); OnRev(OUT_C, snelheid); Wait(DRAAI_TIJD); } OnFwd(OUT_AC, snelheid); Wait(RIJ_TIJD); OnRev(OUT_A, snelheid); Wait(RIJ_TIJD); Off(OUT_AC); }

18

Opdracht 3 (4 pt): Schrijf een programma dat de robot steeds sneller in een cirkel van ongeveer 50 cm. doorsnee laat rondrijden. De versnelling moet met behulp van een variabele geprogrammeerd worden.

Opdracht 4 (4 pt): Schrijf een programma dat de robot vooruit laat rijden, waarbij er om en om een bocht naar rechts en een bocht naar links gemaakt wordt op willekeurige momenten.

19

Hoofdstuk 4 Controlestructuren In het vorige hoofdstuk zagen we de repeat- en de while-opdracht. Deze opdrachten controleren de manier waarop andere opdrachten in het programma worden uitgevoerd. Zij heten “controlestructuren”. In dit hoofdstuk zien we er nog een aantal van.

De if-opdracht Soms wil je dat een bepaald deel van je programma alleen wordt uitgevoerd in bepaalde situaties. In dat geval wordt de if-opdracht gebruikt. Een voorbeeld. We gebruiken weer het programma van hiervoor, maar met een nieuwe draai. We willen de robot in een rechte lijn laten rijden en dan een draai naar links of naar rechts laten maken. Om dit te bereiken hebben we weer Random getallen nodig. We nemen deze tussen 0 en 1, d.w.z. het is of 0, of 1. Als het getal 0 is draait de robot naar rechts; in andere gevallen naar links. Hier is het programma:

#include "NXCDefs.h" #define MOVE_TIME #define TURN_TIME

1000 450

task main() { while(true) { OnFwd(OUT_AC,50); Wait(MOVE_TIME); if (Random(1) == 0) { OnRev(OUT_C,50); } else { OnRev(OUT_A,50); } Wait(TURN_TIME); } }

De if-opdracht lijkt wat op de while-opdracht. Als de voorwaarde tussen de haakjes waar is, dan wordt het deel tussen de accolades uitgevoerd. Zo niet, dan wordt het deel tussen de accolades achter het woord else uitgevoerd. Laten we wat beter kijken naar de gebruikte voorwaarde. Er staat Random(1) == 0. Dit betekent dat Random(1) gelijk moet zijn aan de waarde 0 om de voorwaarde waar te laten zijn. Je vraagt je misschien af waarom er == gebruikt wordt en niet alleen =. De reden is om het te onderscheiden van een opdracht die een waarde aan een variabele geeft.

20

De belangrijkste van deze symbolen staan hieronder: == < <= > >= !=

gelijk aan kleiner dan kleiner dan of gelijk aan groter dan groter dan of gelijk aan ongelijk aan

Je kunt ook samengestelde combinaties maken als &&, wat betekent ‘EN’, of ||, wat betekent ‘OF’. Hier zijn een paar voorbeelden van deze voorwaarden: true

altijd waar

false

nooit waar

ttt != 3

waar als ttt niet gelijk is aan 3

(ttt >= 5) && (ttt <= 10)

waar als ttt ligt tussen 5 en 10

(aaa = = 10) || (bbb = = 10)

waar als óf aaa óf bbb (of beide) gelijk zijn aan de waarde 10

Let erop dat de if-opdracht uit twee delen bestaat. Het deel direct na de voorwaarde, dat uitgevoerd wordt als de voorwaarde waar is, en het deel, dat uitgevoerd wordt na else, als de voorwaarde níet waar is. Het sleutelwoord else en het deel erachter is facultatief. Je kunt het dus weglaten als er niets moet gebeuren als de voorwaarde onjuist is.

De do-opdracht Een andere controlestructuur is de do-opdracht. De opdrachten tussen de accolades na do worden uitgevoerd zolang de voorwaarde waar is. De voorwaarde heeft dezelfde vorm als bij de if-opdracht hierboven besproken. Hier een voorbeeld van een programma. De robot rijdt 20 seconden random rond en stopt dan. #include “NXCDefs.h” int move_time, turn_time, total_time; task main() { total_time = 0; do { move_time = Random(1000); turn_time = Random(1000); OnFwd(OUT_AC,50); Wait(move_time); OnRev(OUT_C,50); Wait(turn_time); total_time += move_time; total_time += turn_time; } while (total_time < 20000); Off(OUT_AC); }

21

Let er in dit voorbeeld op dat we 2 opdrachten op één regel hebben gezet. Dat mag. Je mag zo veel mogelijk opdrachten op een regel zetten als je wilt (zolang er maar puntkomma’s tussen staan). Maar voor de leesbaarheid van je programma is dat niet zo’n goed idee. Let er verder op dat de do-opdracht zich bijna net zo gedraagt als de while-opdracht. Maar in de while-opdracht is de voorwaarde getest vóór uitvoering van de opdracht, terwijl in de do-opdracht de voorwaarde aan het eind wordt getest. Bij de while-opdracht wordt de opdracht wellicht nooit uitgevoerd, maar bij de do-opdracht minstens 1 keer.

Samenvatting We hebben 2 nieuwe controlestructuren leren kennen: de if-opdracht en de do-opdracht. Samen met de repeat- en de while-opdracht controleren zij de manier waarop het programma wordt uitgevoerd. We zagen ook dat we meerdere opdrachten op één regel kunnen zetten.

Opdrachten bij hoofdstuk 4 (11 pt) Opdracht 1 (1 pt): Leg uit wat het gevolg is voor het programma wanneer je in de if-opdracht van het programma aan het begin van dit hoofdstuk == vervangt door != Opdracht 2 (1 pt): Idem wanneer je == vervangt door >= Opdracht 3 (1 pt): Bij de hiervoor beschreven do-opdracht rijdt de robot maximaal 20 sec. schoksgewijs random rond. Leg uit dat berekening van het minimum of het maximum aantal keren dat de robot in deze 20 sec. vooruit rijdt niet mogelijk is. Opdracht 4 (4 pt): Wijzig het programma dat je bij opdracht 1 van hoofdstuk 3 hebt gemaakt in een programma met een do-opdracht. Als de robot vijf keer vooruit heeft gereden moet deze in één keer achteruit terugrijden naar zijn beginpositie. Opdracht 5 (4 pt): Wijzig het programma van opdracht 4 nu zo dat er een if-opdracht gebruikt wordt i.p.v. een do-opdracht.

22

Hoofdstuk 5 Sensoren Eén van de aardige aspecten van de Lego NXT-robot is dat je er sensoren op kunt aansluiten en dat je de robot op de sensoren kunt laten reageren. Voor we dat kunnen zien, moeten we de robot iets veranderen door er een sensor op aan te sluiten. Bouw daartoe het model dat in de bij de doos geleverde handleiding staat. Zie ook bijlage 1.

Verbindt de aanraaksensor met input 1 op de NXT.

Wachten op een sensor Laten we beginnen met een eenvoudig programma waarin de robot vooruit rijdt tot hij ergens tegenaan botst. Hier zie je het: #include "NXCDefs.h" task main() { SetSensorTouch(IN_1); OnFwd(OUT_AC, 70); until (SENSOR_1 == 1); Off(OUT_AC); } Er staan 2 belangrijke regels in. De eerste regel van het programma vertelt de robot welk type sensor gebruikt wordt. IN_1 is het input-nummer waaraan de sensor gekoppeld is. De andere 3 sensor-inputs zijn IN_2, IN_3 en IN_4. SetSensorTouch geeft aan dat het de

23

aanraaksensor is. Voor de lichtsensor gebruiken we SetSensorLight. Nadat het type sensor gespecificeerd is, schakelt het programma beide motoren in en begint de robot vooruit te rijden. De volgende opdracht is een bijzonder bruikbare constructie. Er wordt gewacht tot de voorwaarde tussen haken waar is. Deze voorwaarde zegt dat de waarde van de sensor IN_1 gelijk moet zijn aan de waarde 1, wat betekent dat de sensor ingedrukt wordt. Zo lang de sensor niet wordt ingedrukt, is de waarde 0. Dus deze opdracht wacht tot de sensor wordt ingedrukt. Dan schakelen we de motor uit en is de taak beëindigd.

Werken met een druksensor We gaan nu proberen de robot obstakels te laten ontwijken. Telkens als de robot een voorwerp aanraakt, laten we hem 2 seconden achteruitrijden, een draai maken van anderhalve seconde en dan weer verderrijden. Hier is het programma:

#include “NXCDefs.h” task main() { SetSensorTouch(IN_1); OnFwd(OUT_AC, 75); while (true) { if (SENSOR_1 == 1) { OnRev(OUT_AC, 75); Wait(2000); OnFwd(OUT_A, 75); Wait(1500); OnFwd(OUT_AC, 75); } } }

Net als in het vorige voorbeeld, geven we eerst het type sensor aan. Daarna begint de robot voorwaarts te bewegen. In de oneindige ‘while(true)’ loop testen we steeds of de sensor ingedrukt is en, als dat zo is, gaan we terug voor 2000 milliseconde, draaien en daarna weer vooruit.

Lichtsensoren In het MindStorms pakket zit naast een aanraaksensor ook een lichtsensor. De lichtsensor meet de hoeveelheid licht in een bepaalde richting. De lichtsensor straalt ook licht uit. Daardoor is het mogelijk de lichtsensor in een bepaalde richting te sturen en een onderscheid te maken in de intensiteit van het voorwerp in die richting. Dit is makkelijk als de robot een lijn op de grond moet volgen. Dat gaan we in het volgende voorbeeld doen. We moeten eerst de lichtsensor zo op de robot aansluiten, dat hij in met midden vooraan zit en naar beneden wijst. Verbind hem met input 2.

We hebben ook een soort ‘racebaan’ nodig die helaas niet in het pakket zit (bijv. een groot stuk papier met een zwart spoor erop). De bedoeling is nu dat de robot er voor zorgt dat de lichtsensor steeds boven het spoor blijft. Telkens als de intensiteit van het licht toeneemt, is de lichtsensor van het spoor en moeten we de richting aanpassen. Hier een

24

voorbeeld van een eenvoudig programma dat alleen werkt als we met de wijzers van de klok mee rondrijden.

#include “NXCDefs.h” #define THRESHOLD 50 task main() { SetSensorLight(IN_2); OnFwd(OUT_AC, 35); while (true) { if (Sensor(IN_2) > THRESHOLD) { OnRev(OUT_C, 35); Wait(100); until(Sensor(IN_2) <= THRESHOLD); OnFwd(OUT_AC, 35); } } }

Het programma geeft eerst aan dat sensor 2 een lichtsensor is. Daarna laat het de robot vooruit rijden en begint een oneindige ‘loop’. Telkens als de lichtwaarde groter is dan 50 (we gebruiken een constante zodat hij makkelijk kan worden aangepast, omdat het sterk van het omringende licht afhangt) stopt er 1 motor en wachten we tot we weer op het goede spoor zitten. Om een beweging langs een willekeurig gekozen pad mogelijk te maken is een veel ingewikkelder programma nodig.

Geluidssensor In de legodoos van MindStorms zitten ook een geluidssensor en een ultrasone sensor. De geluidssensor kan geluiden waarnemen en de ultrasone sensor kan afstanden meten tot een bepaald voorwerp. In het volgende programma staat een voorbeeld van hoe je de geluidssensor zou kunnen gebruiken. Dit programma laat de robot eerst stilstaan, totdat hij een geluid waarneemt. Dan rijdt de robot 1 seconde vooruit totdat een volgend geluid wordt gehoord. (De sensor is verbonden met input 3.)

#include “NXCDefs.h” #define THRESHOLD 40 #define MIC SENSOR_2 task main() { SetSensorSound(IN_2);

25

while(true) { until(MIC > THRESHOLD); OnFwd(OUT_AC, 75); Wait(1000); until(MIC > THRESHOLD); Off(OUT_AC); Wait(1000); } }

Eerst wordt een THRESHOLD constante gedefinieerd en wordt een bijnaam gegeven aan SENSOR_2. In de main task wordt gezegd dat poort 2 gegevens moet lezen van de geluidssensor en dan begint een oneindige loop. Door until te gebruiken, wacht het programma tot er een geluid van een niveau wordt waargenomen dat groter is dan de gekozen geluidsdrempel (threshold). Als de robot een luid geluid hoort, begint hij vooruit te rijden totdat hij wordt gestopt door een ander geluid. De wait opdrachten zijn noodzakelijk, omdat de robot anders zou beginnen te rijden en direct zou stoppen. De NXT is zo snel dat er geen tijd nodig is om regels tussen twee until opdrachten uit te voeren. Hetzelfde geluid waardoor de robot gaat rijden, zorgt er dus ook voor dat de robot stopt. Dit zou opgelost kunnen worden door while te gebruiken in plaats van until. while(MIC <= THRESHOLD) Verder is er niet veel meer wat je moet weten over de analoge sensors, behalve dat ze een bereik hebben van 0 tot 100.

Ultrasone sensor De ultrasone sensor werkt ongeveer als een sonar. De sensor zendt ultrasone golven uit en meet de tijd die nodig is voor de golven om teruggekaatst te worden door het voorwerp. Dit is een digitale sensor, wat betekent dat het een “embedded integrated device” is om gegevens te analyseren en te verzenden. Met deze nieuwe sensor is het mogelijk om een robot obstakels te laten zien en ze te ontwijken vóórdat hij er tegenaan rijdt. #include “NXCDefs.h” #define NEAR 25

//het aantal cm van het bereik

task main() { SetSensorLowspeed(IN_4); while(true) { OnFwd(OUT_AC, 50); while(SensorUS(IN_4) > NEAR); Off(OUT_AC); OnRev(OUT_C, 40); Wait(800); } }

26

In dit programma laat poort 4 de gegevens lezen die deze binnenkrijgt van de US sensor, maakt een oneindige loop waarin de robot vooruit rijdt, totdat hij dichterbij iets komt dan 25 cm, stopt dan, rijdt een stukje achteruit, maakt een bocht en begint weer vooruit te rijden.

Samenvatting In dit hoofdstuk hebben we het gebruik van druk-, licht-, geluids- en ultrasone sensoren gezien. We zagen ook de until opdracht, die nuttig is bij sensorgebruik. Schrijf nu zelf een aantal programma’s. Je hebt nu alle ingrediënten om de robot een ingewikkeld gedrag te laten vertonen. Zet bijvoorbeeld twee sensoren op je robot, één aan de rechter-, één een aan de linkervoorkant, en laat de robot wegrijden van obstakels die hij raakt. Probeer ook de robot binnen een gebied te houden aangegeven door een dikke zwarte ‘grens’ op de grond.

Opdrachten bij hoofdstuk 5 (2 pt) Opdracht 1 (1 pt): Je kunt een druksensor ook zo bevestigen dat hij steeds ingedrukt wordt totdat hij ergens tegen aankomt. Hoe moet je het eerste programmaatje van dit hoofdstuk dan wijzigen om de robot op dezelfde manier te laten reageren?

Opdracht 2 (1 pt): Leg precies uit wat de variabele THRESHOLD doet.

27

Hoofdstuk 6 Taken en subroutines Tot nu toe bevatten onze programma’s slechts één taak. Maar NXC-programma’s kunnen meer taken tegelijkertijd aan. Het is ook mogelijk om bepaalde delen van de code om te zetten in zogenaamde subroutines die je op verschillende plaatsen in je programma kunt gebruiken. Je programma’s worden compacter en eenvoudiger te begrijpen door het gebruik van taken en subroutines. In dit hoofdstuk zullen we de verschillende mogelijkheden bekijken.

Taken Een NXC-programma bestaat uit ten hoogste 255 taken. Elke taak heeft een naam. Een taak wordt ‘main’ genoemd en deze taak wordt uitgevoerd.. De andere taken worden slechts uitgevoerd wanneer een (andere) taak die op een bepaald moment wordt uitgevoerd vraagt om een startcommando. Vanaf dat moment worden beide taken gelijktijdig uitgevoerd. (De eerste taak blijft doorlopen). Een lopende taak kan er ook voor zorgen dat een taak wordt gestopt door middel van een stop commando. De betreffende taak kan naderhand weer herstarten, maar zal dan weer van af het begin uitgevoerd worden en niet op de plaats waar de taak werd stopgezet.. We zullen het gebruik van taken demonstreren. Zet je aanraaksensor maar weer op je robot. We gaan een programma maken waarin de robot in vierkanten gaat rijden. Als hij een obstakel raakt moet hij daarop reageren. Dit is moeilijk in één taak te realiseren, omdat de robot twee dingen tegelijkertijd moet doen: rondrijden; oftewel de motoren op het juiste moment aan en uit zetten én op de sensoren letten. Vandaar dat het beter is om hiervoor twee taken te maken: één taak voor het rijden en de andere voor het in de gaten houden van de sensoren. Hier volgt het programma:

28

#include “NXCDefs.h” mutex moveMutex; task rijden() { while (true) { Acquire(moveMutex); OnFwd(OUT_AC, 75); Wait(1000); OnRev(OUT_C, 75); Wait(500); Release(moveMutex); } } task druksensor() { while (true) { if (SENSOR_1 == 1) { Acquire(moveMutex); OnRev(OUT_AC, 75); Wait(500); OnFwd(OUT_A); Wait(500); Release(moveMutex); } } } task main() { Precedes(rijden, druksensor); SetSensorTouch(IN_1); }

De hoofdtaak geeft het sensortype aan en start dan de beide andere taken. Dan is de hoofdtaak afgelopen. De taak: ‘rijden’ zorgt ervoor dat de robot blijft rijden. De taak ‘druksensor’ controleert of de aanraaksensor wordt ingedrukt. Als dat zo is, worden de volgende handelingen verricht: eerst wordt de taak ‘rijden’ stil gezet. Dit is erg belangrijk. De taak ‘druksensor’ neemt nu het commando over de bewegingen van de robot over. Vervolgens zorgt deze taak ervoor dat de robot een stukje terug gaat en draait. Daarna laat hij de taak ‘rijden’ weer beginnen om de robot zijn stukjes vooruit te laten rijden. Het is erg belangrijk dat je beseft dat de taken die je start ook tegelijkertijd uitgevoerd worden. Dit kan onverwachte gevolgen hebben. Om deze problemen te vermijden, is er een vreemd soort variabele gebruikt, mutex, wat staat voor “mutual exclusion”. Deze variabele werkt alleen met de functies Acquire en Release.

Subroutines Soms heb je een stuk code op meer plaatsen in je programma nodig. In dat geval kun je die code in een subroutine plaatsen en een naam geven. Dan kun je deze code laten uitvoeren door gewoon de naam van de subroutine aan te roepen binnen een taak.

29

Laten we een voorbeeld bekijken.

#include “NXCDefs.h” sub turn_around(int pwr) { OnRev(OUT_C, pwr); Wait(900); OnFwd(OUT_AC, pwr); } task main() { OnFwd(OUT_AC, 75); Wait(1000); turn_around(75); Wait(2000); turn_around(75); Wait(1000); turn_around(75); Off(OUT_AC); }

In dit programma hebben we een subroutine gedefinieerd die de robot om zijn as laat draaien. De hoofdtaak roept de routine drie keer aan. Let op dat we de routine aanroepen met zijn naam, daarachter komen twee haakjes ( ). Deze schrijfwijze lijkt veel op de opdrachten die we al eerder gebruikten. Enige waarschuwingen zijn echter wel op zijn plaats. Subroutines zijn enigszins bijzonder. Je mag subroutines, bijvoorbeeld niet aanroepen vanuit een andere subroutine. Je kunt subroutines wel aanroepen vanuit verschillende taken maar ook dit wordt zeer afgeraden. Het leidt namelijk snel tot ongewenste effecten. Ook kun je, als je subroutines aanroept vanuit verschillende taken de gecompliceerde expressies misschien niet meer gebruiken. Dus, tenzij je precies weet wat je doet, een subroutine niet vanuit verschillende taken

aanroepen!

Inline functies Zoals hierboven al is aangegeven kunnen subroutines tot problemen leiden. Het voordeel van het gebruik ervan is dat ze slechts één keer worden opgeslagen in het geheugen van de NXT. Dat bespaart geheugenplaatsen en dat is nuttig omdat de NXT maar een beperkt aantal geheugenplaatsen heeft. Maar als subroutines kort zijn kun je ze beter vervangen door ‘inline functies’. Deze worden niet afzonderlijk opgeslagen maar gekopieerd naar elke plek van het geheugen waar ze gebruikt worden. Dit kost weliswaar meer geheugen maar je vermijdt er problemen mee, zoals het verlies van het gebruik van gecompliceerde expressies. Een ander voordeel is dat er geen beperking is wat het aantal inline functies betreft. Het definiëren en aanroepen van inline functies gaat op dezelfde wijze als bij subroutines. Zij gebruiken echter het sleutelwoord void in plaats van sub. (het woord void wordt gebruikt omdat het in andere talen als C ook gebruikt wordt)

30

Het bovenstaande voorbeeld ziet er nu met gebruik van inline functies als volgt uit:

#include "NXCDefs.h" inline void turn_around() { OnRev(OUT_C, 75); Wait(900); OnFwd(OUT_AC, 75); } task main() { OnFwd(OUT_AC, 75); Wait(1000); turn_around(); Wait(2000); turn_around(); Wait(1000); turn_around(); Off(OUT_AC); }

Inline functies hebben nog een ander voordeel ten opzichte van subroutines. Zij kunnen gebruikt worden met parameters. Parameters kunnen gebruikt worden om een bepaalde waarde te geven aan een variabele in een inline functie zoals in het volgende voorbeelden.

#include "NXCDefs.h" inline void turn_around(int pwr, int turntime) { OnRev(OUT_C, pwr); Wait(turntime); OnFwd(OUT_AC, pwr); } task main() { OnFwd(OUT_AC, 75); Wait(1000); turn_around(50, 2000); Wait(2000); turn_around(60, 750); Wait(1000); turn_around(40, 2500); Off(OUT_AC); } Let erop dat we de parameters tussen de haakjes () achter de naam van de inline functie specificeren. In dit geval krijgt de parameter de naam turntime en is hij van het type ‘gehele getal’ (integer). Er zijn echter ook andere mogelijkheden. Wanneer er meer parameters zijn moet je ze scheiden door middel van komma’s.

31

Macro’s Er is nog een manier om kleine stukken code een naam te geven. Je kunt in NQC NXT ook macro’s vastleggen, deze moet je echter niet verwarren met de macro’s in de RCX Bricx Command Center. We hebben gezien dat we constanten kunnen definiëren door gebruik te maken van het commando #define gevolgd door een naam. We kunnen echter elke willekeurige code zo definiëren. Hieronder volgt weer hetzelfde programma om de robot te laten draaien maar met gebruikmaking van een macro in plaats van een inline functie.

#include "NXCDefs.h" #define turn_around \ OnRev(OUT_B,75);Wait(3000);OnFwd(OUT_AB,75); task main() { OnFwd(OUT_AB,75); Wait(1000); turn_around; Wait(2000); turn_around; Wait(1000); turn_around; Off(OUT_AB); }

Na de #define opdracht staat het woord turn_around voor de tekst die erop volgt. Elke keer dat je nu turn_around typt in de tekst van je programma, wordt dat woord vervangen door de tekst die in de macro achter dat woord turn_around staat. Let op dat die tekst niet langer is dan één regel. Define-opdrachten zijn echter veel krachtiger. Zij kunnen gebruikt worden met parameters. We kunnen bijvoorbeeld de tijd om te draaien als parameter in de opdracht meegeven. Hier volgt een voorbeeld waarbij we vier macro’s definiëren: - één om naar voren te rijden, - één om naar achteren te rijden, - één om naar links te draaien - en één om naar rechts te draaien. Elk van hen heeft twee parameters: snelheid (s) en tijd (t).

32

#include "NXCDefs.h" #define turn_right(s,t) \ OnFwd(OUT_A, s);OnRev(OUT_B, s); Wait(t); #define turn_left(s,t) \ OnRev(OUT_A, s);OnFwd(OUT_B, s); Wait(t); #define forwards(s,t) \ OnFwd(OUT_AB, s); Wait(t); #define backwards(s,t) \ OnRev(OUT_AB, s); Wait(t); task main() { backwards(50,2000); forwards(50,3000); turn_left(75,750); forwards(75,1000); backwards(75,2000); forwards(75,1000); turn_right(75,750); forwards(30,2000); Off(OUT_AB); }

Het is zeer nuttig om zulke macro’s te definiëren omdat daardoor je code compacter en beter leesbaar maakt. Je kunt ook gemakkelijker je code wijzigen als je bijvoorbeeld de aansluitingen van de motoren veranderd.

Samenvatting In dit hoofdstuk hebben we het gebruik van taken, subroutines, inline functies en macro’s bekeken. Zij worden op verschillende wijze gebruikt. Taken worden naast elkaar uitgevoerd en regelen geheel verschillende zaken die tegelijkertijd plaats moeten vinden. Subroutines zijn nuttig als er grotere stukken code op verschillende plaatsen binnen één en dezelfde taak gebruikt worden. Inline functies worden gebruikt als je stukken code op verschillende plekken in verschillende taken wilt gebruiken. Zij gebruiken echter meer geheugen. Macro’s tenslotte zijn erg nuttig voor kleine stukken code die op verschillende plaatsen gebruikt moeten worden. Zij kunnen ook parameters mee krijgen. Nu je deze zes hoofdstukken hebt doorgewerkt, moet je voldoende kennis hebben om je robot gecompliceerde opdrachten te laten uitvoeren. In hoofdstuk 7 leer je zaken die slechts in een aantal gevallen van belang zijn.

33

Opdrachten bij hoofdstuk 6 (8 pt) Opdracht 1 (1 pt): Bekijk het onderstaande programma. Is je robot in staat dit programma zonder problemen uit te voeren? Beschrijf in eigen woorden je bevindingen en herschrijf eventueel het programma.

#include "NXCDefs.h" task main() { sub turn_around() { OnRev(OUT_C, 50); Wait(450); OnFwd(OUT_AC); } OnFwd(OUT_AC); Wait(1000); turn_around(); Wait(2000); turn_around(); Wait(1000); turn_around(); Off(OUT_AC); }

Opdracht 2 (2 pt): Opdracht 1 ging over subroutines. Definieer een macro waarbij de robot 2 seconden vooruit rijdt.

Opdracht 3 (2 pt): Schrijf nu een programma voor de robot waarin een inline functie wordt toegepast voor het achteruitrijden van 3 seconden.

Opdracht 4 (3 pt): Stel je werkt met twéé druksensoren; wat is hiervan het voordeel t.o.v. één druksensor? Bouw een robot met twee druksensoren en programmeer het programma zo, dat het aan deze eisen voldoet. Plak je code in je Word-verslag.

34

Hoofdstuk 7 Parallelle taken Zoals eerder is aangeduid, worden taken in de NXT-taal gelijktijdig uitgevoerd of anders gezegd parallel. Dit is buitengewoon nuttig. Het stelt je in staat om sensoren te bekijken die één taak uitvoeren, terwijl een andere taak er voor zorgt dat de robot rondrijdt en nog weer een andere taak muziek afspeelt. Maar parallelle taken kunnen ook problemen veroorzaken. De ene taak kan een andere taak storen.

Een programma met fouten Bekijk het volgende programma. Hier zorgt een taak ervoor dat de robot in vierkanten (zoals we dat al zo vaak deden) rondrijdt en een tweede taak controleert de aanraaksensor. Wanneer de sensor aangeraakt wordt, rijdt de robot een stukje achteruit en maakt een draai van 90 graden.

#include "NXCDefs.h" task check_sensors() { while (true) { if (SENSOR_1 == 1) { OnRev(OUT_AC, 75); Wait(500); OnFwd(OUT_A, 75); Wait(850); OnFwd(OUT_C, 75); } } } task submain() { while (true) { OnFwd(OUT_AC, 75); Wait(1000); OnRev(OUT_C, 75); Wait(500); } } task main() { SetSensor(IN_1,SENSOR_TOUCH); Precedes(check_sensors, submain); }

Dit ziet er waarschijnlijk uit als een perfect werkend programma. Maar als je het programma uitvoert, zul je hoogstwaarschijnlijk enkele onverwachte bewegingen

35

tegenkomen. Probeer het volgende maar: laat de robot ergens tegenaan rijden, terwijl deze draait. Hij zal terugrijden, maar meteen weer vooruit gaan rijden en opnieuw tegen het obstakel botsen. De reden hiervoor is dat de verschillende taken elkaar waarschijnlijk storen. Bekijk het volgende schouwspel. De robot draait naar rechts, op het moment dat de tweede taak in een slapende toestand verkeert. Nu raakt de robot de sensor en begint achteruit te rijden, maar precies op dat moment komt de hoofdtaak uit zijn slapende toestand en zorgt ervoor dat de robot weer vooruit rijdt. De tweede taak blijft slapende zodat deze de botsing niet waarneemt. Dit is zeer zeker niet het programma dat we graag hadden gezien. Het probleem zit ‘m in het feit, dat terwijl de tweede taak in een slapende toestand verkeert we ons niet realiseerden dat de eerste taak nog steeds actief was en op deze manier de acties van de tweede taak stoort.

Het stoppen en weer starten van taken Een manier om dit probleem op te lossen is er zeker van te zijn dat slechts één taak per keer de robot aanstuurt. Dat was de aanpak die we in Hoofdstuk 6 hanteerden. Hier staat het programma nog een keer.

#include "NXCDefs.h" mutex moveMutex; task move_square() { while (true) { Acquire(moveMutex); OnFwd(OUT_AC, 75); Wait(1000); OnRev(OUT_C, 75); Wait(850); Release(moveMutex); } } task check_sensors() { while (true) { if (SENSOR_1 == 1) { Acquire(moveMutex); OnRev(OUT_AC, 75); Wait(850); OnFwd(OUT_A, 75); Wait(1000); Release(moveMutex); } } } task main() { SetSensor(IN_1,SENSOR_TOUCH); Precedes(check_sensors, move_square); }

36

De essentie is dat de check_sensors taken de robot alleen besturen wanneer de move_square taken zijn afgehandeld. Op die manier kan deze taak het wegrijden van de robot van het obstakel niet storen. Als de back-upprocedure is beëindigd, kan de move_square taak weer opstarten. Hoewel dit een goede oplossing voor de boven geschetste situatie is, blijft er een probleem. Als we de taak move_square opnieuw starten, start deze weer vanaf het begin. Dit is leuk bij kleine taken, maar vaak is dat niet het gewenste resultaat. We zien liever dat de taak op een bepaald punt eindigt en daar ook weer begint. Helaas is dit geen gemakkelijke opgave.

Het gebruik van semaforen (signalen) Een algemene techniek om deze problemen het hoofd te bieden is een varabele te gebruiken die aangeeft welke taak de motoren controleert. De andere taken wordt niet toegestaan de motoren aan te sturen, totdat de eerste taak via een variabele aangeeft, dat hij klaar is. Zo’n variabele wordt vaak een semafoor genoemd. We gebruiken hiervoor de afkorting sem. We nemen aan dat de waarde 0 aangeeft dat er geen taak is die de motoren aanstuurt. Telkens als een taak iets met de motoren wil gaan doen, moeten voortaan onderstaande commando’s worden uitgevoerd. until (sem == 0); sem = 1; //Acquire(sem); // Do something with the motors // critical region sem = 0; //Release(sem);

Dus, eerst wachten totdat niemand de motoren nodig heeft. Dan nemen we de besturing over door sem de waarde 1 te geven. Nu kunnen we de motoren aansturen. Klaar, dan geven we sem weer de waarde 0. Hierboven vermelde programma legt de implementatie van het gebruik sem uit. Wanneer de aanraaksensoren iets voelen, wordt de semafoor aangezet (waarde 1) en de back-upprocedure uitgevoerd. Tijdens deze procedure moet de taak move_square wachten. Wanneer de back-upprocedure klaar is, wordt de semafoor uitgezet en kan de move_square taak verder uitgevoerd worden. #include "NXCDefs.h" int sem; task move_square() { while (true) { until (sem == 0); sem = 1; OnFwd(OUT_AC, 75); sem = 0; Wait(1000); until (sem == 0); sem = 1; OnRev(OUT_C, 75);

37

sem = 0; Wait(850); } } task submain() { SetSensor(IN_1, SENSOR_TOUCH); while (true) { if (SENSOR_1 == 1) { until (sem == 0); sem = 1; OnRev(OUT_AC, 75); Wait(500); OnFwd(OUT_A, 75); Wait(850); sem = 0; } } } task main() { sem = 0; Precedes(move_square, submain); }

Semaforen zijn erg nuttig, wanneer je een gecompliceerd programma met parallelle taken schrijft. Bijna altijd heb je er wel een paar nodig.

Samenvatting In dit hoofdstuk bestudeerden we enkele problemen die kunnen optreden bij het gebruik van verschillenden taken. Pas goed op voor zijdelingse effecten. Veel onverwachte zaken in het programma zijn hier aan te wijten. We hebben twee verschillende manieren om zulke problemen op te lossen bekeken. De eerste oplossing met mutex moveMutex; laat een taak stoppen en weer herstarten om er zeker van te zijn dat slechts de belangrijkste taak op een bepaald moment actief is. De tweede benadering maakt gebruikt van semaforen om de afhandeling van taken te sturen. Deze zorgt er zeker voor dat op elk moment alleen het belangrijkste deel van een taak wordt uitgevoerd.

38

Opdrachten bij hoofdstuk 7 (9 pt) Opdracht 1 (3 pt): In de onderstaande programmacode wordt een semafoor gebruikt. Geef aan wat de functie van deze semafoor is en verklaar waarom dit programma niet zal werken. Kijk evt. welke foutmelding de compiler geeft.

#include “NXCDefs.h” int sem; task main() { sem = 1; start move_square; SetSensor(IN_1, SENSOR_TOUCH); while (true) { if (SENSOR_1 == 1) { until (sem == 0); sem = 1; OnRev(OUT_AC, 70); Wait(500); OnFwd(OUT_A, 70); Wait(850); sem = 0; } } } task move_square() { while (true) { until (sem == 0); sem = 1; OnFwd(OUT_AC, 70); sem = 0; Wait(1000); until (sem == 0); sem = 1; OnRev(OUT_C); sem = 0; Wait(850); } }

Opdracht 2 (6 pt): Bouw een robot met een werkende geluidssensor en een ultrasone sensor. Programmeer ‘m zo dat de robot nooit tegen de muur of een object aanrijdt, en twee hele draaien om zijn as maakt (2 x 360° dus) als hij een, niet al te zacht, geluid waarneemt.

39

Bijlage A Het bouwen van een Lego Mindstorms robot Bij een set Lego Mindstorms Robotics Invention System zit een bouwbeschrijving, de “Construct-opedia”, voor het maken van verschillende robots. Probeer het model te bouwen uit deze handleiding. Het model ziet er als volgt uit:

Het aansluiten van sensoren op de NXT Bovenop de NXT zitten 4 gekleurde knoppen en een klein LCD scherm. Met de oranje knop zet je de robot aan of uit. Met de twee lichtgrijze kun je zoeken naar iets uit het menu. Met de oranje kun je de geselecteerde functie kiezen of laten uitvoeren. En met de donkergrijze knop kun je terug gaan naar het vorige menu. Op de NXT zitten ook zeven contacten. Drie voor de motoren A, B en C en vier voor de sensoren 1, 2, 3 en 4.

40

Het verzenden van programma’s van de computer naar de robot Om programma’s van de computer naar het geheugen van de NXT te verzenden moet deze met de USB-kabel zijn aangesloten. Controleer dit, eventueel met hulp van je docent.

De NXT moet met de USB-kabel zijn aangesloten aan de computer. De NXT moet aan staan. Als het Bricx Command Center wordt gestart, zal het automatisch de NXT zoeken. Als je het scherm hierboven ziet, klik dan op OK.

Het compileren van een programma

Nadat een programma correct is getypt in de NXT-editor klik je op de knop “Compile Program”. Als de compiler geen fouten vindt, kun je het programma verzenden naar de NXT. Klik op de knop rechts van “Compile Program”. Deze knop heet “Download Program”. Het verzenden begint dan, mits de NXT op de juiste wijze is aangesloten met de USB-kabel om het programma te ontvangen.

41

Het Programmeren van Lego Robots met NXC Leerlingenboek

Recommend Documents