GEBRUIK VAN DWENGO IN DE VRIJE RUIMTE

Academiejaar 2011 - 2012

R & 0 VAN TECHNOLOGIE

- ONDERWIJS

GEBRUIK VAN DWENGO IN DE VRIJE RUIMTE VAN HET ZESDE JAAR ASO

Wim Eyckmans

Inhoud Inleiding..............................................................................................................................................4 Aanpak ...............................................................................................................................................6 Module 1: kennismaking met het Dwengo Board ................................................................................8 1.

Doelstellingen .........................................................................................................................8

2.

Uitwerken van de module .......................................................................................................8

3.

2.1.

Het Dwengo Board...........................................................................................................8

2.2.

Dwengo Blocks ................................................................................................................9

2.3.

Een eerste klein programma .......................................................................................... 11

De module in de les gebruiken .............................................................................................. 14

Module 2: een teller en knight rider .................................................................................................. 16 1.

Doelstellingen ....................................................................................................................... 16

2.

Uitwerken van de module ..................................................................................................... 16

3.

2.1.

De teller......................................................................................................................... 16

2.2.

Knight rider.................................................................................................................... 18


Module 3: Gebruik maken van de drukknoppen ................................................................................ 22 1.

Doelstellingen ....................................................................................................................... 22

2.


3.

2.1.

Programmeren in C ........................................................................................................ 22

2.2.

De drukknoppen gebruiken............................................................................................ 24


Module 4: Ontwerpen van een eigen schakeling: lichtsensor ............................................................ 32 1.

Doelstellingen ....................................................................................................................... 32

2.


3.


Module 5: Ontwerpen van een eigen systeem: zonnepanelen naar de zon richten. ........................... 37 1.

Doelstellingen ....................................................................................................................... 37

2.


3.


Module 6: Ontwerpen van een eigen systeem: een verkeerslicht. ..................................................... 42 1.

Doelstellingen ....................................................................................................................... 42

2.


1

3.


Module 7: Aanmaken van een functie: Het LCD display ..................................................................... 46 1.

Doelstellingen ....................................................................................................................... 46

2.


3.


Module 8: Kennismaking met de Dwengo robot. ............................................................................... 52 1.

Doelstellingen ....................................................................................................................... 52

2.


3.


Module 9: Een lichtzoekende robot. ................................................................................................. 56 1.

Doelstellingen ....................................................................................................................... 56

2.


3.


Module 10: Een lijnvolgende robot. .................................................................................................. 61 1.

Doelstellingen ....................................................................................................................... 61

2.


3.


Module 11: Een muurvolgende robot................................................................................................ 65 1.

Doelstellingen ....................................................................................................................... 65

2.


3.


Module 12: Ontwerpen van een spel: Simon Says ............................................................................. 69 1.

Doelstellingen ....................................................................................................................... 69

2.

De module uitwerken ............................................................................................................ 69

3.


Hoe in Nederland? ............................................................................................................................ 75 Programmeren aanleren met instruct ........................................................................................... 76 Visual basic [11]: ....................................................................................................................... 77 Andere programmeertalen........................................................................................................ 78 Conclusie .................................................................................................................................. 80 Gebruik maken van Dwengo ......................................................................................................... 81 Groepswerk en projectmanagement ................................................................................................. 82 Groepswerk .................................................................................................................................. 82 Groepen samenstellen .............................................................................................................. 82

2

Groepssamenstelling ................................................................................................................. 83 Het ontwerpen van de groepsopdracht ..................................................................................... 84 Begeleiden van een groepswerk ................................................................................................ 85 Evaluatie van een groepswerk ................................................................................................... 86 Conclusie .................................................................................................................................. 87 Projectmanagement ..................................................................................................................... 87 Wat is projectmanagement? ..................................................................................................... 87 Het probleem identificeren ....................................................................................................... 88 Het plan van aanpak.................................................................................................................. 88 Conclusie .................................................................................................................................. 91 Reflectie ........................................................................................................................................... 92 Problemen en oplossingen ............................................................................................................ 92 Hoe in de toekomst? ..................................................................................................................... 93 Gevolgen van de beperkte programmeerervaring ......................................................................... 94 Eigen ervaringen tijdens de stage .................................................................................................. 95 Ervaringen van de leerlingen ......................................................................................................... 96 Bibliografie ....................................................................................................................................... 98 Dankwoord ....................................................................................................................................... 99

3

Inleiding In de derde graad van het algemeen secundair onderwijs beschikken scholen over een vrije ruimte. Deze vrije ruimte mogen ze volledig zelf invullen. In het kader van het vak “reflectie en ontwikkeling van technologie – onderwijs” ging ik opzoek naar een zinvolle opvulling van deze ruimte. Voor deze vrije ruimte lijkt het mij zeer interessant om gebruik te maken van de Dwengo robot. Op de leerlingen van de richting wetenschappen – sport na kregen alle leerlingen in de tweede graad het vak informatica. In dit vak zijn de leerlingen echter vooral bezig met alleen de computer. Informatica is echter zoveel meer dan enkel computers. In het dagelijkse leven wordt er enorm veel gebruik gemaakt van informatica: GSM’s, machines in fabrieken, tabletten … . Het is mijn bedoeling om leerlingen te leren hoe ze de Dwengo robot kunnen programmeren met de hoop dat leerlingen inzien dat informatica zoveel meer is dan alleen een computer. Aan de hand van de computer kunnen ze op de robot LED’s laten branden, motoren laten draaien , drukknoppen bedienen … . Deze zaken zijn echter slechts een middel. De bedoeling is om leerlingen in staat te stellen om een gegeven probleem, zoals bijvoorbeeld: programmeer een verkeerslicht, zelfstandig op te lossen. Het ontwikkelen van het algoritmisch denken van de leerlingen staat dus centraal. Naast programmeren alleen zijn er nog veel meer mogelijkheden met de Dwengo robot. De leerlingen kunnen bijvoorbeeld zelf een schakeling bouwen en deze aansturen/programmeren. Ze kunnen ook gebruik maken van de bijgeleverde servomotoren om bijvoorbeeld een systeem te bouwen dat zich steeds naar het licht richt. Zo’n systeem wordt bijvoorbeeld gebruikt bij zonnepanelen. Op die manier kan de Dwengo robot vakoverschrijdend gebruikt worden. Ik zal dan ook gebruik maken van verschillende modules. Deze modules zijn een combinatie van problemen die ik zelf opstelde en tutorials op de site van Dwengo. Ik zal de tutorials echter gedetailleerder uitschrijven zodat leerkrachten ze meteen in de les kunnen gebruiken. Afhankelijk van de tijd en infrastructuur kunnen leerkrachten kiezen welke modules ze zullen gebruiken tijdens de les. In het vervolg van deze tekst zal ik volgende modules bespreken: -

Module 1: Kennismaking met het Dwengo board. Module 2: Een teller en knight rider. Module 3: Gebruik maken van de drukknoppen. Module 4: Ontwerpen van een eigen schakeling: lichtsensor. Module 5: Ontwerpen van een eigen systeem: zonnepanelen naar de zon richten. Module 6: Ontwerpen van een eigen systeem: een verkeerslicht. Module 7: Aanmaken van een functie: Het LCD display Module 8: Kennismaking met de Dwengo robot. Module 9: Een lichtzoekende robot. Module 10: Een lijnvolgende robot. Module 11: Een muurvolgende robot. Module 12: Ontwerpen van een spel: Simon Says.

Voor elke module zal ik de doelstellingen van die module weergeven, het probleem oplossen en volledig uitschrijven en in een laatste puntje zal ik aangeven hoe de module in de les gebruikt kan worden.

4

De Dwengo robot kan op twee verschillende manieren geprogrammeerd worden: met Dwengo blocks en met C – code. Aangezien de leerlingen al een kennis van programmeren hebben kan er vrij snel overgegaan worden naar C – code. Het lijkt mij echter zinvol om bij de eerste kennismaking met Dwengo, de leerlingen gebruik te laten maken van Dwengo blocks. Met Dwengo blocks kunnen de leerlingen grafisch programmeren aan de hand van een soort flowchart. Op deze manier kunnen de leerlingen even de gezien leerstof herhalen en kennismaken met de commando’s die gebruikt worden bij de Dwengo robot. Belangrijk om te vermelden is dat ik bij het begin van dit project een zeer beperkte achtergrond van programmeren had. Door de tutorials op de Dwengo website (www.dwengo.org) te volgen leer je heel snel met de robot werken. Leerkrachten die interesse hebben om gebruik te maken van de Dwengo robot, maar een beperkte programmeerkennis hebben, moeten zich dus zeker en vast niet laten afschrikken! Het ontwikkelen van het lessenpakket voor de vrije ruimte zal duidelijk het grootste deel van dit verslag innemen, maar daarnaast zal ik ook nog enkele nauw aansluitende zaken bespreken. Zo zal ik ook even over de grenzen heen kijken naar Nederland aan de hand van de handboeken van instruct. Hier zal ik aangeven hoe men aan de hand van deze handboeken informatica onderwijs geeft in Nederland en hoe Dwengo in dit plaatje past. Aangezien groepswerk en projectwerk in de huidige maatschappij steeds meer en meer gebruikt worden zal ik ook hier dieper op ingaan. Aan de hand van de Dwengo robot kunnen leerlingen in groep leren werken. Ook projectmanagement kan aan de hand van de robot aangeleerd worden. De vrije ruimte lijkt mij ideaal om deze zaken aan te leren waardoor ik hier ook even bij zal stilstaan. Ten slotte zal ik in een laatste hoofdstuk terugkijken op dit project en er over reflecteren. Ik zal het dan hebben over de problemen en moeilijkheden die ik tegenkwam en hoe ik ze oploste. Ik zal hier ook aangeven hoe ik een zelfde project in de toekomst zal aanpakken aan de hand van de zaken die ik doorheen dit project leerde. Ook mijn ervaringen tijdens de stage, maar ook die van de leerlingen zullen hier opgenomen worden. Als laatste zal ik nog even terugkomen op het feit dat ik maar een beperkte programmeerkennis had bij aanvang van dit project en hoe ik dit doorheen het project ervaren heb.

5

Aanpak Voor ik begin aan de uitleg van de modules is het belangrijk om even terug te komen op hoe ik dit project heb aangepakt. Zoals ik al aangaf had ik bij aanvang van dit project een zeer beperkte programmeerervaring. Voor ik kon beginnen aan het opstellen van de modules moest ik dus zelf leren programmeren en kennismaken met de Dwengo robot. Op de website van Dwengo staan een aantal tutorials met een stijgende moeilijkheidsgraad. Door deze tutorials te doorlopen heb ik mezelf leren programmeren, maar ook gebruik leren maken van de commando’s die typisch zijn aan Dwengo. De ene tutorial was al eenvoudiger te begrijpen als de andere. Sommige tutorials begreep ik vrij snel, maar voor andere (zoals Simon Says) had ik meerdere dagen nodig. De tutorials zijn geschreven in C. Ik wist wel dat er ook een mogelijkheid was om de robot aan de hand van blokdiagrammen te programmeren, maar dit had ik nog niet uitgeprobeerd. Ik maakte kennis met deze manier van programmeren op een workshop van Dwengo op de KHLeuven. Het werd mij tijdens deze workshop duidelijk dat het een eenvoudige manier is om kennis te maken met de Dwengo robot. Dit was dan ook de reden waarom ik beslist heb om bij de eerste twee modules gebruik te maken van Dwengo blocks. Op deze manier kunnen de leerlingen de geziene leerstof eenvoudig herhalen en kennismaken met Dwengo. Na de tutorials en de workshop was het tijd om te beginnen aan de modules. De ideeën voor enkele modules zijn overgenomen van de tutorials op de Dwengo website. Omdat ik hier en daar de stap tussen de tutorials vrij groot vond, heb ik enkele modules zelf toegevoegd. Op deze manier kunnen de leerlingen, zonder veel hulp van de leerkracht, de verschillende modules doorlopen. Het is dan ook de bedoeling dat de leerlingen zoveel mogelijk zelfstandig zaken ontdekken. Voor het opstellen van de modules bepaalde ik wat ik in de module wou bereiken. Aan de hand van deze doelstellingen koos ik dan een opdracht waarmee ik de doelstellingen kan bereiken. Na het oplossen van de opdracht bekeek ik bij elke module hoe deze in de les gebruikt kan worden. Er zijn uiteraard verschillende manieren om een module aan te leren in de les. Het is dan ook de taak van de leerkracht om te bepalen welke didactische werkvorm hij/zij zal gebruiken. Ik geef gewoon bij elke module aan welke werkvorm ik zou gebruiken. Tijdens het ontwikkelen van de modules deed ik ook onderzoek naar andere zaken zoals informatica in Nederland, maar ook hoe groepswerken en projectmanagement in de les gebruikt kunnen worden. Hiervoor maakte ik gebruik van handboeken en van papers die ik op het internet terugvond. Een samenvatting van dit onderzoek vindt u dan ook terug op het einde van dit werk. Bij elk onderzoek geef ik ook mijn mening over de gevonden resultaten. Tot slot moet ik nog kort iets zeggen over mijn aanpak van de stage. Ik mocht 8 uur lesgeven in de vrije ruimte van het 6de middelbaar wetenschappen – wiskunde. Hiervoor koos ik enkele modules die ik in de les wou uittesten. Het was mijn bedoeling om zoveel mogelijk verschillende zaken te proberen. Zo maakte ik gebruik van Dwengo blocks, maar ook van programmeren in C. Ik liet de leerlingen ook zelf schakelingen bouwen om te kijken hoe ze hier mee omgingen. Op het einde liet ik

6

de leerlingen ook een groepswerk uitvoeren. Ik wou dan ook kijken hoe de leerlingen samenwerkten en hoe ze de opdracht aanpakten. De ontwikkeling van de modules, het onderzoek en de bevindingen van de stage vindt u terug in het vervolg van deze tekst.

7

Module 1: kennismaking met het Dwengo Board In deze eerste module zullen de leerlingen kennismaken met de Dwengo robot. Aan de hand van het programma Dwengo Blocks zullen ze de geziene leerstof herhalen. In een eerste puntje zal ik, zoals ik bij alle modules zal doen, de doelstellingen van de module formuleren. In een tweede puntje zal ik de module volledig zelf uitwerken. Het is uiteraard niet de bedoeling dat de leerlingen deze oplossing krijgen of dat de leerkracht dit voordoet en de leerlingen de oplossing gewoon overnemen. Ik werk de module uit omdat ik zo tewerk ben gegaan en omdat het een houvast kan zijn voor leerkrachten die gebruik willen maken van Dwengo. In een laatste puntje zal ik dan aangeven hoe de module tijdens de les gebruikt kan worden. Het idee voor deze module komt van de Dwengo workshop die ik bijwoonde in de KHLeuven. Een groepje leerlingen leerde op deze manier Dwengo (Blocks) kennen.

1. Doelstellingen Zoals eerder aangegeven is het de bedoeling dat de leerlingen in deze module kennismaken met de Dwengo robot. Ze leren enkele commando’s die typisch zijn aan de Dwengo robot zoals een LED aanzetten en uitzetten. Daarnaast herhalen ze aan de hand van Dwengo Blocks de leerstof die ze eerder leerden in de lessen informatica. In deze module herhalen de leerlingen de while – lus en de delay opdracht.

2. Uitwerken van de module 2.1.

Het Dwengo Board USB aansluiting

Aansluiting voeding LCD Display

Dwengo breadboard

5 Drukknoppen

Programmer aansluiting + programmer

8 Led’s

Figuur 1: Dwengo Board [1]

8

Acht Led’s: De leerlingen kunnen de 8 LEDs afzonderlijk aansturen. Elke LED kan aangestuurd worden door gebruik te maken van zijn nummer. Van rechts naar links hebben de LEDs een nummer van 0 tot en met 7. Vijf knoppen: De leerlingen kunnen ook gebruik maken van vijf drukknoppen. De middelste knop kan aangestuurd worden met de letter C (center), de overige vier met de eerste letter van de overeenkomstige windstreek: E (east), N (north), W (west) en S (south). LCD scherm: Op het LCD scherm kunnen de leerlingen zelf een tekst tonen. Het scherm heeft twee lijnen van 16 tekens. Door het scherm juist te programmeren kan een langere tekst rollend over het scherm weergegeven worden (zie module 7). USB aansluiting: Deze kan gebruikt worden om het Dwengo board via de computer van stroom te voorzien. Via deze aansluiting kan echter NIET geprogrammeerd worden. Aansluiting voeding: Via deze aansluiting kan je met de bijgeleverde voeding het Dwengo board aansluiten op het stopcontact. Programmer aansluiting: Hierop kan je de programmer aansluiten waarop je dan een USB kabel kan aansluiten. Het Dwengo board wordt dan ook van stroom voorzien en je kan het Dwengo board dan ook programmeren. Dwengo breadboard: Op het breadboard kunnen de leerlingen zelf een schakeling bouwen. 2.2.

Dwengo Blocks

Dwengo Blocks is een gratis online toepassing waarbij de leerlingen aan de hand van een soort van flow chart de Dwengo robot kunnen programmeren. Aan de hand van Dwengo Blocks kunnen de leerlingen de geziene theorie herhalen en tegelijkertijd kennismaken met de Dwengo robot. Het lijkt mij dan ook zinvol om in een eerste les gebruik te maken van Dwengo blocks. De leerlingen kunnen op deze manier ook al snel beginnen programmeren waardoor ze snel resultaten zien. Dit komt de motivatie alleen maar ten goede. De toepassing heeft ook de mogelijkheid om het gecreëerde blokdiagram om te zetten in C – code. Op deze manier kan dus eenvoudig de link gelegd worden naar programmeren in C. In het verdere verloop van de modules zal ik dan ook overschakelen van Dwengo Blocks naar programmeren in C.

9

Dwengo Blocks kan je vinden op: http://blocks.dwengo.org . Wanneer je de link opent krijg je volgend scherm te zien:

Figuur 2: Dwengo Blocks

De makers van Dwengo, en dus ook van deze toepassing, geven aan dat je Dwengo Blocks het best opent in google chrome. Je kan google chrome ook gratis downloaden op volgend adres: www.google.com/chrome . Wanneer we het basisscherm van Dwengo Blocks bekijken kunnen we volgende zaken onderscheiden:    

   

Links bovenaan kan je een demo openen. Dit is een voorbeeldprogramma dat standaard in de toepassing zit. Door op “new graph” te klikken open je een leeg blokdiagram. De “hex” knop kan gebruikt worden om het geschreven programma naar de Dwengo robot te schrijven. Hier komen we later op terug. Met “save” en “bestand kiezen” kan je het blokdiagram opslaan of een bestaand blokdiagram openen. Het is zeker en vast aan te raden om regelmatig het blokdiagram op te slaan. Rechts zien we een afbeelding van het Dwengo board. Door op de playknop te klikken kan je het programma testen zonder het al naar de Dwengo robot te schrijven. Wanneer je op de knop helemaal rechts klikt wordt het blokdiagram weergegeven in C – code. Centraal in het beeld wordt het programma opgebouwd. Het programma loopt logischerwijs van het blauwe naar het groene bolletje. Links vind je de elementen die gebruikt kunnen worden in het programma. In de verschillende modules zullen we gebruik maken van deze elementen.

10

Op het moment dat dit werk geschreven wordt is Dwengo Blocks nog in de bèta fase. Er zijn dus nog een aantal kleine bugs in het programma. Belangrijk om te weten is dat het af te raden is om de backspace toets te gebruiken. Omdat je werkt in een browser zal er dan worden teruggegaan naar de vorige pagina. Het geschreven programma is dan dus verloren. De makers werken wel hard aan het oplossen van de bugs. De toepassing wordt dan ook regelmatig vernieuwd. Meer info over Dwengo Blocks kan je terugvinden op volgende website: http://www.dwengo.org/nl/blog/teaser-dwengo-blocks 2.3.

Een eerste klein programma

Het eerste programma is zeer eenvoudig. We slepen gewoon een geel blokje in het main programma. Een geel blokje wordt gebruikt wanneer we willen dat de Dwengo robot iets doet. Met het gele blokje zullen we een methode oproepen die in de bibliotheek aanwezig is. Dit kan gaan van LEDs laten branden tot motoren laten draaien, maar ook om waarden van sensoren (zie later) uit te lezen. We zien dat volgende commando in het blokje staat: “setLed();”. Met dit commando kunnen we een LED aanzetten. Zoals eerder aangegeven hebben de LEDs een nummer van 0 tot en met 7 en dit van rechts naar links. Door op het blokje te klikken kan je ingeven welke LED je wil laten branden. Op volgende voorbeeld zal de derde LED (van rechts te beginnen) aangezet worden.

Figuur 3: Een eerste klein programma

11

Als we nu op de playknop klikken zien we dat de derde LED gaat branden. In een volgende stap gaan we de LED laten flikkeren. Hiervoor moeten we de LED dus ook terug uitzetten. Dit doen we door terug een geel blokje in het programma te slepen. We klikken terug op het blokje en selecteren het commando “clearLed” en doen dit voor LED 2. Als je nu op de play knop klikt zien we dat de LED één keer zeer snel flikkert. Er zijn dus nog twee problemen: de LED gaat veel te snel uit en ze flikkert maar 1 keer. Het eerste probleem lossen we op met een “delay” commando. Met dit commando pauzeert het programma even. Wanneer we tussen het “setLed” en “clearLed” commando een delay van 500 ms plaatsen zal de LED 0,5 s branden voor hij wordt uitgeschakeld. Het “delay” commando voegen we ook toe met een geel blokje. Ook achter het “clearLED” commando plaatsen we een “delay” commando zodat de LED eerst 0,5 s uitgeschakeld is voor we ze weer aanschakelen. Om het tweede probleem op te lossen moeten we ervoor zorgen dat het programma steeds opnieuw doorlopen wordt. Dit kunnen we oplossen met een “while(TRUE) – lus”. De while – lus vinden we ook aan de linker kant. Deze heeft een paarse kleur. Wanneer je op de while – lus klikt kan je in het lege vakje TRUE typen. Intermezzo: While(TRUE) – lus: Tijdens de lessen informatica hebben de leerlingen al leren werken met een while – lus. Het begrijpen van deze lus mag dus geen probleem zijn. De leerlingen hebben misschien echter wel geleerd dat ze een oneindige lus beter niet gebruiken. We zouden bijvoorbeeld ook een while – lus kunnen gebruiken die blijft lopen tot een knop wordt ingedrukt. Wanneer we het programma echter naar de robot schrijven, zal de programmer zelf een while(TRUE) – lus rond het programma toevoegen. Als de leerlingen dit zelf doen, zijn ze zich ervan bewust dat deze lus gebruikt wordt. Daarnaast moet de code in de lus ook heel de tijd opnieuw doorlopen worden. Dit is het geval bij een while(TRUE) – lus. Daarom heb ik ervoor gekozen om gebruik te maken van een while(TRUE) – lus.

Volgende figuur geeft aan hoe we een while - lus toevoegen.

Figuur 4: Invoegen van een while lus

12

In het paarse blokje (de while – lus) zal een logische opdracht als test uitgevoerd worden. Indien deze opdracht de waarde “TRUE” terug geeft zal de lus uitgevoerd worden. Na het doorlopen van de lus zal de logische opdracht opnieuw getest worden. Indien deze weer de waarde “TRUE” teruggeeft zal de lus opnieuw doorlopen worden. Zodra de opdracht de waarde “FALSE” teruggeeft zal er uit de lus gesprongen worden. Wanneer we dus als voorwaarde “TRUE” gebruiken zal de logische opdracht steeds de waarde “TRUE” teruggeven. De lus wordt dan dus steeds opnieuw doorlopen. Als we nu het programma van LED 3 in de “yes” kant van de while – lus plaatsen is het programma klaar. Volgende figuur geeft het blokdiagram van het volledige programma weer:

Figuur 5: LED 3 laten flikkeren

Als we nu op de playknop klikken zien we dat de derde led blijft flikkeren. Belangrijk om te vermelden is dat wanneer je een fout maakt, je het blokje gewoon naar de prullenbak (onderaan links) kan slepen. Ook bij het instellen van de while – lus is een prullenbak. Wanneer je een foute voorwaarde aan de lus koppelt kan je ze dus ook gewoon naar de prullenbak slepen. Nu we ons eerste werkend programma hebben, kunnen we dit naar onze robot schrijven. Hiervoor kunnen we gebruik maken van een eenvoudige toepassing die ontwikkeld werd door de makers van Dwengo. Je kan deze toepassing echter (nog) niet downloaden op de website. Wanneer je de makers een mail stuurt, zullen ze de toepassing echter met plezier doorsturen.

13

Aan de hand van de toepassing is het heel eenvoudig om het programma naar de robot te schrijven. Door in Dwengo Blocks op “hex” te klikken wordt het programma gecompileerd en dus omgezet in een code die de microprocessor verstaat. Je kan dan een hex – file downloaden. Deze hex – file moet je dan opslaan in de map van de toepassing. Het is wel belangrijk dat de hex – file altijd de naam “code.hex” heeft, anders zal de toepassing niet werken. Als je nu dubbelklikt op “program” wordt de hex – code naar de robot geschreven. Zolang het streepje in het geopende scherm ronddraait is de programmer de code aan het wegschrijven. Zodra de code naar de robot geschreven is zal het programma starten. In dit geval begint de derde LED dus meteen te flikkeren.

3. De module in de les gebruiken Zoals eerder aangegeven is het de bedoeling dat de leerlingen zoveel mogelijk zelfstandig alles ontdekken. Voor we kunnen beginnen programmeren moet de leerkracht echter wel een korte inleiding geven over Dwengo. Op de website van Dwengo staan talloze filmpjes die gebruikt kunnen worden als introductie. Doordat de leerlingen zien wat ze met de robot kunnen en zullen doen, zullen ze alleen maar gemotiveerder zijn. In een tweede fase kan de leerkracht dan Dwengo Blocks openen en even de basisfuncties toelichten. Het is zeker nuttig om aan te geven dat de leerlingen het programma kunnen simuleren. Het is dus niet nodig om het programma elke keer opnieuw naar de robot te schrijven. Deze inleiding moet echter niet lang duren, de leerlingen kunnen snel zelf aan de slag met Dwengo Blocks. In een eerste opdracht moeten ze dan gewoon een geel blokje naar het programma slepen en aangeven wat er hierdoor zal gebeuren. Aan de hand van dit eerste blokje moeten de leerlingen dan zelf de nummering van de LEDs achterhalen. In een tweede opdracht moeten ze een LED laten flikkeren. Door zelf de mogelijke commando’s te doorlopen moeten de leerlingen in staat zijn om de LED aan te zetten en uit te zetten. Vanaf nu heeft de leerkracht een ondersteunende rol. Door gerichte vragen te stellen, al dan niet klassikaal, moet de leerkracht de leerlingen in de juiste richting sturen. De leerlingen moeten zo zelf achterhalen dat ze een delay functie moeten gebruiken om de LED trager te laten flikkeren. Je kan dit doen door de leerlingen te laten inzien dat ze het programma moeten “pauzeren”. Door zelf de mogelijke commando’s te doorlopen zullen de leerlingen dan inzien dat ze hiervoor een delay functie moeten gebruiken. Door het programma te simuleren zien de leerlingen zelf dat de LED maar 1 keer flikkert. Aangezien ze in de lessen informatica de while – lus al geleerd hebben, moeten ze er zelf kunnen achter komen dat ze deze nodig hebben. Indien dit niet het geval is kan de leerkracht ook hier de leerlingen doormiddel van gerichte vragen in de juiste richting sturen. Door de leerlingen te laten aangeven dat het aan – en uitzetten elke keer herhaald moet worden, zullen ze de link met de while – lus sneller leggen. Voor de voorwaarde “TRUE” is er echter wel meer uitleg nodig. Zoals eerder aangegeven is de kans groot dat de leerlingen geleerd hebben dat ze een oneindige while – lus moeten vermijden. De leerkracht moet dan dus uitleggen waarom we er in dit geval gebruik van maken. Eventueel kunnen

14

de leerlingen ook gebruik maken van een lus die blijft lopen zolang er geen knop wordt ingedrukt. De leerkracht moet dan wel nog altijd aangeven dat de programmer zelf een while(TRUE) – lus toevoegt om ervoor te zorgen dat de leerlingen de volledige werking begrijpen.

15

Module 2: een teller en knight rider In deze module moeten de leerlingen al echt algoritmisch beginnen denken. Ik heb de module bewust opgesplitst in 2 delen: de teller en de knight rider. Bij het programmeren van de teller maken de leerlingen kennis met het LCD scherm en variabelen. De knight rider bouwt voort op deze teller. Er moeten nu echter twee while – lussen gebruikt worden. Zoals eerder gezegd stijgt de moeilijkheid dus doorheen de verschillende oefeningen. Het idee van de knight rider komt van de Dwengo website [2]. Ik vond de stap naar de knight rider echter te groot waardoor ik de teller zelf heb toegevoegd. Op deze manier leren de leerlingen ook werken met het LCD display.

1. Doelstellingen In deze module leren de leerlingen gebruik maken van het LCD scherm. Daarbij herhalen ze ook de theorie van de variabelen die ze in eerdere lessen informatica leerden. Vanaf deze module wordt algoritmisch denken ook een doelstelling. Het is dan ook de bedoeling dat de leerlingen eerst nadenken voor ze beginnen programmeren. Het opstellen van een stappenplan zal het algoritmisch denken stimuleren.


De teller

We zullen een programma schrijven voor een teller die op het LCD scherm tot 10 telt. Het eerste wat we doen is een variabele creëren waarop we de telbewerking zullen uitvoeren. Dit doen we door op het blauwe bolletje te klikken. De variabele wordt dus op deze plaats gedeclareerd:

Figuur 6: Variabele aanmaken

Aangezien we zullen tellen voegen we een int variabele toe. We noemen deze “teller”.

16

Voor we aan het programma beginnen, bepalen we eerst de verschillende stappen in het programma: 1. 2. 3. 4. 5. 6. 7.

Aan “teller” waarde 0 geven. Het licht van het LCD scherm aanzetten. “teller” op het LCD scherm weergeven. De waarde 0,5 seconden weergeven. Bij “teller” 1 optellen. Het LCD scherm leegmaken. Stap 3 t.e.m. 6 doorlopen tot “teller” de waarde 11 heeft.

In dit programma moeten we dus telkens een nieuwe waarde aan de variabele toekennen. Hiervoor zullen we gebruik maken van toekenningsopdrachten. Met het groene blokje kunnen we toekenningsopdrachten aan het programma toevoegen. We slepen dus een groen blokje naar ons programma en schrijven hier het commando “teller = 0” in. Daarna zetten we het licht van het LCD scherm aan met een geel blokje en het commando “backlightOn();”. Stap 3 t.e.m. 6 moeten we doorlopen tot “teller” een waarde van 11 heeft. We voegen dus een while – lus toe met als voorwaarde “teller < 11”. De while – lus zal nu dus doorlopen worden zolang “teller” een waarde heeft kleiner dan 11. Dan komen we aan stap 3. We geven een waarde op het LCD scherm weer met een geel blokje en het commando “printIntToLCD();”. Als nummer kiezen we “teller”, als lijn kiezen we 1 (we hebben de keuze uit 2 lijnen) en als positie kiezen we 0 (er zijn 16 posities: van 0 t.e.m. 15). Voor stap 4 voegen we weer een delay van 500 ms in. Bij stap 5 voeren we weer een bewerking uit. Hiervoor gebruiken we een toekenningsopdracht. We hebben dus een groen blokje nodig. In dit blokje plaatsen we het commando: “teller = teller + 1”. Bij de waarde teller wordt dan dus 1 opgeteld en deze nieuwe waarde wordt weer in teller opgeslagen. Als laatste stap moeten we het LCD scherm leegmaken. Bij dit programma zou het niet echt een probleem zijn, maar als we bijvoorbeeld zouden aftellen van 10 naar 9 zouden achtereenvolgens de waarden 10  19 verschijnen omdat de 1 voor de 9 niet verwijderd is. We maken er dus best een gewoonte van om het LCD scherm leeg te maken voor we er een nieuwe waarde opschrijven. Hiervoor gebruiken we een geel blokje en het commando “clearLCD”. Het programma is nu klaar. Op onderstaande figuur vind je het volledige blokdiagram terug. Door op de playknop te klikken kan je het programma testen. Als het programma goed werkt kan je het naar de Dwengo robot schrijven zoals eerder werd uitgelegd. De ene leerling zal sneller klaar zijn dan een andere leerling. Om ervoor te zorgen dat niemand met zijn vingers zit te draaien kan je extra opdrachten voorzien. Enkele voorbeelden hiervan zijn:  

Op de C knop drukken voor het programma begint te tellen. De tekst op het LCD display aanpassen. Bijvoorbeeld: “Optellen “ en dan de waarde van “teller”.

17



Achtereenvolgens op en af tellen van 0 tot 10 en van 10 tot 0. (Dit is een goede voorbereiding op het volgende programma: “knight rider”.

De extra opdracht is echter geen middel om de leerlingen bezig te houden. Het doel blijft het algoritmisch denken van de leerlingen ontwikkelen. De extra opdracht is daarom moeilijker dan de originele opdracht. Door het uitvoeren van de extra opdracht moeten de leerlingen dus een moeilijkere code opbouwen. Op die manier werken ze dus aan hun algoritmisch denken. De extra opdrachten in verdere modules steunen ook op dit principe.

Figuur 7: De teller

2.2.

Knight rider

De eerste vraag is: wat is een knight rider? Als voorbeeld, ook voor de leerlingen, kan je hiervoor een filmpje op youtube opzoeken. (Bijvoorbeeld: http://www.youtube.com/watch?v=Mo8Qls0HnWo begin van de video, de LEDs op de wagen.) De bedoeling is dus dat we bij de 8 LEDs een LED van rechts naar links en omgekeerd laten lopen. We gaan weer werken met een variabele en noemen deze weer “teller” . Voor we beginnen aan het programmeren stellen we weer een stappenplan op: 1. Aan “teller” de waarde 0 geven. 2. De LED met waarde “teller” doen oplichten. 3. De LED 10 ms laten branden.

18

4. De LED met waarde “teller” uitschakelen. 5. Bij de waarde van “teller” 1 optellen. 6. Stap 2 t.e.m. 5 doorlopen tot “teller” de waarde 7 heeft. 7. 8. 9. 10. 11.

De LED met waarde “teller” doen oplichten. De LED 10 ms laten branden. De LED met waarde “teller” uitschakelen. Van de waarde van “teller” 1 aftrekken. Stap 7 t.e.m. 10 doorlopen tot “teller” de waarde 0 heeft.

12. Stap 2 t.e.m. 11 continu laten doorlopen. Alle lussen en commando’s die nodig zijn voor dit programma kennen we al. We combineren gewoon wat we gezien hebben bij “de teller” en bij module 1. Voor het programma zullen we gebruik maken van drie while – lussen. Eén while(TRUE) lus waarin we het hele programma zullen plaatsen. Hiermee zorgen we ervoor dat het programma constant doorlopen wordt. Eén while – lus met de voorwaarde “teller < 7” deze gebruiken we voor stap 2 t.e.m. 6 en één lus met als voorwaarde “teller > 0” voor stap 7 t.e.m. 11. De tweede lus komt in de “no” zijde van de eerste while – lus. Daardoor wordt ze uitgevoerd als we uit de eerste while – lus springen. In de twee lussen moeten we een LED aanschakelen, gebruik maken van de delay functie, een LED uitschakelen en een toekenningsopdracht uitvoeren. Wanneer we al deze zaken in het programma plaatsen bekomen we volgend programma:

Figuur 8: Knight Rider

19

Ook nu kunnen leerlingen, wanneer ze sneller klaar zijn, verder werken aan extra opdrachten waardoor ze nuttig bezig blijven. Een voorbeeld hiervan is een tekstje op het LCD – display laten verschijnen of zelfs tellen hoe vaak de LED heen en weer beweegt. Belangrijk om te zeggen is dat je dit programma op meerdere manieren kan realiseren. In mijn opzicht is dit de eenvoudigste oplossing, maar dat wil absoluut niet zeggen dat andere oplossingen fout zijn. Wat wel af te raden is, is dat leerlingen zelf LED per LED gaan in en uitschakelen. Met 8 LEDs is dit nog mogelijk, maar wanneer we over 20 LEDs spreken is dit niet meer haalbaar. De gesuggereerde oplossing is eenvoudig uit te breiden tot meerdere LEDs.

3. De module in de les gebruiken Net zoals bij module 1 is het de bedoeling dat de leerlingen het programma bouwen. De leerkracht heeft enkel een ondersteunende rol. Het is dus duidelijk niet de bedoeling dat de leerkracht alles voordoet en de leerlingen dit gewoon overnemen. Het is de taak van de leerkracht om de leerlingen aan de hand van gerichte vragen in de juiste richting te sturen. Voor de leerlingen beginnen programmeren is het misschien wel nuttig om even de theorie van een variabele te herhalen. Je kan dit bijvoorbeeld doen door aan de leerkracht informatica te vragen hoe hij/zij deze theorie heeft aangeleerd en welke oefening hij/zij hiervoor gebruikt heeft. Op deze manier kan je de leerlingen zelf laten aangeven wat een variabele is. De leerlingen zullen dan ook aangeven dat ze op deze variabele bewerkingen / toekenningsopdrachten kunnen uitvoeren. Voor de leerlingen echt “losgelaten worden” kan de leerkracht nog even aangeven hoe de leerlingen in Dwengo Blocks een variabele moeten aanmaken. De leerkracht kan ook aangeven dat voor toekenningsopdrachten het groene blokje nodig is. Aangezien de leerlingen al weten dat het gele blokje dient om commando’s uit te voeren, zullen de leerlingen zelf snel door hebben dat het groene blokje dient om toekenningsopdrachten uit te voeren. De leerlingen kunnen nu beginnen met het programmeren van de teller. Sommige leerlingen zullen hier snel mee weg zijn, andere zullen er iets meer moeite mee hebben. Het is dan ook misschien geen slecht idee om de sterke leerlingen uitleg te laten geven aan de zwakkere leerlingen. Op deze manier zullen de zwakkere leerlingen snappen wat ze moeten doen en de sterkere leerlingen krijgen (nog) meer inzicht in de leerstof omdat ze deze moeten uitleggen. Het is wel belangrijk dat de sterke leerlingen niet zomaar het antwoord cadeau geven aan de minder sterke leerlingen. De leerkracht kan hier dus eventueel ook wat didactiek bijbrengen bij de sterkere leerling. Wanneer hetzelfde probleem bij meerdere leerlingen voorkomt moet je dit als leerkracht niet aan elke computer uitleggen. Je kan het probleem dan voorleggen aan de hele klas en op die manier klassikaal tot een oplossing komen. Het is hierbij weer belangrijk dat je de vragen van de leerlingen beantwoordt met vragen. Zoals eerder aangegeven kan/moet je voor de leerlingen die sneller klaar zijn extra opdrachten voorzien. Als leerkracht moet je ervoor zorgen dat de leerlingen nuttig bezig blijven met de leerstof. Wanneer zo goed als alle leerlingen de oplossing gevonden hebben (of toch zeker in de goeie richting aan het denken zijn) kan je VOOR je overgaat naar de knight rider de oplossing van de teller klassikaal overlopen. De leerlingen moeten dan aangeven waarvoor elk blokje dient en waarom het gebruikt

20

wordt. Leerlingen die de oplossing nog niet volledig snapten of gevonden hadden zullen op deze manier de oplossing begrijpen. Aangezien de knight rider verder bouwt op de teller is het zeer belangrijk dat de leerlingen de oplossing van de teller begrijpen. Wanneer je als leerkracht merkt dat een leerling ook na de klassikale bespreking nog steeds moeilijkheden heeft met de oplossing, kan je de oplossing nogmaals individueel gaan bespreken. De leerlingen die de oplossing wel begrepen hebben moeten de uitleg geen twee keer krijgen. Zij kunnen dan dus beginnen aan de knight rider. Zoals eerder aangegeven moeten de leerlingen eerst weten wat een knight rider is. Op Youtube zijn er talloze filmpjes te vinden. Ook op de website van Dwengo staat een filmpje waarop de werking van een knight rider duidelijk is. De leerlingen kunnen daarna zelfstandig aan de oefening werken. Een probleem dat kan optreden is dat de leerlingen niet doorhebben dat ze de LEDs met een variabele kunnen aansturen. Dit probleem is echter eenvoudig op te lossen. Door klassikaal de vraag te stellen “wat zou er gebeuren als ik daarnet de waarde van de teller in het commando setLed() zou plaatsen?”. De leerlingen zullen dan zelf aangeven dat de LED met waarde “teller” zal oplichten. Ze zullen dan ook doorhebben dat naarmate de teller optelt, telkens 1 LED verder zal oplichten. Op deze manier is het dus zeer duidelijk hoe ze aan het programma moeten beginnen. Een tweede probleem dat zal optreden is een foute voorwaarde in de while – lussen. Hierdoor zal LED 0 en/of 7 twee keer oplichten of helemaal niet oplichten. De leerlingen hebben echter de kans om het programma te simuleren. Ze kunnen dan dus hun voorwaarde aanpassen en kijken of dit het probleem oplost. Als leerkracht kan je de leerlingen hier weer in de juiste richting sturen. Het is echter ook belangrijk dat de leerlingen weten waarom ze die welbepaalde voorwaarde gebruiken. Je kan hiervoor de leerlingen laten uitleggen wat er in de lus gebeurt. Op die manier wordt het snel duidelijk welke leerling het programma begrijpt en welke niet. Indien nodig kan je de leerlingen hier dus bijsturen. Net als bij de teller moet je extra opdrachten voorzien voor de leerlingen die sneller klaar zijn. Wanneer ongeveer alle leerlingen klaar zijn is het nuttig om de oplossing klassikaal te bespreken. De leerlingen moeten dan weer aangeven wat elk blokje doet en waarom het gebruikt wordt. Aan de hand van deze bespreking zullen de meeste leerlingen de werking begrijpen. Wanneer een leerling het toch nog moeilijk heeft met de oplossing kan hier individueel op teruggekomen worden. Het is zeker ook aan te raden om met de leerlingen even te bekijken wat ze gepresteerd hebben. De leerlingen maken hier namelijk gebruik van geneste lussen (een lus die op zijn beurt een of meerdere lussen bevat). Dit is iets wat de leerlingen in het vierde jaar ASO niet geleerd hebben. Door aan te geven dat de leerlingen hier al gebruik van maken in één van de eerste programma’s die ze ontworpen hebben, zullen volgens mij een aantal leerlingen extra gemotiveerd raken. Ze zien namelijk dat ze wel degelijk verder staan dan in het vierde jaar en ze beseffen dat ze zelfstandig al een eerder complex programma gemaakt hebben.

21

Module 3: Gebruik maken van de drukknoppen In de vorige modules leerden de leerlingen al gebruik maken van de LEDs en van het LCD scherm. Het enige wat nu nog overblijft zijn de drukknoppen. In deze module zullen de leerlingen dan ook kennis maken met de drukknoppen. Daarnaast zullen we ook overstappen van Dwengo Blocks naar programmeren in C. Alle opdrachten in deze module heb ik zelf opgebouwd. Op de website van Dwengo is de eerste tutorial waarin de drukknoppen gebruikt worden “Simon Says”. Deze tutorial is in mijn ogen echter zeer moeilijk. Daarom heb ik gekozen voor eenvoudigere oefeningen om de leerstof verder op te bouwen. Simon Says komt wel nog terug in de laatste module.

1. Doelstellingen In deze module leren de leerlingen werken met de drukknoppen. Ze leren de drukknoppen gebruiken als voorwaarde van o.a. de lussen. Daarnaast leren de leerlingen ook programmeren in C. Ze leren de syntax kennen en moeten ervoor zorgen dat de code overzichtelijk blijft. De opdrachten worden ook steeds langer en complexer. Het algoritmisch denken van de leerlingen zal zich dan ook meer en meer ontwikkelen.


Programmeren in C

Vanaf nu worden de programma’s steeds langer en langer. Dwengo blocks wordt dan naar mijn gevoel steeds minder overzichtelijk. De leerlingen hebben in de vorige modules ook kennis gemaakt met enkele basiscommando’s van de Dwengo robot. We kunnen daarom overschakelen naar programmeren in C. 2.1.1. Het programma installeren Op de website van Dwengo kan je vinden hoe je het programma moet installeren. Toen ik het programma installeerde kwam ik echter wat problemen tegen. Daarom hier een overzicht van hoe ik het programma, werkend, installeerde: 1. Programma’s downloaden: (zie ook Dwengo website) a. Download de C18 compiler op http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406 &dDocName=en010014 b. Download MicroShip MPLAB IDE http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406 &dDocName=en019469&part=SW007002#P167_6858 2. Installeer de C18 compiler. Volg hiervoor gewoon de stappen van het installatie proces. Enkel wanneer er gevraagd wordt naar de installatie map kies je als map: “C:\MCC18”. 3. Doe hetzelfde voor MicroShip MPLAB IDE. Installeer ook dit programma in dezelfde map.

22

4. Als laatste moeten we nog de Dwengo library installeren. Deze library maakt het programmeren een stuk eenvoudiger. a. Download de library op http://www.dwengo.org/files/dwengo-library.zip . b. Unzip de file en kopieer de inhoud naar C:\MCC18\lib en C:\MCC18\h. Alles wat we nodig hebben is nu geïnstalleerd. Je kan het programma openen door op het bureaublad te dubbelklikken op “MPLAB IDE v8.83” (rood icoontje). 2.1.2. Stappenplan om te programmeren Elke keer als we een programma maken voor de Dwengo robot moeten er een aantal stappen doorlopen worden. Daarom bespreek ik hier even het stappenplan: 1. Project creëren: a. Klik in de menubalk op “project” en dan “project wizard” en klik op volgende. b. Selecteer als device “PIC18F4550” en klik op volgende. c. Selecteer de MPLAB C18 C Compiler en klik op volgende. d. Klik op “Browse”, kies waar je het project wil opslaan, geef het project een naam en klik op opslaan en dan op volgende. e. Klik nogmaals op volgende en dan op voltooien. 2. Library toevoegen: a. Klik met je rechtermuisknop op het mapje “Library Files” en klik op “Add Files”. b. Selecteer “dwengo.lib” in de map C:\MCC18\lib. c. Klik op openen. 3. Code schrijven: a. Klik in het menu op “Project” en dan op “Add New Files To Project …” b. Kies de locatie waar je het C – bestand wil opslaan (normaal gewoon dezelfde locatie als het project). c. Geef het bestand een naam en zet achter de naam “.c” !!! (vb.: code.c). d. Klik op opslaan. e. Nu kan je in het scherm met de naam van je C – bestand de code schrijven. De code die we in de volgende modules zullen opstellen moet je dus hier typen. 4. De code compileren: a. Klik met je rechtermuisknop op het mapje “Linker Script” en klik op “Add Files”. b. Ga naar de map C:\MCC18\bin\LKR, selecteer het bestand 18f4550_g.lkr en klik op openen. c. Klik in het menu op “project” en dan op “Build All”. i. Als er geen fouten in de code staan krijg je de melding “Build Succeeded”. ii. Als er wel fouten in de code staan krijg je de melding “Build Failed” 1. Zoek in de blauwe tekst naar c : “nummer” : Error 2. Klik op dit nummer 3. Nu kom je op de lijn waar de fout staat. Verbeter de fout en klik weer op “Build All” 4. Blijf dit doen tot je de melding “Build Succeeded” krijgt.

23

5. De Dwengo robot aansluiten: a. Sluit de Dwengo robot op dezelfde manier aan als we deden bij het programmeren met Dwengo Blocks. 6. De Dwengo robot programmeren: a. Klik in het menu “Programmer” op “Select Programmer” en kies dan “PICkit2”. b. Klik dan op “Program” in het menu “Programmer”. c. Klik dan in het menu “Programmer” op “Release From Reset”. d. Het programma staat nu op de Dwengo robot en is klaar om uitgevoerd te worden. Je kan nu nog steeds aanpassingen aanbrengen in je code. Na de aanpassingen doorloop je gewoon terug stap 4, 5 en 6. 2.2.

De drukknoppen gebruiken

Naast LEDjes staan er ook drukknoppen op het Dwengo board. Dankzij de Dwengo library kunnen we heel eenvoudig gebruik maken van de drukknoppen. Met volgende code kunnen we de drukknoppen gebruiken: -

SW_C: de centrale drukknop SW_E: de rechter drukknop (east) SW_W: de linker drukknop (west) SW_N: de bovenste drukknop (north) SW_S: de onderste drukknop (south)

We zullen de drukknoppen gebruiken als voorwaarde in o.a. lussen. We zullen dan ook gebruik maken van volgende voorwaarden: “SW_C == PRESSED” (als er op knop C gedrukt wordt) en “SW_C != PRESSED” (als er niet op knop C gedrukt wordt). Op die manier kunnen we dus controleren of de knop al dan niet ingedrukt wordt. 2.2.1. Een eerste programma in C Als kennismaking met het programmeren in C gaan we het programma van onze knight rider bekijken en hier enkele zaken in aanpassen. Zoals eerder aangegeven kan je in Dwengo Blocks het blokdiagram omzetten in C code. Deze code kan je dan kopiëren naar het venster in MPLab waar je de C – code moet schrijven. Door het eerder opgestelde stappenplan te volgen kan je de code naar de robot schrijven en dan zie je dat we inderdaad de C – code voor een knight rider hebben. Als eerste aanpassing zullen we nu de tekst “knight rider” op het scherm laten verschijnen. Dit stukje code zullen we toevoegen voor de while(TRUE) – lus. De tekst moet maar één keer naar het LCD – scherm geschreven worden. Wanneer we de code in de lus zouden plaatsen wordt de tekst telkens opnieuw naar het scherm geschreven en dit is niet nodig. Uit Dwengo Blocks weten we al welke commando’s we moeten gebruiken. Op deze manier kunnen we de code zeer eenvoudig toevoegen: backlightOn(); printStringToLCD("Knight Rider!",0,0);

24

Zoals je kan zien zijn deze commando’s identiek aan de commando’s uit Dwengo Blocks. Merk op dat er na elk commando een “;” staat! Bij een tweede aanpassing zullen we ervoor zorgen dat de knight rider pas gestart kan worden als er op de C – knop gedrukt wordt. We zullen dan ook een boodschap op het LCD – scherm weergeven waardoor de gebruiker weet dat hij op de C – knop moet drukken. Het moeilijke aan dit stukje code is ervoor zorgen dat het programma niet begint zolang er niet op de C – knop gedrukt wordt. Door het probleem zo voor te stellen wordt de oplossing echter al duidelijker. Eerder hebben we gezien dat de drukknoppen als voorwaarde gebruikt worden in o.a. de lussen. Wanneer we “niet op de C – knop gedrukt” als voorwaarde van een lege while – lus nemen. Zal het programma “blijven hangen” in de while – lus tot er op de C – knop gedrukt wordt. Het toevoegen van de tekst doen we op dezelfde manier als bij de eerste aanpassing. We moeten er echter wel voor zorgen dat het display leeggemaakt wordt voor de tekst “knight rider” er op geschreven wordt. De code voor de twee aanpassingen samen ziet er als volgt uit: backlightOn(); printStringToLCD("Druk Op Knop C",0,0); while(SW_C != PRESSED) { } clearLCD(); printStringToLCD("Knight Rider!",0,0); Je kan het programma nu naar de robot schrijven! Intermezzo: Event driven programmeren: Om te controleren of knop C ingedrukt wordt, wordt er gebruik gemaakt van een lege while – lus. Om dit soort “vreemde” lussen te vermijden heeft men event driven programmeren uitgevonden. Het programma reageert dan op handelingen (events) van de gebruiker. Het indrukken van de knop zou hier dus als event gebruikt kunnen worden. In deze paper wordt er echter geen gebruik gemaakt van event driven programmeren. Daarom wordt er met de lege while – lus gecontroleerd of de knop ingedrukt wordt. 2.2.2. Een programma in C volledig zelf schrijven We zullen voor dit programma gebruik maken van commando’s die we al kennen, maar er zullen ook een aantal nieuwe commando’s toegevoegd worden. Het is belangrijk om veel aandacht te besteden aan de syntax. Alle haakjes, puntkomma’s, hoofdletters … moeten op de juiste plaats staan. Als eerste volledige programma in C – code zullen we met de E en W knoppen een brandend LEDje respectievelijk naar rechts of links doen opschuiven. We zullen de code stap voor stap opbouwen. Voor je begint aan de code stel je best een stappenplan op: 1. De variabele “teller” declareren en de waarde 0 geven.

25

2. Het eerste LEDje laten branden. 3. Kijken of er op de E of W knop gedrukt wordt. a. Als op knop E gedrukt wordt: i. “teller” met een waarde 1 verminderen. ii. Als “teller” = -1 moet hij de waarde 7 krijgen (we springen dan van het meest rechtse LEDje naar het meest linkse LEDje). b. Als op knop W gedrukt wordt: i. “teller” met een waarde 1 vermeerderen. ii. Als “teller” = 8 moet hij de waarde 0 krijgen (we springen dan van het meest linkse LEDje naar het meest rechtse LEDje). 4. Alle LEDjes doven. 5. Het LEDje op positie “teller” doen branden. 6. Een delay toevoegen. (Deze zorgt ervoor dat het LEDje niet blijft opschuiven als we de knop te lang induwen. Je kan er dus de gevoeligheid van de knoppen mee instellen.) 7. Stap 3 t.e.m. 6 continu blijven doorlopen. We beginnen elk programma met het toevoegen van bibliotheken. Voor dit programma hebben we twee bibliotheken nodig. Onze code begint dan ook op volgende manier: #include #include Daarna starten we het main programma : void main (void) { Tussen de haakjes van het main programma komt de eigenlijke code. Dan declareren we de variabelen en initialiseren we de zaken van de Dwengo robot die we zullen gebruiken. In dit geval hebben we één variabele: “teller” en zullen we gebruik maken van het Dwengo board en van het LCD scherm. Hiervoor voegen we volgende code toe: int teller; initBoard(); initLCD(); We zitten nu aan stap 1 en 2 van ons stappenplan. We hebben “teller” al gedeclareerd. Nu moeten we “teller” enkel nog de waarde 0 geven en het eerste lampje (met waarde 0) laten branden. Hiervoor gebruiken we volgende code: teller = 0; setLed(teller);

// Hier kan je ook gewoon settled(0) gebruiken.

Nu komen we aan stap 3. Stap 7 geeft aan dat we stap 3 t.e.m. 6 continu moeten blijven doorlopen. Net zoals bij Dwengo blocks zullen we hiervoor gebruik maken van een while(TRUE) – lus. Nu plaatsen we dus volgende code: while (TRUE) {

26

Nu kunnen we de code voor stap 3a schrijven. We moeten dus eerst kijken of er op knop E gedrukt wordt. Dit zullen we doen met een if opdracht. Als er inderdaad op knop E gedrukt wordt moeten we “teller” met waarde 1 verminderen. Dan moeten we kijken of “teller” de waarde -1 heeft. Ook dit doen we met een if opdracht. Als “teller” de waarde -1 heeft moeten we “teller” de waarde 7 geven. De code voor stap 3 ziet er dus als volgt uit: if (SW_E == PRESSED) { teller = teller - 1; if (teller == -1) {teller = 7;} } } Als er niet op knop E gedrukt wordt moeten we kijken of er op knop W gedrukt wordt. Dit zullen we doen met een else if opdracht. We gebruiken de else if opdracht omdat we er enkel naar moeten kijken als er niet voldaan is aan de voorwaarde van de if opdracht van knop E. De code is zeer gelijkaardig aan de code van de E knop. Alleen moeten we bij “teller” nu de waarde 1 optellen. Als “teller” de waarde 8 heeft moeten we “teller” de waarde 0 geven. Dit geeft ons volgende code: else if (SW_W == PRESSED) { teller = teller + 1; if (teller == 8) {teller = 0;} } Dan kunnen we de code voor stap 4, 5 en 6 toevoegen. Om de LEDjes te doven zullen we het commando “setLedPattern()” gebruiken. Dan moeten we de LED met waarde “teller” laten branden en dan voegen we een delay van 200 ms toe (gevoeligheid knoppen). Dit geeft ons volgende code: setLedPattern(0,0,0,0,0,0,0,0); setLed(teller); delay_ms(200); Dan moeten we enkel nog de while(TRUE) – lus en het main programma sluiten: } } Nu hebben we de volledige code om het probleem op te lossen. Het is echter makkelijk om op het LCD scherm te laten verschijnen wat er van de gebruiker verwacht wordt. We zullen dan ook aan de gebruiker vragen om op een knop te drukken. We moeten dan dus het LCD scherm laten oplichten en onze boodschap op het scherm laten verschijnen. We plaatsen hiervoor volgende code voor de eerste if opdracht: backlightOn(); printStringToLCD("Kies een knop!",0,0);

27

Onze code is nu volledig klaar. Als alles goed ging heb je nu volgende code op je scherm staan: #include #include void main (void) { unsigned char teller; initBoard(); initLCD(); teller = 0; setLed(teller); while (TRUE) { backlightOn(); printStringToLCD("Kies een knop!",0,0); if (SW_E == PRESSED) { teller = teller - 1; if (teller == -1) {teller = 7;} } else if (SW_W == PRESSED) { teller = teller + 1; if (teller == 8) {teller = 0;} }

} }

setLedPattern(0,0,0,0,0,0,0,0); setLed(teller); delay_ms(200);

Je kan de code nu testen op het Dwengo board!

3. De module in de les gebruiken De leerlingen moeten niet weten hoe ze het programma moeten installeren. Indien ze hier toch interesse voor hebben kan je ze verwijzen naar de Dwengo website. Het belangrijkste van deze, en andere, modules is dat de leerlingen een probleem leren omzetten in een programma en dat ze dus hun algoritmisch denken verder ontwikkelen. Het is daarom van minder belang dat de leerlingen weten hoe ze een project moeten aanmaken. Zeker omdat ze in latere opleidingen of in hun beroepsleven hoogstwaarschijnlijk met andere programma’s zullen werken. Je kan dit aanbrengen op twee manieren.

28

De eerste manier is de leerlingen een stappenplan geven (zoals ik hierboven opstelde). Door dit stappenplan samen kort te overlopen weten de leerlingen waarom ze de taken moeten uitvoeren, maar er gaat geen tijd verloren omdat de leerlingen niet moeten zoeken hoe ze het moeten doen. Een tweede mogelijkheid is de leerlingen een soort van template aanbieden. In deze template zorg je er dan voor dat de leerlingen enkel de code moeten toevoegen. Je opent dus als leerkracht zelf de dwengo bibliotheek en het linker – bestand. Ook voor de C – code kan je al een basis code voorzien zodat de leerlingen zich echt enkel moeten bezighouden met het omzetten van het probleem in een programma. Ik schreef hiervoor volgende “basiscode”: // Bibliotheken toevoegen. # include # include # include # include # include # include // Main programma openen. void main (void) { // Hier moet je variabelen aanmaken (en initialiseren) // Dwengo Board initialiseren. initServo(); initLCD(); initBoard(); initADC(); // Hier komt het eigenlijk programma // Main programma sluiten. } Mijn voorkeur gaat uit naar deze laatste manier op voorwaarde dat je als leerkracht wel aan de leerlingen uitlegt waarvoor de code dient. Op deze manier begrijpen de leerlingen wel alle code, maar moeten ze deze niet elke keer opnieuw zelf toevoegen. Door de commentaar die ik toevoegde aan de code is het voor de leerlingen ook duidelijk waar ze zelf code moeten toevoegen en waarvoor de andere stukken code dienen. Voor de eerste opdracht, het aanpassen van de knight rider, kunnen de leerlingen zelf de code van Dwengo Blocks naar het programma kopiëren. Het is volgens mij nuttig om deze code dan klassikaal te overlopen. De leerlingen bouwden zelf de knight rider op waardoor ze de code zullen begrijpen. Op deze manier kan je even de aandacht vestigen op de syntax van C – code: het toevoegen van

29

lussen, een “;” na elk commando … . Je kan de leerlingen er in deze fase ook op wijzen hoe ze fouten in hun code kunnen opsporen. De leerlingen moeten dan in staat zijn om de eerste aanpassing toe te voegen. Ze mogen hiervoor gebruik maken van Dwengo Blocks als ze zich de commando’s niet kunnen herinneren. De tweede aanpassing is echter iets moeilijker. Als leerkracht moet je eerst klassikaal bespreken hoe de drukknoppen werken. Doormiddel van gerichte vragen zullen de leerlingen aangeven dat de knoppen als voorwaarde in o.a. lussen gebruikt zullen worden en dat er twee mogelijke voorwaarden zijn (wel of niet ingedrukt). Aangezien algoritmisch denken en het ontwerpen van de code centraal staan is het van minder belang dat de leerlingen de code vanbuiten kennen. Het is veel belangrijker dat de leerlingen weten hoe ze de code moeten gebruiken. Je kan daarom, volgens mij, de code voor de drukknoppen op bord zetten. Wanneer de leerlingen regelmatig gebruik maken van deze code zullen ze na verloop van tijd de code toch vanbuiten kennen. Klassikaal kan dan besproken worden hoe het probleem opgelost moet worden. De leerlingen hebben zelf door dat de knight rider pas mag starten als er op de C – knop gedrukt wordt. Daarnaast weten de leerlingen ook dat de knoppen als voorwaarde van lussen gebruikt worden. Aan de hand hiervan moeten de leerlingen, volgens mij, in staat zijn om de while(SW_C != PRESSED) – lus toe te voegen. Eventueel moet je ze als leerkracht de leerlingen door middel van gerichte vragen in de juiste richting duwen. Voorbeelden hiervan zijn: “Wat moet de robot doen zolang er niet op de knop gedrukt wordt?”, “Wat zal er dus in de lus staan?”, “Welke lus zullen we gebruiken?”, “Wat is de voorwaarde van deze lus dan?” … . De leerlingen moeten nu zelf de code kunnen opbouwen en uittesten. Achteraf kan de oplossing kort klassikaal besproken worden. Aan de hand van vorige modules en wat er eerder geleerd werd in deze module moeten de leerlingen in staat zijn om het volgende probleem met de drukknoppen, een LED naar links of rechts laten opschuiven, op te lossen. Het is echter wel belangrijk dat de opdracht voor de leerlingen zeer duidelijk is. Daarom bespreek je klassikaal best even de opdracht. Volgende vragen kunnen hierbij helpen: “Wat moet er met de variabele gebeuren als we op de E – knop drukken?”, “Wat gebeurt er als de variabele de waarde 0 heeft en we drukken op de E – knop?”, “Welke waarde moet de variabele op dat moment eigenlijk hebben?”, “Hoe zullen we controleren of de variabele de waarde “-1” heeft?”. Door de lessen informatica, die de leerlingen reeds kregen, zullen ze kunnen aangeven dat er een if opdracht gebruikt moet worden. De leerlingen weten nu genoeg om zelf het programma te maken. Voor ze aan het programmeren zelf beginnen is het echter belangrijk dat ze een stappenplan opstellen. Dit moet je als leerkracht dan ook aangeven. Het stappenplan voor de E – knop werd doormiddel van de vragen eigenlijk al opgesteld. Aan de hand hiervan moeten ze ook het stappenplan voor de W – knop en zo ook het volledige stappenplan kunnen opstellen. Net zoals in de vorige modules heeft de leerkracht nu een ondersteunende rol. Wanneer er een probleem is moet hij/zij de leerlingen dus doormiddel van vragen in de juiste richting duwen. Je voorziet voor deze opdracht ook beste extra opdrachten voor de leerlingen die sneller klaar zijn. Zo kan je op het scherm laten verschijnen of de LED naar rechts of naar links beweegt. Na afloop kan de oplossing klassikaal besproken worden zodat ook de minder sterke leerlingen de oplossing vinden/begrijpen. Het is echter ook interessant om de sterke leerlingen de zwakkere leerlingen te

30

laten helpen. Zoals eerder aangegeven halen zowel de zwakkere als de sterke leerlingen hier voordeel uit.

31

Module 4: Ontwerpen van een eigen schakeling: lichtsensor In volgende modules zullen de leerlingen gebruik maken van de sensoren van de Dwengo robot. Om ervoor te zorgen dat de leerlingen de sensoren wat beter begrijpen en weten wat er gebeurt, moeten ze in deze module zelf een sensor bouwen. Ze kunnen deze dan ook zelf programmeren om het licht op te meten. Voor deze module maakte ik gebruik van de tutorial op de website van Dwengo [3]. Op de website wordt aangegeven hoe je de sensor moet bouwen en hoe je hem moet programmeren. Ik schreef dit echter uitgebreider uit.

1. Doelstellingen Aan de hand van deze module moeten de leerlingen de werking van een lichtsensor begrijpen. Ze leren hoe ze elektronische componenten moeten aanbrengen op het Dwengo Breadboard en hoe ze hierop serie – en parallelschakelingen kunnen bouwen. Daarna leren de leerlingen hoe ze zo’n lichtsensor moeten uitlezen en hoe ze deze uitgelezen waarde naar het LCD scherm kunnen schrijven. Aan de hand van dit programma leren ze dan hoe ze de waarde van de sensor moeten interpreteren.

2. Uitwerken van de module Om te beginnen moeten we de schakeling maken. Voor de lichtsensor maken we gebruik van een fototransistor. Als er geen licht is zal deze geen stroom doorlaten en als er veel licht is zal hij de stroom zeer goed doorlaten. We moeten er dan ook voor zorgen dat er geen kortsluiting ontstaat wanneer er zeer veel licht is. We zullen daarom een weerstand opnemen in de schakeling. Dankzij deze weerstand zal de spanning over de transistor ook veranderen omdat de totale spanning altijd verdeeld zal worden over de transistor en de weerstand. We kunnen de werking van de sensor uitleggen aan de hand van de wet van Ohm:

met R de weerstandswaarde, U de spanning over de weerstand en I de

stroomsterkte. We maken ook gebruik van het feit dat de totale spanning (spanning over de transistor + spanning over de weerstand) altijd constant is. Als de spanning over de weerstand stijgt zal de spanning over de transistor dus dalen en omgekeerd. Als er geen licht is zal de transistor weinig stroom doorlaten. Aangezien “R” in de formule constant is bij de weerstand, zal er bij een lagere stroom door de weerstand dus ook een lagere spanning over de weerstand staan. Hierdoor zal er een hogere spanning over de transistor staan. Wanneer er veel licht is zal de transistor veel stroom doorlaten. Aangezien “R” constant is bij de weerstand, zal bij een hogere stroom door de weerstand dus ook veel spanning over de weerstand staan. Hierdoor zal er een lagere spanning over de transistor staan. Aan de hand van de spanning over de transistor kunnen we dan de lichtsterkte bepalen. We maken gebruik van een weerstand van 22 kOhm. Als we een te lage waarde gebruiken zal er snel een lage spanning over de weerstand staan (zie formule: lage R, dus bij een zelfde I ook een lage U).

32

Hierdoor zal er dus snel veel spanning over de transistor staan waardoor de sensor snel zijn maximale waarde zal bereiken. Als de weerstandswaarde te hoog is zal er al snel een hoge spanning over de weerstand staan (zie formule) waardoor er dus weinig spanning over de transistor zal staan. Hierdoor zal de sensor snel aangeven dat er weinig licht aanwezig is. Nu kunnen we de schakeling daadwerkelijk gaan bouwen. Aangezien de spanning verdeeld moet worden over de transistor en de weerstand zullen we de componenten in serie plaatsen. De schakeling ziet er dan als volg uit:

Figuur 9: Schema lichtsensor

Belangrijk om te vermelden is dat de transistor maar in één richting de stroom geleidt. Hier moeten we dus rekening mee houden als we de transistor aansluiten. Om de spanning uit te lezen zullen we ingang A0 gebruiken. We zullen de transistor tussen de grond en de A0 ingang plaatsen. Op die manier stijgt de waarde van A0 als de spanning over de transistor stijgt en omgekeerd. Als we de transistor tussen A0 en de “+” aansluiting zouden plaatsen zou de waarde van A0 dalen als de spanning over de transistor stijgt. Voor we de schakeling daadwerkelijk bouwen moeten we eerst het breadboard van dichterbij bekijken.

Figuur 10: Dwengo Breadboard [4]

Op deze afbeelding is het duidelijk hoe de “gaatjes” onderling met elkaar verbonden zijn. Wanneer we dus een been van de transistor en een been van de weerstand op dezelfde lijn plaatsen zijn ze elektrisch met elkaar verbonden. Op deze manier kan er dus makkelijk een schakeling opgebouwd worden zonder te solderen. Nu kunnen we de schakeling daadwerkelijk bouwen.

33

We bouwen de schakeling als volgt:

1. Verbind het lange been van de transistor met de “-“ connector (grond). 2. Plaats het korte been op het Dwengo breadboard. 3. Plaats de weerstand (22 kOhm) in serie met de transistor. a. Het eerste been plaats je op dezelfde rij als de transistor. b. Het tweede been plaats je op een nieuwe / andere rij.

4. Verbind de weerstand met de “+” connector (5 V). 5. Verbind het kort been van de transistor met de “A0” connector. a. Dit punt heeft dus dezelfde potentiaal als het korte been van de transistor. b. “A0” zal de spanning over de transistor dus opmeten. Als alles goed verlopen is moet de schakeling er als volgt uitzien:

Figuur 11: Schakeling lichtsensor [3]

Nu we de schakeling gebouwd hebben zullen we het programma kunnen opbouwen waarmee we de sensor kunnen uitlezen. Zoals altijd moeten we eerste de bibliotheken toevoegen. #include #include #include De bibliotheek “dwengoADC.h” hebben we nodig om de sensor uit te lezen. De spanning is in eerste instantie een analoge waarde. De microprocessor werkt met digitale waarden. We moeten de analoge waarde dus omzetten in een digitale waarde. Daarvoor hebben we deze bibliotheek nodig (ADC = analoog – digitaal – conversie). Nu moeten we het main programma openen en het Dwengo board en de analoog – digitaal – conversie initialiseren. Aangezien we gebruik zullen maken van het LCD scherm zullen we hier ook het licht van het LCD scherm aanschakelen. void main(void) { initBoard(); initADC(); backlightOn();

34

Nu is het tijd om de sensor uit te lezen en de waarde naar het LCD scherm te schrijven. Aangezien de waarde heel de tijd uitgelezen moeten worden en dus zal veranderen moeten we dit deel van de code in een while – lus schrijven. De code ziet er uit als volgt: while(TRUE) { clearLCD(); appendStringToLCD("Licht: "); appendIntToLCD(readADC(0)); delay_ms(250); } } Aangezien het programma moet blijven doorlopen plaatsen we het in een while(TRUE) – lus. Eerst maken we het LCD scherm leeg. Hierdoor zal de waarde op het scherm altijd verwijderd worden voor we er een nieuwe waarde op plaatsen. Daarna plaatsen we de tekst “licht: “ op het scherm. Dit gewoon om aan te geven dat het om een lichtsensor gaat. Achter deze tekst moet dan de waarde van de sensor komen. Het commando “readADC()” zet de analoge waarde om naar een digitale waarde en geeft ook meteen deze waarde terug. Tussen de haakjes plaatsen we het nummer van de ingang. Met het commando “readADC()” kunnen we alle A ingangen uitlezen. Aangezien we ingang A0 gebruiken plaatsen we dus een “0” tussen de haakjes. Met het commando “appendIntToLCD();’ schrijven we deze waarde meteen op het LCD scherm. Daarna zorgen we ervoor dat de gebruiker de tijd heeft om de waarde te lezen. Daarom voegen we de delay toe. Tot slot sluiten we nog de while – lus en het main programma. De code is nu klaar. Je kan het programma nu naar de robot schrijven en de sensor uittesten. Als je de sensor afdekt zal op het LCD scherm een hoge waarde verschijnen (maximum 255), als je met een zaklamp op de sensor schijnt zal er een lage waarde op het LCD scherm verschijnen.

3. De module in de les gebruiken In het begin van de les moet de schakeling opgebouwd worden. Daarvoor zou ik gebruik maken van een onderwijsleergesprek. Doormiddel van gerichte vragen kan de schakeling dan opgebouwd worden. Het is belangrijk dat je er als leerkracht voor zorgt dat alle leerlingen actief betrokken worden. Hierdoor zijn de leerlingen met de leerstof bezig waardoor ze deze ook zullen begrijpen. Voor je aan de schakeling begint kan je wat dieper ingaan op de werking van een transistor. Zeker in een 6de middelbaar wetenschappen – wiskunde is dit aan te raden. Door hier dieper op in te gaan zullen de leerlingen de werking ook beter begrijpen. Aan de hand van vragen zoals “Wat zal er met de stroomsterkte gebeuren als er veel licht is?”, “Wat betekent dit voor de spanning over de weerstand?” … . kan de leerstof / schakeling opgebouwd worden. Door dit klassikaal te doen kan je ervoor zorgen dat alle leerlingen de leerstof begrijpen en gehoord hebben. Wanneer de schakeling is opgebouwd moet je extra uitleg geven over het Dwengo Breadboard. De afbeelding die je hoger in deze tekst kan vinden maakt al veel duidelijk. De leerlingen zien dan duidelijk hoe de “gaatjes” onderling verbonden zijn. Je kan dan kort met gerichte vragen overlopen hoe de leerlingen de schakeling moeten bouwen.

35

De leerlingen moeten nu zelf de schakeling bouwen. In het ideale geval beschikt elke leerling over een robot en kan elke leerling zelf de schakeling maken. Wanneer je niet over genoeg robots beschikt kan je de leerlingen per twee onderverdelen. Als je dan dezelfde groepjes gebruikt voor het bouwen van het verkeerslicht (zie module 6) kan elke leerling zeker één schakeling bouwen. Als leerkracht heb je nu een ondersteunende rol. De leerlingen beschikken over het schakelschema en weten hoe het breadboard in mekaar zit. Alle leerlingen moeten dus in staat zijn om de schakeling te bouwen. Het is wel belangrijk dat je de schakelingen controleert voor ze deze daadwerkelijk gaan gebruiken. Wanneer de leerlingen de schakeling fout bouwen kan er bijvoorbeeld kortsluiting optreden waardoor de robot stuk zal gaan. Als de leerlingen de schakeling succesvol gebouwd hebben wordt het tijd om het programma op te bouwen. Als leerkracht moet je hier kort aangeven dat ze hiervoor het commando “readADC()” nodig hebben. Je kan dit doen aan de hand van de uitleg in verband met analoge en digitale signalen. Enkele leerlingen zullen weten dat de microprocessor met digitale waarden werkt. Je kan daarom ook dit stuk leerstof aan de hand van gerichte vragen aanbrengen. Wanneer de werking van het “readADC()’ commando duidelijk is voor de leerlingen beschikken ze over alle kennis om het programma zelfstandig op te bouwen. Als leerkracht heb je nu dus een ondersteunende rol. Je kan de leerlingen wel nog aanraden om eerst na te denken voor ze beginnen te typen. Wanneer leerlingen een vraag hebben moet je deze beantwoorden met een vraag. Het is belangrijk dat je de leerlingen zelf laat nadenken over de leerstof. Door de leerlingen in de juiste richting te duwen aan de hand van gerichte vragen, zullen ze nadenken over de leerstof en zelf het probleem oplossen. Leerlingen die sneller klaar zijn moeten zeker en vast nuttig bezig blijven. Je moet dus ook bij deze module extra opdrachten voorzien. Zo kan je de leerlingen een programma laten ontwikkelen dat aangeeft wanneer er veel of weinig licht is. Zeer snelle en sterke leerlingen kan je ook een programma laten maken waarbij de LEDs het lichtniveau aangeven.

36

Module 5: Ontwerpen van een eigen systeem: zonnepanelen naar de zon richten. In de vorige module leerden de leerlingen zelf een lichtsensor bouwen en gebruiken. In deze module zullen we daar gebruik van maken. Door de aandacht in de maatschappij voor groene energie en dus ook voor zonnepanelen is het zeker nuttig om hier tijdens de les ook even bij stil te staan. Om zoveel mogelijk elektriciteit te produceren met de zonnepanelen moeten we ervoor zorgen dat het zonnepaneel altijd naar de zon gericht is. In deze module zullen we hier dan ook een systeem voor ontwikkelen. Het idee voor deze schakeling vond ik terug op de Dwengo website [5]. Ik koppelde hier zelf het voorbeeld van de zonnepanelen aan om de schakeling toch wat concreter te maken. Op die manier zien de leerlingen het nut van de schakeling in en kunnen ze de informatica / elektronica koppelen aan een maatschappelijk probleem.

1. Doelstellingen In deze module zullen de leerlingen leren hoe ze de waarden van de lichtsensoren moeten interpreteren om ervoor te zorgen dat het zonnepaneel altijd naar de zon gericht is. Hiervoor zullen ze ook leren werken met een servomotor. Ze zullen in deze module leren hoe ze deze motor moeten aansturen. Daarnaast zullen de leerlingen, net als in de vorige module, leren hoe ze een systeem vanaf nul moeten opbouwen.

2. Uitwerken van de module Voor we het programma ontwerpen moeten we de servomotor aansluiten. Deze motor zit standaard bij het Dwengo startpakket plus. Je kan de motor, samen met sensoren, ook apart aankopen. De servomotor beschikt over 3 draden. Twee draden die zorgen dat de motor over de nodige voeding beschikt en een derde draad waarmee we de positie kunnen instellen. Het Dwengo board beschikt over twee aansluitingen waarop een servomotor kan aangesloten worden. Op deze manier kunnen we dus zeer eenvoudig de servomotor aansluiten en gebruiken. Op volgende afbeelding is duidelijk hoe de servomotor aangesloten moet worden.

Figuur 12: Aansluiting servomotor [5]

37

Nu we de motor hebben aangesloten moeten we de lichtsensoren nog bouwen. We zullen de lichtsensoren op dezelfde manier bouwen als in module 4. We zullen nu echter gebruik maken van twee lichtsensoren. Later zal duidelijk worden waarom we twee sensoren nodig hebben. Eén sensor sluiten we aan op de A0 ingang en de andere sluiten we aan op de A1 ingang. De schakeling voor de lichtsensoren ziet er als volgt uit:

Figuur 13: Schema twee lichtsensoren

We zien dat dit een parallelschakeling is van twee lichtsensoren. Voor meer informatie over de lichtsensor verwijs ik graag naar module 4. Deze lichtsensoren moeten bevestigd worden aan de servomotor. Op die manieren draaien de sensoren mee met de motor en zal de motor ook stoppen met draaien wanneer de twee sensoren evenveel licht opvangen. Je kan zelf wat uitproberen hoe je de sensoren het beste aan de motor bevestigt. Aan de hand van volgende afbeeldingen is het duidelijk hoe het systeem er moet uitzien.

Figuur 14: Schakeling zonnepaneel [5]

Zoals op de afbeelding ook duidelijk wordt aangegeven is het heel belangrijk dat je de lange benen van de transistoren met de grond (-) verbindt. De korte benen moet je met de weerstanden verbinden. De extra uitleg hiervoor is ook terug te vinden in module 4.

38

Nu kunnen we beginnen aan de code van het systeem. Belangrijk om te vermelden is dat de servomotor naar rechts draait als je de waarde van de positie vermindert. Als je de waarde van de positie vermeerdert zal hij dus naar links draaien. Zoals altijd beginnen we de code met het toevoegen van de bibliotheken: #include #include #include De bibliotheek “dwengoServo.h” is nieuw. Deze bibliotheek hebben we nodig om de servomotor aan te sturen. Nu kunnen we het main programma openen, variabelen declareren en de AD – conversie en de servomotor initialiseren. void main(void) { int rechterSensor, linkerSensor; int positie; initADC(); initServo(); De variabelen “rechterSensor” en “linkerSensor” zullen we gebruiken om de sensoren uit te lezen. Met de variabele “positie” zullen we de positie van de motor veranderen. Nu kunnen we aan het eigenlijke programma beginnen. Aangezien dit programma heel de tijd doorlopen moet worden zullen we het in een while(TRUE) – lus plaatsen. In eerste instantie moeten we de sensoren uitlezen. In deze code is de sensor die aangesloten is op de A0 ingang de linker sensor en de sensor aan de A1 ingang de rechter sensor. Om te beginnen zullen we deze twee sensoren uitlezen. while (TRUE) { rechterSensor = readADC(0); linkerSensor = readADC(1); Aan de hand van deze waarden kunnen we bepalen wat er met de motor moet gebeuren. Als de rechter sensor meer licht opvangt moet de motor naar rechts draaien. Meer licht wil echter wel zeggen dat de sensor een lagere waarde heeft (zie module 4). De motor moet dus naar rechts draaien als de waarde van de linker sensor groter is als de waarde van de rechter sensor. Om ervoor te zorgen dat de motor niet begint te schokken zullen we een drempelwaarde gebruiken. De motor zal dan pas bewegen als het verschil tussen de sensoren groter is als deze drempelwaarde. Wanneer we deze drempelwaarde niet zouden gebruiken zou de motor op het minste lichtverschil reageren en zou hij heel de tijd bewegen / schokken. We kunnen de motor een positie laten aannemen tussen 0 en 255. Als de positie de waarde 0 heeft wordt het dus moeilijker om de motor nog meer naar rechts te laten draaien. Wanneer we er echter voor zorgen dat de waarde 0 voorbij het westen ligt (richting het noorden) zal de robot nooit verder dan deze waarde moeten draaien, want de zon komt daar niet. Het zelfde geldt voor de waarde 255 en het oosten.

39

De code ziet er dan als volgt uit: if ((linkerSensor - rechterSensor > 50) && (positie > 0)) { positie--; } else if ((rechterSensor - linkerSensor > 50) && (positie < 255)) { positie++; } Eerst wordt er gekeken of de waarde van de linker sensor groter is dan de waarde van de rechtersensor. Indien dit het geval is moet de motor naar rechts draaien. De waarde van “positie” zal dan verminderd worden. Bovendien zorgen we er ook voor dat de waarde van “positie” niet onder 0 kan gaan. Indien we de motor goed opstellen, zoals eerder aangegeven, zal dit echter nooit een probleem zijn. Het commando “positie--“ zal enkel uitgevoerd worden indien aan beide voorwaarden voldaan is. We gebruiken hiervoor de AND – functie of “&&”. Indien aan deze voorwaarden niet voldaan is kijken we of de waarde van de rechter sensor groter is dan de waarde van de linker sensor. Indien dit het geval is moet de motor naar links draaien. We zorgen er bovendien ook voor dat de waarde van “positie” niet groter kan worden dan 255. Zoals eerder aangegeven zal dit, bij een juiste plaatsing van de motor, nooit het geval zijn. Tot slot moeten we ervoor zorgen dat de servomotor de nieuwe positie aanneemt. We moeten de motor ook de tijd geven om deze nieuwe positie in te nemen. Hiervoor zullen we dus een delay toevoegen. Op het einde moeten we ook de while – lus en het main programma sluiten. setPosition(1,positie); delay_ms(10); } } Met het commando “setPosition( , );” kunnen we de positie van de motor aangeven. Voor de komma moeten we aangeven over welke servomotor het gaat. We sloten de servomotor aan op servo – aansluiting één dus we plaatsen daar een 1. Na de komma plaatsen we de gewenste positie van de servomotor. Daar plaatsen we dus de variabele “positie”. De motor zal nu de waarde van “positie” innemen. De code is nu klaar. Je kan deze code nu naar de robot schrijven en met een zaklamp de zon simuleren. Je moet er echter wel voor zorgen dat de zon altijd opkomt in het oosten en ondergaat in het westen.

3. De module in de les gebruiken Zoals in het hoofdstuk “projectmanagement” wordt aangegeven kan deze module perfect gebruikt worden voor een projectwerk. Voor meer informatie rond projectmanagement verwijs ik graag naar het desbetreffende hoofdstuk. Ik zou in eerste instantie module 4 gebruiken. Op deze manier kunnen de leerlingen al werken met de lichtsensoren en moet je hier als leerkracht niet meer bij stilstaan. Bij aanvang van het project moet je echter wel even wat aandacht besteden aan de servomotor. De leerlingen kunnen hier zelf veel informatie over vinden op het internet waardoor je als leerkracht enkel moet stilstaan bij het

40

aansluiten van de motor en het commando om de motor te besturen. Beide zaken zijn echter zeer eenvoudig waardoor hier niet te lang bij moet worden stil gestaan. Je kan de leerlingen wel laten onderzoeken hoe ze de motor naar links en naar rechts kunnen laten draaien. Op die manier leren ze aan de hand van een eenvoudig programma werken met de servomotor en weten ze meteen ook hoe ze de motor naar de juiste richting kunnen laten draaien. Dan begint het eigenlijke project. Als probleem kan je aangeven dat de leerlingen een bedrijf zijn dat zonnepanelen installeert bij de mensen. De werknemers van dit bedrijf moeten dan opzoek gaan naar een systeem om met dezelfde, statische, zonnepanelen meer elektriciteit op te wekken. De leerlingen moeten dan in eerste instantie zelf nadenken over het feit dat ze een systeem moeten ontwikkelen waardoor het zonnepaneel de zon volgt. Voor het project zou ik de groepjes per vier onderverdelen (zie hoofdstuk groepswerk). Twee personen stellen dan het bouwteam voor en twee personen het programmeerteam. Op die manier kan er gelijktijdig gebouwd en geprogrammeerd worden. De twee teams moeten echter nog steeds met elkaar communiceren om ervoor te zorgen dat de code is afgestemd op het systeem en omgekeerd. Als middelen beschikken de leerlingen uiteraard over transistors, weerstanden, draden, een servomotor en de Dwengo robot. Bovenop die middelen beschikken de leerlingen ook over een vooraf bepaald experten – budget waarbij de leerkracht de expert is. De leerlingen kunnen op die manier in beperkte mate advies vragen aan de expert. Door het beperkte budget kunnen de leerlingen dit echter niet heel de tijd doen en moeten ze goed nadenken over wanneer ze beroep zullen doen op de expert. De leerlingen zullen daarom volgens mij altijd eerst zelf nadenken voor ze de hulp van de leerkracht inroepen. Op die manier wordt hun probleemoplossend vermogen alleen maar beter ontwikkeld omdat ze zelf in eerste instantie opzoek gaan naar de oplossing. De leerkracht heeft dus een ondersteunende rol. Hij moet de vragen van de leerlingen beantwoorden met vragen om er zo voor te zorgen dat, zelfs wanneer de leerlingen advies van de expert vragen, ze zelf over de oplossing nadenken. Dit om het probleemoplossend vermogen van de leerlingen verder te ontwikkelen. De leerkracht moet hiervoor wel consequent omgaan met het experten – budget. Wanneer hij/zij dit niet doet valt heel het idee in het water en zullen de leerlingen dus sneller de hulp van de leerkracht vragen. Op het einde van de projecten kunnen de leerlingen dan hun projecten aan elkaar voorstellen. Hierbij moeten ze ook aandacht besteden aan de problemen die ze tegenkwamen en hoe ze deze oplosten. Op die manier kunnen de leerlingen dus ook leren uit de problemen / fouten van de andere leerlingen.

41

Module 6: Ontwerpen van een eigen systeem: een verkeerslicht. In vorige modules maakten de leerlingen al gebruik van de LEDs op het Dwengo board. In deze modules werd hier echter geen extra uitleg bij gegeven. Daarom moeten de leerlingen in deze module zelf een verkeerslicht bouwen. Daarbij zullen ze gebruik maken van LEDs en zo ook de werking beter begrijpen. Deze module ontwierp ik zelf omdat ik vind dat de leerlingen ook mogen weten wat er achter de LEDs zit. Zo zullen ze in eerste instantie niet doorhebben dat er per LED ook een weerstand aanwezig is. Met deze module wordt dit wel duidelijk.

1. Doelstellingen In deze module zullen de leerlingen wat dieper ingaan op de werking van de LEDs die gebruikt worden op het Dwengo board. Ze zullen zelf een schakeling met LEDs leren maken en zullen deze gebruiken om een verkeerslicht te ontwerpen. Ze moeten dan zelf een werkend verkeerslicht programmeren. Zoals in elke module wordt dus ook een beroep gedaan op het algoritmisch denken van de leerlingen.

2. Uitwerken van de module Om te beginnen moeten we de schakeling van het verkeerslicht bouwen. Een LED zal werken bij een spanning van 1,5 Volt en een stroomsterkte van 8 mA. Aangezien de microcontroller enkel een spanning van 5 Volt opwekt moeten we er dus voor zorgen dat niet al deze spanning over de LED komt te staan. Daarom zullen we gebruik maken van een weerstand. We weten dat er door deze weerstand 8 mA zal lopen en dat er een spanning van 3,5 Volt (= 5 V – 1,5 V) over moet staan. Via de wet van Ohm kunnen we dan berekenen dat de weerstand een waarde van 437,5 Ohm heeft. Er wordt echter niet voor elke waarde een weerstand ontwikkeld. De weerstand met waarde 470 Ohm ligt dicht in de buurt van de berekende waarde. Daarom zullen we voor deze schakeling gebruik maken van een weerstand van 470 Ohm. Een verkeerslicht bestaat uit drie kleuren: rood, oranje en groen. We hebben voor onze schakeling dus 3 LEDs nodig in deze kleuren en 3 weerstanden van 470 Ohm. We moeten elke LED ook afzonderlijk kunnen aansturen. Daarom zullen we de LEDs aansluiten op verschillende uitgangen. We zullen hiervoor uitgang D0, D1 en D2 gebruiken. Deze uitgangen zijn ook verbonden met de LEDs die al aanwezig zijn op het Dwengo Board. Wanneer we LED 0 aansturen zal dus ook de LED die verbonden is met uitgang D0 oplichten. Op deze manier is het voor de leerlingen ook duidelijk dat beide LEDs op dezelfde manier werken. De potentiaal op het einde van de drie LEDs + weerstanden is in de drie gevallen 0 Volt. We kunnen deze dus met elkaar verbinden. We zullen deze uitgangen dan ook met de grond verbinden. De schakeling ziet er dan als volgt uit:

42

Figuur 15: Schema verkeerslicht

We kunnen deze schakeling dan eenvoudig op het breadboard bouwen. Hiervoor kunnen we volgende instructies volgen: 1. Verbind het lange been van de rode LED met de “D0” connector. 2. Plaats het korte been van de rode LED op het Dwengo breadboard. 3. Plaats een weerstand (470 Ohm) in serie met de LED. a. Het eerste been plaats je op dezelfde rij als de LED. b. Het tweede been plaats je op een nieuwe / andere rij. 4. Verbind het lange been van de oranje LED met de “D1” connector. 5. Plaats het korte been van de oranje LED op het Dwengo breadboard. 6. Plaats een weerstand (470 Ohm) in serie met de LED. a. Het eerste been plaats je op dezelfde rij als de LED. b. Het tweede been plaats je op dezelfde rij als het tweede been van de weerstand van de rode LED. 7. Verbind het lange been van de groene LED met de “D2” connector. 8. Plaats het korte been van de groene LED op het Dwengo breadboard. 9. Plaats een weerstand (470 Ohm) in serie met de LED. a. Het eerste been plaats je op dezelfde rij als de LED. b. Het tweede been plaats je op dezelfde rij als het tweede been van de weerstanden van de rode en de oranje LED. 10. Verbind de lijn met de tweede benen van de weerstanden met de “-“ connector (grond).

Figuur 16: Schakeling verkeerslicht

43

Bij de groene LED werd een extra draadje gebruikt omdat de benen van deze LED korter zijn dan de benen van de andere twee LEDs. Nu kunnen we aan de code voor het verkeerslicht beginnen. Alles wat in deze code gebruikt wordt werd al bekeken in vorige modules. Daarom zal ik hier niet te lang bij stil staan. Wat ik wel nog wil vermelden is dat ik korte delays gebruikte om ervoor te zorgen dat je geen minuut moet wachten voor het licht op groen springt. Deze waarden kunnen uiteraard nog aangepast worden. De code ziet er als volgt uit: # include # include # include # include void main (void) { initLCD(); initBoard(); while (TRUE) { setLed(2); delay_ms(500); clearLed(2); setLed(1); delay_ms(200); clearLed(1); setLed(0); delay_ms(400); clearLed(0); } }

// Groene LED // Oranje LED // Rode LED

Het is duidelijk dat de code voor het verkeerslicht zeer eenvoudig is. Je kan deze code nu naar de robot schrijven en uittesten.

3. De module in de les gebruiken De module kan op ongeveer dezelfde manier als module 4 gebruikt worden. Bij aanvang van deze module is het zeker en vast interessant om even wat dieper in te gaan op de LED. Zeker in een zesde middelbaar wetenschappen – wiskunde is dit aan te raden. Aangezien er in de maatschappij momenteel veel aandacht is voor LED verlichting kunnen de leerlingen dit dan ook meteen koppelen aan de maatschappij en aan de voordelen voor de maatschappij. Dit is alleen maar een voordeel. De leerlingen zullen hierdoor aandachtiger zijn omdat ze het nut van de leerstof beter zullen inzien. Je kan dit doen aan de hand van een onderwijsleergesprek. Je kan bijvoorbeeld volgende vragen stellen: “Wat is het voordeel van LED verlichting?”, “Hoe zou het komen dat een LED minder verbruikt?”, … . Dan kan er overgegaan worden naar het opbouwen van de schakeling. Aangezien de leerlingen in andere vakken, zoals fysica, al heel wat geleerd hebben over elektrische schakelingen, in het

44

bijzonder het schakelen van weerstanden, moeten de leerlingen in staat zijn om de schakeling zelf op te bouwen. Je kan dan ook gebruik maken van een soort van oefening die de leerlingen dan individueel moeten oplossen. Op die manier zijn alle leerlingen actief met de leerstof bezig en denken ze zelf na over de oplossing. Daarna kan je de oplossing klassikaal overlopen en indien nodig extra uitleg geven wanneer er leerlingen zijn die niet helemaal mee zijn. Op die manier ben je er zeker van dat elke leerling weet hoe de schakeling er uit ziet. Als leerkracht moet je hier wel aangeven dat de leerlingen uitgang D0, D1 en D2 moeten gebruiken omdat ze de LEDs dan op dezelfde manier aan te sturen als ze in vorige modules deden. In een volgende fase moeten de leerlingen dan ook daadwerkelijk de schakeling bouwen. Voor extra uitleg over het Dwengo breadboard verwijs ik naar module 4. In het ideale geval kan elke leerling zelf de schakeling bouwen. Indien nodig kan je de leerlingen ook per twee verdelen. Wanneer je dezelfde groepjes gebruikt als bij module 4 kan elke leerling zeker één schakeling zelf bouwen. Tijdens mijn stage merkte ik dat de leerlingen het super vinden om dit te doen omdat ze dit nog nooit gedaan hebben. Tot slot moeten de leerlingen het verkeerslicht programmeren. Zoals eerder aangegeven is dit een heel eenvoudige code. De leerlingen moeten daarom in staat zijn om volledig zelfstandig de code op te bouwen. De leerkracht heeft hier dus duidelijk een ondersteunende rol. Wanneer de leerlingen een probleem / vraag hebben moet de leerkracht dit beantwoorden met een vraag. Op die manier denken de leerlingen zelf na en komen ze zelf tot de oplossing. Zoals in elke module zullen er bepaalde leerlingen sneller klaar zijn. Om ervoor te zorgen dat deze leerlingen nuttig bezig blijven moet je dus extra oefeningen voorzien. Zo kan je de leerlingen een verkeerslicht laten ontwerpen dat ook rekening houdt met een trein. Je kan de trein dan simuleren met het indrukken van een knop. Wanneer er dan op de knop gedrukt wordt moet het licht op rood springen. Eventueel kan je ook een lichtsensor gebruiken om een aankomende trein te simuleren. Wanneer alle leerlingen het verkeerslicht geprogrammeerd hebben is het zeker nuttig om de oplossing kort klassikaal te overlopen. Op die manier kan je er voor zorgen dat ook leerlingen die de oplossing niet helemaal snappen nu ook de oplossing begrijpen.

45

Module 7: Aanmaken van een functie: Het LCD display In vorige modules maakten we al gebruik van het LCD scherm. We gebruikten echter altijd tekst die op het scherm paste. Aangezien het scherm over twee lijnen van elk 16 tekens beschikt was de tekst per lijn nooit langer dan 16 tekens. In deze module zullen we een lichtkrant ontwikkelen. Op deze lichtkant kunnen we dan tekst die langer is dan 16 tekens weergeven. Door de tekst over het LCD scherm te laten rollen zal de gebruiker ook lange zinnen kunnen weergeven / lezen. Voor deze module baseerde ik mij op de tutorial “Lichtkrant” op de website van Dwengo [6]. Ik paste de code echter wat aan zodat ze wat duidelijker werd. Ik veranderde bijvoorbeeld de namen van de variabelen en gebruikte een while – lus i.p.v. een for – lus. Aangezien in de vorige modules, en in Dwengo blocks, enkel een while – lus werd gebruikt leek mij dit de aangewezen oplossing. De leerlingen kunnen al werken met een while – lus en aangezien je elke for – lus ook kan bouwen met een while – lus moet er dus geen extra tijd gaan naar het uitleggen van een for – lus. Ik veranderde ook het declareren van de variabelen. Zo wordt er in de tutorial veel gebruik gemaakt van “unsigned char”. De microprocessor bepaalt dan zelf het soort variabele. Ik heb er voor gekozen om altijd duidelijk aan te geven over wat voor soort variabele het gaat. Op die manier is het voor de leerlingen in mijn ogen duidelijker waarover het gaat. Er moet dan ook geen tijd besteed worden aan het uitleggen van “unsigned char” zodat er meer tijd kan gaan naar het algoritmisch denken wat toch de centrale doelstelling van dit project is.

1. Doelstellingen De leerlingen zullen in deze module gebruik leren maken van een functie. Aan de hand van deze functie zullen ze tekst over het scherm kunnen laten rollen. Met deze functie zullen ze ook gebruik leren maken van argumenten. Zo zal de functie bestaan uit twee argumenten: de totale weer te geven tekst en de positie vanwaar de tekst moet worden weergegeven. Dit zal in de volgende tekst duidelijker worden.

2. Uitwerken van de module Zoals altijd beginnen we de code met het toevoegen van de bibliotheken. Voor de lichtkrant hebben we volgende bibliotheken nodig: #include #include #include #include In de vorige modules openden we nu het main programma. Dit main programma zal nu echter gebruik maken van een functie. Daarom zullen we nu voor we aan het main programma beginnen, de functie maken. Deze functie zal 16 karakters op het scherm schrijven. Hiervoor heeft de functie twee argumenten nodig. In eerste instantie moet de functie weten welke tekst er op het scherm moet verschijnen en de functie moet ook weten vanaf welke positie de tekst moet weergegeven worden. We zullen

46

volgende tekst over het scherm laten rollen: “In deze module gebruiken we de Dwengo robot als lichtkrant! “. Wanneer we bijvoorbeeld aan positie 5 zitten moet volgende tekst op het scherm verschijnen: “e module gebruik”. Als we aan positie 6 zitten zal de tekst “ module gebruike” op het scherm verschijnen. Op die manier zal de tekst dus over het scherm rollen. De functie zal ook telkens de positie terug geven waarop de volgende tekst op het scherm moet beginnen. We zullen in dit programma ook gebruik maken van de manier waarop een tekst in het geheugen wordt opgeslagen. De microcontroller voegt namelijk op het einde van de tekst een “0” toe. Aan de hand van die “0” kunnen we dus bepalen wanneer we op het einde van de tekst zitten. We beginnen de functie met volgende code: int lichtkrant(rom char *text, int positie) { We noemen de functie “lichtkrant”. Aangezien de functie een getal zal teruggeven gebruiken we “int lichtkrant”. Tussen de haakjes noteren we dan de argumenten van de functie. Met “rom char *tekst” geven we aan dat de tekst zich in het rom geheugen van de microcontroller bevindt. Zoals eerder aangegeven zullen we gebruik maken van de manier waarop de tekst in het geheugen wordt opgeslagen. Als tweede argument hebben we de positie van de tekst nodig. Dit is uiteraard een getal waardoor we “int positie” gebruiken. Intermezzo: geheugen van de microcontroller: Een microcontroller bezit verschillende soorten geheugen. Zo wordt er onderscheid gemaakt tussen datageheugen (ram) waarin bijvoorbeeld de variabelen zitten en programmageheugen (rom) waarin het programma zit. Het read only geheugen kan enkel uitgelezen worden. Aangezien de tekst standaard in het programma zit, en dus ook niet veranderd kan worden, wordt deze in het rom geheugen opgeslagen. De term “char *” is een char – pointer. Dit is een mechanisme waarmee men kan verwijzen naar het geheugenadres waarop de string die men wil tonen is opgeslagen. Met het commando “rom char *tekst” maken we dus gebruik van de tekst die in het rom geheugen is opgeslagen. Variabelen wijzigen voortdurend tijdens het uitvoeren van het programma. Deze kunnen dus niet opgeslagen worden in het rom geheugen. Daarom maakt men voor variabelen gebruik van het ram geheugen. Om te beginnen declareren en initialiseren we enkele variabelen. Variabele “i” zullen we gebruiken om de plaats op het scherm aan te geven. Als “i” bijvoorbeeld gelijk is aan 6 zal er een karakter op plaats 6 van het scherm geschreven worden. Variabele “j” zullen we gebruiken om de plaats van het karakter in de tekst te bepalen. Wanneer “j” bijvoorbeeld gelijk is aan “8” zal er een “m” op het scherm geschreven worden. Als we deze twee variabelen combineren zal er dus in dit voorbeeld een “m” op plaats 6 van het scherm geschreven worden. We declareren en initialiseren de variabelen met volgende code: int i,j; i=0; j=positie;

47

Het eerste karakter moet uiteraard op plaats 0 van het scherm geschreven worden. Het eerste karakter dat op het scherm geschreven moet worden bevindt zich, zoals eerder aangegeven, op positie “positie” van de tekst. Om de tekst op het scherm te schrijven gebruiken we volgende code: while (i<16) { if (text[j]==0) { j=0; } appendCharToLCD(text[j]); j++; i++; } Aangezien er 16 tekens op het scherm geschreven kunnen worden (plaats 0 t.e.m. 15) zal deze while – lus doorlopen worden tot “i” gelijk is aan 16. Eerst kijken we of we nog niet op het einde van de tekst zitten. Wanneer het karakter op positie “j” gelijk is aan 0 zitten we, zoals eerder aangegeven, aan het einde van de tekst. We moeten dan dus het eerste karakter van de tekst (positie 0) op het scherm schrijven. Daarom stellen we “j” gelijk aan nul als het karakter op plaats “j” gelijk is aan 0. Met het commando “appendCharToLCD(text[j]);” schrijven we het karakter op plaats “j” in de tekst op het scherm. Aangezien we “append” gebruiken zal het karakter altijd na het laatste karakter dat op het scherm staat geschreven worden. Het eerste karakter komt dus op plaats nul omdat er nog geen karakter op het scherm staat, het tweede komt op plaats 1 omdat er al een karakter op plaats 0 staat en zo verder. Dan vermeerderen we “i” en “j” met één. Op die manier wordt de volgende keer het volgende karakter van de tekst op de volgende plaats op het scherm geschreven. Zoals eerder aangegeven moet de functie nu nog de nieuwe positie terug geven. Deze positie kan dan gebruikt worden wanneer de functie een volgende keer opgeroepen moet worden. Hiervoor gebruiken we volgende code: if (text[positie+1]==0) return 0; else return positie+1; } Als we op het einde van de tekst zitten (karakter = 0) moet de volgende functie gewoon met het begin van de tekst starten. Indien we nog niet op het einde van de tekst zitten moet de functie gewoon starten vanaf de volgende positie (zoals aangegeven in het voorbeeld eerder in deze tekst). Tot slot sluiten we de functie. Met deze functie schrijven we dus 16 karakters op het scherm beginnend met het karakter op positie “positie” van de tekst. We gebruiken een functie omdat dit elke keer opnieuw gedaan moet worden om zo de tekst te laten rollen. Het is dus aangewezen om een functie te schrijven die elke keer opnieuw opgeroepen kan worden.

48

Dit was eigenlijk het moeilijkste gedeelte van de code. Nu kunnen we aan het main programma beginnen. We openen het main programma, declareren de variabele en initialiseren de nodige zaken. De code ziet er dan als volgt uit: void main(void) { int positie; positie=0; initBoard(); initLCD(); We moeten hier uiteraard de variabele “positie” aanmaken. Daarna stellen we positie gelijk aan 0 omdat we op positie nul van de tekst moeten beginnen. Tot slot initialiseren we het Dwengo board en het LCD scherm. Aangezien we gebruik zullen maken van het LCD scherm maken we vervolgens het scherm leeg zodat we zeker zijn dat er geen tekens op het scherm staan. We moeten daarna ook nog het licht van het LCD scherm aanschakelen. clearLCD(); backlightOn(); Nu kunnen we de tekst naar het scherm schrijven. Aangezien de tekst over het scherm moet blijven rollen plaatsen we de code in een while(TRUE) – lus: while (TRUE) { setCursorLCD(0, 0); positie=lichtkrant("In deze module gebruiken we de Dwengo robot als lichtkrant! ", positie); delay_ms(200); } } Eerst zorgen we ervoor dat de functie altijd op de beginpositie van de bovenste lijn begint te schrijven. Daarna moet het programma de functie oproepen. Deze functie wordt elke keer opnieuw opgeroepen. Op deze manier worden altijd de juiste 16 tekens op het scherm geschreven. Daarna voegen we nog een delay toe om de gebruiker de tijd te geven om de tekst op het scherm te lezen. Door deze delay aan te passen kan je de tekst sneller of trager over het scherm laten rollen. Tot slot sluiten we de while – lus en het main programma. Het programma is nu volledig klaar. Je kan het nu naar de robot schrijven en uittesten.

3. De module in de les gebruiken Om deze module in de klas te gebruiken moet je als leerkracht eerst het gebruik van functies uitleggen. Dit kan je doen aan de hand van enkele voorbeelden waarin duidelijk wordt dat het eenvoudiger is om met één functie hetzelfde een aantal keer uit te voeren in vergelijking met altijd opnieuw een stuk code toe te voegen. De code wordt hierdoor een stuk korter en hierdoor eenvoudiger.

49

Als voorbeeld kan je hier bijvoorbeeld het volgende gebruiken: wanneer er nieuwe mensen in een databank toegevoegd moeten worden gebruik je best een functie. Het is beter om elke keer dezelfde functie te gebruiken. Wanneer je voor elke persoon een nieuw stuk code zou schrijven wordt dit na een tijd onbegonnen werk. Zeker wanneer je bijvoorbeeld 100 personen aan de databank moet toevoegen. Je kan dit dan linken aan deze module. Doormiddel van enkele gerichte vragen kunnen de leerlingen er achter komen dat er elke keer opnieuw 16 tekens naar het scherm geschreven moeten worden. Het is eenvoudiger om dit met een functie te doen. Wanneer je elke keer een nieuw stuk code moet schrijven om de juiste karakters naar het scherm te schrijven wordt de code al snel heel lang en onoverzichtelijk. Aan de hand hiervan zal het voor de leerlingen duidelijk zijn waarom ze een functie moeten gebruiken en wat de voordelen hier van zijn. De code van de functie is echter niet eenvoudig. Het is daarom volgens mij aangewezen om eerst klassikaal een stappenplan op te stellen. Dit ook om aan te geven dat de leerlingen dit eigenlijk elke keer moeten doen wanneer ze een programma ontwikkelen. Hiervoor kan je, zoals hoger in deze tekst, gebruik maken van een voorbeeld. Je kan hiervoor volgende vragen stellen “Welke karakters moeten er eerst op het scherm verschijnen?”, “Welke karakters moeten er dan op het scherm verschijnen?”, “Op welke positie van de tekst begint de eerste reeks karakters?”, “En de tweede reeks?” … . Op deze manier wordt het voor de leerlingen duidelijk wat de functie moet doen en dat ze hiervoor elke keer de positie moeten bepalen waarop de karakters op het scherm moeten beginnen. Aan de hand van dit soort vragen kan dan het stappenplan opgebouwd worden. Op deze manier kan je ook aangeven dat de functie gebruik zal maken van twee argumenten. De leerlingen beschikken nu over voldoende informatie om de code van de functie op te bouwen. Het is misschien wel aangewezen om ze dit per twee te laten doen. Op die manier beschikken de leerlingen over twee inputs. De kans dat ze tot de juiste oplossing komen wordt hierdoor vergroot. Als leerkracht moet je er wel over blijven waken dat de twee leerlingen actief met het programmeren bezig zijn. Daarnaast heb je ook weer een ondersteunende functie en moet je de vragen van leerlingen, net zoals bij de andere modules, beantwoorden met een vraag om ervoor te zorgen dat de leerlingen hun probleemoplossend vermogen blijven ontwikkelen. Wanneer zo goed als alle groepjes de functie opgebouwd hebben moet je deze klassikaal overlopen. Het is geen eenvoudige functie waardoor voor enkele leerlingen zeker wat extra uitleg noodzakelijk is. Op die manier kan je ervoor zorgen dat alle leerlingen de functie begrijpen. Wanneer je merkt dat een leerling hier nog steeds moeilijkheden mee heeft, bekijk je best individueel de juiste oplossing om ervoor te zorgen dat de rest van de klas niet wordt opgehouden. Daarna moet het main programma ontwikkeld worden. Dit is vrij kort en eenvoudig waardoor dit gerust klassikaal kan gebeuren. Het is echter wel niet de bedoeling dat je hier als leerkracht de oplossing cadeau geeft. Door gerichte vragen te stellen (bij voorkeur aan de minder sterke leerlingen) kan je de code opbouwen. Door zeker de minder sterke leerlingen actief bij de les te betrekken kan je ervoor zorgen dat alle leerlingen de code begrijpen. Aangezien je op het main programma klassikaal opbouwt moet je hier geen extra oefeningen voorzien. Je moet er wel over waken dat de leerlingen die sneller met de functie klaar zijn nuttig bezig blijven. Zij kunnen bijvoorbeeld de minder sterke leerlingen helpen. Zoals eerder aangegeven is

50

dit een meerwaarde voor beide leerlingen. Omdat de sterkere leerling de leerstof moet uitleggen zal hij hier dieper over nadenken. Ook op didactisch gebied kan de sterkere leerling hier veel bijleren. Zo moet je als leerkracht aangeven dat de leerling niet zomaar het antwoord cadeau mag geven. De minder sterke leerling krijgt extra uitleg waardoor hij makkelijker de juiste oplossing zal vinden.

51

Module 8: Kennismaking met de Dwengo robot. In deze en de volgende modules zullen we gebruik maken van de volledige Dwengo robot. We zullen nu dus ook de wielen, en hun bijhorende motor, aansturen. In deze module zal er kort kennis gemaakt worden met de robot en zijn motoren. Aan de sensoren besteed ik nog geen aandacht omdat deze in de volgende modules uitgebreid aan bod komen.

1. Doelstellingen De leerlingen leren in deze module werken met de Dwengo robot. Ze zullen onder andere leren hoe ze de motoren moeten aansturen. In eerste instantie zullen de leerlingen leren hoe ze de robot gewoon rechtdoor moeten laten rijden. Daarnaast zullen ze ook nog leren hoe ze de lichten van de robot moeten aan en uit zetten.

2. Uitwerken van de module Voor we kunnen beginnen met de code moeten we de robot volledig klaarmaken. Eerst moeten we 6 AA batterijen in de robot steken. Je kan de batterijen houder terugvinden onder het Dwengo Board (tussen de wielen). Daarna kan je het Dwengo Board weer op de wielen bevestigen. Zorg er wel voor dat de aansturing van de motoren achteraan bevestigd kan worden. Ook de voeding moet je achteraan in het Dwengo Board kunnen insteken. Je kan nu de motoren verbinden met het Dwengo board. Je vindt de connector achteraan de robot. De connector ziet er als volgt uit:

Figuur 17: Aansluiting motor [7]

Zorg er nu voor dat je de connector bevestigt aan de 4 connectoren waar M1 en M2 bij staat. Wanneer de robot geprogrammeerd is kan je ook de voeding insteken. Hiervoor verwijs ik naar module 1.

52

We kunnen nu beginnen aan de code. Zoals altijd beginnen we met het toevoegen van de bibliotheken. # include # include # include # include # include # include # include Hier zijn twee nieuwe bibliotheken opgenomen. Eén bibliotheek is nodig om de sensormodule aan te sturen. Deze hebben we later nodig voor het aansturen van de lichten. De tweede nieuwe bibliotheek is de bibliotheek voor de motoren. Het spreekt voor zich dat we deze nodig hebben om de motoren aan te sturen. In een volgende stap openen we het main programma en initialiseren we de nodige zaken: void main (void) { initLCD(); initBoard(); initADC(); initSensorModule(); initMotor(); Ook hier zijn er twee nieuwe zaken die we moeten initialiseren. Net als bij de bibliotheken is het initialiseren van de sensormodule en de motoren hier nieuw. Daarna zullen we een klein stukje code toevoegen waardoor we eerst op de C – knop moeten duwen voor we het programma uitvoeren. Hierdoor beginnen de motoren niet meteen te draaien als we de voeding insteken. backlightOn(); printStringToLCD("Druk op knop C",0,0); while(SW_C != PRESSED) {} clearLCD(); backlightOff(); Deze code werd in een eerdere module al uitgelegd waardoor ik hier niet lang bij zal stilstaan. Kort gezegd zal de tekst “Druk op knop C” verschijnen. Het programma blijft de while – lus dan uitvoeren tot er op knop C gedrukt wordt. Als er op knop C gedrukt wordt zal het LCD scherm leeggemaakt worden en zal de tekst verwijderd worden. Daarna wordt de rest van de code uitgevoerd. Met de volgende code zullen we de lichten aansturen. Hiervoor zullen we twee eenvoudige commando’s gebruiken: setHeadlights(LD1,TRUE); setHeadlights(LD2,TRUE);

53

De voorlichten bevinden zich op de sensormodule. Bij de lichten staat LD1 of LD2. Dit geeft dus aan over welke lampen het gaat. In het commando “setHeadlights( , )” moeten we twee argumenten invullen. Eerst moeten we aangeven welke LED we willen aandoen. Dit is dus LD1 of LD2. Daarna moeten we aangeven of we de LED willen aandoen (TRUE) of uitdoen (FALSE). Nu kunnen we de code voor de motoren toevoegen. We plaatsen deze code in een while(TRUE) – lus omdat ze constant uitgevoerd moet worden. Als we geen while(TRUE) – lus gebruiken zal het hele programma telkens opnieuw uitgevoerd worden. De motoren worden dan elke keer opnieuw geïnitialiseerd waardoor ze schokkend zullen draaien. Als we de code in de while(TRUE) – lus plaatsen wordt enkel de code voor de motoren herhaald. Hierdoor zullen ze vloeiend ronddraaien. De code ziet er als volgt uit: while(TRUE){ setSpeedMotor1(-800); setSpeedMotor2(800); delay_ms(200); } } Met het commando “setSpeedMotor1();” geven we de snelheid van motor 1 aan, met “setSpeedMotor2();” geven we uiteraard de snelheid van motor 2 aan. Zoals je kan zien zijn de snelheden tegengesteld aan elkaar. Dit omdat de motoren omgekeerd in de robot zitten. De positie kan per robot verschillen. Het kan ook zijn dat de snelheid van motor 1 positief moet zijn en die van motor 2 negatief om rechtdoor te rijden. Daarna voegen we een delay toe om de motoren de tijd te geven om te reageren. Tot slot sluiten we de while – lus en het main programma. Het programma is nu klaar. Je kan de code nu naar de robot schrijven en uittesten.

3. De module in de les gebruiken Deze module is zeker en vast niet moeilijk. De leerlingen moeten daarom zelf in staat zijn om de code op te bouwen. Als leerkracht moet je op voorhand wel even de nieuwe commando’s bespreken (setHeadlights en setSpeedMotor). Deze commando’s spreken echter voor zich waardoor je hier niet te lang bij moet blijven stil staan. Deze leerstof kan dan ook aan de hand van gerichte vragen opgebouwd worden om ervoor te zorgen dat de leerlingen actief met de leerstof bezig zijn. Daarna kan je de leerlingen zelfstandig laten programmeren. De leerlingen zullen dan zelf ontdekken dat ze de code van de motoren in de while(TRUE) – lus moeten plaatsen en dat ze de twee motoren een tegengestelde snelheid moeten geven. Als leerkracht heb je hier een ondersteunende rol. Het spreekt voor zich dat de leerlingen zullen vragen waarom de motor schokt of waarom hij niet gewoon rechtdoor rijdt maar ronddraait. Net als in de andere modules moet de leerkracht hier een vraag beantwoorden met een vraag om de leerlingen in de juiste richting te duwen. Voorbeelden van deze vragen zijn “Wat gebeurt er als het programma volledig doorlopen is?”, “Wat zal er dus elke keer opnieuw gebeuren?”, “Welke code moet er eigenlijk elke keer herhaald worden?”, “Hoe kan je hiervoor zorgen?”, “Hoe zouden de motoren geplaatst zijn in de robot?” … .

54

Tijdens mijn stage merkte ik dat de leerlingen aan de hand hiervan heel eenvoudig de motoren op de juiste manier kunnen programmeren. Net zoals altijd zijn er uiteraard een aantal leerlingen die sneller zullen klaar zijn als de andere leerlingen. Om ervoor te zorgen dat deze leerlingen nuttig bezig blijven kan je extra opdrachten voorzien. Zo kan je de snellere leerlingen vragen om de robot in een vierkant te laten rijden.

55

Module 9: Een lichtzoekende robot. In deze module zullen we de robot zo programmeren dat hij naar het licht toe rijdt. Deze code is, zoals u zal merken, gebaseerd op de code van module 5 waar een systeem ontwikkeld wordt om ervoor te zorgen dat een zonnepaneel altijd naar de zon gericht is. Het idee voor deze module komt van de website van Dwengo [7]. Ik paste de code echter wat aan. Zo zaten er volgens mij een aantal kleine foutjes in. Ik veranderde ook de namen van de variabelen om de code zo wat duidelijker te maken. Daarnaast voegde ik onder andere ook het gebruik van de C knop toe. Zoals ik later zal aangeven wordt deze module het beste samen gebruikt met de twee volgende modules. Zo kan je de klas onderverdelen in verschillende groepjes. Elk groepje kan dan aan een andere robot werken. Hier kom ik op terug wanneer ik bespreek hoe de module in de klas gebruikt kan worden.

1. Doelstellingen Bij deze module zal het algoritmisch denken, dat de leerlingen in de vorige modules ontwikkelden, op de proef gesteld worden. De leerlingen moeten nadenken hoe ze de sensoren moeten uitlezen, hoe ze deze moeten interpreteren en wat de motoren dan moeten doen. Aan de hand hiervan kunnen ze dan een stappenplan opstellen en zo de robot programmeren. Daarnaast leren de leerlingen in de module uiteraard werken met de lichtsensoren op de sensormodule. Tot slot leren de leerlingen in deze module ook werken met constanten.

2. Uitwerken van de module We kunnen in deze module meteen beginnen met het opbouwen van de code omdat het aansluiten van de motoren en de voeding al in vorige module bekeken werd. Het enige nieuwe in deze module is het gebruik van constanten en uitlezen van de sensoren van de sensormodule. We zullen hier daarom tijdens het opbouwen van de code even bij stilstaan. Zoals altijd voegen we eerst de bibliotheken toe: #include #include #include #include #include #include Nu zullen we enkele constanten definiëren. Het gebruik van deze constanten is niet noodzakelijk, maar de code wordt hierdoor volgens mij wat overzichtelijker. Wanneer we geen constanten zouden gebruiken zouden er in de code een aantal getallen gebruikt worden. Het is dan niet altijd even duidelijk waarom deze getallen gebruikt worden. Door het gebruik van constanten is dit wel duidelijk.

56

We definiëren volgende constanten: #define DREMPELWAARDE 20 #define MAXSNELHEID 1023 #define MINSNELHEID 700 De constante “drempelwaarde” zal gebruikt worden om ervoor te zorgen dat de robot niet op de minste verandering reageert. Hierdoor zal de robot minder schokkend voortbewegen (zie module 5). De constanten “MAXSNELHEID” en “MINSELHEID” spreken voor zich. Het gebruik van deze constanten zal in de verdere code ook duidelijk worden. Daarna openen we het main programma, declareren we enkele variabelen en initialiseren we de nodige zaken: void main(void) { int licht1; int licht2; licht1 = 0; licht2 = 0; initBoard(); initLCD(); initSensorModule(); initMotor(); Enkel de twee variabelen moeten hier kort toegelicht worden. In de variabele “licht1” zullen we de waarde van de eerste lichtsensor steken. In “licht2” de waarde van de tweede lichtsensor. Aan de hand van de waarden van deze variabelen zal dan bepaald worden hoe de robot moet reageren. Net zoals in de vorige module zullen we een klein stukje code toevoegen waardoor de gebruiker eerst op knop C moet drukken voor het eigenlijke programma wordt uitgevoerd. Hierdoor begint de robot niet meteen te rijden als we de voeding insteken. backlightOn(); printStringToLCD("Druk Op Knop C",0,0); while (SW_C != PRESSED) {} clearLCD(); backlightOff(); Nu kunnen we beginnen aan het eigenlijke programma. Aangezien de robot telkens opnieuw moet bepalen hoe hij moet rijden plaatsen we de code in een while(TRUE) – lus. Het eerste wat we moeten doen is de lichtsensoren uitlezen: while (TRUE) { licht1 = readSensor(D1, AMBIENT_MODE); licht2 = readSensor(D2, AMBIENT_MODE);

57

Het commando “readSensor( , );” geeft de waarde van de sensor in kwestie terug. Deze waarde stoppen we dan in variabele licht1 of licht2. Zoals u kan zien heeft het commando twee argumenten. Eerst moeten we aangeven over welke sensor het gaat. De naam van de sensoren wordt weergegeven op de sensormodule. Bij de twee lichtsensoren vinden we inderdaad D1 en D2 terug. Daarna moeten we aangeven hoe we de sensoren willen uitlezen. We kunnen de lichtsensoren echter maar op 1 manier uitlezen. Het maakt daarom niet uit welke mode je hier plaatst. Aangezien de lichtsensor slechts op 1 manier uitgelezen kan worden zal dit tweede argument bij deze sensor genegeerd worden. Bij de volgende module kunnen we de sensoren wel op verschillende manieren uitlezen. Daarom zal ik hier in volgende module uitgebreider op terug komen. De variabelen hebben nu de waarde van de lichtsensoren. Aan de hand van deze variabelen zullen we nu moeten bepalen hoe de robot moet reageren. Als “licht2” groter is dan “licht1” ontvangt lichtsensor D1 dus het meeste licht (hoe meer licht, hoe lager de waarde van de sensor). Aangezien sensor D1 zich aan de rechterkant bevindt moeten we dan dus naar rechts draaien. Hiervoor zullen we de rechter motor (motor 1) traag laten draaien en de linker motor (motor 2) snel. De robot zal dan dus naar rechts draaien. Zoals eerder aangegeven willen we niet dat de motor bij de minste lichtverandering reageert omdat hij dan schokkend zal bewegen. We maken daarom gebruik van de drempelwaarde. Als het verschil tussen “licht2” en “licht1” groter is dan deze drempelwaarde, moet de robot naar rechts draaien. Dit geeft volgende code: if((licht2-licht1) > DREMPELWAARDE) { setSpeedMotor1(-MINSNELHEID); setSpeedMotor2(MAXSNELHEID); } Als aan deze voorwaarde niet voldaan wordt moeten we controleren of lichtsensor D2 meer licht ontvangt dan lichtsensor D1. In dat geval moet de robot naar links draaien. Deze code wordt op dezelfde manier opgebouwd als het vorige stukje code. Indien het verschil van “licht1” en “licht2” groter is dan de drempelwaarde moet de robot naar links draaien. De linker motor moet dan dus traag draaien, de rechtermotor snel. Dit geeft ons volgende code: else if((licht1-licht2) > DREMPELWAARDE) { setSpeedMotor1(-MAXSNELHEID); setSpeedMotor2(MINSNELHEID); } Indien aan deze twee voorwaarden niet voldaan is, ontvangen de twee lichtsensoren dus evenveel licht. De robot moet dan dus gewoon rechtdoor bewegen. Aangezien dit zeker het geval is wanneer er aan de twee voorwaarden niet voldaan wordt moeten we hier dus geen nieuwe voorwaarde aangeven. We gebruiken daarom een gewone “else” en geen “else if”. De code ziet er dan als volgt uit: else { setSpeedMotor1(-MAXSNELHEID); setSpeedMotor2(MAXSNELHEID); }

58

Tot slot moeten we de robots nog de tijd geven om te reageren. Daarvoor zullen we een delay gebruiken. Daarna moeten we enkel nog de while(TRUE) – lus en het main programma sluiten: delay_ms(50); } } De code is nu volledig klaar. Je kan deze code nu naar de robot schrijven en uittesten. Hierbij kan je ook wat spelen met de waarde van de constanten om de robot beter af te stellen.

3. De module in de les gebruiken Zoals eerde aangegeven is het volgens mij aan te raden om deze module samen met de twee volgende modules te gebruiken. Je kan de klas dan onderverdelen in verschillende groepjes en elk groepje een andere robot laten maken. Op het einde moeten de verschillende groepjes hun robot dan aan de andere groepjes voorstellen. Op die manier weet iedereen wel hoe de code voor de verschillende robots in elkaar zit. Tijdens deze presentaties moet er zeker en vast aandacht besteed worden aan de problemen en de gevonden oplossingen. Leerlingen kunnen namelijk zeer veel leren uit de fouten van andere leerlingen. Ik zou elk groepje dan een werkblad geven waarop de opdracht wordt uitgelegd. Bij deze module zal ik het werkblad voor de lichtvolgende robot bespreken. In de volgende modules zullen de andere werkbladen besproken worden. Op dit werkblad moet uiteraard de opdracht uitgelegd worden: de leerlingen moeten een robot ontwikkelen die naar het licht toe rijdt. Hiervoor moeten ze gebruik maken van de lichtsensoren op de sensormodule. Aangezien de leerlingen in een vorige module al met lichtsensoren werkten moet hier niet aangegeven worden over welke sensoren het gaat. De leerlingen zullen de sensoren zelf herkennen en kunnen zo de naam bepalen. Op het werkblad moet je dan ook nog het gebruik van constanten uitleggen. Je kan dit bijvoorbeeld aan de hand van een simpel voorbeeld doen. Je kan de leerlingen een programma laten ontwerpen waarbij altijd een vast getal opgeteld wordt bij de vorige uitkomst als er op knop C gedrukt wordt. Als extra uitleg kan je dan gewoon aangeven hoe ze een constante moeten definiëren. De leerlingen leren op die manier zelfstandig, aan de hand van een eenvoudig programma, werken met een constante. Ze kunnen dan zelf beslissen of ze hiervan gebruik zullen maken in hun programma voor de lichtvolgende robot. Je moet ook aangeven hoe de leerlingen de sensoren moeten uitlezen. Hiervoor moet je het commando geven en de twee argumenten wat uitleggen. De naam hebben de leerlingen gevonden op de sensormodule en aan de mode moet hier minder aandacht besteed woorden. De leerlingen van de andere modules zullen hier tijdens hun presentatie dieper op ingaan waardoor ook de leerlingen van deze module de verschillende modes kennen. Tot slot kan je nog enkele vraagjes op het werkblad formuleren die de leerlingen wat op weg moeten helpen. Volgende vragen zijn hier een voorbeeld van: “Wanneer moet de robot naar rechts rijden?”, “Wanneer moet de robot naar links rijden?”, “Wat kan je dan zeggen over de waarde van de sensoren?” … . Je kan de leerlingen ook aanraden om eerst de waarde van de sensoren naar het LCD

59

display te schrijven. Op die manier leren ze hoe ze deze waarde moeten interpreteren. Aangezien de leerlingen dit al in een eerdere module deden is dit hier echter niet noodzakelijk. De leerlingen beschikken nu volgens mij over voldoende informatie om de code op te bouwen. Ik testte dit ook uit tijdens mijn stage en de leerlingen konden inderdaad deze robot vrij eenvoudig programmeren. Dit is in mijn ogen wel de makkelijkste module van de drie, zeker omdat er in de vorige modules al gebruik gemaakt wordt van de lichtsensoren. Het is daarom misschien aangewezen om de minder sterke leerlingen deze opdracht te geven. Op deze manier kunnen de leerlingen ook de succeservaring van een werkende robot ervaren. Dit komt hun motivatie alleen maar ten goede. Tijdens de presentaties zullen de andere robots uitgelegd worden. De minder sterke leerlingen zullen misschien minder snel zelfstandig die code opbouwen, maar aan de hand van de uitleg zullen ze deze wel begrijpen. De minder sterke leerlingen kunnen hierdoor hun algoritmisch denken ontwikkelen en een succeservaring beleven. Wanneer ze deze robot succesvol kunnen programmeren zal de stap naar de andere robots minder groot zijn waardoor ze de uitleg zullen begrijpen en eventueel zelf deze andere robots kunnen programmeren.

60

Module 10: Een lijnvolgende robot. Zoals de titel het zelf zegt zal er in deze module een robot ontwikkeld worden die een lijn kan volgen. We hebben hiervoor een zwarte lijn op een witte ondergrond nodig. Deze zwarte lijn moet zo weinig mogelijk licht reflecteren. Je kan hiervoor dus best een matte zwarte plakband gebruiken. Zoals in de vorige module al werd aangegeven gebruik je deze module het best in combinatie met module 9 en module 11. Net zoals de vorige module komt het idee voor deze module van de website van Dwengo [7]. Ik heb hier echter wel een aantal zaken in aangepast.

1. Doelstellingen In deze module staat het algoritmisch denken van de leerlingen centraal. De leerlingen zullen een robot leren ontwikkelen die een zwarte lijn op een witte ondergrond kan volgen. Daarvoor leren ze gebruik maken van de twee grondsensoren van de robot. De leerlingen leren hoe ze deze sensoren moeten uitlezen, hoe ze deze moeten interpreteren en ze moeten dan nadenken hoe de robot moet reageren. Op die manier kunnen de leerlingen de robot dan programmeren.

2. Uitwerken van de module De werking van deze robot lijkt eigenlijk op de werking van de lichtvolgende robot. Net zoals in de vorige module zal er aan de hand van de twee sensoren bepaald worden of de robot naar links, naar rechts of rechtdoor moet rijden. Het grote verschil met de vorige module is de manier waarop de sensoren worden uitgelezen. We beginnen de code echter op dezelfde manier: invoegen van bibliotheken, constanten definiëren, main programma openen, variabelen declareren, de nodige zaken initialiseren en ervoor zorgen dat de gebruiker op de C knop moet drukken voor het eigenlijke programma wordt uitgevoerd. Voor meer uitleg over deze code verwijs ik naar de vorige module. #include #include #include #include #include #include #define DREMPELWAARDE 60 #define MAXSNELHEID 900 #define MINSNELHEID 400 void main(void) { int srechts; int slinks; srechts = 0; slinks = 0;

61

initBoard(); initLCD(); initSensorModule(); initMotor(); backlightOn(); printStringToLCD("Druk op knop C",0,0); while(SW_C != PRESSED) {} backlightOff(); clearLCD(); De waarde van de rechter grondsensor (OS 2) zullen we in variabele “srechts” steken. De waarde van de linker grondsensor (OS 3) steken we in “slinks”. Aan de hand van deze variabelen zal dan bepaald worden hoe de robot moet reageren. We kunnen nu de while(TRUE) – lus openen en de sensoren uitlezen: while(TRUE){ srechts = readSensor(OS2, DIFF_MODE); slinks = readSensor(OS3, DIFF_MODE); In tegenstelling tot de vorige module kunnen we deze sensoren wel op verschillende manieren uitlezen. De sensor bestaat uit een infrarood LED en een lichtsensor. We kunnen de sensor op drie manieren uitlezen: -

ACTIVE_MODE: De infrarood LED zal aangezet worden. De lichtsensor meet dan het weerkaatste infraroodlicht en het omgevingslicht. AMBIENT_MODE: De infrarood LED wordt niet ingeschakeld. De lichtsensor meet dan enkel het omgevingslicht. DIFF_MODE: Er wordt een meting gedaan in ACTIVE_MODE en één in AMBIENT_MODE. Deze worden dan van elkaar afgetrokken. Het voordeel van deze methode is dus dat de sensor geen rekening zal houden met het omgevingslicht. Daarom zullen we deze mode gebruiken.

Wanneer de sensor in DIFF_MODE een hoge waarde teruggeeft wordt er dus veel licht weerkaatst. (Er is dan een groot verschil tussen de waarde van de twee modes). De sensor bevindt zich dan boven een witte ondergrond. Wanneer de sensor zich boven een zwarte ondergrond bevindt wordt er bijna geen licht weerkaatst. De sensor zal dan een lage waarde teruggeven. (Er is dan bijna geen verschil tussen de waarde van de twee modes.) Als de rechter grondsensor een hoge waarde heeft en de linker grondsensor een lage moet de robot dus naar links draaien. De linker motor (motor 2) moet dan traag draaien en de rechter motor snel. Op die manier zal de robot dus naar links draaien als de linker sensor zich boven de plakband bevindt en de rechter sensor zich boven de witte ondergrond bevindt. Als de linker grondsensor een lage waarde heeft en de rechter grondsensor een hoge moet het omgekeerde gebeuren. De robot moet dan dus naar rechts draaien. De rechter motor moet dan traag draaien en de linker motor snel.

62

Net zoals bij de lichtvolgende robot moet de robot gewoon rechtdoor rijden als aan deze twee voorwaarden niet voldaan wordt. Tot slot gebruiken we een delay om de motoren de tijd te geven om te reageren en sluiten we de while(TRUE) – lus en het main programma. Analoog aan de vorige module geeft dit ons volgende code: if((srechts-slinks) > DREMPELWAARDE) { setSpeedMotor1(-MAXSNELHEID); setSpeedMotor2(MINSNELHEID); } else if((slinks-srechts) > DREMPELWAARDE) { setSpeedMotor1(-MINSNELHEID); setSpeedMotor2(MAXSNELHEID); } else { setSpeedMotor1(-MAXSNELHEID); setSpeedMotor2(MAXSNELHEID); } delay_ms(10); } } De code is nu volledig klaar. Je kan deze code nu naar de robot schrijven en uittesten. Je kan dan wat spelen met de waarde van de constanten om de robot beter af te stellen.

3. De module in de les gebruiken Zoals in de vorige module al werd aangegeven kan je deze module het beste gebruiken in combinatie met module 9 en module 11. Voor de uitleg in verband met het groepswerk dat je hier aan kan verbinden verwijs ik naar module 9. Het werkblad dat je bij deze module aan de leerlingen moet geven ziet er enigszins anders uit. Op dit werkblad moet de opdracht uitgelegd worden: de leerlingen moeten een robot ontwikkelen die een zwarte lijn op een witte ondergrond kan volgen. Hiervoor moeten ze gebruik maken van de twee grondsensoren. Je kan hier ook aangeven dat het over sensoren OS2 en OS3 gaat. De leerlingen kennen de werking van deze sensoren nog niet. Daarom kan je dit kort uitleggen op het werkblad. De leerlingen moeten daarna tijdens de presentaties de werking van de sensoren ook uitleggen. Hierdoor zullen ze dieper nadenken over de werking en kan je er zeker van zijn dat ze de werking begrijpen. Indien de leerlingen de uitleg van de werking van de sensoren op de werkblaadjes niet begrijpen zullen ze vastlopen tijdens het programmeren. De leerlingen zullen dan extra uitleg aan de leerkracht vragen. De leerkracht kan de leerlingen dan aan de hand van gerichte vragen in de goede richting duwen. Op die manier zullen de leerlingen zelf actief nadenken over de werking van de sensoren. Net zoals bij de vorige module moet je ook het gebruik van constanten uitleggen. Dit kan je doen aan de hand van een eenvoudige oefening. Voor de uitleg en de bedoeling van deze oefening verwijs ik graag naar module 9. Bij deze module is het wel aan te raden om aan de leerlingen te vragen dat ze eerste de waarde van de sensoren naar het LCD scherm schrijven. Aan de hand van de module over de lichtsensor moeten de leerlingen in staat zijn om hiervoor eenvoudig de code op te bouwen.

63

De leerlingen kunnen dan kijken welke waarden de sensoren aangeven als ze zich boven de zwarte of de witte ondergrond bevinden. Aan de hand hiervan kunnen de leerlingen dan afleiden welke waarde de sensoren zullen aangeven als één sensor zich boven een zwarte ondergrond bevindt en de andere boven een witte ondergrond. Op basis van deze resultaten kunnen ze dan uitmaken hoe de robot moet reageren. De leerlingen beschikken nu over voldoende informatie om het programma op te bouwen. Ze moeten dan ook in staat zijn om zelfstandig de code op te bouwen. De leerkracht heeft dus ook hier een ondersteunende rol en moet de leerlingen, wanneer zij problemen ondervinden, aan de hand van gerichte vragen in de juiste richting duwen.

64

Module 11: Een muurvolgende robot. In deze module zal er een robot ontwikkeld worden die een muur kan volgen. Hij zal bovendien obstakels op zijn pad kunnen ontwijken. Zoals eerder aangegeven gebruik je deze module best in combinatie met module 9 en module 10. Net zoals de vorige twee modules komt het idee voor deze module van de Dwengo website [7]. Ik heb echter wel een aantal zaken aangepast in de code.

1. Doelstellingen In deze module leren de leerlingen hoe ze een robot kunnen programmeren die een muur kan volgen en obstakels kan ontwijken. Hierbij zullen de leerlingen leren werken met constanten en met afstandssensoren. Ze leren hoe deze sensoren werken, hoe ze de waarden van de sensoren moeten interpreteren en hoe de robot aan de hand hiervan moet reageren.

2. Uitwerken van de module Deze module verschilt wat van de twee vorige modules. Het begin van de code is echter vrij analoog aan het begin van de vorige twee modules. We moeten de bibliotheken toevoegen, constanten definiëren , het main programma openen, variabele declareren, de nodige zaken initialiseren en ervoor zorgen dat de gebruiker op knop C moet drukken voor het eigenlijke programma uitgevoerd wordt. #include #include #include #include #include #include #define TEVER 5 #define TEDICHT 8 #define OBSTAKEL 500 #define MAXSNELHEID 1023 #define MINSNELHEID 550 void main(void) { int sensorMuur; int sensorObstakel; sensorMuur = 0; sensorObstakel = 0; initBoard(); initLCD(); initSensorModule(); initMotor(); backlightOn(); printStringToLCD("druk op C", 0, 0);

65

while(SW_C != PRESSED) {} clearLCD(); backlightOff(); Bij deze module zullen we meer constanten gebruiken. Net zoals bij de vorige module zullen we de sensor die de afstand t.o.v. de muur bepaalt in DIFF_MODE uitlezen (voor meer uitleg over de modes: zie vorige module). Ook deze sensor bestaat uit een infraroodlicht LED en een lichtsensor. Als de sensor dicht bij de muur is zal er veel licht weerkaats worden en zal de sensor, in DIFF_MODE, een hoge waarde terug geven. Indien de sensor ver van de muur is zal de sensor een lage waarde terug geven. Bij deze robot zullen we een muur rechts van de robot volgen. Als de robot te dicht bij de muur is gaat de waarde van de sensor boven “TEDICHT”. De robot moet dan naar links draaien. Als de robot te ver van de muur is gaat de waarde van de robot onder “TEVER”. De robot moet dan dus naar rechts draaien. De langeafstandssensor kunnen we maar op één manier uitlezen. Het maakt dus niet uit welke mode we hiervoor gebruiken. Net zoals bij de lichtsensoren zal dit argument genegeerd worden. Als de sensor dicht bij een obstakel komt zal hij dus een hoge waarde aangeven. Indien deze waarde boven de waarde “OBSTAKEL” gaat moet de robot naar links draaien. De waarde van de sensor die de afstand tot de muur zal aangeven steken we in variabele “sensorMuur”. De waarde van de sensor die de afstand tot het obstakel aangeeft steken we in variabele “sensorObstakel”. We kunnen nu de while(TRUE) – lus openen en de sensoren uitlezen. Voor we dit doen moeten we echter de langeafstandssensor aanschakelen. Omdat deze sensor een hoog vermogen nodig heeft is deze standaard uitgeschakeld om de batterijen te sparen. We zullen nu echter gebruik maken van deze sensor waardoor we hem moeten aanzetten. Dit geeft volgende code: powerLongRange(TRUE); while (TRUE) { sensorMuur = readSensor(OS5, DIFF_MODE); sensorObstakel = readSensor(OS8, ACTIVE_MODE); We kunnen nu bepalen hoe de robot moet reageren, afhankelijk van de waarden van de sensoren. Hiervoor moeten we ons afvragen wanneer de robot naar rechts of naar links moet draaien en wanneer hij rechtdoor moet rijden. Eerst zullen we bepalen wanneer de robot naar links moet draaien. Dit is het geval als de waarde van “sensorMuur” onder “TEVER” gaat. Dit levert ons volgende code: if(sensorMuur < TEVER) { setSpeedMotor1(-MINSNELHEID); setSpeedMotor2(MAXSNELHEID);

66

De robot moet naar links draaien als de waarde van “sensorMuur” boven “TEDICHT” gaat of als de waarde van “sensorObstakel” onder “OBSTAKEL” gaat. In de voorwaarde moeten we dus een OR – functie gebruiken. Hiervoor gebruiken we “||”. De code ziet er dan als volgt uit: } else if(sensorMuur > TEDICHT || sensorObstakel < OBSTAKEL) { setSpeedMotor1(-MAXSNELHEID); setSpeedMotor2(MINSNELHEID); Indien er niet aan de vorige voorwaarden voldaan wordt zijn er geen problemen en moet de robot, net als bij de vorige modules, gewoon rechtdoor rijden. Tot slot moeten we de motoren de tijd geven om te reageren en de while(TRUE) – lus en het main programma sluiten. Hiervoor hebben we volgende code nodig: } else { setSpeedMotor1(-MAXSNELHEID); setSpeedMotor2(MAXSNELHEID); } delay_ms(10); } } De code is nu volledig klaar. Je kan deze nu naar de robot schrijven en uittesten. Je kan dan ook spelen met de waarden van de constanten om de robot zo beter af te stellen.

3. De module in de les gebruiken Zoals eerder al werd aangegeven gebruik je deze module best in combinatie met module 9 en module 10. Voor de uitleg i.v.m. het groepswerk dat hiermee samenhangt verwijs ik graag naar module 9. Het werkblad voor deze module is vrij analoog aan dat van module 10. In eerste instantie moet de opdracht uitgelegd worden: de leerlingen moeten een robot ontwerpen die langs de rechterkant een muur kan volgen. De robot moet bovendien ook obstakels op zijn weg kunnen ontwijken. Je kan de leerlingen dan ook aangeven dat ze hiervoor sensoren OS5 en OS8 moeten gebruiken. De leerlingen kennen de werking van deze sensoren nog niet. Daarom kan je dit kort uitleggen op het werkblad. De leerlingen moeten daarna tijdens de presentatie de werking van de sensoren ook uitleggen. Hierdoor zullen ze dieper nadenken over de werking en kan je er zeker van zijn dat ze de werking begrijpen. Indien de leerlingen de uitleg van de werking van de sensoren op de werkblaadjes niet begrijpen zullen ze vastlopen tijdens het programmeren. De leerlingen zullen dan extra uitleg aan de leerkracht vragen. De leerkracht kan de leerlingen dan aan de hand van gerichte vragen in de goede richting duwen. Op die manier zullen de leerlingen zelf actief nadenken over de werking van de sensoren. Net zoals bij de vorige modules moet je ook het gebruik van constanten uitleggen. Dit kan je doen aan de hand van een eenvoudige oefening. Voor de uitleg en de bedoeling van deze oefening verwijs ik graag naar module 9.

67

Bij deze module is het, zoals bij module 10, aan te raden om aan de leerlingen te vragen dat ze eerst de waarde van de sensoren naar het LCD scherm schrijven. Aan de hand van de module over de lichtsensor moeten de leerlingen in staat zijn om eenvoudig de code hiervoor op te bouwen. De leerlingen kunnen dan kijken welke waarden de sensoren aangeven als ze zich te dicht bij de muur of een obstakel bevinden. Aan de hand hiervan kunnen de leerlingen dan de waarden “TEVER”, “TEDICHT” en “OBSTAKEL” bepalen. Ze kunnen dan ook afleiden hoe de robot moet reageren indien hij onder of boven deze waarden gaat. De leerlingen beschikken nu over voldoende informatie om het programma op te bouwen. Ze moeten dan ook in staat zijn om zelfstandig de code op te bouwen. De leerkracht heeft dus ook hier een ondersteunende rol en moet de leerlingen, wanneer zij problemen ondervinden, aan de hand van gerichte vragen in de juiste richting duwen. Tijdens mijn stage heb ik de module op deze manier uitgetest. De leerlingen slaagden er ook in om de robot succesvol te programmeren. Dit is in mijn ogen echter de moeilijkste module van de drie. Daarom zou ik hem door de sterkere leerlingen laten uitvoeren. Hierdoor zullen deze leerlingen voldoende uitgedaagd worden. Dit zal hun motivatie alleen maar ten goede komen. Het kan wel zijn dat je de leerlingen bij deze module iets meer moet ondersteunen. Indien je dit doet door gerichte vragen te stellen en de leerlingen zo zelf actief laat nadenken is dit echter geen probleem.

68

Module 12: Ontwerpen van een spel: Simon Says Deze module is in mijn ogen de moeilijkste. Daarom dat het ook de laatste module is. Zowat alles wat in eerdere modules geleerd werd komt in deze module samen. Doorheen de vorige modules hebben de leerlingen ook hun algoritmisch denken verder ontwikkeld. Ze zullen dit dan ook nodig hebben om deze module op te lossen. Het idee voor deze module komt van de Dwengo website [8].

1. Doelstellingen Deze module heeft als doelstelling dat de leerlingen een complex probleem leren omzetten in een programma. Ze moeten hiervoor zeker en vast een stappenplan opstellen. Daarnaast zou ik deze module als groepswerk of projectwerk gebruiken. De leerlingen leren dan dus ook samenwerken in een team. Zoals in een later hoofdstuk wordt aangegeven kan je deze module ook gebruiken om doelstellingen i.v.m. projectmanagement toe te voegen.

2. De module uitwerken De code van dit spel is niet eenvoudig. Het is dus belangrijk dat je als leerkracht zelf aanvoelt of je leerlingen hier klaar voor zijn of niet. Wanneer je veel tijd uit de vrije ruimte aan Dwengo wil besteden kan je dit als een soort van eindproject beschouwen. De leerlingen krijgen dan enkele lesuren de tijd om, met begeleidende hulp, de opdracht tot een goed einde te brengen. De leerlingen leren op die manier samenwerken, want het is zeker interessant om de leerlingen in groepjes te laten nadenken. De leerlingen leren op deze manier ook algoritmisch denken en aan de hand van een opgesteld stappenplan een complex programma ontwerpen. Wat is nu het doel van het spel? Drie LEDs zullen een bepaalde sequentie tonen. De gebruiker moet dan a.d.h.v. drie drukknoppen de sequentie proberen te reproduceren. Eerst moet de gebruiker een sequentie van 1 LED reproduceren, dan van twee LEDs, dan drie en zo verder tot de maximale lengte van de sequentie bereikt is (in ons geval 10). Voor we aan de code beginnen stellen we zoals altijd een stappenplan op: 1. 2. 3. 4. 5. 6. 7. 8. 9.

We starten met een lege sequentie (geen elementen in de sequentie) Verleng de sequentie (1 element toevoegen) Toon de volledige sequentie Wacht tot de speler een drukknop indrukt Controleer of de ingedrukte drukknop overeenkomt met de juiste LED in de sequentie Indien er een fout gemaakt werd: stop het programma, de speler is verloren Herhaal stap 4, 5 en 6 tot de volledige sequentie is ingetoetst door de speler Keer terug naar stap 2 indien de maximale lengte van de sequentie nog niet bereikt is De maximale lengte sequentie werd bereikt: de speler is gewonnen

69

Voor we aan het eigenlijke spel beginnen moeten we de nodige bibliotheken invoeren en variabelen declareren. Net zoals bij de drukknoppen zullen we gebruik maken van twee bibliotheken. We beginnen de code met: #include #include Omdat het een redelijk lang en complex programma wordt is het interessant om in de plaats van getallen gebruik te maken van constanten. Op die manier is het programma overzichtelijker omdat we aan de hand van de naam van de constanten kunnen afleiden wat er gebeurt in plaats van dat er zomaar een getal staat. We definiëren twee constanten: #define MAX_LENGTH_SEQ 10 #define ALFA 3 Wanneer we nu in onze code “MAX_LENGTH_SEQ” typen weten we dat het over de maximale lengte van de sequentie (hier 10) gaat. Dit zegt veel meer dan dat we gewoon “10” zouden typen. Nu kunnen we beginnen aan het main programma. We declareren ook een aantal variabelen. Het is zeker en vast niet onverstandig om de variabelen zo klein mogelijk te houden. De meeste variabelen die we zullen gebruiken hebben aan 1 byte voldoende. Dankzij de Dwengo bibliotheek kunnen we deze declareren door het commando “BYTE” te gebruiken. Enkel voor de variabele “seed” volstaat dit niet. We maken ook een rij van “unsigned chars” aan met als naam “sequence” . Hierin zullen we de sequentie van de LEDs opnemen. De rij kan niet groter worden dan “MAX_LENGTH_SEQ”. Als laatste moeten we ook nog het Dwengo board initialiseren. Als code geeft dit: void main(void) { unsigned int seed; BYTE sequence[MAX_LENGTH_SEQ]; BYTE error, n, i, j, is_button_pressed, button_pressed; initBoard(); We zullen het spel laten beginnen als de gebruiker de knop C heeft ingedrukt. We moeten dus een boodschap naar het display sturen die dat aangeeft: backlightOn(); appendStringToLCD("Press button C to play"); Om te controleren of de speler de C knop heeft ingeduwd zullen we een while – lus gebruiken die blijft lopen zolang de knop niet ingedrukt wordt. Wanneer er dan op de C knop gedrukt wordt, zal er uit de lus gesprongen worden. Om te zorgen dat het spel altijd gebruik zal maken van een andere, willekeurige, sequentie zullen we gebruik maken van een random generator. In deze random generator zitten allemaal vaste sequenties. Hieruit moeten we dus willekeurig een sequentie selecteren. Hiervoor zullen we tellen hoelang het duurt voor de gebruiker op de C – knop drukt. Door deze willekeurige gebeurtenis zullen we dus een willekeurige sequentie selecteren. We zullen de variabele “seed” gebruiken om te tellen. Hiervoor moeten we deze eerste de waarde 0 geven. De code wordt dan:

70

seed = 0; while (SW_C != PRESSED) { seed++; } srand(seed); // willekeurig een sequentie selecteren Nu zullen we beginnen aan de eigenlijke code van het spel en dus aan het stappenplan dat we opstelden. Hiervoor stellen we de variabele “error” in op “FALSE” om aan te geven dat er nog geen fouten gemaakt zijn. De variabele “n” geven we waarde 0 omdat de sequentie voorlopig nog leeg is. error = FALSE; n = 0; Vervolgens zullen we een grote while – lus maken die blijft lopen zolang het spel nog niet voorbij is, dus zolang er nog geen fout gemaakt is en de maximale lengte van de sequentie nog niet bereikt is. Op het scherm zullen we aan de gebruiker tonen in welke ronde (n + 1) we zitten en we geven aan dat we de sequentie zullen tonen: while (n < MAX_LENGTH_SEQ && error != TRUE) { clearLCD(); printStringToLCD("Ronde ", 0, 0); appendIntToLCD(n + 1); appendStringToLCD(": sequentie tonen "); Omdat de LEDs verbonden zijn met de datalijnen van het LCD scherm, zullen ze even oplichten als we iets naar het scherm schrijven. Om er zeker van te zijn dat de LEDs uit zijn zullen we ze zelf uitzetten. Daarna zullen we 250 ms wachten om de gebruiker tijd te geven om naar de LEDs te kijken. LEDS = 0; delay_ms(250); Vervolgens zullen we een getal aan de sequentie toevoegen op plaats n. De eerste keer voegen we dus een getal toe op plaats 0. Dit doen we door gebruik te maken van de random generator. De random generator geeft echter een willekeurig natuurlijk getal terug. Aangezien we slechts 3 LEDs gebruiken kunnen we enkel de getallen 0, 1 en 2 gebruiken. Hiervoor nemen we de modulo 3 (ALFA) van het gegenereerde natuurlijk getal. sequence[n] = rand() % ALFA; // Willekeurig getal tussen 0 en 2 selecteren. Intermezzo: Modulo 3 [9] Bij modulair rekenen met modulo m wordt gerekend met de getallen 0, 1, 2, …, m-1. Na m-1 volgt niet het getal m, maar het getal 0. De m getallen (0 t.e.m. m-1) staan dus in een soort van kring. Wanneer een getal (bijvoorbeeld bij een optelling of vermenigvuldiging) groter of gelijk is aan m, wordt van dat getal m afgetrokken tot het getal wel kleiner is dan m. Door van het willekeurig gegenereerde natuurlijk getal door de random generator de modulo 3 te nemen, zijn we dus zeker dat het getal gelijk is aan 0, 1 of 2.

71

Nu zullen we de hele sequentie aflopen en elk element uit de sequentie afzonderlijk tonen. Het getal 0 komt overeen met LED 0 en dus het binair getal 0. Eén komt overeen met LED 1 en dus het binair getal 1. Twee komt overeen met LED 2 en dus het binair getal 4. De eerste keer zal n nog gelijk zijn aan 0 en tonen we dus enkel het eerste element uit de rij. We zullen de LED 500 ms laten oplichten om de gebruiker de tijd te geven om naar de LED te kijken. Tussen twee elementen van de sequentie zullen we 250 ms wachten. Deze getallen kunnen aangepast worden om de sequentie trager of sneller te laten verschijnen. Om de sequentie af te lopen zullen we gebruik maken van een for – lus. Dit geeft ons volgende code: for (i=0;i<=n;i++) { if (sequence[i] == 0) LEDS = 1; else if (sequence[i] == 1) LEDS = 2; Else LEDS = 4; delay_ms(500); LEDS = 0; delay_ms(250); } Na dat de sequentie getoond werd zullen we een andere tekst op het scherm laten verschijnen. Dit om aan de gebruiker aan te geven dat hij met de drukknoppen de sequentie moet reproduceren: clearLCD(); appendStringToLCD("Ronde "); appendIntToLCD(n+1); appendStringToLCD(": druk juiste knoppen "); Nu moet de gebruiker de sequentie reproduceren. We zullen hiervoor opnieuw de sequentie aflopen met een for – lus. In deze for – lus wachten we elke keer tot de gebruiker een knop heeft ingedrukt. Knop E komt overeen met LED 0, C met LED 1 en W met LED 2. We zullen hiervoor gebruik maken van een while – lus waarin we kijken of de knoppen al dan niet worden ingedrukt. Wanneer de gebruiker een drukknop indrukt zullen we de waarde van die drukknop opslaan in de variabele “BUTTON_PRESSED”. We zullen dan op het display een “*” tonen zodat de gebruiker weet dat hij de drukknop mag loslaten. Bij het indrukken van de knoppen zullen we telkens 250 ms wachten om ervoor te zorgen dat de knop niet meerdere keren gerekend wordt. De gebruiker heeft dus 250 ms om de knop weer los te laten. Tot slot moeten we controleren of de gebruiker de juiste knop heeft ingedrukt. We zullen hiervoor kijken of de waarde van “BUTTON_PRESSED” overeenkomt met de opgelichte LED uit de sequentie. Dit doen we met een if opdracht. Wanneer de gebruiker de foute knop indruk zetten we de variabele “error” op TRUE, hierdoor zullen we uit de grote while – lus (while(n < MAX_LENGTH_SEQ && error != TRUE) springen waardoor het programma beëindigd wordt. Wanneer de gebruiker in het midden van de sequentie een fout maakt moeten we de rest van de sequentie niet meer controleren. We zullen hiervoor de variabele “i” groter maken dan “n” waardoor we uit de for – loop springen. Als code geeft dit ons:

72

for (i=0;i<=n;i++) { is_button_pressed = FALSE; while (!is_button_pressed) { is_button_pressed = TRUE; if (SW_E == PRESSED) button_pressed = 0; else if (SW_C == PRESSED) button_pressed = 1; else if (SW_W == PRESSED) button_pressed = 2; else is_button_pressed = FALSE; } appendStringToLCD("*"); delay_ms(250); if (button_pressed != sequence[i]) { error = TRUE; i = n + 1; } } Wanneer de sequentie juist doorlopen werd mag aan de sequentie een waarde toegevoegd worden. We mogen dan terugspringen naar het begin van de grote while – lus: n++; } Wanneer de while – lus gedaan is kan dit maar twee zaken betekenen: het spel is gedaan omdat de gebruiker een fout gemaakt heeft (ERROR = TRUE) of omdat de maximale sequentie bereikt werd (ERROR = FALSE). We zullen dit controleren met een if opdracht en afhankelijk van het resultaat de juiste boodschap op het scherm tonen: if (error == TRUE) { clearLCD(); appendStringToLCD(" Verloren :("); } else { clearLCD(); appendStringToLCD("Gewonnen :)"); } Het spel is nu gedaan, maar dit wil niet zeggen dat we klaar zijn met de code. Wanneer we hier het haakje van het main programma zouden sluiten zal de compiler ervoor zorgen dat het programma opnieuw begint bij het begin van het main programma (door extra code toe te voegen). Dit is niet de bedoeling, want de tekst of de gebruiker gewonnen heeft of niet zou dan meteen van het scherm verdwijnen. Dit kunnen we vermijden door op het einde een while(TRUE) lus toe te voegen. De gebruiker kan het programma dan enkel opnieuw starten door op de reset – knop te drukken. We zullen dit dan ook aangeven op het scherm: delay_s(1);

73

printStringToLCD("RESET to restart", 1,0); delay_s(2); backlightOff(); while (TRUE); } De code is nu volledig klaar. Je kan de code nu uittesten op het Dwengo board!

3. De module in de les gebruiken Zoals ik eerder al aangaf is het interessant om deze module als groepswerk of projectwerk te gebruiken. Je moet er als leerkracht dan ook de nodige lessen voor uittrekken. Naast de doelstellingen i.v.m. algoritmisch denken leren de leerlingen ook samenwerken. Daarnaast kan je ze ook doelstellingen i.v.m. projectmanagement aanbrengen. Zoals ik in een later hoofdstuk zal aantonen verdeel je de klas best in groepen van vier. Daarnaast moet je ervoor zorgen dat de opdracht zeer duidelijk is voor de leerlingen. De leerlingen moeten dus weten wat het spel juist inhoudt en hoe het dus gespeeld moet worden. In een eerste fase moeten ze dan als groep het stappenplan opstellen. Voor ze beginnen programmeren moeten ze dit plan voorleggen aan de leerkracht. Na dit gesprek kunnen de leerlingen beginnen aan het programmeren of moeten ze het stappenplan nog wat aanpassen. Bij het programmeren zelf kunnen ze het spel verdelen over twee groepjes van twee. Ze moeten er wel voor zorgen dat ze blijven communiceren omdat ze dezelfde variabelen en dergelijke moeten gebruiken. Dit moet je dan ook duidelijk aangeven in de opdracht. Als leerkracht heb je dus weer een ondersteunende rol. Wanneer er problemen optrede moeten de leerlingen deze eerst in groep proberen op te lossen. Als ze dan nog niet tot een oplossing komen kan de leerkracht doormiddel van gerichte vragen de leerlingen in de juiste richting sturen. Als leerkracht moet je daarnaast ook het proces kunnen evalueren. Dit kan je doen doormiddel van observatie, gesprekken en peer assessment (zie later hoofdstuk). Op basis hiervan en op basis van het uiteindelijke resultaat kunnen de leerlingen dan geëvalueerd worden. Het is daarbij ook belangrijk dat je als leerkracht regelmatig feedback geeft. Zo kan je tussentijds samenzitten met de leerlingen en hun vooruitgang bespreken. Goede en minder goede elementen van het programma kunnen dan besproken worden. Op deze manier ken je van elk groepje de vooruitgang, maar je kan ook tijdig ingrijpen wanneer de leerlingen de verkeerde richting uitgaan. Je kan deze module eventueel ook gebruiken als rode draad doorheen alle lessen i.v.m. Dwengo. Wanneer de leerlingen dan iets nieuws leren kunnen ze een stukje aan hun code toevoegen. Zo wordt analoog aan het opbouwen van de leerstof ook het spel opgebouwd. Op het einde van de rit hebben de leerlingen dan een werkend Simon Says spel.

74

Hoe in Nederland? Naast het ontwikkelen van lesmateriaal voor de vrije ruimte is het ook interessant om een kijkje te nemen over de grenzen. Hoe gaat men in Nederland te werk? Kan Dwengo hier ook ingezet worden en op welke manier? Om hier dieper op te kunnen ingaan, bekeek ik het handboek “Fundament Informatica” van instruct [10]. Dit is een handboek voor de tweede fase van het Nederlands onderwijs en dit komt overeen met ons 4de, 5de en 6de middelbaar. Een eerste interessante opmerking is het feit dat het handboek niet is onderverdeeld in hoofdstukken, maar in modules. Een module is op zijn beurt wel onderverdeeld in enkele hoofdstukken. Elke module is een afgerond geheel, hierdoor kunnen de modules in een gewenste volgorde doorlopen worden. De leerkracht behoudt hier dus de vrijheid om de leerstof aan te bieden in de volgorde die hem / haar het beste lijkt. Elke module is zo opgebouwd dat de leerkracht gebruik kan maken van verschillende didactische werkvormen.   



Theoriegerichte werkwijze: dit is de klassieke manier van lesgeven. De leerkracht geeft de theorie en de leerlingen oefenen deze in aan de hand van oefeningen. Praktijkgerichte werkwijze: elk hoofdstuk van een module bezit een praktijkopdracht. De leerlingen maken zich op deze manier al doende de leerstof eigen. Projectgerichte werkwijze: elke module beschikt over een projectopdracht. De leerlingen krijgen hierdoor op een aansprekende manier met de materie te maken. Het is bovendien de bedoeling dat zij hierbij projectmanagementvaardigheden ontwikkelen. Vraaggerichte werkwijze: aan de hand van doelgerichte vragen doorlopen leerlingen de leerstof.

Zeker voor beginnende leerkrachten lijkt dit mij ideaal. Ondanks het gebrek aan ervaring kunnen ze toch afwisselen tussen verschillende werkvormen. Oudere leerkrachten daarentegen hebben genoeg ervaring om zelf een didactische werkvorm uit te werken. Door het voorstellen van deze vier werkvormen per module kan de creativiteit van de leerkracht beperkt worden. Het is dus, in mijn ogen, zeer belangrijk dat de leerkracht zelf ook zoekt naar didactische werkvormen. Hij / zij kan hiervoor uiteraard wel steunen op de werkvormen die in het boek terug te vinden zijn. De leerstof die in het boek is opgenomen is het kernprogramma. Elke leerling zou dus na de tweede fase de leerstof uit het boek moeten beheersen. Daarnaast kan je op de website www.informaticaonline.nl verdiepingsopdrachten terugvinden voor elke module. Sterkere leerlingen kunnen op deze manier dus voldoende uitgedaagd worden. Niets houdt de leerkracht echter tegen om zelf op zoek te gaan naar creatieve verdiepingsopdrachten. Het handboek bestaat uit 8 modules. De module die voor dit werk interessant is, is module 5: programmeren.

75

Programmeren aanleren met instruct In een eerste hoofdstuk wordt ingegaan op “programmeertalen”. Hiervoor wordt de evolutie van de programmeertalen in een historisch perspectief geplaatst van machinecode tot objectgeoriënteerde talen. Voor elke groep van programmeertalen wordt kort aangegeven wat het is en waarvoor het gebruikt werd /wordt. Daarna wordt ingegaan op een aantal veelgebruikte programmeertalen. Voor elke taal wordt kort beschreven waarvoor ze gebruikt wordt en door wie ze ontwikkeld werd. Het lijkt mij zeker en vast interessant om de leerlingen te laten kennis maken met de verschillende talen zonder er, in een eerste stadium, dieper op in te gaan. Later zullen de leerlingen leren programmeren in een bepaalde programmeertaal, maar door eerst dit overzicht te geven weet de leerling dat er nog andere manieren om te programmeren bestaan. De programmeertalen die men kort beschrijft zijn: C en C++, Java, Delphi, Visual Basic.NET en enkele programmeertalen voor het net. In een tweede hoofdstuk bekijkt men hoe men een probleem kan omzetten in een programma. Hiervoor maakt men gebruik van een PSD (Programma structuur diagram). Dit is een schema dat de samenhang en de structuur van instructies binnen een programma weergeeft. Door voor een probleem zo’n schema op te stellen, zal het later eenvoudiger zijn om een probleem om te zetten in programmeercode. Door een PSD op te stellen maakt men eigenlijk een algoritme. Net zoals in België staat het algoritmisch denken dus centraal. Het programmeren is enkel een middel om dit algoritmisch denken te ontwikkelen. Bij het opstellen van een PSD maakt men gebruik van volgende zaken:  



Sequentie: de opdrachten worden van boven naar onder doorlopen. Ook in een programma is dit het geval. Iteratie: bepaalde delen van een programma moeten een aantal keer herhaald worden zonder elke keer het hele programma te moeten doorlopen. Bij de programmeertaal maakt men hiervoor gebruik van een while - of for - lus. Selectie: het programma splitst zich op een bepaalde plaats op grond van een vraag. Afhankelijk van het antwoord op deze vraag zal het programma de ene serie van opdrachten of de andere serie uitvoeren. Bij programmeertaal maakt men hiervoor gebruik van een if opdracht.

Heel deze theorie wordt opgehangen aan eenzelfde voorbeeld: het bakken van een ei. Men begint met een eenvoudige sequentie en breidt deze sequentie telkens uit. Zo voegt men een iteratie toe om meer eieren te bakken en een selectie om te kijken of het vuur uitstaat. Het is voor de leerlingen, volgens mij, zeker en vast interessant om elke keer op hetzelfde voorbeeld terug te komen. De leerlingen zien zo duidelijk wat er verandert aan het programma. Het is op die manier duidelijk wat een sequentie, iteratie of selectie is. Nu is het tijd om over te stappen op het programmeren zelf. Instruct voorziet hiervoor 5 verschillende manieren. Er zijn vijf verschillende boekjes die het programmeren aanleren. Elk boekje maakt hiervoor gebruik van een andere methode. De leerkracht kan dus beslissen welke methode voor hem / haar het beste lijkt. Men kan gebruik maken van volgende methodes: visual basic, BlueJ, PHP, Delphi en Java. Niets houdt de leerkracht uiteraard tegen om een eigen methode uit te werken.

76

Zo kan er bijvoorbeeld gebruik gemaakt worden van de Dwengo robot om het algoritmisch denken van de leerlingen te ontwikkelen. Men zou dan gebruik maken van C. Hier kom ik later nog op terug. Ik zal nu even kort de verschillende methodes overlopen. Visual basic [11]: Het boek geeft duidelijk aan dat de leerlingen thuis de theorie moeten bekijken en dat ze tijdens de les hier oefeningen op moeten maken. Ik denk echter niet dat dit voor elke klas haalbaar is. Volgens mij zullen veel leerlingen denken dat ze het tijdens de les wel zullen snappen. Aangezien ze thuis de theorie niet grondig bekijken, zullen ze tijdens de les meer tijd nodig hebben voor de oefeningen omdat ze dan de theorie nog moeten bekijken. Hierdoor zal het volgens mij moeilijk worden om de lessen volledig rond te krijgen. Aangezien ook in België Visual Basic in veel scholen gebruikt wordt om te leren programmeren is het zeker niet oninteressant om het boek eens van naderbij te bekijken. In een eerste hoofdstuk wil men Visual Basic vergelijken met andere programmeertalen. Het is volgens mij nuttiger om dit op het einde van de cursus te doen. De leerlingen hebben, zoals eerder aangegeven, al een besef van het feit dat er meerdere programmeertalen bestaan. Wanneer je op het einde van de cursus Visual Basic de code gaat vergelijken met andere programmeertalen zullen de leerlingen beter begrijpen wat de code voorstelt waardoor ze ook de andere programmeertalen beter zullen begrijpen. In een tweede hoofdstuk legt men uit hoe je Visual Basic moet gebruiken. Aan de hand van opdrachten wordt uitgelegd hoe je de ontwikkelomgeving moet openen en wat de verschillende knoppen van de ontwikkelomgeving voorstellen. Het is belangrijk dat de leerlingen weten waar alles voor dient en hoe ze met de ontwikkelomgeving moeten werken, maar dit is echter geen doel op zich. De ontwikkelomgeving is een middel om te leren programmeren en dus algoritmisch te denken. De leerlingen kunnen dit dus gerust thuis bekijken en kunnen hier altijd naar terugbladeren. Door zelf te programmeren zullen de leerlingen zelf ontdekken waar alles voor dient. Dit is een goede voorbereiding op later, waar de leerlingen zullen werken met andere ontwikkelomgevingen (al dan niet om te programmeren). Ze moeten dan ook zelfstandig met deze ontwikkelomgevingen leren werken. Bij Visual Basic moeten de leerlingen ook een gebruikersinterface bouwen. Door dit te doen leren de leerlingen hoe ze deze efficiënt en ordelijk kunnen opbouwen. Ook nu is het volgens mij belangrijker dat de leerlingen de opdrachten uit voeren en zo leren hoe ze een interface moeten opbouwen. Het is minder nuttig om eerst de theorie te geven en leerlingen dan pas oefeningen te laten maken. Aan de hand van korte eenvoudige stukken code leren de leerlingen werken met de ontwikkelomgeving. Door de opdrachten steeds complexer te maken leren de leerlingen stapsgewijs moeilijkere opdrachten oplossen. In een derde hoofdstuk leren de leerlingen werken met variabelen. Ook nu is het de bedoeling dat de leerlingen dit leren aan de hand van kleine opdrachten. De leerlingen leren ook hoe ze ervoor kunnen zorgen dat hun code overzichtelijk blijft. Door te werken met inspringen en commentaar is het voor een buitenstaander duidelijk waarover de code gaat. Het is volgens mij dan ook zeer goed

77

dat men hier extra aandacht aan besteedt. Ook bij het programmeren van de Dwengo robot is structuur belangrijk. In een vierde hoofdstuk gaat men in op enkele basisstructuren zoals de if opdracht en de while lus. Men valt ook terug op het PSD dat men eerder in het handboek introduceerde. Het is volgens mij voor de leerlingen dan ook duidelijker wat men bedoelt met bijvoorbeeld een if opdracht en waarvoor ze gebruikt kan worden. Ook nu leert men deze basisstructuren aan door middel van kleine korte opdrachten. In een laatste hoofdstuk bekijkt men dan hoe je grotere programmeeropdrachten moet aanpakken. Men bespreekt hier kort volgende stappen:      

Probleemdefinitie Probleemanalyse Oplossing schematiseren Programma – instructies coderen Testen Levering en onderhoud

Ook bij het gebruik van de Dwengo robot is dit zeker relevant. Aangezien ik de Dwengo robot gebruik in de vrije ruimte van het 6de middelbaar ASO hebben de leerlingen de basis van programmeren al onder de knie. Ze zullen dan ook langere en complexe opdrachten moeten oplossen. Wanneer de leerlingen eerst duidelijk het probleem analyseren zullen ze er volgens mij beter in slagen om het probleem op te lossen. Andere programmeertalen Aangezien de andere boeken ongeveer dezelfde structuur vertonen als het Visual Basic boek is het niet echt nuttig om elk boek op dezelfde manier te analyseren. Daarom zal ik kort opvallende zaken en verschillen bij de verschillende programmeertalen overlopen: BlueJ [12]: Daar waar Visual Basic procedureel programmeren was leert men met BlueJ object georiënteerd programmeren. BlueJ is echter geen programmeertaal op zich, maar een omgeving. Aan de hand van dit handboek leert men aan de hand van Java programmeren. BlueJ is een ontwikkelomgeving waarmee men de Java klassen eenvoudig kan testen. In tegenstelling tot het handboek van Visual Basic gebruikt men in dit handboek geen eenvoudige code voorbeelden om de leerstof op te bouwen. Men gebruikt grotere programma’s in de BlueJ omgeving waarop de leerling meteen dingen kan uitproberen. Men moet echter een soort kookboek recept in het handboek volgen. Door opeenvolgende handelingen uit te voeren zal het programma bepaalde zaken uitvoeren. In het handboek geeft men dan aan dat men de broncode van de klasse moet bekijken en deze analyseren. Aan de hand van deze code moeten de leerlingen dan zelf een nieuwe methode aanmaken. Men begint met relatief eenvoudige methodes en doorheen het handboek worden er telkens complexere methodes toegevoegd. Zo leert men hier ook variabelen aanmaken en later leert men gebruik maken van lussen.

78

In mijn ogen zou men echter beter beginnen met procedureel programmeren en wanneer de leerlingen dit goed onder de knie hebben kan men overgaan naar object georiënteerd programmeren. Door het gebruik van klassen, methodes, … is object georiënteerd programmeren in mijn ogen complexer. BlueJ is echter wel een goede omgeving om de code uit te testen. Je kan ook snel zelf beginnen programmeren en uittesten zonder dat je alle theorie al gezien hebt. In de richting boekhouden – informatica is object georiënteerd programmeren echter wel opgenomen in het leerplan. Het is duidelijk de bedoeling van BlueJ om het object georiënteerd programmeren zo eenvoudig mogelijk voor te stellen. BlueJ lijkt mij daarom wel een zeer goed instrument om deze vorm van programmeren aan te leren. PHP [13]: In het handboek geeft men in een eerste hoofdstuk duidelijk aan waarvoor PHP gebruikt wordt en waarom men het nodig heeft. In mijn ogen heeft PHP het voordeel dat men het kan linken aan gegevensbanken, leerstof die men ook moet kennen. Een nadeel is echter wel dat men ook html code moet gebruiken voor je de php code zichtbaar kan maken. Ofwel moeten de leerlingen eerst een basis html krijgen, ofwel staat er altijd een stuk code waarvan de leerlingen niet weten waarvoor ze dient. Het eerste is in mijn ogen duidelijk de beste oplossing. In het handboek geeft men in het tweede hoofdstuk dan ook een basis html mee. Aan de hand van een klein stukje code (html en php) brengt men de eerste begrippen aan. Op die manier begrijpen de leerlingen ook het klein stukje html code dat gebruikt wordt. Als eerste kennismaking met php breidt men in het eerste hoofdstuk deze code langzaam uit. Het is volgens mij voor de leerlingen dan ook zeer duidelijk wat er gebeurt. Net zoals in de andere handboeken leert men aan de hand van eenvoudige voorbeelden variabelen en lussen aan. De leerlingen moeten op het einde van elk hoofdstuk dan enkele eenvoudige opdrachten uitvoeren. Ze kunnen de theorie dan ook meteen toepassen. In tegenstelling tot de andere handboeken gaat men hierna wel nog verder. De leerlingen leren ook gebruik maken van html formulieren en ze leren gegevens uit een database oproepen en bewerken. Zoals ik al eerder aangaf worden op deze manier twee leerstof onderdelen aan mekaar gelinkt: gegevensbanken en programmeren. Delphi [14]: Delphi was een voor mijn nog onbekende programmeertaal. In het eerste hoofdstuk ontdekte ik dan ook (zoals de leerlingen dit ook doen) hoe Delphi ontstaan is en wat voor programmeertaal het is. Net zoals bij Visual Basic overloopt men in een tweede hoofdstuk hoe de ontwikkelomgeving in mekaar zit. Men overloopt uit welke vensters de ontwikkelomgeving bestaat en men bekijkt enkele basisknoppen. Net zoals bij Visual Basic is deze omgeving geen doel op zich, maar een middel om het programmeren en dus het algoritmisch denken aan te leren. Een voordeel van Delphi is dat het zeer nauw aansluit bij een PSD. In het handboek heeft men, in tegenstelling tot de andere handboeken, meer aandacht voor het ontwikkelen van een PSD. Aan de hand van enkele eenvoudige opdrachten leert men de leerlingen dan hoe ze een goed PSD kunnen opstellen. Aan de hand van kleine opdrachten leren de leerlingen dan een PSD omzetten in code. De

79

leerlingen maken, net als in de vorige hoofdstukken, op deze manier kennis met variabelen en lussen. Java [15]: Net zoals in alle andere handboeken geeft men in een eerste hoofdstuk aan waarvoor Java gebruikt wordt. Men gaat echter vrij snel over naar een eerste eenvoudig programma. Dit programma bespreekt men dan lijn voor lijn zodat de leerlingen duidelijk begrijpen waarvoor elke lijn code dient. Aan de hand van enkele voorbeelden leert men de eerste code dan uitbouwen. In een tweede hoofdstuk leert men eenvoudige vormen tekenen zoals lijnen en rechthoeken. Op het einde van het hoofdstuk wordt ook wat aandacht besteed aan de lay – out van de broncode. Zoals ik al eerder aangaf vind ik dit zeker en vast een pluspunt. Een overzichtelijk programma zorgt er niet alleen voor dat buitenstaanders de code snel kunnen begrijpen, maar ook dat je zelf het overzicht kan behouden. In een derde hoofdstuk leert men dan knoppen en invoervakken aanmaken. Men zorgt er in het handboek wel voor dat de leerling van elke lijn code weet waarvoor ze gebruikt wordt. Ook nu bouwt men doormiddel van eenvoudige voorbeelden de leerstof op. Net zoals de andere handboeken leert men in verdere hoofdstukken aan hoe je gebruik kan maken van variabelen en lussen. Aangezien Java een object georiënteerde programmeertaal is heeft men ook aandacht voor onder andere methodes. In het laatste hoofdstuk leert men de leerlingen een schildpad maken die je kan laten bewegen en figuren kan laten tekenen. In het handboek van BlueJ wordt in een eerste hoofdstuk gebruik gemaakt van deze schildpad om de leerstof op te bouwen. Zoals eerder aangegeven begrijpen de leerlingen de code van deze schildpad nog niet in het handboek van BlueJ. In het handboek van Java is dit wel het geval. Conclusie Ik denk dat het wel duidelijk is dat elk handboek zijn voor – en nadelen heeft. De handboeken worden gebruikt om leerlingen te leren programmeren. Het is dan ook de eerste kennismaking met programmeren. Mijn voorkeur gaat hierdoor naar het handboek van Visual Basic. Dit omdat het gaat over procedureel programmeren. De leerlingen moeten zich enkel bezighouden met variabelen en lussen en niet met methodes en klassen. Variabelen en lussen zijn voor leerlingen al moeilijk genoeg. Daarom lijkt het mij aangewezen om leerlingen eerst procedureel programmeren aan te leren. Het handboek van Visual Basic maakt ook gebruik van eenvoudige opdrachten om de leerstof aan te leren. De andere handboeken gebruiken eenvoudige voorbeelden. Het lijkt mij aangewezen om gebruik te maken van eenvoudige opdrachten omdat de leerlingen dan sneller zelf aan het werk zijn. Doordat de leerlingen zelf meteen met de leerstof bezig zijn zullen ze volgens mij enthousiaster zijn en de leerstof beter begrijpen omdat ze deze zelf moeten ontleden. Dit is de reden waarom ik dit handboek boven de andere procedurele programmeertalen verkies. Ik heb echter niet echt een voorkeur voor een bepaalde programmeertaal. Ook bijvoorbeeld Java kan je volgens mij gebruiken om in een eerste stadium het procedureel programmeren aan te leren. In een later stadium kan je dan overgaan naar het object georiënteerd programmeren. Ook Visual Basic

80

biedt de mogelijkheid om over te gaan naar object georiënteerd programmeren. PHP kan je dan weer linken aan gegevensbanken wat ook weer zijn meerwaarde heeft. Ook de ontwikkelomgeving BlueJ vind ik zeer interessant. Ik zou echter wel de leerstof opbouwen zoals het handboek van Java dit doet. Ook in BlueJ kan je eenvoudige vierkanten tekenen of lijnen trekken. De leerlingen zouden hierdoor van elk stukje code begrijpen waarvoor het dient. Zoals ik al aangaf leer je op het einde van het handboek Java de schildpad tekenen waarmee het handboek BlueJ begint. Het is volgens mij echter beter dat de leerlingen de volledige code begrijpen. Zoals eerder aangegeven is object georiënteerd programmeren opgenomen in het leerplan van de richting boekhouden – informatica. De leerkracht kan hiervoor gebruik maken van Visual Basic of BlueJ. Het grote verschil tussen deze twee ontwikkelomgevingen is dat VB het object georiënteerd programmeren eerder op de achtergrond houdt. De leerlingen moeten niet echt weten wat een klasse is en hoe ze deze moeten gebruiken. Bij BlueJ wordt dit echter op de voorgrond gebracht. Het is net de didactische bedoeling van BlueJ om het object georiënteerd programmeren zo eenvoudig / duidelijk mogelijk op de voorgrond te brengen. Afhankelijk van de doelen van de leerkracht kan hij / zij dus een keuze maken tussen deze ontwikkelomgevingen.

Gebruik maken van Dwengo Ook C is volgens mij een goede taal om de leerlingen te leren programmeren en dus algoritmisch te leren denken. In een eerste stadium kan men dan gebruik maken van Dwengo blocks. Het PSD kan eenvoudig omgezet worden in een blokdiagram. De leerlingen kunnen dan kennis maken met variabelen en lussen zonder echt bezig te moeten zijn met de juiste syntax. Later kan men dan overgaan naar het programmeren van complexere programma’s in C code. Net zoals in het handboek van Visual Basic zou ik gebruik maken van eenvoudige opdrachten om de leerstof op te bouwen. Op die manier zijn de leerlingen snel aan het programmeren. In tegenstelling tot de besproken handboeken speelt Dwengo zich niet enkel op de computer af. De leerlingen leren de robot programmeren waardoor de leerlingen, volgens mij, enthousiaster zullen zijn. Ook het gebruik van een project lijkt mij een interessante didactische werkvorm. Doorheen het project leren de leerlingen dan zelf de leerstof opbouwen. Als project kan bijvoorbeeld de module van het spel Simon Says gebruikt worden. In deze module komt zowel de leerstof van variabelen als lussen samen. In elk hoofdstuk kan men dan de nieuwe leerstof aanleren met eenvoudige opdrachten. Op het einde van elk hoofdstuk kunnen de leerlingen dan een stuk code aan het programma toevoegen. In dit werk is het echter de bedoeling om Dwengo te gebruiken in de vrije ruimte. Het is dus de bedoeling dat de leerlingen de leerstof uit de handboeken al beheersen. Aangezien in alle handboeken gebruik gemaakt wordt van variabelen en lussen zal Dwengo verder kunnen bouwen op elk handboek. Dwengo blocks kan dan als schakel dienen tussen de eerder geziene programmeertaal en C. Tijdens de lessen die ik geef in de vrije ruimte van het 6de middelbaar wetenschappen – wiskunde zal ik de leerlingen dan ook laten overschakelen van Visual Basic naar C. Verder in dit werk zullen de resultaten hiervan besproken worden.

81

Groepswerk en projectmanagement Bij het bestuderen van de handboeken van Instruct botste ik ook op een module genaamd “projectmanagement”. In de huidige maatschappij wordt er in bedrijven veel gewerkt met projecten. Om veranderingen succesvol en beheersbaar door te voeren worden er in bedrijven projecten opgestart. Het opstarten van een nieuw informaticasysteem of automatisering zijn hier voorbeelden van. De vrije ruimte lijkt mij daarom de uitgelezen kans om leerlingen kennis te laten maken met projectmanagement. Aangezien projecten in groep gebeuren zal ik eerst wat dieper ingaan op het organiseren van een groepswerk. Hierbij zal ik telkens terugkomen op een voorbeeld dat met de Dwengo robot uitgevoerd kan worden: een robot bouwen die een lijn kan volgen of een muur kan volgen of naar het licht toe rijdt. Dit groepswerk zal tevens uitgetest worden in de vrije ruimte van het 6de middelbaar.

Groepswerk In dit hoofdstuk zal ik mij baseren op de handleiding voor groepswerk van de KU Leuven [16]. Zoals eerder gezegd zal ik de theorie toepassen op een project met de Dwengo robot. Groepen samenstellen Een eerste probleem dat je tegenkomt is de groepsgrootte. Onderzoek heeft aangetoond dat je leerlingen best per 4 samen zet. Hoe kleiner de groep, hoe actiever de verschillende leden betrokken zullen zijn. Toch heeft een groep van vier personen enkele voordelen op groepen van drie of twee personen 

 

In en groep van vier kan er gewerkt worden in duo’s. Het aantal mogelijke duo’s loopt op tot zes. Er zijn dus aanzienlijk meer mogelijke communicatielijnen dan in een groep van twee of drie leerlingen. In een groep van drie zal er vaak iemand uit de boot vallen. Onderzoek toont aan dat we het meeste bijleren van mensen die sterk van ons verschillen. In vergelijking met een groep van twee of drie vermeerdert dus de kans op verschillen met groepsleden.

Bij een groep groter dan vier personen zal de actieve inbreng van bepaalde deelnemers dalen. Het wordt ook moeilijker om te traceren wat welke leerling gedaan heeft. Voor grote groepen wordt het tevens moeilijker om een geschikte opdracht te ontwikkelen. Project met de Dwengo robot: De klas waar ik het project zal uittesten telt 10 leerlingen. Ik zal 1 groep van 4 personen maken en 2 groepen van 3 personen. Aanvankelijk was ik van plan om groepen van twee te maken, maar na het lezen van de tekst heb ik mijn mening herbekeken. De keuze voor een groep van 4 is duidelijk. Bovenstaande voordelen hebben mij hiervoor over de streep getrokken. Er zijn dan dus nog 6 personen over. Ik kies ervoor om deze per drie op te delen omdat:

82

 

Met drie personen er meer kans is op verschillen tussen de leerlingen in vergelijking met een groep van 2 personen. Het zou oneerlijk zijn om de zes leden te verdelen in groepen van twee. Aangezien ze dan per twee moeten werken aan een opdracht die de andere groep met 4 kan uitvoeren.

Als leerkracht zal ik wel duidelijk in het oog moeten houden dat er geen leerling uit de boot valt. Aangezien het maar drie groepen zijn ben ik er van overtuigd dat ik ervoor kan zorgen dat elke leerling actief meewerkt. Een bijkomend voordeel is dat er op deze manier drie groepen ontstaan. Zoals eerder aangegeven zijn er drie mogelijke opdrachten. Elke groep kan dan een andere opdracht uitvoeren en deze achteraf aan elkaar voorstellen. Groepssamenstelling Groepen kunnen op verschillende manieren samengesteld worden. Je kan gebruik maken van heterogene groepen waarin sterkere en zwakkere leerlingen samen zitten. Deze samenstelling is het beste voor zwakkere leerlingen omdat ze beter zullen presteren door de begeleiding van de sterkere leerlingen. De sterkere leerlingen zullen een dieper inzicht in de leerstof verwerven omdat ze deze moeten uitleggen aan de zwakkere leerlingen. Een nadeel is wel dat de zwakkere leerlingen minder kansen krijgen om hun leidinggevende eigenschappen te ontwikkelen. Een andere mogelijkheid is het vormen van homogene groepen. Leerlingen van eenzelfde niveau worden dan in een groep samen gezet. Sterke leerlingen hebben hier het meeste baat bij omdat ze kunnen werken met “gelijken”. Zwakkere groepen zullen waarschijnlijk minder presteren dan de sterkere groepen. De sterke groepen hebben hier dus een voordeel. Een laatste mogelijkheid is het samenstellen van willekeurige groepen. Deze samenstelling heeft als voordeel dat de leerkracht minder kennis moet hebben van de voorkennis van de leerlingen. Het is vooral voor de leerkracht dus eenvoudiger om gebruik te maken van willekeurige groepen. Er zal echter wel een groot verschil zijn tussen de groepen onderling. Project met de Dwengo robot: Aangezien ik de leerlingen die de projecten zullen uitvoeren niet goed ken wordt het moeilijk om de leerlingen op een juiste manier te verdelen. Mijn voorkeur gaat uit naar het vormen van heterogene groepen omdat het niveau van de zwakkere leerlingen hierdoor het meeste zal stijgen. Toch moet je er bij heterogene groepen voor zorgen dat de sterkere leerlingen voldoende uitgedaagd worden. Op het eerste zich is er in de klas een groot verschil tussen de verschillende leerlingen. Bij eerdere opdrachten waren er leerlingen al klaar met de extra oefeningen, terwijl anderen nog aan het zoeken waren naar een oplossing voor de eerste oefening. Aan de hand van deze observaties zou ik de groepen dus op een heterogene manier kunnen onderverdelen. In samenspraak met de leerkracht werd besloten om het toch anders te doen. De leerkracht kent de leerlingen wel goed en wist mij te vertellen dat bepaalde leerlingen die traag werkten geen zwakkere leerlingen zijn, maar leerlingen die constant aangemoedigd moeten worden. Ze zullen minder snel zelf initiatief nemen dan de snellere leerlingen die nochtans over dezelfde mogelijkheden beschikken.

83

Daarom werd beslist om de snelle leerlingen samen te zetten. Zij kunnen zo op hun eigen tempo aan de opdracht werken. Ik zal er wel over moeten waken dat de leerlingen wel degelijk samenwerken en dat ze niet elk de opdracht afzonderlijk uitvoeren. Deze indeling heeft ook als voordeel dat de tragere leerlingen niet kunnen “meeliften” met de snellere leerlingen. Ze zullen zelf initiatief moeten nemen om de opdracht tot een goed einde te brengen. Door een cijfer aan deze opdracht te koppelen weten de leerlingen ook dat ze tot een resultaat moeten komen. Dit zal vooral een motiverende factor zijn voor de tragere leerlingen. Het ontwerpen van de groepsopdracht Bij het ontwerpen van een goede groepsopdracht zijn er een aantal elementen die ook gelden voor een gewone opdracht. Ik zet ze hier even op een rijtje:     

Het doel en de functie van de opdracht zijn duidelijk voor de leerlingen. De opdracht is lonend: door het maken van de opdracht kan het doel gehaald worden. De relevantie van de opdracht is duidelijk voor de student. De opdracht is uitvoerbaar: de randvoorwaarden voor het uitvoeren ervan zijn gerealiseerd. De opdracht is uitdagend.

Daarnaast zijn er ook enkele voorwaarden die specifiek zijn voor het ontwerpen van een groepsopdracht: 

Collaboratief werken bewerkstelligen: De leerlingen moeten een gelijke deelname hebben aan de opdracht. Elk groepslid moet bovendien aansprakelijk zijn voor zijn/haar bijdrage. Het meeliften wordt hierdoor verhinderd. Er moet ook voor gezorgd worden dat de leerlingen elkaar onderling nodig hebben om tot een goed resultaat te komen. o o o



Je moet er daarom voor zorgen dat de opdracht makkelijk verdeeld kan worden in deeltaken. Je moet er ook voor zorgen dat de opdracht niet door één persoon uitgevoerd kan worden. Opdrachten formuleren waarvoor er een groepsconsensus bereikt moet worden.

Afstemmen op doelstellingen: Er moet voor gezorgd worden dat het uitvoeren van de opdracht de leerling toelaat om de vooraf bepaalde doelstellingen te bereiken. o o o

Is het proces een doelstelling? Voorafgaande aan de opdracht moet deze vraag beantwoord worden. Een open of gestructureerde opdracht? Is het een opdracht met een open of een gesloten einde?

84



Afstemmen op leerlingenkenmerken: Afhankelijk van het feit of de leerlingen beschikken over zelfsturend vermogen moet de opdracht meer of minder gestructureerd zijn. De opdracht moet daarnaast ook aansluiten bij de voorkennis van de leerlingen. Als laatste moet ervoor gezorgd worden dat de leerlingen gemotiveerd zijn om de opdracht uit te voeren. Het gebruiken van een authentieke situatie kan hierbij helpen.



Afstemmen op groepskenmerken: Een belangrijke factor voor het slagen van de groepsopdracht is de groepscohesie. Hoe groter de sociale cohesie tussen de groepsleden, hoe groter de kans op een open communicatie en hoe groter de motivatie van de groepsleden om zich in te zetten voor de andere groepsleden. De opgave moet er dus voor zorgen dat de opdracht niet door één persoon uitgevoerd kan worden. Door ervoor te zorgen dat de groepen zich kunnen vergelijken met andere groepen wordt de ontwikkeling van een groepsidentiteit gestimuleerd. Daarnaast ontstaat er op deze manier ook een vorm van competitie.

Project met de Dwengo robot: Het totale project zal verdeeld worden in enkele deeltaken. Hierdoor kunnen de leerlingen het werk verdelen en is elke leerling met de opdracht bezig. Ik zal de leerlingen alle sensoren op de robot laten onderzoeken. Elke leerling kan dan 1 sensor bestuderen. Na afloop moet de groep dan beslissen welke sensor(en) ze zullen gebruiken voor het uitvoeren van het project. Door het tijdsgebrek zal de opdracht eerder gestructureerd zijn dan open. Doormiddel van tips zal ik de leerlingen in de juiste richting duwen. Indien er meer tijd zou zijn kan deze opdracht vrij open gehouden worden. Zeker omdat de opdracht nauw aansluit bij de voorkennis van de leerlingen. Tijdens eerdere sessies maakten de leerlingen reeds kennis met de Dwengo robot en zijn sensoren. Voor de meeste leerlingen is het programmeren van de robot al een motivatie op zich. Dit werd duidelijk tijdens de eerdere sessies waarin de leerlingen heel enthousiast waren. Andere leerlingen zijn minder gemotiveerd. Door deze tragere, maar toch sterke, leerlingen samen te zetten, moeten ze wel een verantwoordelijkheid opnemen omdat ze niet kunnen meeliften met de snellere leerlingen. Hierdoor zal hun motivatie hoger zijn. Ook het feit dat er een cijfer aan de opdracht gekoppeld zal worden zal bij een aantal leerlingen de motivatie verhogen. Begeleiden van een groepswerk Begeleiding voor aanvang van de opdracht: Het is best om voor aanvang van de opdracht duidelijke afspraken te maken en richtlijnen te geven. De leerkracht kan deze zelf geven of de leerlingen kunnen deze als eerste opdracht zelf opstellen. Het gaat hier over afspraken over de organisatie van het groepswerk. Dit kan gaan van afspraken omtrent de digitale communicatie tot de taakverdeling. Deze afspraken dienen er vooral voor te zorgen dat er tijdens het groepswerk geen misverstanden ontstaan.

85

De leerkracht moet ook duidelijke informatie geven over alle aspecten van het groepswerk. Hierbij kan je denken aan de doelstellingen, begeleiding, evaluatie … . Als leerlingen de waarde en het doel van het groepswerk inzien en ze er van overtuigd zijn dat de opdracht haalbaar is, zal dit de motivatie alleen maar ten goede komen. Begeleiding tijdens de opdracht: Het is zeer belangrijk om de leerlingen voldoende feedback te geven. Door de feedback verschaffen de leerlingen inzicht in hun leerproces en kunnen ze dit proces eventueel ook bijsturen. Het is zeker ook niet oninteressant om de leerlingen elkaar feedback te laten geven. Bij het geven van feedback mix je het beste positieve en negatieve feedback. Je geeft de feedback best zo snel mogelijk en verwijst hierbij best naar de doelstellingen van de opdracht. Verder kan de leerkracht een sturende of coachende houding aannemen. Sturend wil zeggen dat je zelf deadlines gaat opleggen en dat je heel nadrukkelijk aanwezig bent. Een coachende houding houdt in dat je de leerlingen tips geeft en vragen beantwoordt. De leerkracht is dan merkbaar, maar niet nadrukkelijk aanwezig. Project met de Dwengo robot: Aangezien het voor de leerlingen mogelijk moet zijn om het groepswerk tijdens de les te voltooien moeten er eigenlijk geen afspraken gemaakt worden over de communicatie tijdens het groepswerk. De leerlingen krijgen wel een blad waarop de opdracht duidelijk wordt uitgelegd. Daarnaast worden er enkele tips voorzien waardoor de opdracht vlot moet verlopen. Het is echter wel de bedoeling dat de leerlingen zelf het programma ontwikkelen. Tijdens de opdracht zal ik een coachende houding aannemen. De leerlingen zitten in het zesde middelbaar waardoor ze minder sturing nodig hebben. Wanneer leerlingen vragen of problemen hebben zal ik ze doormiddel van vragen in de juiste richting duwen. Het is dus niet de bedoeling om zelf de oplossing voor te kauwen. De leerlingen moeten, mits bijsturing, zelf tot de juiste oplossing komen. Evaluatie van een groepswerk In een eerste fase moet het voor de lesgever en de leerlingen duidelijk zijn wat er geëvalueerd zal worden. Dit hangt vanzelfsprekend nauw samen met de vooropgestelde doelstellingen. Het product dat de leerlingen op het einde van het project moeten afleveren is vrij eenvoudig te evalueren. De evaluatie van het proces ligt iets moeilijker. Wanneer samenwerken in groep een doelstelling is moet dit ook geëvalueerd worden. Het is echter niet eenvoudig om dit te evalueren. De leerkracht kan dit doen doormiddel van observatie, (individuele) gesprekken, logboeken, verslagen … . Daarnaast is een peer assessment ook zeer nuttig. De leerlingen zijn heel de tijd aanwezig in de groep en zijn dus het beste geplaatst om de samenwerking te beoordelen. Het is hierbij ook belangrijk dat de leerlingen weten wat er geëvalueerd wordt en hoe. De criteria moeten hiervoor duidelijk en eenduidig geformuleerd worden. De criteria moeten uiteraard haalbaar zijn. Je kan ze zelf formuleren, maar je kan ze voor aanvang van het project ook samen met de

86

leerlingen opstellen. Dit zal ervoor zorgen dat ze het belang van de criteria beter begrijpen en bovendien zullen ze de criteria zelf ook beter begrijpen. Project met de Dwengo robot: Bij de evaluatie van het groepswerk zal het eindresultaat uiteraard een deel van de punten bepalen, maar dit is zeker niet het belangrijkste. Daarnaast zal er ook gekeken worden naar hoe de leerlingen het resultaat gerealiseerd hebben. Hadden ze veel hulp nodig? Werkten ze goed samen? Door het tijdsgebrek zullen de leerlingen geen tussentijdse verslagen inleveren en zullen er geen individuele gesprekken gehouden worden. Ik zal zelf observeren en zo het proces beoordelen (ook de eigenlijke leerkracht zal hierbij helpen). Aangezien het slechts drie groepen zijn ben ik er van overtuigd dat we een juiste score voor het proces zullen kunnen geven. Conclusie Het is dus duidelijk dat er bij een project en een groepswerk heel wat komt kijken. Het is zeker een goede manier om dingen aan te leren op voorwaarde dat het project goed in mekaar zit. De opdracht moet duidelijk zijn en moet aansluiten bij de voorkennis van de leerlingen, maar ze moet ook uitdagend genoeg zijn. Er moeten goede afspraken gemaakt worden, zowel tussen de leerlingen en de leerkracht als tussen de leerlingen onderling. Het is niet omdat de leerlingen zelf moeten werken dat de leerkracht het rustig heeft. De leerkracht moet de verschillende groepen in de gaten houden en moet observeren om het proces te kunnen beoordelen. Aan de hand van deze observatie en eventuele tussentijdse verslagen moet de leerkracht regelmatig feedback geven en zo het leerproces bijsturen. Ook voor de leerkracht is het een tijdrovende opdracht!

Projectmanagement Zoals eerder aangegeven zal ik nu even dieper ingaan op projectmanagement. De vrije ruimte lijkt mij ideaal om de basis hiervan aan te leren aan de leerlingen. Je kan echter heel veel vertellen over projectmanagement en hier heel diep op ingaan, maar omdat het over middelbaar onderwijs gaat zal ik enkel de basis bespreken. Om een groot project uit te voeren is er veel tijd nodig. Omdat ik slechts enkele lessen beschikbaar heb om de Dwengo uit te testen zal ik dit niet kunnen uittesten met de leerlingen. Er zijn echter wel een aantal modules waarbij het mogelijk is om de leerstof van projectmanagement toe te passen. Voor het opstellen van deze tekst maak ik gebruik van het handboek van Instruct [10]. Uit dit handboek zal ik module 6 gebruiken. Daarnaast zal ik de informatie uit het handboek aanvullen met informatie uit de tekst “Everyone’s Guide to Successful Project Planning: Tools for Youth. Facilitator Guide” die ik vond ik de ERIC database [17]. Wat is projectmanagement? In de literatuur wordt projectmanagement als volgt omschreven: “het uitvoeren van een project volgens een van tevoren opgesteld projectplan op zo’n manier dat het project op tijd gereed is, dat

87

de kosten binnen het geplande budget blijven en dat het resultaat voldoet aan de vooraf gedefinieerde specificaties” [10]. Er moest dus een planning opgesteld worden om het project in goede banen te leiden. Hiervoor zal het project opgesplitst worden in deeltaken en zullen er deadlines voor deze deeltaken afgesproken worden. Al deze informatie zal opgenomen worden in het plan van aanpak. Het probleem identificeren Voor je kan beginnen met de planning van een project moet het eerst heel duidelijk zijn wat het probleem is. Op deze manier kom je tijdens het project niet voor verrassingen te staan. Hierbij kan je volgende vragen stellen: “Wat is het?”, “Waarom doen we het?” ,”Welk (maatschappelijk) probleem wordt hierdoor opgelost?” … . De leerlingen moeten dan ook de tijd krijgen om deze vragen in groep op te lossen. Daarnaast moet er ook nagedacht worden over de doelen die met het project bereikt moeten worden. Het is belangrijk om hier een onderscheid te maken tussen project en persoonlijke doelen. Project doelen zijn die doelen waarvan de groep hoopt dat ze op het einde van het project bereikt zijn. De persoonlijke doelen zijn de zaken waarvan de leerlingen hopen/verwachten dat ze deze verwerven doorheen het project door samen te werken in een team. Door de leerlingen hierover te laten nadenken gaan ze “the big picture” van het project zien. Ze focussen zich niet enkel op het probleem, maar ook op de impact van de oplossing. Zo zal bijvoorbeeld een systeem dat een zonnepaneel altijd naar de zon richt ervoor zorgen dat er meer groene energie beschikbaar is. Door het opstellen van persoonlijke doelen zien de leerlingen ook dat ze via het project affectieve doelstellingen bereiken. Het plan van aanpak Elk project begint met een plan van aanpak. Hierin worden onder andere volgende onderwerpen opgenomen: de activiteiten die tijdens het project worden uitgevoerd, de planning van de activiteiten en de middelen. Een activiteit is een afgeronde hoeveelheid handelingen die meestal een product oplevert. Door het handboek en de tekst naast mekaar te leggen stelde ik volgende stappenplan op: 1. 2. 3. 4. 5. 6. 7. 8.

Schrijf het doel van het project neer. Denk aan de taken die nodig zijn om het doel te bereiken. Rangschik deze activiteiten chronologisch. Herbekijk de lijst. Stel een tijdlijn op. Bepaald de benodigde middelen. Stel een management structuur op. Maak het plan van aanpak.

88

1. Schrijf het doel van het project neer. Dit is een zeer cruciale stap! De medewerkers moeten het doel van het project kunnen uitleggen aan alle betrokkenen. Wanneer medewerkers het niet eens zijn over een doel of ze interpreteren een doel anders zullen er problemen opduiken doorheen het project. Het is dus zeer belangrijk dat er een duidelijk doel op papier staat. Hierdoor kunnen veel problemen voorkomen worden. 2. Denk aan de taken die nodig zijn om het doel te bereiken. Elk probleem kan opgesplitst worden in kleinere deelproblemen. In deze stap moet er dan ook nagedacht worden over alle activiteiten die nodig zijn om het doel te bereiken. Het is belangrijk dat je hier voldoende tijd voor neemt zodat er geen activiteiten over het hoofd gezien worden. Je kan hiervoor de groep opsplitsen in kleinere groepen waarin gebrainstormd wordt. Alle lijsten kunnen dan achteraf naast elkaar gelegd worden en zo kan er een definitieve lijst opgesteld worden. Op deze manier begrijpt iedereen wat er moet gebeuren. 3. Rangschik deze activiteiten chronologisch. Bepaalde activiteiten moeten voor een andere activiteit gebeuren. Zo kan je bijvoorbeeld niet beginnen met programmeren van het systeem voor het zonnepaneel voor er beslist is welke en hoeveel sensoren er gebruikt zullen worden. 4. Herbekijk de lijst. Elke lijst moet flexibel zijn en er moet een mogelijkheid zijn om zaken toe te voegen en te veranderen. Het eerste ontwerp van de lijst moet dus herbekeken worden, want hier en daar zullen er nog wijzigingen aangebracht kunnen en moeten worden. 5. Stel een tijdlijn op. Alle taken staan nu in chronologische volgorde. Er kan nu beslist worden wanneer welke activiteit kan beginnen en welke activiteiten er al dan niet gelijktijdig uitgevoerd kunnen worden. Zo kan na het beslissen van de sensoren en dergelijke gelijktijdig gebouwd worden aan het systeem voor het zonnepaneel en geprogrammeerd worden. Je kan deze activiteiten dan uitzetten op een Gantt – Chart. Elke activiteit stelt dan een horizontaal balkje voor. Door verticale streepjes kan aangegeven worden welke activiteiten van elkaar afhankelijk zijn. Bepaalde activiteiten zullen een speling hebben, dit kan aangegeven worden aan de hand van een stippellijn. Zo moet activiteit g op de figuur wachten op activiteit d en f. Activiteit d is sneller klaar dan activiteit f waardoor activiteit d een speling heeft. Op deze manier is de planning en de beschikbare tijd meteen zeer duidelijk. Ook de deadlines van de verschillende activiteiten zijn duidelijk aan de hand van zo’n Gantt – Chart. Aan de hand van de Gantt – Chart kan ook het kritieke pad bepaald worden. Met dit kritieke pad wordt aangegeven welke activiteiten de einddatum zullen beïnvloeden. Wanneer een activiteit op het kritieke pad vertraging oploopt zal de einddatum opschuiven. Zo ligt activiteit c bijvoorbeeld niet op het kritieke pad, want na de activiteit is er nog wat speling. Met rood wordt het kritieke pad aangegeven.

89

Figuur 18: Gantt - Chart

6. Bepaal de benodigde middelen. Elk project wordt uitgevoerd door mensen die papier, computers, machines … nodig hebben. Al deze zaken noemen we de benodigde middelen of resources. Het is dan ook belangrijk om in deze stap na te gaan of de benodigde middelen op het juiste moment beschikbaar zijn. Zo moeten de sensoren op het juiste moment aangekocht worden en moet het team op het juiste moment over een computer beschikken om te programmeren. Indien men hier problemen tegenkomt, moet de tijdlijn eventueel aangepast worden. 7. Stel een management structuur op. Het opstellen van deze structuur is niet eenvoudig. De leerkracht moet er dan ook over waken dat de leerlingen niet bij elk project dezelfde rol hebben. Zo kunnen stille kinderen ook groepsleider zijn. Dit kan hun helpen om sociale vaardigheden te ontwikkelen. Hetzelfde geld voor luide kinderen die dan ook leren luisteren. Elk project heeft een projectleider. Hij behoudt het overzicht en zorgt ervoor dat iedereen zich aan zijn taak houdt. Daarnaast zijn er andere verantwoordelijken die vlak onder de projectleider staan. Zo kan er een verantwoordelijke zijn voor het programmeren en één voor het bouwen. Onder deze verantwoordelijken staat dan een team van programmeurs of bouwers. Er kan dan ook regelmatig vergaderd worden binnen het programmeerteam zelf. De teamleiders kunnen dan ook eens samenzitten met de projectleider om zo de vooruitgang te bespreken. 8. Maak het plan van aanpak. Al deze zaken worden dan opgenomen in het plan van aanpak. Elk teamlid kan beschikken over dit plan van aanpak zodat hij/zij weet wanneer hij wat moet opleveren en aan wie. Als alle afspraken duidelijk zijn opgenomen in het plan van aanpak zal dit de teamsfeer alleen maar ten goede komen. Met een goed plan van aanpak kunnen veel plotse verrassingen vermeden worden. Eventueel kan men in dit plan van aanpak ook een vergaderschema opnemen en/of een lijst met gegevens van elk teamlid.

90

Conclusie Er kruipt duidelijk veel tijd in het opstellen van een plan van aanpak, maar het heeft zeker zijn voordelen. Het is aan de hand van dit plan voor elk teamlid duidelijk wat er van hem/haar verwacht wordt. Door duidelijke afspraken te maken kunnen er discussies vermeden worden en dit zal er alleen maar voor zorgen dat het project vloeiender en leuker verloopt. De meeste leerlingen zullen in hun latere carrière zeker nog in contact komen met een plan van aanpak. Dit al in hun hogere opleidingen. Zo moest ik op Groep T voor elk project zo’n plan van aanpak opstellen. Ook in hun latere job zullen ze een dergelijk plan moeten opstellen en volgen. In de huidige maatschappij wordt er steeds meer gebruik gemaakt van projecten. Voor elk van deze projecten wordt een plan van aanpak opgesteld. Het is bovendien ook een hulpmiddel voor de leerkracht. Aan de hand van het plan van aanpak is het voor de leerkracht duidelijk welke leerling verantwoordelijk is voor welke activiteit. Op deze manier kan de leerkracht ook het proces van elke leerling afzonderlijk volgen. Leerlingen zullen zich ook niet meer kunnen verstoppen achter andere leerlingen omdat het duidelijk is welke leerling welke taak heeft.

91

Reflectie Problemen en oplossingen Een eerste probleem waar ik op stootte was het installeren van de MPLab software. Ik volgde gewoon de stappen op de website en kon het programma ook daadwerkelijk openen. Toen ik de code wou compileren liep het echter mis. Het programma stootte op een fout die ik op het eerste zicht niet kon verklaren. Na wat opzoekwerk op het internet kwam ik op een forum waar men aangaf dat het programma moeilijkheden heeft met spaties in de bestandsnamen. Aangezien ik het programma installeerde in de map “Program Files” maakte ik dus wel degelijk gebruik van een bestandsnaam met daarin een spatie. Toen ik het programma opnieuw installeerde in de map C:\MCC18 (zonder spatie dus) deed het probleem zich dus niet meer voor. Dit is dan ook de reden waarom ik in module 3 een uitgebreide uitleg heb opgenomen om het programma te installeren. Door deze stappen te volgen zou het programma moeten werken. Later in dit hoofdstuk zal echter duidelijk worden dan dit niet altijd het geval is. Een tweede probleem dat zich stelde was het feit dat ik slechts over één robot beschikte. Dit was dus geen ideale situatie om aan de stage te beginnen. Ik nam hiervoor contact op met de makers van Dwengo. Zij waren meteen zeer enthousiast over het project en stelden dadelijk voor om enkele robots uit te lenen. Hierdoor beschikte ik tijdens mijn stage over 11 robots. Aangezien de klas uit 10 leerlingen bestond was dit dus wel een ideale situatie. Dit heeft zeker bijgedragen tot het succes van de stagelessen. Een volgende probleem waren de bugs in Dwengo Blocks. Deze toepassing is nog in de bèta fase waardoor het normaal is dat er nog enkele foutjes inzitten. Ik heb Dwengo Blocks dan ook uitgebreid getest en kende hierdoor de meest voorkomende fouten. Een eerste probleem is het gebruik van de backspace toets. Wanneer je deze op het verkeerde moment gebruikt ga je terug naar de vorige pagina waardoor het programma verloren is. Ik raadde de leerlingen dan ook aan om gebruik te maken van de delete toets. Daarnaast gebeurde het soms dat het programma vastliep of dat er een opening in de lus ontstond. Voor dit probleem vond ik geen oplossing. Ik melde de leerlingen dan ook dat ze regelmatig hun programma moesten opslaan. Hierdoor kunnen ze het gewoon terug laden als het zou vastlopen. De leerlingen klaagden hier eigenlijk niet over. Het gebeurde wel dat het programma vastliep, maar dan zeiden ze gewoon “ah meneer, weer een bug tegengekomen”. Ze openden dan gewoon opnieuw Dwengo Blocks en gingen weer verder. Aan de hand hiervan kan je leerlingen ook aantonen hoe men programma’s ontwikkelt. Zo zal elk programma een bèta fase doorlopen om het uitgebreid te testen en zo de laatste foutjes uit het ontwerp te halen. Je kan hierdoor dus ook even aandacht besteden aan softwareontwikkeling. Deze bugs hoeven dus geen probleem te zijn, wanneer je er goed mee omgaat kunnen ze zelfs een meerwaarde betekenen.

92

Een vierde probleem was de installatie van de software MPLab op de computers van het Heilig Hartinstituut. Ik had aan de ICT – coördinatoren doorgegeven wat ze moesten installeren en ze hadden dit dan ook gedaan. Toen ik het programma testte kwam ik echter een vrij groot probleem tegen. De PICKit 2, die nodig is om het programma naar de robot te schrijven, was niet geïnstalleerd. Hierdoor moest ik snel improviseren en besloot ik om die les nog gebruik te maken van Dwengo Blocks. De programma’s die de leerlingen moesten maken waren nog niet zo uitgebreid waardoor dit nog net kon. Na de les nam ik meteen contact op met de makers van Dwengo. Zij konden ook niet meteen een verklaring voor het probleem geven, maar ze gaven wel een oplossing. In MPLab kunnen de leerlingen wel perfect de code compileren. Ze kunnen dan de hex – file op dezelfde manier naar de robot schrijven als ze doen bij Dwengo Blocks. Op die manier kunnen de leerlingen de robot dus wel programmeren in C code. De oorzaak van het probleem is tot op heden echter nog niet gevonden. Waarschijnlijk is het programma niet helemaal goed geïnstalleerd. Ik raad iedereen die gebruik wil maken van Dwengo dan ook aan om de software meer op voorhand te (laten) installeren. Op die manier kan je de software uitgebreid testen en eventuele problemen oplossen. Een laatste probleem deed zich voor bij het ontwerpen van de baan voor de lijnvolgende robot. Het duurde vrij lang voor ik de juiste plakband gevonden had. Wanneer de plakband ook maar het minste licht reflecteerde was het voor de robot moeilijk om het verschil te zien tussen zwart en wit. Uiteindelijk vond ik een effen zwarte plakband met wat reliëf. Het licht dat dan toch weerkaatst zou worden wordt naar alle kanten weerkaatst. Hierdoor vangt de sensor dus minder licht op waardoor het verschil tussen wit en zwart nu wel heel duidelijk is. Daarnaast koos ik er ook voor om een lus in de baan op te nemen. Daar waar de wegen elkaar kruisen volgt de robot echter de bocht niet meer. Hij rijdt hierdoor gewoon rechtdoor. Daarna komen de twee sensoren vrij snel beide op het witte deel. Hierdoor rijdt de robot gewoon rechtdoor in plaats van de baan te volgen. Ik koos er echter voor om de lus niet uit de baan te verwijderen. Wanneer de leerlingen merken dat hun wagentje de baan niet meer volgt moeten ze dit kunnen verklaren. Het is dus een extra mogelijkheid om het probleemoplossend vermogen van de leerlingen te ontwikkelen en te testen. Ook het feit dat ik maar over een beperkte programmeerervaring beschikte voor dit project zou als een probleem gezien kunnen worden. Ik ga hier echter dieper op in in een later hoofdstuk van deze reflectie. Het zal in dit hoofdstuk ook duidelijk worden dat dit ook als een voordeel beschouwd kan worden.

Hoe in de toekomst? In de toekomst zou ik, wanneer ik een soortgelijk project uitvoer, een aantal zaken anders aanpakken. Zo zou ik meer onderzoek uitvoeren bij aanvang van het project. Ik ben nu eigenlijk meteen begonnen met het uittesten van de Dwengo Robot en bijschaven van mijn programmeerkennis. Ik ben hier dan meteen op verdergegaan en ben begonnen met het ontwikkelen van de verschillende modules. Ik had hier echter misschien beter eerst wat onderzoek gedaan naar andere projecten die vergelijkbaar zijn met dit project. Ik zou dan verder kunnen werken met de conclusies van deze

93

projecten en ideeën opdoen. Ik heb nu mijn onderzoek pas later uitgevoerd. Hierbij heb ik groepswerk en projectwerk onderzocht. Daarnaast kan ik mijn stage ook als onderzoek beschouwen. Dit onderzoek was zeker niet verloren of zinloos. Ik heb hier veel uit geleerd en het is in mijn ogen zeker en vast een meerwaarde voor dit project. Maar onderzoek bij aanvang van het project was volgens mij ook op zijn plaats geweest. Ook tijdens de stage zou ik wat veranderen. Ik wou eigenlijk zo veel mogelijk modules uittesten in de stage waardoor ik, naar mijn gevoel, met momenten vrij snel ben gegaan. Hierdoor waren er een aantal leerlingen die moeite hadden met het programmeren in C. Er waren zeker en vast ook een heel aantal leerlingen die hier wel snel mee weg waren, maar ik had hier volgens mij wat meer aandacht aan mogen besteden. Op die manier zouden alle leerlingen de basis begrijpen. Ik had hier bijvoorbeeld een kleine oefening voor kunnen gebruiken. Leerlingen die moeite hadden met het programmeren zouden door deze kleine oefening de basis beter begrijpen en leerlingen die er snel mee weg zijn zouden extra oefeningen kunnen uitvoeren. Op die manier is iedereen nuttig bezig en kan iedereen een basis programma in C programmeren. Ik denk dan ook dat de leerlingen er dan wel in zouden slagen om de drie robots (lijnvolgende, muurvolgende, lichtvolgende) te programmeren. Nu slaagde hier maar twee groepjes in. Het derde en laatste groepje had duidelijk meer moeite met de C code. Tot slot zal ik ook kort iets zeggen over de toekomst van dit project. Om dit project verder uit te bouwen zouden de modules verder uitgetest moeten worden om te kijken welke modules er werken en welke niet. Er kunnen zo eventueel nog extra modules toegevoegd worden daar waar de stap tussen de modules te groot blijkt te zijn. Daarnaast kan er, zoals eerder al aangegeven, ook onderzoek gedaan worden naar gelijkaardige projecten. De conclusies uit die projecten en dit project kunnen dan gebundeld worden. Dit zal de resultaten van alle projecten alleen maar ten goede komen.

Gevolgen van de beperkte programmeerervaring Ik heb het feit dat ik maar een beperkte programmeerervaring had / heb eigenlijk meer als positief ervaren. Ik had in het begin van dit project wel vrij veel tijd nodig om de tutorials te ontcijferen en wegwijs te raken in de code. In het begin kreeg ik dan ook altijd de melding “build failed”. Je leert echter zeer veel wanneer je zelf al deze fouten maakt. Ik wist dan ook vrij snel welke fouten een beginnend programmeur maakt en dit was dan ook een meerwaarde tijdens de lessen. Doordat ik zelf de modules, met vallen en opstaan, heb uitgetest en opgebouwd had ik op voorhand al een goed idee van waar de leerlingen zouden vastlopen. Ik kon mijn begeleiding tijdens de lessen hier dan ook op afstemmen. Wanneer je als leerkracht al veel programmeerervaring hebt zal je de modules zonder problemen kunnen opbouwen. Hierdoor zal je echter pas tijdens de lessen door hebben waar de leerlingen het moeilijk mee hebben. Wanneer je hier voor de les al een idee van hebt win je in mijn ogen kostbare tijd omdat je direct op deze problemen kan inspelen. Het is volgens mij echter wel noodzakelijk dat de leerkracht al over een zekere basis beschikt. Wanneer je nog niet weet wat lussen of variabelen zijn wordt het volgens mij zeer moeilijk. Het ontcijferen van de tutorials of van de modules in dit werk wordt dan onbegonnen werk. Tijdens mijn

94

studies aan Groep T had ik dan ook een semester Java. Tijdens deze lessen heb ik dan ook de basis gelegd die nodig was voor dit project. Het is dus wel duidelijk dat leerkrachten die een even beperkte programmeerervaring als mij hebben zich niet moeten laten ontmoedigen. In tegendeel! Zoals ik eerder in deze tekst al aantoonde is dit alleen maar een meerwaarde. Alle informaticaleerkrachten hebben volgens mij dan ook de nodige programmeerervaring om gebruik te maken van de robots. Zij moeten de leerlingen namelijk zelf de basis van programmeren bijbrengen. Hierdoor moeten alle leerkrachten informatica volgens mij de stap naar de robots kunnen en vooral durven zetten.

Eigen ervaringen tijdens de stage Ik vond dat de leerlingen zeer snel weg waren met Dwengo Blocks. Het duurde dan ook niet lang voor de eerste LEDjes aan het branden waren. Het programma werkt naar mijn gevoel zeer intuïtief waardoor de leerlingen heel behendig de blokjes van links naar rechts sleepten. Ook bij het maken van de teller en de Knight Rider waren er zeer weinig problemen. Hier en daar hadden de leerlingen wel wat uitleg nodig in verband met de variabelen en hoe ze deze moesten aanmaken. Dit had ik volgens mij dan ook klassikaal moeten aanbrengen in plaats van bij elk groepje apart. Het bouwen van de schakelingen verliep iets minder vlot. Het duurde vrij lang voor de leerlingen de weerstanden op de juiste plaats gemonteerd hadden. Het was wel duidelijk dat de leerlingen het super vonden om ook eens zelf een schakeling te bouwen. Ze gaven dan ook aan dat het de eerste keer was dat ze zoiets deden. Ik vind dat leerlingen in hun middelbaar onderwijs toch minstens één keer een schakeling zelf moeten opbouwen. De vrije ruimte lijkt mij dan ook de ideale plaats om hier wat dieper op in te gaan. Dankzij de Dwengo Robot kunnen de leerlingen dit zeer eenvoudig doen zonder soldeerwerk. Ze kunnen de schakeling dan ook zelf programmeren waardoor ze eigenlijk zelf het hele systeem ontwikkeld hebben. Wanneer leerlingen vanaf nul een systeem helemaal succesvol opbouwen denk ik dat ze toch een gevoel van fierheid ervaren. Ik heb dan ook een aantal modules voorzien waarin dit mogelijk is. Aan de overgang van Dwengo Blocks naar C had ik relatief weinig aandacht besteed. Ik wou de leerlingen dan ook echt zelf het programmeren laten ontdekken. Ze beschikten wel over een template waarin de bibliotheken al aanwezig zijn. Op die manier moesten ze zich enkel bezig houden met het programma zelf. Daarnaast kunnen de leerlingen ook gebruik maken van Dwengo Blocks wanneer ze niet goed weten hoe ze een stukje code moeten noteren. Ze kunnen dit dan bouwen in Dwengo Blocks en de C code opvragen. Aangezien de leerlingen over deze hulpmiddelen beschikten ging ik er van uit dat ze de overstap van Dwengo Blocks naar C code wel konden maken. In twee van de drie groepjes ging dit dan ook vrij vlot. Dit waren ook de twee groepjes die het enthousiasts waren bij het gebruik van de robots. Zij waren dus duidelijk zeer gemotiveerd om een goed programma te schrijven. Het derde groepje was in mijn ogen minder gemotiveerd en raakte moeizamer opgang met de C code. Ik denk dat de lessen qua algoritmisch denken wel goed waren opgebouwd. Ze begonnen met een heel eenvoudig probleem en dit probleem werd steeds uitgebreider / moeilijker. De leerlingen moesten bij hun eerste kennismaking met C code echter meteen al een complex programma maken. Hier had ik misschien wel een kleine tussenstap moeten maken en de leerlingen eerst een eenvoudig

95

programma laten schrijven zodat ze wat vertrouwd zouden raken aan de code. Misschien dat de derde groep hierdoor wel de lijnvolgende robot goed had kunnen programmeren. Over het algemeen was ik eigenlijk tevreden over de stage. De meeste leerlingen waren zeer enthousiast en werkten elke les goed mee. Het feit dat ze gebruik konden maken van een robot en niet alleen op de computer moesten programmeren, zoals ze gewoon waren met Visual Basic, speelde hier duidelijk een grote rol in. Dwengo was en is dus zeker en vast een meerwaarde voor deze lessen. Zeker omdat de robot zoveel mogelijkheden heeft. Zo kunnen de leerlingen, zoals eerder gezegd, naast alleen programmeren ook zelf eenvoudig een schakeling bouwen. Dit is volgens mij alleen maar een meerwaarde.

Ervaringen van de leerlingen Op het einde van de laatste sessie liet ik de leerlingen op een papiertje schrijven wat ze van de lessen vonden. Als hulp kregen ze volgende vragen:  



Wat vonden jullie goed / niet goed aan de lessen? Wat vonden jullie goed / niet goed aan de Dwengo robot? o Dwengo Blocks o Programmeren in C Wat is jullie algemene mening over de acht lessen?

De meningen van de leerlingen waren overtuigend positief. Zo gaven er zelfs enkele leerlingen aan dat het de leukste lessen waren van hun 2 jaar Wetenschappelijke vorming. Alle leerlingen gaven ook aan dat de robot een duidelijke meerwaarde is omdat ze echt resultaat zien van hun programmeren. Een aantal leerlingen gaven dan ook aan dat ze dit “echt programmeren” vonden. Eén leerlingen gaf ook aan dat dit soort lessen de reden was dat hij voor Wetenschappelijke Vorming: informatica – fysica gekozen had. Uiteraard was niet iedereen super enthousiast, maar dit beperkte zich tot twee leerlingen. Ze gaven beide wel aan dat de Dwengo robot een meerwaarde is, maar één leerling schreef “programmeertaal beter uitleggen”. Zoals ik eerder al vermelde had ik misschien inderdaad een extra oefening moeten toevoegen. De meeste leerlingen waren snel weg met de programmeertaal, maar met de extra oefening was het volgens mij voor iedereen duidelijk geweest. Ik kan me dan ook volledig vinden in deze feedback. De feedback van de andere leerling kan ik minder goed volgen. Hij schreef “Te veel zelfstandigheid”. Ik ben van mening dat leerlingen in een zesde middelbaar zelfstandig aan een opdracht moeten kunnen werken. Tijdens hun hogere studies, die al binnen een paar maanden beginnen, zal dit voortdurend het geval zijn. Ik vind dan ook dat het middelbaar, en zeker de laatste graad, de leerlingen hierop moet voorbereiden. Ik heb de leerlingen dan ook bewust vrij veel vrijheid gegeven, maar de leerlingen beschikten wel over duidelijke opdrachten. De laatste opdracht was ook opgedeeld in kleinere tussenstappen. Op die manier hadden de leerlingen wel een beperkte begeleiding. Het doel van de lessen was voor de leerling volgens mij ook niet duidelijk. Als laatste schreef hij ook het volgende: “Nut van het programmeren? Bestaat er geen Software voor?”. Achteraf gezien had ik

96

deze interviews beter mondeling afgenomen, maar hier was absoluut te weinig tijd voor. De leerlingen hadden tot het laatste moment nodig om hun robot te programmeren. Het was meteen ook de laatste les Wetenschappelijke Vorming waardoor ik niet tijdens een latere les kon terugkomen. Indien ik dit wel had kunnen doen had ik kunnen reageren op de meningen van de leerlingen en hun om meer uitleg vragen. Zo zou ik bij de laatste leerling kunnen aangeven dat het bedoeld is om hun probleemoplossend denken te verbeteren. Wanneer deze modules in de toekomst verder worden uitgetest zou ik dus zeker aanraden om de slotinterviews mondeling af te nemen. Over het algemeen waren de leerlingen wel duidelijk enthousiast en de meerwaarde van de robots is ook duidelijk. Dit is volgens mij alleen maar een motivatie om in de toekomst verder te werken met deze robots en de modules / lessen verder te ontwikkelen. Met de robots zien de leerlingen heel snel resultaat van hun programmeren. Ik hoop dan ook dat meerdere leerkrachten in de toekomst het nut van de robots inzien en uit hun vertrouwde omgeving van bijvoorbeeld Visual Basic durven stappen en het “risico” nemen om met de robots aan de slag te gaan.

97

Bibliografie [1] Dwengo. Dwengo Starters Kit Plus. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/products/dwengo-starters-kit-plus [2] Dwengo. Programming a Knight Rider LED light scanner. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/tutorials/knight-rider [3] Dwengo. Analog to digital converter: Light measurement. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/tutorials/light-measurement [4] Dwengo. Dwengo Breadboard. Laatst opgeroepn op juni 21, 2012, van Dwengo: http://www.dwengo.org/products/dwengo-breadboard [5] Dwengo. Interrupts, driving a servo: a light tracker. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/tutorials/light-tracker [6] Dwengo. Using the LCD: making a new sticker. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/tutorials/lcd [7] Dwengo. Getting started with the robot starters kit. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/tutorials/robot-starters-kit [8] Dwengo. Playing a game with push buttons: Simon says. Laatst opgeroepen op juni 21, 2012, van Dwengo: http://www.dwengo.org/tutorials/simon-says [9] Wikipedia. Modulair rekenen. Laatst opgeroepen op juni 21, 2012, van Wikipedia: http://nl.wikipedia.org/wiki/Modulair_rekenen [10]Van der Laan, J. Fundament Informatica: ICT voor de tweede fase, Uitgeverij Instruct, 2007 [11]Van Andel, I, Krooswijk, M. Fundament Informatica: ICT voor de tweede fase: Keuzemodule Visual Basic, Uitgeverij Instruct, 2002 [12]Laan, G. Fundament Informatica: ICT voor de tweede fase: Keuzemodule BlueJ, Uitgeverij Instruct, 2005 [13]Kassenaar, P. Programmeermodule PHP, Uitgeverij Instruct, 2005 [14]Koortens, R. Fundament Informatica: ICT voor de tweede fase: Keuzemodule Delphi, Uitgeverij Instruct, 2003 [15]Laan, G. Fundament Informatica: ICT voor de tweede fase: Keuzemodule JAVA, Uitgeverij Instruct, 2002 [16]KU Leuven, Handleiding groepswerk, Uitgeverij DUO (Dienst Universitair Onderwijs) [17]Edwards, Keisha M. Everyone’s Guide to Successful Project Planning: Tools for Youth. Facilitator Guide., Uitgeverij Northwest Regional Educational Laboratory, 2000

98

Dankwoord Na afloop van dit project zou ik graag een aantal mensen bedanken. In de eerste plaats wil ik professor Martens en professor Dehaene bedanken om mij de mogelijkheid te geven dit project uit te voeren en een Dwengo robot ter beschikking te stellen. Ik wil in het bijzonder professor Martens bedanken voor het nalezen van de tussentijdse versies, de feedback en de tips. Ik wil ook de makers van Dwengo, in het bijzonder Francis Wyffels, bedanken voor het uitlenen van de Dwengo robots. Daarnaast wil ik hem ook bedanken voor de snelle en uitgebreide antwoorden op mijn mails met daarin oplossingen voor problemen en tips. Tot slot wil ik zeker en vast het Heilig Hartinstituut te Heverlee bedanken en in het bijzonder Sofie Veldeman om mij de mogelijkheid te geven om de modules uit te testen in een klas. Ik wil ook de leerlingen bedanken voor hun medewerking en feedback.

99

GEBRUIK VAN DWENGO IN DE VRIJE RUIMTE

Recommend Documents