! "
#
$! %
&& &'
' ()
) %
2
* )
+
Inleiding…………………………………………. 3 Hoofdstuk 1 Het schrijven van een eerste programma…….. 6 Opdrachten bij hoofdstuk 1……………………. 8 Hoofdstuk 2 Een interessanter programma…………………. 9 Opdrachten bij hoofdstuk 2……………………. 12 Hoofdstuk 3 Variabelen gebruiken…………………………... 13 Opdrachten bij hoofdstuk 3……………………. 16 Hoofdstuk 4 Controlestructuren………………………………. 18 Opdrachten bij hoofdstuk 4…………………….. 21 Hoofdstuk 5 Sensoren………………………………………….. 22 Opdrachten bij hoofdstuk 5…………………….. 23 Hoofdstuk 6 Taken en subroutines…………………………….. 24 Opdrachten bij hoofdstuk 6………………………33 Hoofdstuk 7 Parallelle taken…………………………………… 34 Opdrachten bij hoofdstuk 7…………………..… 38 Bijlage A De Lego Mindstorms robot…………… 39
3
! ! , 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.
+ 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 NQC die speciaal geschreven is voor het programmeren van Lego robots. Deze letters staan voor “Not Quite C”, een taal die ontworpen is door Dave Baum. Zoals de naam al suggereert (niet helemaal C) is NQC afgeleid van de (hogere programmeer)taal C.
- (
(
)
De programmeerbare Legosteen RCX vormt de kern van het Mindstorms RIS. Om het programmeren van de robots nog makkelijker te maken, maken we gebruik van het “RCX Command Center”. Dit is een bijzonder handig en nuttig hulpmiddel bij het schrijven van NQC 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 RCX Command Center is bedacht en geschreven door Mark Overmars. Op zijn website vind je nog veel meer over Lego en programmeren met NQC. Het adres is: http://www.cs.uu.nl/people/markov
*
- (
(
)
Bij het starten van het RCXCC 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 RCX-CC 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 NQC naar machinetaal die de robot (de RCX steen) “begrijpt”.
Als je later besluit met de RCX robot te gaan werken en je programma’s naar de RCX wil verzenden, kun je via
het RCX 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.
5
6
.
)$ / ( * !0
+
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 task main() { OnFwd(OUT_A); OnFwd(OUT_C); Wait(400); OnRev(OUT_A+OUT_C); Wait(400); Off(OUT_A+OUT_C); }
Het ziet er wellicht ingewikkeld uit, dus laten we het eens bekijken. Programma’s in NQC 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 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; … }
Ons programma heeft 6 statements. We bekijken ze één voor één: OnFwd(OUT_A);
Dit statement vertelt de robot om output A te starten, dat wil zeggen, de motor die via output A is aangesloten op de RCX, en naar voren te gaan rijden. Hij rijdt op maximale snelheid (deze is overigens in te stellen, maar dat komt later). OnFwd(OUT_C);
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(400);
Nu komt het wachten. Dit statement laat het programma 4 seconden wachten. Het argument (ook wel parameter of variabele genoemd), dat is het getal tussen haakjes, geeft het aantal ”tikken”. Elke tik duurt 1/100 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_A+OUT_C);
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_A+OUT_C); dat was dus bij het starten hierboven ook mogelijk. Wait(400);
Wederom doet het programma “niets” gedurende 4 seconden. Off(OUT_A+OUT_C);
Tenslotte schakelen we beide motoren uit. Als je het programma in de RCX-editor 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 NQC. Andere belangrijke woorden verschijnen eveneens vetgedrukt (zien we later nog).De kleuren zijn ook nog handig om fouten te ontdekken in je typewerk.
1
* !
De robot ging in het programma snel. In principe houdt de robot zonder verdere mededelingen de hoogste snelheid aan. De snelheid kan aangepast worden met SetPower(). De kracht is een nummer tussen 0 (langzaamst)en 7 (snelst). Hier is een nieuwe versie van ons programma waarin de robot langzamer beweegt: task main() { SetPower(OUT_A+OUT_C,2); OnFwd(OUT_A+OUT_C); Wait(400); OnRev(OUT_A+OUT_C); Wait(400); Off(OUT_A+OUT_C); }
2
!
Wat betreft programmeren hebben we een aantal belangrijke aspecten van de taal NQC 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 motorcommando’s gezien: OnFwd(), OnRev(), SetPower() en Off(). Tenslotte hebben we iets over het Wait() statement geleerd.
8
+
(*
!0 *
.
) $ /3
Opdracht 1: Open een nieuw bestand en type de volgende code: task main() { OnFwd(OUT_D); OnFwd(OUT_C); Wait(400); OnRev(OUT_A+OUT_C); Wait(400); Of(OUT_A+OUT_C); }
In de code zitten twee fouten. Misschien heb je ze bij het typen al ontdekt. De NQC 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 NQC 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 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 (400) in regel 5 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 RCX 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
.
)$ 4
!
+
We gaan nu stapsgewijs een interessanter programma maken, waarbij een aantal belangrijke onderdelen van de programmeertaal NQC naar voren komt.
! 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. task main() { OnFwd(OUT_A+OUT_C); Wait(100); OnRev(OUT_C); Wait(85); Off(OUT_A+OUT_C); }
Misschien moet je een iets ander getal dan de 85 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 NQC kun je constanten (dat zijn dus constante waarden) definiëren zoals in het volgende programma: #define MOVE_TIME #define TURN_TIME
100 85
task main() { OnFwd(OUT_A+OUT_C); Wait(MOVE_TIME); OnRev(OUT_C); Wait(TURN_TIME); Off(OUT_A+OUT_C); }
De eerste 2 regels 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 RCX Command Center weer een eigen kleur.
10
* !
(
5
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.
#define MOVE_TIME #define TURN_TIME
100 85
task main() { repeat(4) { OnFwd(OUT_A+OUT_C); Wait(MOVE_TIME); OnRev(OUT_C); Wait(TURN_TIME); } Off(OUT_A+OUT_C); }
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: #define MOVE_TIME #define TURN_TIME
100 85
task main() { repeat(10) { repeat(4) { OnFwd(OUT_A+OUT_C); Wait(MOVE_TIME); OnRev(OUT_C); Wait(TURN_TIME); } } Off(OUT_A+OUT_C); }
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.
11
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 groen weergegeven in het RCX Command Center. Het volledige programma zou er als volgt uit kunnen zien: /*
10 VIERKANTEN door Mark Overmars
Dit programma laat de robot 10 vierkanten maken */ #define MOVE_TIME #define TURN_TIME
100// Tijd voor recht vooruit 85// tijd voor 90° draaien
task main() { repeat(10) // Maak 10 vierkanten { repeat(4) { OnFwd(OUT_A+OUT_C); Wait(MOVE_TIME); OnRev(OUT_C); Wait(TURN_TIME); } } Off(OUT_A+OUT_C); // Zet de motoren uit }
1
!
3
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 RCX. Dit is trouwens 8 K groot. 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.
2
!
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.
12
+
(*
!0 *
.
) $ 43
Opdracht 1: Wat is er mis met het volgende programma: # MOVE_TIME # TURN_TIME
100 85
task main() { repeat(10) { repeat(4) { OnFwd(OUT_A+OUT_C); Wait(MOVE_TIME); OnRev(OUT_C); } Off(OUT_A+OUT_C); }
Beantwoordt deze vraag zonder gebruik te maken van de compiler. Aanwijzing: er zitten vier fouten in. Opdracht 2: Schrijf een programma dat de RCX 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 circel van plm. een meter doorsnee laat rijden.
13
. 1
)$ 6
!
) !$
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.
+!
$
,
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 NQC eenvoudig worden gedefinieerd. Je kunt er 32 van hebben en ze kunnen elk een andere naam krijgen. Hier is het programma van de spiraal: #define TURN_TIME int move_time;
85 // definieer een variabele
task main() { move_time = 20; // repeat(50) { OnFwd(OUT_A+OUT_C); Wait(move_time); // // OnRev(OUT_C); Wait(TURN_TIME); move_time += 5; // } Off(OUT_A+OUT_C); }
geef de beginwaarde
gebruik van variabele voor wachten verhoog de variabele
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. (ditzelde geldt voor constanten, task namen, enz.) De afkorting int staat voor integer; dit zijn gehele getallen. Alleen deze getallen mogen hier staan.
14
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; int bbb, ccc; task main() { aaa = 10; bbb = 20 * 5; ccc = bbb; ccc /= aaa; ccc -= 5; aaa = 10 * (ccc + 3); 80 }
// aaa is now equal to
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.
7
%
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 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. int move_time, turn_time; task main() { while(true) { move_time = Random(60); turn_time = Random(40); OnFwd(OUT_A+OUT_C); Wait(move_time); OnRev(OUT_A); Wait(turn_time); } }
15
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.
2
!
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.
16
1
+
(*
!0 *
.
) $ 63
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: # define RIJ_TIJD 100 # define DRAAI_TIJD 75 task main() { OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); OnRev(OUT_A); OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); OnRev(OUT_C); OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); OnRev(OUT_C); OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); Off(OUT_A+OUT_C); }
Voor VWO: # define RIJ_TIJD 100 # define DRAAI_TIJD 85 task main() { OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); OnRev(OUT_A); repeat(2) { OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); OnRev(OUT_C); } OnFwd(OUT_A+OUT_C); Wait(RIJ_TIJD); Off(OUT_A+OUT_C); }
17
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.
18
.
)$ 8 )( )
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.
!. +
(*
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: #define MOVE_TIME #define TURN_TIME
100 85
task main() { while(true) { OnFwd(OUT_A+OUT_C); Wait(MOVE_TIME); if (Random(1) == 0) { OnRev(OUT_C); } else { OnRev(OUT_A); } 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: == < <=
gelijk aan kleiner dan kleiner dan of gelijk aan 19
> >= !=
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 false ttt != 3 (ttt >= 5) && (ttt <= 10) (aaa = = 10) || (bbb = = 10)
altijd waar nooit waar waar als ttt niet gelijk is aan 3 waar als ttt ligt tussen 5 en 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.
+
(*
Een andere controlestructuur is de do-opdracht. Deze heeft de volgende vorm: do { statements; } while (condition);
De opdrachten tussen 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. int move_time, turn_time, total_time; task main() { total_time = 0; do { move_time = Random(100); turn_time = Random(100); OnFwd(OUT_A+OUT_C); Wait(move_time); OnRev(OUT_C); Wait(turn_time); total_time += move_time; total_time += turn_time; } while (total_time < 2000); Off(OUT_A+OUT_C); }
20
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 whileopdracht. 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.
2
!
We hebben 2 nieuwe controlestructuren leren kennen: de if-opdracht en de doopdracht. 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.
21
+
(*
!0 *
.
) $ 83
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.
22
.
)$
2 Eén van de aardige aspecten van de Lego robot is, dat je er sensoren aan kunt verbinden 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 de constructie zoals op blz. 28 van de Constructopedia te zien is. Je kunt het ook iets ruimer maken, zoals de foto hieronder laat te zien:
Verbindt de sensor met input 1 op de RCX.
9 (*
+
Laten we beginnen met een eenvoudig programma waarin de robot vooruit rijdt tot hij ergens tegenaan botst. Hier zie je het: task main() { SetSensor(SENSOR_1,SENSOR_TOUCH); OnFwd(OUT_A+OUT_C); until (SENSOR_1 == 1); Off(OUT_A+OUT_C); }
Er staan 2 belangrijke regels in. De eerste regel van het programma vertelt de robot welk type sensor gebruikt wordt. SENSOR_1 is het input-nummer waaraan de sensor gekoppeld is. De andere 2 sensor-inputs zijn SENSOR_2 en SENSOR_3. SENSOR_TOUCH geeft aan dat het de aanraaksensor is. Voor de lichtsensor gebruiken we SENSOR_LIGHT. 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 23
zegt dat de waarde van de sensor SENSOR_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.
9
$
$
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: task main() { SetSensor(SENSOR_1,SENSOR_TOUCH); OnFwd(OUT_A+OUT_C); while (true) { if (SENSOR_1 == 1) { OnRev(OUT_A+OUT_C); Wait(30); OnFwd(OUT_A); Wait(30); OnFwd(OUT_A+OUT_C); } } }
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 1/3 seconde en daarna weer vooruit.
!(* In het MindStrorms 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. Maak bijvoorbeeld een constructie als je hier ziet:
24
We hebben ook een ‘racebaan’ nodig die in het pakket zit (groot stuk papier met het zwarte 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. #define THRESHOLD 40 task main() { SetSensor(SENSOR_2,SENSOR_LIGHT); OnFwd(OUT_A+OUT_C); while (true) { if (SENSOR_2 > THRESHOLD) { OnRev(OUT_C); until (SENSOR_2 <= THRESHOLD); OnFwd(OUT_A+OUT_C); } } }
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. Je zult bij de uitvoering van het programma zien, dat het niet erg gelijkmatig is. Probeer een Wait(10) opdracht voor de until opdracht te zetten om de robot beter te laten bewegen. Om een beweging langs een willekeurig gekozen pad mogelijk te maken is een veel ingewikkelder programma nodig.
25
2
!
In dit hoofdstuk hebben we het gebruik van aanraak- en lichtsensoren 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.
26
+
(*
!0 *
.
)$ 3
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.
27
. ' $
)$ : )
) !
Tot nu toe bevatten onze programma’s slechts één taak. Maar NQCprogramma' 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 verschillende mogelijkheden bekijken.
' $ Een NQC programma bestaat uit ten hoogste 10 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 daar op 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
task main() { SetSensor(SENSOR_1,SENSOR_TOUCH); start check_sensors; start move_square; } task move_square() { while (true) { OnFwd(OUT_A+OUT_C); Wait(100); OnRev(OUT_C); Wait(85); } } task check_sensors() { while (true) { if (SENSOR_1 == 1) { stop move_square; OnRev(OUT_A+OUT_C); Wait(50); OnFwd(OUT_A); Wait(85); start move_square; } } }
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. In hoofdstuk 10 zullen we nader op deze problemen ingaan en er oplossingen voor geven.
2)
) !
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. NQC (of eigenlijk de RCX) staat maximaal acht subroutines toe. Laten we een voorbeeld bekijken.
29
sub turn_around() { OnRev(OUT_C); Wait(340); OnFwd(OUT_A+OUT_C); } task main() { OnFwd(OUT_A+OUT_C); Wait(100); turn_around(); Wait(200); turn_around(); Wait(100); turn_around(); Off(OUT_A+OUT_C); }
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. Alleen zijn er nu geen parameters dus de haakjes blijven leeg. 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 niet meer gebruiken vanwege een beperking in de RCX-Firmware. Dus, tenzij je precies weet wat je doet, een subroutine niet vanuit verschillende taken aanroepen!
!
.) ( !
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 RCX. Dat bespaart geheugenplaatsen en dat is nuttig omdat de RCX 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) Het bovenstaande voorbeeld ziet er nu met gebruik van inline functies als volgt uit:
30
void turn_around() { OnRev(OUT_C); Wait(340); OnFwd(OUT_A+OUT_C); } task main() { OnFwd(OUT_A+OUT_C); Wait(100); turn_around(); Wait(200); turn_around(); Wait(100); turn_around(); Off(OUT_A+OUT_C); }
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. void turn_around(int turntime) { OnRev(OUT_C); Wait(turntime); OnFwd(OUT_A+OUT_C); } task main() { OnFwd(OUT_A+OUT_C); Wait(100); turn_around(200); Wait(200); turn_around(50); Wait(100); turn_around(300); Off(OUT_A+OUT_C); }
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.
(
5
Er is nog een manier om kleine stukken code een naam te geven. Je kunt in NQC ook macro’s vastleggen, deze moet je echter niet verwarren met de macro’s in de RCX 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. 31
#define turn_around OnRev(OUT_C);Wait(340);OnFwd(OUT_A+OUT_C); task main() { OnFwd(OUT_A+OUT_C); Wait(100); turn_around; Wait(200); turn_around; Wait(100); turn_around; Off(OUT_A+OUT_C); }
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). #define turn_right(s,t) SetPower(OUT_A+OUT_C,s);OnFwd(OUT_A);OnRev(OUT_C);Wait(t); #define turn_left(s,t) SetPower(OUT_A+OUT_C,s);OnRev(OUT_A);OnFwd(OUT_C);Wait(t); #define forwards(s,t) SetPower(OUT_A+OUT_C,s);OnFwd(OUT_A+OUT_C);Wait(t); #define backwards(s,t) SetPower(OUT_A+OUT_C,s);OnRev(OUT_A+OUT_C);Wait(t); task main() { forwards(3,200); turn_left(7,85); forwards(7,100); backwards(7,200); forwards(7,100); turn_right(7,85); forwards(3,200); Off(OUT_A+OUT_C); }
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.
32
2
!
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.
33
+
(*
!0 *
.
) $ :3
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.
34
.
)$ ; $
,
Zoals eerder is aangeduid, worden taken in de NQC-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.
+
. )
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. task main() { SetSensor(SENSOR_1,SENSOR_TOUCH); start check_sensors; while (true) { OnFwd(OUT_A+OUT_C); Wait(100); OnRev(OUT_C); Wait(85); } } task check_sensors() { while (true) { if (SENSOR_1 == 1) { OnRev(OUT_A+OUT_C); Wait(50); OnFwd(OUT_A); Wait(85); OnFwd(OUT_C); } } }
Dit ziet er waarschijnlijk uit als een perfect werkend programma. Maar als je het programma uitvoert, zul je hoogstwaarschijnlijk enkele onverwachte bewegingen 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 35
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.
++
#
$
,
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. task main() { SetSensor(SENSOR_1,SENSOR_TOUCH); start check_sensors; start move_square; } task move_square() { while (true) { OnFwd(OUT_A+OUT_C); Wait(100); OnRev(OUT_C); Wait(85); } } task check_sensors() { while (true) { if (SENSOR_1 == 1) { stop move_square; OnRev(OUT_A+OUT_C); Wait(50); OnFwd(OUT_A); Wait(85); start move_square; } } }
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.
36
) !$
.
!
%
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 = // Do sem =
(sem == 0); 1; something with the motors 0;
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. int sem; task main() { sem = 0; start move_square; SetSensor(SENSOR_1,SENSOR_TOUCH); while (true) { if (SENSOR_1 == 1) { until (sem == 0); sem = 1; OnRev(OUT_A+OUT_C); Wait(50); OnFwd(OUT_A); Wait(85); sem = 0; } } } task move_square() { while (true) { until (sem == 0); sem = 1; OnFwd(OUT_A+OUT_C); sem = 0; Wait(100); until (sem == 0); sem = 1; OnRev(OUT_C); sem = 0; Wait(85); } }
37
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.
2
!
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.
38
+
(*
!0 *
.
) $ ;3
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. int sem; task main() { sem = 1; start move_square; SetSensor(SENSOR_1,SENSOR_TOUCH); while (true) { if (SENSOR_1 == 1) { until (sem == 0); sem = 1; OnRev(OUT_A+OUT_C); Wait(50); OnFwd(OUT_A); Wait(85); sem = 0; } } } task move_square() { while (true) { until (sem == 0); sem = 1; OnFwd(OUT_A+OUT_C); sem = 0; Wait(100); until (sem == 0); sem = 1; OnRev(OUT_C); sem = 0; Wait(85); } }
39
< !0 ! )# 3 Bij een set Lego Mindstorms Robotics Invention System zit een bouwbeschrijving, de “Constructopedia”, voor het maken van verschillende robots. De robot die wij zullen gebruiken is een aangepaste versie van de robot die beschreven wordt op pagina 39 t/m 46. In deze handleiding wordt uitgegaan van de handleiding bij versie 1.5, nr. 9747!
)!
+
-3
Bovenop de RCX zitten 4 gekleurde knoppen en een klein LCD scherm. Met de rode knop zet je de robot aan of uit. Met de grijze kun je kiezen uit een van de vijf programma’s die in het geheugen van de RCX zijn opgeslagen. Met de groene knop start en stop je een programma. Met de zwarte knop kun je zien welke van de zes sensoren actief zijn. Op de RCX zitten ook zes sensorcontacten. Drie voor de motoren A, B en C en drie voor de sensoren 1, 2 en 3
=
+
5
3 Om programma’s van de computer naar het geheugen van de RCX te verzenden moet de infrarood zender op de seriële poort van de computer zijn aangesloten. Controleer dit, eventueel met hulp van je docent. De RCX moet met de kant waar de IRpoort zit voor de Ir-zender zijn geplaatst. De RCX moet aan staan. Als het 40
(
+)
RCX Command Center wordt gestart, zal het automatisch de RCX zoeken. Als je het scherm hiernaast ziet, klik dan op OK.
41
(
+!
+
Nadat een programma correct is getypt in de RCX editor klik je op de knop “Compile Program”. Als de compiler geen fouten vindt, kun je het programma verzenden naar de RCX.
Klik op de knop rechts van “Compile Program”. Deze knop heet “Download Program”. Het verzenden begint dan, mits de RCX op de juiste wijze voor de IR-zender staat om het programma te ontvangen.
42
3
