Inleiding. 3. Hoofdstuk 1 Het schrijven van een eerste programma.. 6 Opdrachten bij hoofdstuk 1. 8
|
|
- Simon Boender
- 8 jaren geleden
- Aantal bezoeken:
Transcriptie
1 !" # $!%
2 & & & ' ' ())% ())% 2
3 *)+ 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 Hoofdstuk 3 Variabelen gebruiken Opdrachten bij hoofdstuk Hoofdstuk 4 Controlestructuren. 18 Opdrachten bij hoofdstuk Hoofdstuk 5 Sensoren.. 22 Opdrachten bij hoofdstuk Hoofdstuk 6 Taken en subroutines.. 24 Opdrachten bij hoofdstuk 6 33 Hoofdstuk 7 Parallelle taken 34 Opdrachten bij hoofdstuk Bijlage A De Lego Mindstorms robot 39 3
4 !!, 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: * -( () 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
5 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 <Tools> <find RCX> 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 6
7 . ) $/ (*!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 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: 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
8 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: 2! SetPower(OUT_A+OUT_C,2); Wait(400); OnRev(OUT_A+OUT_C); Wait(400); Off(OUT_A+OUT_C); 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
9 + (*!0*.)$/3 Opdracht 1: Open een nieuw bestand en type de volgende code: 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
10 . ) $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. 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 100 #define TURN_TIME 85 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
11 *!( 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 100 #define TURN_TIME 85 repeat(4) 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 100 #define TURN_TIME 85 repeat(10) repeat(4) 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
12 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 100// Tijd voor recht vooruit #define TURN_TIME 85// tijd voor 90 draaien repeat(10) repeat(4) Wait(MOVE_TIME); OnRev(OUT_C); Wait(TURN_TIME); Off(OUT_A+OUT_C); // Maak 10 vierkanten // 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
13 + (*!0*.)$43 Opdracht 1: Wat is er mis met het volgende programma: # MOVE_TIME 100 # TURN_TIME 85 repeat(10) repeat(4) 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
14 . ) $6 1! )!$ 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 85 int move_time; // definieer een variabele move_time = 20; // geef de beginwaarde repeat(50) Wait(move_time); // gebruik van variabele // voor wachten OnRev(OUT_C); Wait(TURN_TIME); move_time += 5; Off(OUT_A+OUT_C); // 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
15 In de tweede commentaarregel geven we de variabele de waarde 20. Nu volgt de herhalingslus waarin we de variabele gebruiken om de wachttijd aan te geven, en aan het einde van de lus verhogen we de waarde met 5. Zo wacht de robot eerst 20 tikken, de tweede keer 25, de derde keer 30, enz. Bij een variabele kun je naast optellen, zoals hierboven, ook vermenigvuldigen (met *=), aftrekken (met -=) en delen (met /=). (N.B. bij delen wordt de uitkomst afgerond op de dichtstbijliggende integer) Je kunt ook de ene variabele bij de andere optellen, en meer gecompliceerde expressies gebruiken. Hieronder een paar voorbeelden: int aaa; int bbb, ccc; 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. 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; while(true) move_time = Random(60); turn_time = Random(40); Wait(move_time); OnRev(OUT_A); Wait(turn_time); 15
16 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
17 1 + (*!0*.)$63 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 Wait(RIJ_TIJD); OnRev(OUT_A); Wait(RIJ_TIJD); OnRev(OUT_C); Wait(RIJ_TIJD); OnRev(OUT_C); Wait(RIJ_TIJD); Off(OUT_A+OUT_C); Voor VWO: # define RIJ_TIJD 100 # define DRAAI_TIJD 85 Wait(RIJ_TIJD); OnRev(OUT_A); repeat(2) Wait(RIJ_TIJD); OnRev(OUT_C); Wait(RIJ_TIJD); Off(OUT_A+OUT_C); 17
18 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
19 . ) $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 100 #define TURN_TIME 85 while(true) 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
20 > 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. + + (* 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; total_time = 0; do move_time = Random(100); turn_time = Random(100); 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
21 Let er in dit voorbeeld op dat we 2 opdrachten op één regel hebben gezet. Dat mag. Je mag zo veel mogelijk opdrachten op een regel zetten als je wilt (zolang er maar 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
22 + (*!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
23 . ) $ 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: SetSensor(SENSOR_1,SENSOR_TOUCH); 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
24 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: SetSensor(SENSOR_1,SENSOR_TOUCH); while (true) if (SENSOR_1 == 1) OnRev(OUT_A+OUT_C); Wait(30); OnFwd(OUT_A); Wait(30); 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
25 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 SetSensor(SENSOR_2,SENSOR_LIGHT); while (true) if (SENSOR_2 > THRESHOLD) OnRev(OUT_C); until (SENSOR_2 <= THRESHOLD); 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
26 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
27 + (*!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
28 . ) $: ' $))! 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
29 SetSensor(SENSOR_1,SENSOR_TOUCH); start check_sensors; start move_square; task move_square() while (true) 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
30 sub turn_around() OnRev(OUT_C); Wait(340); 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
31 void turn_around() OnRev(OUT_C); Wait(340); 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); 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
32 #define turn_around OnRev(OUT_C);Wait(340); 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);Wait(t); #define backwards(s,t) SetPower(OUT_A+OUT_C,s);OnRev(OUT_A+OUT_C);Wait(t); 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
33 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
34 + (*!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. sub turn_around() OnRev(OUT_C); Wait(340); 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
35 . ) $; $, 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. SetSensor(SENSOR_1,SENSOR_TOUCH); start check_sensors; while (true) 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
36 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. SetSensor(SENSOR_1,SENSOR_TOUCH); start check_sensors; start move_square; task move_square() while (true) 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
37 )!$.! % 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; // Do something with the motors sem = 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; 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; sem = 0; Wait(100); until (sem == 0); sem = 1; OnRev(OUT_C); sem = 0; Wait(85); 37
38 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
39 + (*!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; 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; sem = 0; Wait(100); until (sem == 0); sem = 1; OnRev(OUT_C); sem = 0; Wait(85); 39
40 <!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
41 RCX Command Center wordt gestart, zal het automatisch de RCX zoeken. Als je het scherm hiernaast ziet, klik dan op OK. 41
42 (+! 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
Het Programmeren van Lego Robots met NXC Leerlingenboek 2011-2012
Het Programmeren van Lego Robots met NXC Leerlingenboek 2011-2012 School Vak Klas Docent : Cartesius Lyceum : Informatica : 5H en 5V : Ron Klaver Inhoudsopgave Het Programmeren van Lego Robots met NXC...
Nadere informatieBEGINNER JAVA Inhoudsopgave
Inhoudsopgave 6 Configuratie Hallo wereld! Praten met de gebruiker Munt opgooien Voorwaarden Lussen......6 Configuratie Met deze Sushi kaarten ga je een simpel spel maken met één van de meest populaire
Nadere informatieNascholing voor leerlingen. Software-ontwikkeling met behulp van Lego Mindstorms
Nascholing voor leerlingen Software-ontwikkeling met behulp van Lego Mindstorms Lego Mindstorms Hardware - RCX (programmeerbare legosteen) - Sensoren - Motoren Software - Robotics Invention System 2.0
Nadere informatieJe gaat leren programmeren en een spel bouwen met de programmeertaal Python. Websites zoals YouTube en Instagram zijn gebouwd met Python.
1 Je gaat leren programmeren en een spel bouwen met de programmeertaal Python. Websites zoals YouTube en Instagram zijn gebouwd met Python. Voordat je leert programmeren, moet je jouw pc zo instellen dat
Nadere informatieProgrammeren met lego mindstorms.
Programmeren met lego mindstorms. Servo-motoren: zorgen voor de beweging van de wielen. Kleine motor: kan een hendel op en neer laten bewegen. Infraroodsensor: kan afstanden meten en vergelijken. EV3-blok:
Nadere informatieSimon de schildpad. 2015 J van Weert 1
Programmeren met Simon Simon de schildpad 2015 J van Weert 1 Inleiding: Wat is programmeren eigenlijk? Een computer doet niets zonder een programma. Die programma s worden geschreven door mensen: programmeurs.
Nadere informatieSimon de schildpad. 2012 J van Weert 1
Programmeren met Simon Simon de schildpad 2012 J van Weert 1 Inleiding: Wat is programmeren eigenlijk? Een computer doet niets zonder een programma. Die programma s worden geschreven door mensen: programmeurs.
Nadere informatieKunstmatige Intelligentie (AI) Hoofdstuk 25 van Russell/Norvig = [RN] Robotica. voorjaar 2016 College 8, 12 april 2016
AI Kunstmatige Intelligentie (AI) Hoofdstuk 25 van Russell/Norvig = [RN] Robotica voorjaar 2016 College 8, 12 april 2016 www.liacs.leidenuniv.nl/ kosterswa/ai/ 1 RoboCup Ξ www.robocup.org 2 Robots Een
Nadere informatieg. Je kan nu door op de play knop te drukken je programma versturen naar de EV3 brick waarna het zal uitgevoerd worden.
EV3 brick verbinden via bluetooth. 1) Alvorens de LEGO software op te starten kijk je het best of bluetooth op je PC is geactiveerd. Vooral bij laptops schakelt men deze functie vaak uit om batterij te
Nadere informatieProgrammeren met Arduino-software
Programmeren met Arduino-software De software waarin we programmeren is Arduino IDE. Deze software is te downloaden via www.arduino.cc. De programmeertaal die hier gebruikt wordt, is gebaseerd op C en
Nadere informatieZo gaat jouw kunstwerk er straks uitzien. Of misschien wel heel anders.
Spirograaf in Python Een kunstwerk maken Met programmeren kun je alles maken! Ook een kunstwerk! In deze les maken we zelf een kunstwerk met Python. Hiervoor zal je werken met herhalingen en variabelen.
Nadere informatieJe gaat leren programmeren in Ruby. En daarna in Ruby een spelletje maken. Websites zoals Twitch en Twitter gemaakt zijn met behulp van Ruby?
1 Je gaat leren programmeren in Ruby. En daarna in Ruby een spelletje maken. Websites zoals Twitch en Twitter gemaakt zijn met behulp van Ruby? Voordat je begint met programmeren, moet je Ruby installeren.
Nadere informatieMeer Blokken. 1. Dit is een functie genaamd Maximum, die twee argumenten heeft: number1 en number2.
Meer Blokken Voorkennis: SuperDojo, Snake Leerdoelen: Meer Blokken Introductie Meer Blokken zijn Scratch s manier van functies. Functies zijn een heel belangrijk concept in alle programmeertalen. Het staat
Nadere informatieMINDSTORM LEGO ROBOTS
MINDSTORM LEGO ROBOTS Les 1: Robot basis, en programma aanpassen Les 2: Eigen robot maken & programmeren Les 3: Eigen robot maken & geschiedenis robot opzoeken Les 4: Eigen robot maken & start film maken
Nadere informatieMINDSTORM LEGO ROBOTS
MINDSTORM LEGO ROBOTS Les 1: Robot basis, en programma aanpassen Les 2 & 3 & 4 : Eigen robot bouwen Les 5 & 6 : Robot programmeren Les 7: Geschiedenis opzoeken robots Les 8 & 9 & 10 : Film maken en op
Nadere informatieKunstmatige Intelligentie (AI) Hoofdstuk 25 van Russell/Norvig = [RN] Robotica. voorjaar 2019 College 9, 11 april 2019
AI Kunstmatige Intelligentie (AI) Hoofdstuk 25 van Russell/Norvig = [RN] Robotica voorjaar 2019 College 9, 11 april 2019 www.liacs.leidenuniv.nl/ kosterswa/ai/robot.pdf 1 RoboCup Ξ www.robocup.org 2 Robots
Nadere informatie[13] Rondjes draaien (loops)
[13] Rondjes draaien (loops) Met de if else uit de leerfiche [11] hebben we leren werken met één van de belangrijkste programmeerstructuren in Python. Bijna even belangrijk zijn de verschillende mogelijkheden
Nadere informatieStroomschema s maken in Word
1 Stroomschema s maken in Word Een programma direct maken in Scratch gaat vaak wel goed als het een klein programma is. Als het programma groter en moeilijker is, is het lastig om goed te zien welk commando
Nadere informatieINHOUDSTAFEL... 2 VOORWOORD... 3 INLEIDING... 4 GEBRUIK VAN MOTOREN... 8 DE HERHAALFUNCTIE... 9 SAMENVATTENDE OEFENING... 10
BASISCURSUS INHOUDSTAFEL INHOUDSTAFEL... 2 VOORWOORD... 3 INLEIDING... 4 DE SCHERMINDELING... 4 DE ROBOT EDUCATOR... 5 HET PROGRAMMEERVENSTER... 5 DE KNOPPEN... 6 OPDRACHTEN... 7 GEBRUIK VAN MOTOREN...
Nadere informatieModule 3: Scratch programmeren: is het logisch of is het niet logisch?
Module 3: Scratch programmeren: is het logisch of is het niet logisch? Inhoudsopgave Module 3: Scratch programmeren: is het logisch of is het niet logisch?...1 Wat is een computerprogramma eigenlijk?...2
Nadere informatieII. ZELFGEDEFINIEERDE FUNCTIES
II. ZELFGEDEFINIEERDE FUNCTIES In Excel bestaat reeds een uitgebreide reeks van functies zoals SOM, GEMIDDELDE, AFRONDEN, NU enz. Het is de bedoeling om functies aan deze lijst toe te voegen door in Visual
Nadere informatieInhoudsopgave Voorwoord 5 Voordat je begint 6 Wat heb je nodig? 7 De website bij het boek 7 Voor ouders, verzorgers en leraren
Inhoudsopgave Voorwoord... 5 Voordat je begint... 6 Wat heb je nodig?... 7 De website bij het boek... 7 Voor ouders, verzorgers en leraren... 8 Vervolgboeken over programmeren... 8 1. Aan de slag met Python
Nadere informatieHOOFDSTUK 3. Imperatief programmeren. 3.1 Stapsgewijs programmeren. 3.2 If Then Else. Module 4 Programmeren
HOOFDSTUK 3 3.1 Stapsgewijs programmeren De programmeertalen die tot nu toe genoemd zijn, zijn imperatieve of procedurele programmeertalen. is het stapsgewijs in code omschrijven wat een programma moet
Nadere informatieAls een PSD selecties bevat, deelt de lijn van het programma zich op met de verschillende antwoorden op het vraagstuk.
HOOFDSTUK 3 3.1 Stapsgewijs programmeren In de vorige hoofdstukken zijn programmeertalen beschreven die imperatief zijn. is het stapsgewijs in code omschrijven wat een programma moet doen, net als een
Nadere informatieOver Betuwe College. Lego Mindstorm project
Inhoudsopgave 1 Het aansluiten van onderdelen.... 3 2 De lego software.... 4 2.1 Het programeerscherm.... 5 2.2 Programma naar NXT... 6 3 Introductie tot programmeren.... 7 3.1 De druksensor.... 7 3.2
Nadere informatieStroomschema s maken op papier
1 Stroomschema s maken op papier Een programma direct maken in Python, gaat vaak wel goed als het een klein programma is. Als het programma groter en moeilijker is, is het lastig om goed te zien welk commando
Nadere informatieScratch in drie uur. Hallo, mijn naam is Minti Mint! Ik ga je uitleggen hoe je je eigen computerspel kunt maken. We gaan een racespel maken!
Scratch in drie uur Hallo, mijn naam is Minti Mint! Ik ga je uitleggen hoe je je eigen computerspel kunt maken. We gaan een racespel maken! Bernd Gärtner Nederlandse vertaling en bewerking: Martine Segers
Nadere informatie[8] De ene 1 is de andere niet
[8] De ene 1 is de andere niet Volg mee via 08_Types.py In de volgende leerfiche gaan we rekenen met Python. Dat kan je in een programma doen, maar dat kan je ook gewoon vanuit het Shell-venster doen.
Nadere informatieJava Les 3 Theorie Herhaal structuren
Java Les 3 Theorie Herhaal structuren Algemeen Een herhaal structuur een is programmeertechniek waarbij bepaalde Java instructies worden herhaald net zo lang tot een bepaalde voorwaarde is bereikt. Een
Nadere informatieVariabelen en statements in ActionScript
Ontwikkelen van Apps voor ios en Android Variabelen en statements in ActionScript 6.1 Inleiding Als we het in de informatica over variabelen hebben, bedoelen we een stukje in het geheugen van de computer
Nadere informatieVAN HET PROGRAMMEREN. Inleiding
OVERZICHT VAN HET PROGRAMMEREN Inleiding Als je leert programmeren lijkt het nogal overweldigend om die eerste stappen te doorworstelen. Er zijn dan ook heel wat programmeertalen (Java, Ruby, Python, Perl,
Nadere informatieHANDLEIDING PROGRAMMEREN IN PASCAL (LAZARUS)
HANDLEIDING PROGRAMMEREN IN PASCAL (LAZARUS) Vereiste voorkennis Voldoende kennis van het besturingssysteem (in deze handleiding wordt uitgegaan van Windows) De basisprincipes van programmeren Vereiste
Nadere informatieProgrammeerstructuren met App Inventor
Programmeerstructuren met App Inventor Kevin Krul, Universiteit Utrecht Roncalli, Bergen op Zoom Inhoud: Les 1: Introductie tot App Inventor, when statement en variabelen. Les 2: Introductie if-statement
Nadere informatieSmall Basic Programmeren Text Console 2
Oefening 1: Hoogste getal Je leest een reeks positieve gehele getallen in totdat je het getal 0 (nul) invoert. Daarna stopt de invoer en druk je een regel af met het hoogste getal uit de reeks. Voorbeeld:
Nadere informatieStroomschema s maken op papier
1 Stroomschema s maken op papier Een programma direct maken in Scratch, gaat vaak wel goed als het een klein programma is. Als het programma groter en moeilijker is, is het lastig om goed te zien welk
Nadere informatie1. Sluit de LED aan zoals afgebeeld 2. Sluit de USB-kabel aan op de Arduino 3. Klik op de knop uploaden 4. De LED begint te knipperen
Workshop Arduino Inleiding In deze workshop werk je in tweetallen met een Arduino microcontroller. Dit is een kleine computer die je kunt programmeren om te doen wat jij wilt. Om dit te doen gebruik je
Nadere informatieAfhankelijk van wanneer je het programma uitvoert, zie je een van de volgende resultaten:
Hoofdstuk 4 Voorwaarden en vertakkingen Laten we eens teruggaan naar ons eerste programma. Zou het niet leuk zijn als we in plaats van het algemene Hallo wereld, afhankelijk van de tijd van de dag, Goedemorgen
Nadere informatieDe Sense HAT heeft een temperatuursensor waarmee je de temperatuur. #lees de temperatuur van de sensor en sla op als temp
De Astro Pi programmeren De temperatuursensor Mission Zero De Astro Pi is een kleine computer aan boord van het internationale ruimtestation (ISS). En jij kunt deze vanaf jouw computer programmeren! In
Nadere informatieArduino Cursus, Deel 2 Programmeren. Simon Pauw, ZB45, Amsterdam
Arduino Cursus, Deel 2 Programmeren Simon Pauw, ZB45, Amsterdam Programmeren Geen zorgen als je niet alles begrijpt. Doel: Het snappen van bestaande code. Meeste kennis ook toepasbaar buiten de Arduino
Nadere informatieUitleg. Welkom bij de Beverwedstrijd 2006. Je krijgt 15 vragen, die je in maximaal 45 minuten moet beantwoorden.
Uitleg Welkom bij de Beverwedstrijd 2006 Je krijgt 15 vragen, die je in maximaal 45 minuten moet beantwoorden. Je krijgt 5 vragen van niveau A, 5 vragen van niveau B en 5 vragen van niveau C. Wij denken
Nadere informatieDe mbot Ranger. Je wilt zeker meteen al aan de slag. Maar voordat we beginnen moet je 3 dingen weten.
De mbot Ranger De mbot Ranger is een robot die je helemaal zelf kunt programmeren. De mbot Ranger heeft veel meer functionaliteiten dan de originele mbot. Hij kan naast alle functies van de mbot ook de
Nadere informatieIntroductiekaart Niveau B Installatie software
echniek Introductiekaart Niveau B Installatie software 0 Installatie programmeer software - eenmalig Stap. Kijk op de computer of de Mindstorms software geïnstalleerd is. Als hij al geïnstalleerd is kan
Nadere informatieEen spoedcursus python
Een spoedcursus python Zoals je in de titel misschien al gezien hebt, geven wij een spoedcursus Python. Door deze cursus leer je alle basics, zoals het rekenen met Python en het gebruik van strings. Het
Nadere informatieMindstorms-Ev3 Robot
Oefening 1: bouw de robot zie het boekje Mindstorms-Ev3 Robot blz. 4 tot blz. 38 blz. 42 tot blz. 46 blz. 54 tot blz. 67 blz. 69 tot blz. 71 blz. 77 tot blz. 79 Geen gyroscoop (blz. 48) sensor bouwen en
Nadere informatieScratch les 3: Quiz! Je eigen spelshow
Scratch les 3: Quiz! Je eigen spelshow Hoeveel weten jouw vriendjes en vriendinnetjes over jouw favoriete onderwerp? Test het met je zelfgemaakte quiz! Ga naar https://scratch.mit.edu/projects/112774047/.
Nadere informatieJe kunt de mbot ook draadloos programmeren via Bluetooth of met 2.4G Wireless. Bekijk de instructies op mbot draadloos.
Wat is een mbot? mbot is een robot die je eerst zelf in elkaar moet zetten en daarna kunt programmeren. De programmeer omgeving die je erbij kan installeren is mblock welke lijkt op Scratch 2.0 : mblock
Nadere informatiePROS1E1 Handleiding ( ) Kf/Dd/Bd
1 Inleiding De eerste oefening In deze eerste oefening wordt het voorbeeld 2-1 van bladzijde 11 uit het boek De taal C van PSD tot C-programma (enigszins aangepast) ingevoerd in de computer. Tevens wordt
Nadere informatieLogo. De schildpad. Hoofdstuk 8 Grafische afbeeldingen met een schildpad
Hoofdstuk 8 Grafische afbeeldingen met een schildpad Logo In de jaren 70 was er een eenvoudige, maar krachtige programmeertaal met de naam Logo die werd gebruikt door een klein aantal onderzoekers. Totdat
Nadere informatieNumerieke benadering van vierkantwortels
HP Prime Grafische Rekenmachine Numerieke benadering van vierkantwortels Doel: De waarde van een vierkantswortel met een recursieve rij benaderen, het schrijven van een klein programma. Sleutelwoorden:
Nadere informatieStap 1. Batterij aansluiten. We gaan uit van een accu en niet van batterijen
echniek Introductiekaart Niveau A 1 2 1 2 Begeleidende opmerking: kaart 0 is een kaart de een aantal grondbeginselen uitlegt en die handig is om er steeds even bij te houden. Er wordt op beschreven hoe
Nadere informatieTELEPORTEREN MET VARIABELEN
2 TELEPORTEREN MET VARIABELEN Ben je zover dat je de kracht van Python kunt gebruiken om jouw Minecraft wereld te beheersen? In dit hoofdstuk krijg je een korte rondleiding langs de basisbegrippen van
Nadere informatietechniek Motor en as LEGO O P D R A C H T Maak het programma van rechtsboven na, op het open stuk van het scherm.
Motor en as 1 Maak het programma van rechtsboven na, op het open stuk van het scherm. Sleep het startblokje en motor rechtsom tegen elkaar. Als je een fout maakt, dan kan je een blokje ook weer terugslepen
Nadere informatievan PSD naar JavaScript
2015 van PSD naar JavaScript F. Vonk versie 2 19-9-2015 inhoudsopgave 1. inleiding... - 2-2. ontwikkelomgeving... - 3-3. programmeerconcepten... - 4 - statement... - 4 - sequentie... - 4 - variabele en
Nadere informatieOm een doeltreffend programma te leren ontwerpen voor de Pro-Bot met zo weinig mogelijk tijdverlies en/of programmeerfouten let je op volgende punten:
Inhoud Programmeertips... 4 Ken je Pro-Bot... 5 1 - Aan de slag... 6 2 - Eenvoudige commando's... 6 3 - Commando's aanpassen of verwijderen... 6 4 - Digitale cijfers...7 5 - Herhalingslussen...8 6 - Doolhof...
Nadere informatie10. Mijn eerste programma
10. Mijn eerste programma Een korte handleiding voor het invoeren en editten van programmatekst voor een pseudotaal programma. In dit hoofdstuk wordt beschreven hoe je je allereerste pseudotaal programma
Nadere informatieHoe moet je een prachtige presentatie maken?
Hoe moet je een prachtige presentatie maken? www.meestermichael.nl Geef de presentatie een titel. Klik dit vak aan om jouw presentatie een ondertitel te geven. Hier kun je je presentatie een titel geven
Nadere informatieHet hele scherm besturen
De Sense HAT programmeren Het hele scherm besturen Met de Sense HAT kun je allerlei omstandigheden in het ISS waarnemen en opslaan. Ook kun je ze laten zien als tekst of plaatje op het ledscherm. In deze
Nadere informatieDe interface (stuurmodule)
4 Bij Lego NXT Schrijf de juiste benaming bij de invoer-, verwerkings- en uitvoerorganen van de Lego NXT Invoer Verwerking Uitvoer De interface (stuurmodule) Het centrale gedeelte van de computer waar
Nadere informatieRekenen aan wortels Werkblad =
Rekenen aan wortels Werkblad 546121 = Vooraf De vragen en opdrachten in dit werkblad die vooraf gegaan worden door, moeten schriftelijk worden beantwoord. Daarbij moet altijd duidelijk zijn hoe de antwoorden
Nadere informatieINHOUDSTAFEL... 2 VOORWOORD... 3 INLEIDING... 4 GEBRUIK VAN MOTOREN... 9 DE HERHAALFUNCTIE... 10 ZELF EEN BLOK MAKEN... 11
BASISCURSUS INHOUDSTAFEL INHOUDSTAFEL... 2 VOORWOORD... 3 INLEIDING... 4 DE SCHERMINDELING... 4 DE ROBOT EDUCATOR... 5 HET PROGRAMMEERVENSTER... 5 DE KNOPPEN EN BLOKKEN... 6 OPDRACHTEN... 8 GEBRUIK VAN
Nadere informatieBoe-Bots - Arduino robots
Boe-Bots - Arduino robots Voorbereiding - wat hebben we allemaal nodig? 1) Een laptop met de Arduino IDE 2) Een Boe-Bot 3) Een USB printerkabel 4) De Boe Bot Library én NewPing library. Hier te downloaden.
Nadere informatieVerkeerslichten. De Verkeerslichten & de PLC in het TIBBLTO / VICTO lokaal. Werkplek 1. Leer & werkboek.
Verkeerslichten. Werkplek 1 De Verkeerslichten & de PLC in het TIBBLTO / VICTO lokaal. Leer & werkboek. Bij dit boek hoort een antwoordboekje waarin de antwoorden, op de vragen uit dit boek, geschreven
Nadere informatieComputervaardigheden. Universiteit Antwerpen. Computervaardigheden en Programmatie. Grafieken en Rapporten 1. Inhoud. Wat is scripting?
Inhoud Computervaardigheden Hoofdstuk 4 Scripting (Let op: dit is enkel voor studenten Biologie.) Dit hoofdstuk bekijkt heel kort de basis van scripting. - Opstellen van functies. - Conditionele code.
Nadere informatieWerkblad 2 Kracht is een vector -Thema 14 (NIVEAU BETA)
Werkblad 2 Kracht is een vector -Thema 14 (NIVEAU BETA) Practicum Bij een gedeelte van het practicum zijn minimaal 3 deelnemers nodig. Leerlingen die op niveau gevorderd, of basis werken kunnen je helpen
Nadere informatieDe Sense HAT programmeren Je eerste computerprogramma
De Sense HAT programmeren Je eerste computerprogramma De Sense HAT is een uitbreiding voor de Raspberry Pi die speciaal voor de Astro Pi-wedstrijd is gemaakt. Met dit bord is het mogelijk om allerlei informatie
Nadere informatieWorkshop FLL. Leer robots programmeren. Marieke Peelen Lennart de Graaf Daryo Verouden -
Workshop FLL Leer robots programmeren Marieke Peelen Lennart de Graaf Daryo Verouden - 1 Student-coaches 2 FIRST LEGO League 3 FLL Core values We zijn een team We doen zelf het werk met hulp van onze coaches.
Nadere informatieDe mbot. Je wilt zeker meteen al aan de slag. Maar voordat we beginnen moet je 3 dingen weten.
De mbot De mbot is een robot die je helemaal zelf kunt programmeren. Hij kan rijden, geluid maken, heeft verschillende kleuren lampjes, kan lijnen op de grond volgen en heeft zelfs een ultrasonische module!
Nadere informatiedoor Vaksectie Informatica Alberdingk Thijm College ACS-logo
door Vaksectie Informatica Alberdingk Thijm College ACS-logo ACS LOGO Programmeren met een schildpad Het programma Afb. 1 We gaan in deze module werken met het programma ACSLOGO. Dit is een programma waarmee
Nadere informatieExtra oefening Probeer de voorbeeldprogramma s uit de LeJOS tutorial en de samples die bij de LeJOS software geïnstalleerd zijn.
Opdracht 4 Inhoud Applicatiebouw op dag 4 College In het college wordt een introductie gegeven over het programmeren van de Lego Mindstorms NXT in de programmeertaal Java. Werkcollege In het werkcollege
Nadere informatieDE ASTRO PI PROGRAMMEREN VOOR MISSION ZERO
DE ASTRO PI PROGRAMMEREN DOCENTENHANDLEIDING 1 Deze handleiding is bedoeld om leerlingen te ondersteunen bij de Astro Pi Challenge, waarbij leerlingen een programma voor de Astro Pi-computer in het ISS
Nadere informatieG. Schottert Handleiding Freekie 1. Nederlandse handleiding. Freekie DMX ADRES INSTELLINGEN 1
DMX ADRES INSTELLINGEN 1 Freekie Nederlandse handleiding Iedere fixture dat verbonden is met serial link moet voorzien worden van een DMX startadres, welke het eerste kanaal is dat de controller gebruikt
Nadere informatieMindstorms NXT practicum
Mindstorms NXT practicum 2014/2015 Dagdeel 2 SmartProducts 1 mei 2015 Mindstorms NXT practicum 2014/2015 Inhoud Lego sensoren gevorderd Extra elektronica & sensoren Mindstorms programmeren gevorderd Opdracht
Nadere informatie1 Delers 1. 3 Grootste gemene deler en kleinste gemene veelvoud 12
Katern 2 Getaltheorie Inhoudsopgave 1 Delers 1 2 Deelbaarheid door 2, 3, 5, 9 en 11 6 3 Grootste gemene deler en kleinste gemene veelvoud 12 1 Delers In Katern 1 heb je geleerd wat een deler van een getal
Nadere informatieOver Betuwe College. Lego Mindstorm project
Inhoudsopgave 1 Zoeken op vragen.... 3 2 Regelen en sturen.... 3 2.1 Een Flag / signaal... 3 2.2 De motor.... 3 2.3 Verplaatsen.... 4 2.4 Omwentelingen meten... 6 2.5 Licht.... 7 2.6 Variabele.... 7 2.6.1
Nadere informatieScratch. Gemaakt door: Déjan van Noordt en Leroy van den Driesche Leerlingen HAVO 5 SG Spieringshoek Als onderdeel voor het vak Informatica
Scratch sdas Gemaakt door: Déjan van Noordt en Leroy van den Driesche Leerlingen HAVO 5 SG Spieringshoek Als onderdeel voor het vak Informatica Inhoud Wat is scratch?... 2 Deel 1: Account aanmaken... 2
Nadere informatieIn dit lespakket maken we gebruik van de studentenversie van LabVIEW 7.1
Lespakket LabVIEW Starten met LabVIEW en de LEGO NXT LabVIEW starten In dit lespakket maken we gebruik van de studentenversie van LabVIEW 7.1 Om LabVIEW op te starten klik je simpelweg op de snelkoppeling
Nadere informatieDe RCX voor beginners De intelligente steen van LEGO. I. De RCX zonder computer
De RCX voor beginners De intelligente steen van LEGO I. De RCX zonder computer September 2001 Stichting CMA / AMSTEL Instituut Universiteit van Amsterdam Kruislaan 404 1098 SM Amsterdam Teksten: Marion
Nadere informatieOnline c++ leren programmeren:
Online c++ leren programmeren: Inhoud 1)Waar vind ik een c++ compiler?... 2 2)Hoe start ik een programma in c++?... 2 3)Een eerste c++ programma:... 3 Een eerste programma schrijven:... 3 Mijn eerste programma
Nadere informatieUitleg: In de bovenstaande oefening zie je in het eerste blokje een LEES en een SCHRIJF opdracht. Dit is nog lesstof uit het tweede trimester.
In onderstaande oefeningen zijn kleuren gebruikt. Deze dienen aleen om de structuren makkelijker terug te kunnen herkennen. Ze worden niet standaard zo gebruikt. De dunne rood/roze balken zijn ook geen
Nadere informatieSnelstartgids KUBO CODING+
Snelstartgids KUBO CODING+ KUBO is de eerste puzzelgebaseerde educatieve robot ter wereld die ontworpen is om leerlingen te veranderen van passieve consumenten in autonome creatoren. Door complexe concepten
Nadere informatieEen korte samenvatting van enkele FORTRAN opdrachten
Een korte samenvatting van enkele FORTRAN opdrachten Inhoud 1 Introductie 3 2 De structuur van een FORTRAN programma 3 3 Datatypen, variabelen en declaraties 3 4 Expressies-volgorde van uitwerking 4 5
Nadere informatieVariabelen gebruiken in ons programma
Hoofdstuk 3 Variabelen introduceren Variabelen gebruiken in ons programma Het zou leuk zijn als ons programma Hallo kan zeggen met de naam van de gebruiker in plaats van het algemene Hallo wereld?. Als
Nadere informatieVaak wil je een code schrijven, waar je verschillende acties uitvoeren voor verschillende beslissingen. Je kan daarbij keuzestructuren gebruiken.
PHP Les 5 : Interessante links: o http://www.dbzweb.be/moermant/ o http://www.ivobrugge.be/cursusweb/html4/formulieren.asp Vaak wil je een code schrijven, waar je verschillende acties uitvoeren voor verschillende
Nadere informatieVakgroep CW KAHO Sint-Lieven
Vakgroep CW KAHO Sint-Lieven Objecten Programmeren voor de Sport: Een inleiding tot JAVA objecten Wetenschapsweek 20 November 2012 Tony Wauters en Tim Vermeulen tony.wauters@kahosl.be en tim.vermeulen@kahosl.be
Nadere informatieWerkblad 3 Bewegen antwoorden- Thema 14 (NIVEAU BETA)
Werkblad 3 Bewegen antwoorden- Thema 14 (NIVEAU BETA) Theorie In werkblad 1 heb je geleerd dat krachten een snelheid willen veranderen. Je kunt het ook omdraaien, als er geen kracht werkt, dan verandert
Nadere informatieIntroductiekaart Niveau B Installatie software
echniek Introductiekaart Niveau B Installatie software 0 Installatie programmeer software - eenmalig Stap. Kijk op de computer of de Mindstorms software geïnstalleerd is. Als hij al geïnstalleerd is kan
Nadere informatieWindows is het meest gebruikte besturingssysteem ter wereld.
2 Windows, inleiding Windows is het meest gebruikte besturingssysteem ter wereld. 2.1 Windows, een eerste verkenning In het vorige hoofdstuk heb je gezien wat een besturingssysteem is. Nu ga je werken
Nadere informatie2 Ik en autisme VOORBEELDPAGINA S
2 Ik en autisme In het vorige hoofdstuk is verteld over sterke kanten die mensen met autisme vaak hebben. In dit hoofdstuk vertellen we over autisme in het algemeen. We beginnen met een stelling. In de
Nadere informatieKennismaken Greenfoot
HOOFDSTUK 1 Kennismaken met Greenfoot onderwerpen: de interface van Greenfoot, omgaan met objecten, methodes aanroepen, een scenario uitvoeren concepten: object, klasse, methode-aanroep, parameter, retourwaarde
Nadere informatieHoofdstuk 26: Modelleren in Excel
Hoofdstuk 26: Modelleren in Excel 26.0 Inleiding In dit hoofdstuk leer je een aantal technieken die je kunnen helpen bij het voorbereiden van bedrijfsmodellen in Excel (zie hoofdstuk 25 voor wat bedoeld
Nadere informatieMACHINES. ... en kralenkettingen. Onderzoeksprogramma Vierkant voor Wiskunde. Wiskundeclubs. Tristan Cranendonk & Joost Langeveld
MACHINES... en kralenkettingen. Onderzoeksprogramma Vierkant voor Wiskunde Wiskundeclubs Tristan Cranendonk & Joost Langeveld Kralenketting machines 1 Uitleg van de gebruikte symbolen: In de kantlijn staan
Nadere informatieHandleiding ISaGRAF. Wil men het programma bewaren, dan is het verstandig een back-up te maken: C9 Back-up / Restore
Handleiding ISaGRAF C Handleiding ISaGRAF Deze handleiding beoogt een korte samenvatting te geven van handelingen die verricht moeten worden om met behulp van ISaGRAF een PLC-programma te schrijven en
Nadere informatieAAN DE SLAG MET DE MBOT!
AAN DE SLAG MET DE MBOT! Robotjes zijn plezant, maar niet altijd makkelijk: omdat er zo veel onderdelen en software in zit kan er vanalles mis lopen. En meestal is dat zelfs niet jouw fout ;-) In dit documentje
Nadere informatieControle structuren. Keuze. Herhaling. Het if statement. even1.c : testen of getal even of oneven is. statement1 statement2
Controle structuren De algemene vorm: 1 bloks door middel van indentatie Keuze Herhaling if expressie :...... In de volgende vorm is het else gedeelte weggelaten: if expressie :... Het if keuze- of conditioneel
Nadere informatieHandleiding bij de Booktest Generator
Handleiding bij de Booktest Generator Het programma voor het maken van toetsen bij boeken. (c) 2005/2009 Visiria Uitgeversmaatschappij Twisk Inleiding Onze dank voor het aanvragen van de Booktest Generator.
Nadere informatieTIPS EN HINTS VOOR BEGINNERS. Klik nu in de Menu balk op het menu item ELEMENT. Onder het woord Element gaat er nu vervolgens nu een sub menu open
........................................ TIPS EN HINTS VOOR BEGINNERS.................................................... Nadat u WinRail 8 heeft geïnstalleerd krijgt u automatisch een leeg werkblad waarop
Nadere informatieExcel reader. Beginner Gemiddeld. bas@excel-programmeur.nl
Excel reader Beginner Gemiddeld Auteur Bas Meijerink E-mail bas@excel-programmeur.nl Versie 01D00 Datum 01-03-2014 Inhoudsopgave Introductie... - 3 - Hoofdstuk 1 - Databewerking - 4-1. Inleiding... - 5-2.
Nadere informatiexxter scripts handleiding
xxter scripts handleiding De basis Scripts beheren Scripts editor Commando s Componentsturing Het bedienen van (andere) scripts Vertragingen toepassen Scenario s, waarschuwingsservice en planner Opdrachten
Nadere informatie1.3 Rekenen met pijlen
14 Getallen 1.3 Rekenen met pijlen 1.3.1 Het optellen van pijlen Jeweetnuwatdegetallenlijnisendat0nochpositiefnochnegatiefis. Wezullen nu een soort rekenen met pijlen gaan invoeren. We spreken af dat bij
Nadere informatieVereiste kennis. 1 Java-editor. 2 Het compileren van een programma
3 Vereiste kennis Dit boek richt zich op het leren programmeren door het oefenen met programmeercodes. Veel theorie komt in het begin niet aan de orde. Dat is een grote uitdaging want het is niet makkelijk
Nadere informatie