Het Programmeren van Lego Robots met NXChome.kpn.nl › p.kool › resources ›...

Het Programmeren van Lego Robots met NXC

Leerlingenboek

Cartesius Lyceum 2007 - 2008, aangepast materiaal van RCX voor NXT Docent: R.klaver Leerlingen: S. Nooij, R.van Velzen en J. v/d Sluis

2

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

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

Vragen en opdrachten bij hoofdstuk 3 .......................................................................... 18 Hoofdstuk 4 ................................................................................................................ 20

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


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


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


3

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

Opdrachten bij hoofdstuk 7 .......................................................................................... 39 Bijlage A ..................................................................................................................... 40

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

4

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.

5

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”.

6

Als je later besluit met de NXT-robot te gaan werken en je programma’s naar de RCX wil verzenden, kun je via <Tools> → <find NXT> 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.

7

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 punt-komma (;). 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.

8

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 taak 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.

9

Opdrachten bij hoofdstuk 1 Opdracht 1: 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 NXC-compiler 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: 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?

10

Hoofdstuk 2

Een interessanter programma We gaan nu stapsgewijs een interessanter programma maken, waarbij een aantal belangrijke onderdelen van de programmeertaal NQC 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(850); Off(OUT_AC); }

Misschien moet je een iets ander getal dan de 850 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. 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 1000 #define TURN_TIME 850 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.

11

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 1000 #define TURN_TIME 850 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 1000 #define TURN_TIME 850 task main() { repeat(10) { repeat(4) { OnFwd(OUT_AC,75); Wait(MOVE_TIME); OnRev(OUT_C,50); Wait(TURN_TIME); } } Off(OUT_AC); }

12

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 Ron Klaver Dit programma laat de robot 10 vierkanten maken */ #define MOVE_TIME 100// Tijd voor recht vooruit #define TURN_TIME 85// tijd voor 90° draaien task main() { repeat(10) // Maak 10 vierkanten { repeat(4) { OnFwd(OUT_AC,50); Wait(MOVE_TIME); OnRev(OUT_C,80); Wait(TURN_TIME); } } Off(OUT_AC); // Zet de motoren uit }

13

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.

14

Opdrachten bij hoofdstuk 2 Opdracht 1: Wat is er mis met het volgende programma:

#include "NXCDefs.h" # MOVE_TIME 100 # TURN_TIME 85 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: Schrijf een programma dat de NXT robot een eindje vooruitlaat rijden; dan 180° laat draaien en daarna weer terug naar het startpunt laat gaan. Opdracht 3: Schrijf een PSD voor een programma dat de robot drie vierkantjes van 40 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. Laat dit PSD aan je docent zien voordat je met opdracht 4 begint. Opdracht 4: Schrijf het programma aan de hand van het PSD van opdracht 2. 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: Schrijf een programma dat de robot in een cirkel van plm. een meter doorsnee laat rijden.

15

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 85 int move_time; // definieer een variabele task main() { move_time = 20; // geef de beginwaarde repeat(50) { OnFwd(OUT_AC,80); Wait(move_time); // gebruik van variabele // voor wachten OnRev(OUT_C,60); Wait(TURN_TIME); move_time += 5; // verhoog de variabele } Off(OUT_AC); }

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

16

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 dichtstbij liggende integer) Je kunt ook de ene variabele bij de andere optellen, en meer gecompliceerde expressies gebruiken. Hieronder een paar voorbeelden:

int aaa; int bbb, ccc; task main() { aaa = 10; bbb = 20 * 5; ccc = bbb; ccc /= aaa; ccc -= 5; aaa = 10 * (ccc + 3); // aaa is now equal to 80 }

Let erop dat we op de eerste twee regels meerdere variabelen in één regel definiëren.. We hadden de drie zelfs op één regel kunnen zetten.

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 NQC NXC kun je randomgetallen 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(60); turn_time = Random(40); OnFwd(OUT_AC,50); Wait(move_time); OnRev(OUT_A,50); Wait(turn_time); } }

17

Het programma kent twee variabelen met random nummers. Random(60) betekent een willekeurig getal tussen 0 en 60 (maar ook 0 en 60 zelf kunnen). Telkens zijn de getallen verschillend. (Let erop dat we het gebruik van een variabele hadden kunnen vermijden door te schrijven Wait(Random(60)). 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.

18

Vragen en opdrachten bij hoofdstuk 3 Opdracht 1: Schrijf een programma dat de robot een bepaalde afstand rechtdoor laat rijden, b.v. 5 cm; hem vervolgens 3 seconden laat wachten en daarna weer laat rijden, maar nu het dubbele van de vorige afstand. Laat de robot dit vijf keer doen, dus vijf keer rijden afgewisseld met vijf 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: Bestudeer het onderstaande programma. Teken op een vel ruitjespapier de weg die je denkt dat de robot volgens dit programma aflegt. Het programma luidt: Voor Havo:

#include “NXCDefs.h” # define RIJ_TIJD 100 # define DRAAI_TIJD 75 task main() { OnFwd(OUT_AC,50); Wait(RIJ_TIJD); OnRev(OUT_A,50); OnFwd(OUT_AC,50); Wait(RIJ_TIJD); OnRev(OUT_C,50); OnFwd(OUT_AC,50); Wait(RIJ_TIJD); OnRev(OUT_C,50); OnFwd(OUT_AC,50); Wait(RIJ_TIJD); Off(OUT_AC,50); }

Voor VWO: #include “NXCDefs.h” # define RIJ_TIJD 100 # define DRAAI_TIJD 85

19

task main() { OnFwd(OUT_AC,50); Wait(RIJ_TIJD); OnRev(OUT_A,50); repeat(2) { OnFwd(OUT_AC,50); Wait(RIJ_TIJD); OnRev(OUT_C,50); } OnFwd(OUT_AC,50); Wait(RIJ_TIJD); Off(OUT_AC,50); } Opdracht 3: Schrijf een programma dat de robot steeds sneller in een cirkel laat rijden. De versnelling moet met behulp van (een) variabele(n) geprogrammeerd worden. Opdracht 4: Schrijf een programma dat de robot vooruit laat rijden, daarbij afwisselend een bocht naar recht en een bocht naar links makend op willekeurige momenten.

20

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 100 #define TURN_TIME 85 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 0 om de voorwaarde waar te laten zijn. Je vraagt je misschien af waarom er = = gebruikt wordt en niet =. De reden is om het te onderscheiden van een opdracht die een waarde aan een variabele geeft. De belangrijkste van deze symbolen staan hieronder:

21

= = 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 of aaa of bbb (of beide) gelijk zijn aan 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 na ‘false’, dat uitgevoerd wordt als de voorwaarde niet 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); }

22

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 punt-komma’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 Opdracht 1: Leg uit wat het gevolg is voor het programma wanneer je in de if-opdracht van hiervoor = = vervangt door != Opdracht 2: Idem wanneer je = = vervangt door >= Opdracht 3: 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: Wijzig en vul het programma dat je bij opdracht 1 van hoofdstuk 3 hebt gemaakt aan met een do-opdracht. Als de robot vijf keer vooruit heeft gereden moet deze in één keer achteruit terugrijden naar zijn uitgangspositie. Opdracht 5: Schrijf een programma met een if-opdracht, dat hetzelfde doet als de hiervoor beschreven do-opdracht. De robot rijdt 20 sec. random rond en stopt dan.

23

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

24

andere 3 sensor-inputs zijn IN_2, IN_3 en IN_4. SetSensorTouch geeft aan dat het de 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 1 moet zijn, 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 aanraaksensor We gaan nu proberen de robot obstakels te laten ontwijken. Telkens als de robot een voorwerp aanraakt, laten we hem een beetje teruggaan, een draai maken en dan verdergaan. 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(300); OnFwd(OUT_A, 75); Wait(300); 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 loop’ testen we steeds of de sensor geraakt is en, als dat zo is, gaan we terug voor 300 milliseconde 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 ‘racebaan’ nodig die 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 voorbeeld van een eenvoudig programma dat alleen werkt als we met de wijzers van de klok mee rondrijden.

25

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

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 40 (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 spoor zitten. Om een beweging langs een willekeurig gekozen pad mogelijk te maken is een veel ingewikkelder programma nodig.

Geluidssensor In de nieuwe versie van MindStorms zitten ook een ultrasone sensor en een geluidssensor. De ultrasone sensor kan afstanden meten tot een bepaald voorwerp ervoor en de geluidssensor kan geluiden waarnemen. 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 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); while(true) { until(MIC > THRESHOLD); OnFwd(OUT_AC, 75); Wait(300); until(MIC > THRESHOLD); Off(OUT_AC);

26

Wait(300); } }

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 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” 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 voordat hij er tegenaan rijdt. #include “NXCDefs.h” #define NEAR 15 //cm task main() { SetSensorLowspeed(IN_4); while(true) { OnFwd(OUT_AC, 50); while(SensorOS(IN_4)>NEAR); Off(OUT_AC); OnRev(OUT_C, 100); Wait(800); } }

In dit programma laat poort 4 de gegevens lezen die deze binnenkrijgt van de US sensor, maakt dan een oneindige loop waarin de robot vooruit gaat, totdat hij dichterbij iets komt dan 15cm, gaat dan een stuk terug en begint weer vooruit te rijden.

27

Samenvatting In dit hoofdstuk hebben we het gebruik van aanraak-, 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 Opdracht 1: Je kunt volgens de “constuctopedia” ook een tast sensor zo vast maken dat hij steeds ingedrukt wordt totdat hij ergens tegen aankomt. Hoe moet je het eerste programmaatje dan wijzigen om de robot op dezelfde manier te laten reageren? Opdracht 2: Leg uit wat de variabele THRESHOLD doet. Opdracht 3: In de samenvatting staat de suggestie om met twee aanraaksensoren te werken; wat is hiervan het voordeel? Programmeer het programma dat aan deze eisen voldoet. Opdracht 4: Bouw een robot met werkende geluidssensor en ultrasone sensor. Programmeer ‘m, als je daar zin in hebt, zo dat de robot nooit tegen de muur aanrijdt, totdat hij een geluid waarneemt.

28

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:

29

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

De hoofdtaak geeft het sensortype aan en start dan de beide andere taken. Dan is de hoofdtaak afgelopen. De taak: move_square zorgt ervoor dat de robot “rondjes“ blijft rijden. De taak check_sensors controleert of de aanraaksensor wordt ingedrukt. Als dat zo is, worden de volgende handelingen verricht: eerst wordt de taak move_square stil gezet. Dit is erg belangrijk. De taak check_sensors 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 move_square weer beginnen om de robot zijn rondjes te laten maken. 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.

30

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. 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.

31

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) 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(75, 2000); Wait(2000); turn_around(75, 500); Wait(1000); turn_around(75, 3000); Off(OUT_AC); }

32

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.

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(3400);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).

33

#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,10000); forwards(50,10000); 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 de 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.

34

Opdrachten bij hoofdstuk 6 Opdracht 1: 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.

task main() { sub turn_around() { OnRev(OUT_C); Wait(340); OnFwd(OUT_A+OUT_C); } OnFwd(OUT_A+OUT_C); Wait(100); turn_around(); Wait(200); turn_around(); Wait(100); turn_around(); Off(OUT_A+OUT_C); }

Opdracht 2: Opdracht 1 ging over subroutines. Definieer een macro waarbij de robot 2 seconden vooruit rijdt. Opdracht 3: Schrijf nu een programma voor de robot waarin een inline functie wordt toegepast.

35

Hoofdstuk 7

Parallelle taken Zoals eerder is aangeduid, worden taken in de NQC 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 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 tegenkomen. Probeer

36

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(500); OnFwd(OUT_A, 75); Wait(850); Release(moveMutex); } } } task main() { SetSensor(IN_1,SENSOR_TOUCH); Precedes(check_sensors, move_square); }

37

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); sem = 0; Wait(850);

38

} } 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. (Toch is er een kleine kans dat deze semaforen niet functioneren.

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 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.

39

Opdrachten bij hoofdstuk 7 Opdracht 1: In de onderstaande programmacode wordt een semafoor gebruikt. Geef aan wat de functie van deze semafoor is en verklaar waarom dit programma niet werkt.

#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); } }

40

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.

41

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.

Het Programmeren van Lego Robots met NXChome.kpn.nl › p.kool › resources ›...

Documents

Transcript of Het Programmeren van Lego Robots met NXChome.kpn.nl › p.kool › resources ›...