Deze lessen zijn bedoeld als een introductie in programmeren. Je hebt in een eerdere les al kennis gemaakt met het programmeren van de Micro:Bit door blokken te gebruiken.
In deze les gaan we 'echt' aan de slag met programmeren. De blokjes laten we even achter ons en we gaan nu programmeren met Python. Python is een zeer populaire programmeertaal en bovendien relatief makkelijk aan te leren.
Github van Shawn Hymel (antwoorden)
GitHub is een online client voor het Git-versiebeheersysteem en een hostingprovider voor vrije software, die alle mogelijkheden van Git en eigen toevoegingen aanbiedt. Het beschikt onder ander over toegangscontrole en verschilde samenwerkingsfuncties, zoals een issue tracker, een forum voor het aanvragen van functies, takenlijsten en wiki's voor ieder project.
GitHub biedt zowel gratis en privé-repositories voor opensourceprojecten. Om privé-projecten te kunnen hosten op Github is een betaald abonnement nodig.
Code schrijven met behulp van Blockly
Als je nog wat moeite hebt met het zelf schrijven van Python code kun je gebruik maken van dit handige hulpmiddel, waarmee je je programma maakt met blokken en vervolgens wordt de benodigde code voor je geschreven.
Je kunt meteen gebruik maken van een aantal functies, zoals sleep(), running_time(), panic(error_code) en reset().
# sleep for the given number of milliseconds.
sleep(ms)
# returns the number of milliseconds since the micro:bit was last switched on.
running_time()
# makes the micro:bit enter panic mode (this usually happens when the DAL runs
# out of memory, and causes a sad face to be drawn on the display). The error
# code can be any arbitrary integer value.
panic(error_code)
# resets the micro:bit.
reset()
De rest van de functionaliteit zit in de objecten en klassen die gebruikt worden. Als je wil weten wat er mogelijk is met die objecten en klassen, kun je zoeken in de API (Application Programming Interface). Ga naar http://microbit-micropython.readthedocs.io/en/latest/ en vul een zoekterm in.
Zoeken in de API
Zoek bijvoorbeeld naar de term "display" en klik op de bovenste link van de zoekresultaten. Je krijgt dan alle informatie over alle functions die het object display heeft.
show en scroll zul je het vaakst gebruiken. show gebruik je om tekst of een afbeelding te tonen en met scroll kun je tekst over het scherm van links naar rechts laten scrollen.
Nogmaals: bij alle programma's voor de micro:bit moet je eerst de bibliotheek van micro:bit importeren. De eerste regel van je programma is dan ook altijd: from microbit import *
Daarna laat je een regel open begin je met het maken van code.
Als je klaar bent met de code, kies je bovenaan voor Download. De code zal worden gedownload naar de download map op je computer.
Zorg dat de micro:bit is aangesloten op de computer. Klik op Downloads weergeven (of blader naar de downloads map) en lopieer het hex bestand naar de micro:bit. Op de micro:bit wordt meteen de tekst Hello! getoond.
String
Een string is een verzameling van alfanumerieke tekens, zoals letters, cijfers, interpunctietekens en spaties. Het is dus een blok tekst zoals je die met je toetsenbord zou kunnen maken. Met strings kun je niet rekenen en ze staan tussen enkele of dubbele aanhalingstekens. Python gebruikt enkele aanhalingstekens als dubbele.
MAAR LET OP: als je met enkele begint moet je ook met enkele eindigen en als je met dubbele begint moet je ook met dubbele eindigen.
Enkele voorbeelden:
voornaam = 'Jan'
achternaam = "Karelsen"
woonplaats = "Hengelo"
En een bijzondere:
achternaam = "Huis in 't Veld"
Integer
Een integer is een geheel getal, dus zonder dat er een decimale komma wordt gebruikt. Het getal kan wel negatief zijn, als het maar een geheel getal is.
Het display kan geen integers tonen. Als je toch een integer wil tonen, moet je die eerst omzetten naar een string met het commando str.
Bijvoorbeeld:
display.show(str(3))
Opdracht Countdown:
Maak een programma waarbij de micro:bit terugtelt van 9 naar 1 met steeds 1 seconde als tussenpauze. Als het programma bij 0 komt, wordt er een afbeelding naar keuze getoond.
Lever de code van je uitwerking in als een tekstbestand met als naam countdown.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save:
Float
Floats zijn kommagetallen, dus bijvoorbeeld 1,2 of 3,4. Wij schrijven die met een komma maar in programmeertaal wordt de scheiding meestal aangebracht met een punt, dus bijvoorbeeld 1.2 in plaats van 1,2. Met random.random maak je een willekeurige float (kommagetal).
Ook een float kan niet zomaar worden weergegeven via display.show. Ook hierbij moet je de methode str gebruiken (zie het vorige blok over integers).
Array
Een array is een lijst met informatie. Een array heeft een naam en je herkent een array aan de rechte haken.
Bij sommige programmeertalen, zoals C# en Java, waar je later in de opleiding mee gaat werken, moet de elementen van een array van hetzelfde type zijn, maar bij Python hoeft dat niet.
Je kunt een element uit een array opvragen met behulp van de index. Bedenk daarbij dat in de meeste programmeertalen en ook in Python wordt begonnen met de waarde 0 voor het eerste element.
De volgende code zal doorlopend dog weergeven op de Microbit.
Theorie: Images
Lees de theorie over Images met de micro:bit. Tot aan DIY Images.
Knoppen
Maak een programma waarmee je kunt uitlezen hoe vaak button_a is ingedrukt. De opbouw van het programma is als volgt:
Maak een variabele "aantal" en stel die op 0.
Daarna maak je een while True met de volgende dingen:
Toon de afbeelding ARROW_W.
Maak een if waarbij telkens de variabele aantal met 1 wordt opgehoogd als er op button_a wordt gedrukt. Zoek op in de documentatie met welke functie dat kan.
Met een elif bepaal je dat het aantal keren dat er op button_a is gedrukt, kan worden uitgelezen door op button_b te drukken.
Als er zowel op button_a als op button_b wordt gedrukt, wordt de variabele gereset naar 0 en komt er RESET op het display te staan.
Lever de code van je uitwerking in Natschool in als een tekstbestand met als naam buttons.py. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Aan de slag
Toon de HAPPY afbeelding op je microcontroller.
Lever de code van je uitwerking in als een tekstbestand met als naam happy.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Zoek in de documentatie op welke ingebouwde afbeeldingen er zijn en probeer er een paar.
De micro:bit heeft twee knoppen (buttons):
button_a
button_b
Met de methode is_pressed() kun je controleren of die knop is ingedrukt of niet.
button_a.is_pressed() kan True of False zijn.
Met een conditional statement zoals if kunnen we controleren of er aan de voorwaarde is voldaan.
Daarvoor wordt vaak een flowchart gebruikt.
Flowcharts
Flowchart
Een flowchart, is een schematische voorstelling van een proces. Het wordt over het algemeen gebruikt om een proces makkelijker te visualiseren, of om fouten in het proces te kunnen vinden.
Flowcharts worden heel vaak gebruikt bij het ontwikkelen van software. Wij gaan ook gebruik maken van flowcharts voor het ontwikkelen van onze programma's van de micro:bit.
Bovenstaande flowchart is misschien al iets te moelijk om mee te beginnen. Daarom zullen we eerst een eenvoudigere flowchart maken. We maken een flowchart als we de stappen in beeld willen brengen om een probleem op te lossen. Zo'n opeenvolging van stappen noemen we een algoritme.
Neem het volgende voorbeeld
Een vriend die ver weg woont wil bij je langs komen. Hij komt met de trein naar het station dat bij jou in de buurt is. Nu zijn er verschillende manieren voor die vriend om vanaf het station bij jouw huis te komen. Ik noem er een paar:
Het taxi algoritme
zoek een taxi
stap in de taxi
geef de taxichauffeur het adres waar je naar toe moet
Het bellen algoritme
als de trein aankomt bel dan mijn mobiel
wacht op mij op de parkeerplaats bij het station
Het bus algoritme
neem bus 12 naar de wijk Langdonk
stap uit bij de halte Langdonk
loop naar nummer 21
Met elk algoritme bereik je hetzelfde doel, maar je ziet dat je altijd op verschillende manieren het probleem op kunt lossen.
Flowcharts hebben verschillende onderdelen en regels.
Regels
Elke flowchart heeft een naam.
Er zijn geen losse onderdelen die rondzweven (behalve de naam). Alle componenten zijn verbonden door pijlen of lijnen.
Er is één startpunt en één eindpunt.
Een proces (rechthoek) heeft altijd één inkomende en één ujitgaande pijl.
Een beslissing (diamant) heeft tenminste één inkomende en tenminste twee uitgaande pijlen. De uitgaande pijlen zijn gelabeld met de mogelijke antwoorden van de beslissing.
Houd de flowchart zo kort mogelijk,
Onderdelen
Ovaal: begin (start) en einde (stop)
Rechthoek: proces
Parallellogram: invoer/uitvoer
Diamant: beslissing
Pijlen: tonen de richting van het proces
Eerst teken je de flowchart met potlood en papier. Daarna kun je de flowchart prima tekenen met behulp van draw.io.
Loops en if-statements komen in een diamant te staan. Vanuit de diamant komt er een True en een False pijl.
Voorbeeld van een flowchart
Neem het volgende proces. Je weet niet zeker of je een paraplu moet meenemen als je naar buiten gaat. Daarvoor moet je eerst even het huidige weer controleren. Als het droog blijft, kun je de paraplu thuis laten. Als het niet droog blijft, neem je een paraplu mee.
Teken de flowchart met een potlood op een blanco vel A4. Zet je naam er bij en maak een foto van de flowchart met je telefoon.
Daarna ga je naar www.draw.io en teken je dezelfde flowchart met draw.io. We gaan een hele les samen werken met het tekenen van flowcharts en de uitwerking ervan in draw.io.
Lever de code van je uitwerking van onderstaande opdracht in als een tekstbestand met als naam opdracht2_1.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.. Je mag in tweetallen samenwerken maar iedereen levert zijn eigen werk in.
Opdracht 2.1
Maak een programma waarbij:
een spook getoond wordt als je op knop A drukt
een schedel getoond wordt als je op knop B drukt
een zwaard getoond wordt als er op geen enkele knop gedrukt wordt
Maak eerst een flowchart met potlood en papier. Teken de flowchart op een blanco vel A4. Op het vel staan ook je naam en "Opdracht 2.1". Als de flowchart klaar is, maak je er een foto van met je telefoon en je levert de jpg van die foto op je telefoon in. De naam van die foto is voornaam_21.jpg.
Daarna ga je naar www.draw.io en dan teken je met dat programma de flowchart. Exporteer de flowchart naar een png en noem de export voornaam_21.png.
Lever voornaam_21.jpg en voornaam_21.png in Natschool in..
Maak je eigen afbeeldingen
Je kunt je eigen images maken! Het display heeft 5x5=25 LEDs en elke LED kun je een waarde geven van 0 tot en met 9. Met de waarde 0 staat de LED helemaal uit en met de waarde 9 brandt die LED op zijn hardst. Met de waardes van 1 tot en met 8 kun je ze dus laten branden van zacht naar hard.
Als je dat weet kun je bijvoorbeeld een bootje tekenen op de volgende manier:
Zo maak je dus je eigen afbeelding. Elke regel bestaat uit vijf cijfers van 0 tot en met 9 met daarachter een dubbele punt. En die regel staat weer tussen dubbele quotes. Elk cijfer geeft de felheid aan waarmee de LED moet branden. Bij 0 staat die LED uit en hoe hoger het cijfer, hoe harder de LED zal branden. Het hoeft niet met vijf regels. Het mag ook zo:
boat = Image("05050:05050:05050:99999:09990")
Animaties
We kunnen met de micro:bit ook animaties maken door een aantal afbeeldingen achter elkaar af te spelen. Er zitten al enkele lijsten met dezelfde afbeeldingen ingebouwd, nameleijk Image.ALL_CLOCKS en Image.ALL_ARROWS.
from microbit import *
display.show(Image.ALL_CLOCKS, loop=True, delay=100)
Net zoals bi jeen enkele afbeelding gebruiken we display.show om de afbeeldingen te tonen op het display. We geven de opdracht dat MicroPython Image.ALL_CLOCKS moet gebruiken en de micro:bit begrijpt dat hij die afbeeldingen één voor één moet afspelen. We geven ook de opdracht dat het afspelen eindeloos moet doorgaan met loop=True. Tenslotte willen we een korte pauze tussen de verschillende afbeeldingen. Met delay=100 wordt er 100 ms gewacht.
Hetzelfde kun je proberen met Image.ALL_ARROWS. Met loop=False zet je de eindeloze herhaling uit en met delay kun je de snelheid van de animatie aanpassen.
Je kunt dus je eigen plaatjes maken, die in een array zetten en dat array tonen op het display. Hieronder zie je hoe je een bootje kunt laten zinken.
Maak een eigen animatie en lever de code in Natschool in als een tekstbestand met als naam animate.py..
In te leveren opdrachten
1)
Maak een animatie van een ondergaande zon. De zon zakt schuin naar beneden en gaat steeds minder fel stralen. Let ook op de snelheid waarmee de animatie wordt afgespeeld. Plaats de code in een txt bestand en lever dat in Natschool als een tekstbestand in met als naam sundown.py..
2)
Maak een eigen animatie en lever die als een tekstbestand in Natschool in met als naam mijn_animatie.py...
Onder aan de micro:bit zie je een gouden strip met vijf gaten en daaronder 0, 1, 2, 3V en GND. Dat zijn pins die je kunt gebruiken om iets in te voeren. De rechtse pin met GND (ground/massa) houd je ingedrukt of sluit je aan. Als je dan ook één van de andere aansluit of aanraakt, kun je daar code op laten reageren. De eerste drie pins zijn genummerd 0, 1 en 2.
Met de volgende code kun je bijvoorbeeld een HAPPY plaatje laten zien als je GND vasthoudt en pin 0 aanraakt aan de boven- of onderkant. Probeer onderstaande code maar eens. Als je niets doet, wordt er een SAD afbeelding getoond. Probeer eens!
from microbit import *
while True:
if pin0.is_touched():
display.show(Image.HAPPY)
else:
display.show(Image.SAD)
Theorie: Input/Output
Lees de theorie van de pins. We doen nog even niets met Bleeps and Bloops.
Aan de slag
Maak een programma waarmee je met de drie pins drie verschillende afbeeldingen worden getoond. Als er geen enkele pin wordt aangeraakt, wordt er weer een andere afbeelding getoond.
Lever de code van je uitwerking in als een tekstbestand met als naam input_output.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Als je nu een luidspreker aan zou sluiten op pin 0 en op GND, dan zou je dit kunnen afspelen. Je kunt het testen met een eigen koptelefoon.
Lever de code van je uitwerking in als een tekstbestand met als naam vader_jacob.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Lees de theorie over wat je met muziek en de micro:bit kunt doen.
5: Willekeur
Lees de theorie over random tot aan de Seeds of Chaos.
from microbit import *
import random
display.show(str(random.randint(1, 6)))
Hiervoor moet je wel de klasse random importeren. Dat doe je op de tweede regel. Op de eerste regel importeer je microbit zoals je gewend bent. Vervolgens importeer je op de tweede regel de klasse random.
De functie show aangeroepen worden om iets te laten zien op het object display. Nu is het zo dat dit object enkel maar strings (tekst) kan laten zien en geen integers (gehele getallen). De uitkomst moet dan ook worden omgezet van een integer (geheel getal) naar een string (tekst) en dat doe je met str.
De functie die gebruikt wordt voor het willekeurig getal, is randint() en je geeft het kleinste getal en het grootste getal op, dus in het voorbeeld van een dobbelsteen is dat random.randint(1,6). Van de klasse random gebruik je de functie randint() en die functie heeft twee parameters, een minimum en een maximum.
Probeer deze code!
Willekeurige string
MicroPython heeft een module Random waarmee je een willekeurige string kunt laten tonen uit een reeks van strings in een array. Bekijk het volgende voorbeeld.
from microbit import *
import random
names = ["Mary", "Yolanda", "Damien", "Alia", "Kushal", "Mei Xiu", "Zoltan" ]
display.scroll(random.choice(names))
Je ziet dat op de tweede regel de module random apart wordt geïmporteerd. Daarna volgt er een rijtje met namen.
Zo'n rijtje met gegevens noemen we een array. En een array heeft een naam, in dit geval names. De namen in het array hebben een index waarmee je ze kunt vinden. Het eerste item in het array heeft als index 0, het tweede 1, het derde 2, enzovoorts. De index begint dus met 0.
Van het object display gebruik je de methode scroll. Vervolgens toon je van het array de naam met een willekeurige index.
Lever de code van je uitwerking in als een tekstbestand met als naam random_naam.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Nog meer willekeur
In een array kun je elementen stoppen die van een verschillend type zijn.
mixed_up_list = ["hello!", 1.234, Image.HAPPY]
Het array met als naam mixed_up_list heeft drie elementen. Het eerste is een string "hello", het tweede is een float (kommagetal) 1.234 en het derde is een afbeelding. Die kun je gewoon willekeurig tonen.
from microbit import *
display.show(Image.ALL_CLOCKS, loop=True, delay=100)
Commentaar in de code
Het is gebruikelijk boven in je code de naam van de maker te zetten. Je plaatst een # voor een regel zodat de regel niet als code becshouwqd wordt maar als informatie over de code.
Aan de slag
De Postcodeloterij
Bij de Postcode Loterij wint er altijd een postcode. Het numerieke gedeelte van de Nederlandse postcode kan een getal van 1000 tot en met 9999 zijn. Maak een programma voor de micro:bit waarbij een postcodegebied geloot wordt.
Lever de code van je uitwerking in als een tekstbestand met als naam pstcodeloterij.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
In te leveren opdrachten
Liefdesmeter
Maak twee arrays met namen van klasgenoten. In het ene array zitten vijf jongens en in het andere array zitten vijf meisjes. Als je op de linkerknop drukt, wordt er een willekeurige naam van een jongen getoond. Als je op de rechterknop drukt, komt er een willekeurige naam van een meisje door het beeld.
Opdracht 5.1
Lever het tekstbestand van deze opgave in met itslearning. Dus niet het hex bestand, maar het bestand dat je op internet hebt gemaakt voor je de download hebt gedaan. Je mag samenwerken, maar iedereen levert zijn eigen bestand in. Je naam staat als commentaar in de code.
Lever de code van je uitwerking in als een tekstbestand met als naam opdracht5_1.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Opdracht 5.2 Maak nu een dobbelsteen met je eigen afbeeldingen op de volgende manier:
Maak een lijst met als naam "dobbelsteen".
Maak nu zes eigen afbeeldingen zoals ze ook op een echte dobbelsteen staan. Voor de zes branden bijvoorbeeld de eerste en de laatste pixel van de eerste rij, de eerste en de laatste pixel van de derde rij en de eerste en de laatste pixel van de onderste rij.
Dit zou dus de zes zijn:
Image("90009:"
"00000:"
"90009:"
"00000:"
"90009")
De andere maak je zelf.
Het programma begint met het tonen van de afbeelding HAPPY.
In de while True meet je of de gesture 'shake' is.
Daarna gebruik je deze twee regels: display.show(dice, loop=True, wait=False, delay=100)
sleep(4000)
Op de volgende regel wordt dan een willekeurige afbeelding getoond.
Het programma wordt afgesloten met een sleep(10).
Lever de code van je uitwerking in als een tekstbestand met als naam opdracht5_2.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
5: Beweging
De micro:bit heeft een accelerometer. Dat is een versnellingsmeter waarmee je beweging kunt detecteren. In verschillende gsm's, smartphones en sommige iPods zit een versnellingsmeter die wordt gebruikt om te registreren wanneer de gebruiker ermee schudt, zodat bijvoorbeeld de afspeellijst wordt geshuffeld. Ook in de Wii remote en de PlayStation 3 controller zit een versnellingsmeter om bewegingen van de gebruiker waar te nemen.
De accelerometer meet langs drie assen:
X - beweging van links naar rechts
Y - beweging voorwaarts en achterwaarts
Z - beweging op en neer
Voor elke as is er een methode om de accelerometer uit te lezen. De waarde 0 is de basiswaarde.
Zet onderstaand script op de micro:bit en probeer het uit. Als de micro:bit precies waterpas wordt gehouden, zie je drie puntjes (een streepje) in het midden van het display. Beweeg de accelerometer van links naar rechts en andersom en je ziet dat er een L en een R tevoorschijn komen. Probeer deze code.
from microbit import *
while True:
reading = accelerometer.get_x()
if reading > 20:
display.show("R")
elif reading < -20:
display.show("L")
else:
display.show("-")
De y en z as kun je op dezelfde manier uitlezen.Het apparaat moet constant die waardes uitlezen en daarom wordt er een eindeloze lus gebruikt. De waarde van een as wordt in een variabele gezet. In bovenstaand voorbeeld stop je de waarde van de x as dus in de variabele reading.
Op deze manier kan je telefoon bijvoorbeeld bepalen hoe een afbeelding getoond moet worden, rechtop met de korte zijdes boven en onder of met de lange zijdes boven en onder.
Aan de slag
Lees de x uit van de accelerometer en zorg dat die wordt getoond wordt met display.scroll. Let op: het uitlezen van de x geeft een getal terug en je wilt een string laten zien op het display. De variabele naam die je gebruikt is x_acc.
Lever de code van je uitwerking in Natschool in als een tekstbestand met als naam accelerometer.py. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
6: Gebaren
Met de accelerometer kun je detecteren of de micro:bit bewogen wordt en op welke manier. MicroPython kan de volgende gestures detecteren: up, down, left, right, face up, face down, freefall, 3g, 6g, 8g, shake. Gestures worden weergegeven als strings.
Om het huidige gesture uit te lezen, gebruik je de volgende methode: accelerometer.current_gesture
Probeer het volgende voorbeeld te begrijpen. Zet het op je micro:bit.
from microbit import *
while True:
gesture = accelerometer.current_gesture()
if gesture == "face up":
display.show(Image.HAPPY)
else:
display.show(Image.ANGRY)
We gebruiken weer een while loop om constant te meten. In de loop gebruiken we een variabele gesture en daar stoppen we het huidige gesture in. Als de gesture gelijk is aan "face up" wordt de afbeelding HAPPY getoond en anders de afbeelding ANGRY.
Let op het dubbele is gelijk teken om te bepalen of de waarde van de variabele gelijk is aan iets!
from microbit import *
import random
answers = [
"It is certain",
"It is decidedly so",
"Without a doubt",
"Yes, definitely",
"You may rely on it",
"As I see it, yes",
"Most likely",
"Outlook good",
"Yes",
"Signs point to yes",
"Reply hazy try again",
"Ask again later",
"Better not tell you now",
"Cannot predict now",
"Concentrate and ask again",
"Don't count on it"
"My reply is no",
"My sources say no",
"Outlook not so good",
"Very doubtful",
]
while True:
display.show("8")
if accelerometer.was_gesture("shake"):
display.clear()
sleep(1000)
display.scroll(random.choice(answers))
Er wordt een array met antwoorden ingelezen. De naam van het array is answers. Pas bij de while begint het eigenlijke programma. Standaard wordt er een 8 getoond. Als er geschud wordt met de micro:bit wordt eerst het scherm leeggemaakt, dan 1000ms gewacht en tenslotte wordt er een random antwoord getoond.
In te leveren opdrachten
Opdracht 1:
Maak een dobbelsteen. Telkens als je schudt met de micro:bit komt er een willekeurig getal tussen de 1 en de 6 op het display.
Lever de code van je uitwerking in als een tekstbestand met als naam opdracht6_1.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Opdracht 2:
Maak het spel Rock, Paper, Scissors na. Je schudt met de micro:bit en één van de drie afbeeldingen komt tevoorschijn.
Lever de code van je uitwerking in als een tekstbestand met als naam opdracht6_2.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Deze twee opdrachten lever je in op itslearning bij opdracht 6.
Je levert de tekstcode in. Dus de code in een txt bestand. Géén Word bestand of hex bestand.
Opdracht 3:
Maak een stappenteller. Maak gebruik van een variabele die begint met 0 stappen. Telkens als er een "shake" plaatsvindt, wordt de variabele met 1 opgehoogd.
Werk in groepjes van twee of drie. Ga als volgt te werk:
1) Praat eerst in het algemeen in het groepje hoe je denkt dat je dit kunt maken. Maak daar een tekening of een schets van zonder echte code te gebruiken.
2) Maak samen één flowchart met potlood en papier op een blanco vel. Maak met je telefoon een foto van de flowchart en lever ook de flowchart in als jpg.
3) Iedereen maakt de code op zijn eigen micro:bit en levert die in als tekstbestand met als naam opdracht6_3.py.
Herhalingsopdrachten
Toon een letter
Toon de eerste letter van je voornaam op het display.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_1.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Toon een naam
Toon je voornaam op het display. De letters komen achtereenvolgens op het display zonder dat ze scrollen.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_2.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Laat een woord één keer scrollen
Laat je voornaam één keer over het scherm scrollen.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_3.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Zorg dat een woord oneindig blijft scrollen
Maak je voornaam in hoofdletters en zorg dat die naam voortdurend blijft scrollen.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_4.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Toon een afbeelding
Laat een hartje zien.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_5.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Toon een cijfer
Toon het cijfer 3 op het display.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_6.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Toon de uitkomst van een berekening
Toon de uitkomst van de berekening zien van 2x3. De uitkomst daarvan is 6. Je mag geen 6 als antwoord in de code typen, maar je laat de micro_bit dit zelf uitrekenen.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_7.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met button_a
Als button_a wordt ingedrukt, komt er een hartje op het display.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_8.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met button_a en button_b
Als je button_a indrukt, krijg je de afbeelding HAPPY en als je button_b indrukt, krijg je de afbeelding SAD.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_9.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met button_a, button_b en een derde afbeelding
Als je button_a indrukt, krijg je de afbeelding HAPPY. Als je button_b indrukt, krijg je de afbeeldingt SAD. Bij het opstarten van het programma wordt de afbeelding HEART getoond.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_10.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met een pin
Als je pin 0 aanraakt, verschijnt de afbeelding HEART.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_11.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met meerdere pins
Als je pin 0 aanraakt, verschijnt de afbeelding HEART, als je pin 1 aanraakt, verschijnt de afbeelding HAPPY en als je pin 2 aanraakt, verschijnt de afbeelding SAD.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_12.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met random
Laat een random getal zien tussen de 6 en de 9, dus er komt een 6, 7, 8 of 9 in beeld.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_13.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met random en buttons
Als je op button_a drukt, komt er een random getal van 1 tot en met 4. En als je op button_b drukt, komt er een getal van 5 tot en met 9.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_14.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Een random string uit een array
Van onderstaand array moet een willekeurige naam scrollen.
namen = ["Jan","Piet","Kees"]
Test verschillende keren met de reset knop.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_15.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Werken met gestures
Standaard komt er de afbeelding SAD in beeld. Als je met de micro:bit schudt, komt de afbeelding HAPPY.
Lever de code van je uitwerking in als een tekstbestand met als naam herhalingsopdracht_16.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Opdracht: Flappy Bird
We gaan Flappy Bird namaken. Volg de stappen zoals op deze website vermeld staat.
Lever de code van je uitwerking in als een tekstbestand met als naam flappy.py in het OneNote kladblok. Je kunt het tekstbestand maken door in de Micro:Bit editor te klikken op Save.
Eindopdracht - binair rekenen
Binair rekenen
Zoals je weet werken computers met eentjes en nulletjes. Eén zo'n eentje of nulletje noemen we een bit. En 8 bits samen zijn een byte.
Ieder teken kunnen we weergeven als één byte. Bekijk maar eens de tabel met ASCII-codes op Wikipedia:
In de tabel zie je dat de hoofdletter A wordt vertegenwoordigd door de decimale waarde 65 en de binaire waarde is 10000001. Om een binaire waarde om te rekenen naar een decimale waarde ga je als volgt te werk. Als voorbeeld nemen we de waarde 10000001.
We beginnen bij de laatste bit. Als deze aan staat vermenigvuldigen we 1 met 20 en dat levert 1 op (raar maar waar, ieder getal tot de macht 0 is gelijk aan 1). Als de bit niet aan staat vermenigvuldigen we 20 met 0 en dat geeft natuurlijk 0 als uitkomst.
We gaan door met de voorlaatste bit. Als deze aan staat vermenigvuldigen we 1 met 21 en dat levert 2 op. Als de bit niet aan staat vermenigvuldigen we 21 met 0 en dat geeft natuurlijk 0 als uitkomst.
Zo werken we steeds verder naar links.
0
1
0
0
0
0
0
1
27
26
25
24
23
22
21
20
128
64
32
16
8
4
2
1
0
64
0
0
0
0
0
1
We tellen vervolgens alle waarden uit de onderste rij bij elkaar op: 64 + 1 = 65.
Nog een voorbeeld
1
1
0
1
0
1
0
0
27
26
25
24
23
22
21
20
128
64
32
16
8
4
2
1
128
64
0
16
0
4
0
1
We tellen weer alle waarden uit de onderste rij bij elkaar op: 128 + 64 + 16 + 4 = 212.
Zonder tabel kun je vrij snel bepalen wat de hoogste waarde is die we met één byte kunnen maken. Alle bits staan dan aan dus we tellen op 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255.
Opdracht
Je gaat nu een rekenmachine maken voor de Micro:Bit, waarmee de gebruiker een binair getal kan omrekenen naar een decimale waarde. Door op A te drukken wordt een 0 aan de binaire waarde toegevoegd en door op B te drukken een 1.
De gebruiker kan maximaal 8 bits opgeven (dus 1 byte). Door tegelijk op A en B te drukken wordt de binaire waarde omgerekend naar de decimale waarde en de decimale waarde wordt weergegeven op de Micro:Bit.
Als de maximum lengte is bereikt moet een Sad Face worden weergegeven als de gebruiker op A of B drukt.
Lever je uitwerking als tekstbestand in Natschool in met als naam bin_dec.py.
Voor de echte kanjers is er nog een mooie uitbreiding. Door te schudden wordt de binaire waarde omgerekend naar een hexadecimale weergave. Als je deze weet op te lossen mag je jezelf tot de echte goeroes van de Micro:Bit rekenen.
Het arrangement Micro:bit - Versie ROC van Twente is gemaakt met
Wikiwijs van
Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt,
maakt en deelt.
Auteur
Marcel Roesink
Je moet eerst inloggen om feedback aan de auteur te kunnen geven.
Laatst gewijzigd
2018-09-10 19:06:42
Licentie
Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:
het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
voor alle doeleinden, inclusief commerciële doeleinden.
Maak nu een dobbelsteen met je eigen afbeeldingen op de volgende manier:
