Activiteiten van maximaal 10 minuten

In deze eerste les maak je kennis met de TI-Python programmeer editor en het gebruik van een aantal veel voorkomende bewerkingen in Python.

Doelen :

• Het gebruik van de TI-Python editor

• Het verschil tussen editor en shell

Start met een nieuw document en kies voor Add Python en dan New... .

Er verschijnt een scherm waarin je de naam van het te maken programma kunt intypen en voor een type kan kiezen.

Je komt nu in de zogenaamde editor waarin je programma code kunt intypen en wijzigen.

We beginnen met een eenvoudig programma dat alleen een tekst afdrukt.

Daarvoor is de Python opdracht: print().

Dit kun je intypen, maar je kunt deze opdracht ook in het menu vinden.

(Menu > 4:Built-ins > 6:I/O > 1:print())

Maak het programma af door tussen de haakjes de gewenste tekst in te typen.

Belangrijk: Letterlijke tekst moet in Python tussen aanhalingstekens staan. In de editor zie je dat dit groen wordt afgedrukt. Dit voor de duidelijkheid en als hulp om de aanhalingstekens op de juiste plek te sluiten.

Het programma is nu af.

Om te controleren of het voldoet aan de syntax (grammatica) van Python kun je dat checken met Menu > 2:Run > 2:Check syntax & Save.

(Dat kan ook met Ctrl+B)

Als je dit gedaan hebt staat er in de bovenste regel van het scherm achter de programmanaam: saved successfully.

Dat betekent dat er geen syntaxfouten zijn.

Je kunt het programma nu uitvoeren (runnen) door weer naar het menu te gaan en nu te kiezen voor Run (of met Ctrl+R).

Er wordt nu een nieuw scherm aangemaakt waarin het programma wordt uitgevoerd. Dit heet de shell.

Je kunt met Ctrl-links en Ctrl-rechts wisselen tussen de editor en de shell.

Ga eerst weer naar de editor en wijzig het programma door een tweede regel toe te voegen met andere teksten en voer het opnieuw uit.

Je ziet dan direct het resultaat.

In deze tweede les maak je kennis met verschillende datatypes die in Python gebruikt worden.

Doelen :

• Het gebruik van de Python shell
• Omgaan met verschillende gegevenstypes

Start met een nieuw document en kies nu voor Add Python en dan 3:Shell.

Je komt dan in de Python shell.

Het verschil met de editor is dat de opdrachten die je hierin in typt direct worden uitgevoerd.

In het vorige programma drukten we een tekst af. In computer programmeren is tekst van het type: string.

Je kunt dat ook in Python opvragen met de functie type() 

De functie type() kun je vinden bij Menu > 3:Built-ins . 5:Type > 6:type() maar je kunt het ook gewoon intypen.

Als je in de shell intypt: type(“Hallo”) dan geeft Python het type weer.

<class ‘str’> betekent dat de tekst van het type string is.

Zo zijn er verschillende datatypes in Python.

Enkele andere belangrijke datatypes zijn int (gehele getallen), float (komma getallen), list (lijsten).

Merk op dat hiernaast het getal 8 van het type integer (int) is terwijl 8/2 van het type float is (hoewel 8/2 = 4).

Dat komt omdat 8/2 een deling is en door Python benaderd wordt en dus een afgerond getal is.

Soms is het nodig om het datatype in Python te wijzigen.

Zo kun je de deling 8/2 veranderen in een integer met de functie int().

Controleer wat het type is van int(20/5).

Je ziet hiernaast ook dat je de tekst “23” kunt converteren naar een getal van het type integer.

Converteer op dezelfde manier de tekst “35.9” naar een kommagetal met float(“35.9”).

En ook het getal 7 naar het type string met str(7)

In deze les leren we meer over de syntax van Python en het gebruik van variabelen

Doelen :

• Een variabele gebruiken in Python
• De input()-opdracht in Python
• Het gebruik van een functie in Python

Het is vaak nodig dat je de loop van een computerprogramma kan beïnvloeden tijdens de uitvoering. Een van de opdrachten waar dat mee kan is input().

Maak een programma dat eerst vraagt om de naam van de gebruiker en die dan op het scherm afdrukt.

Begin weer met een nieuw Python programma (Nieuw document, Add Python, New.

Begin het programma met de vraag naar de naam van de gebruiker.

De ingevoerde naam moeten we wel ergens opslaan (toekennen aan een variabele).

Noem die variabele bijvoorbeeld naam.

Het programma kan dan beginnen zoals hiernaast.

In deze les maken we kennis met de voorwaardelijke opdrachten.

Doelen :

• Het gebruik van de opdracht if ... else ... .
• Wat is de syntax voor deze opdracht in Python

Voorbeeld :

Een autoverhuurbedrijf heeft de volgende aanbieding:

De huurprijs is € 66,-- voor de eerste 70 kilometer plus nog € 0,25 voor elke kilometer die extra gereden wordt.

We maken een programma dat om het aantal verreden kilometers vraagt en dan de bijbehorende prijs afdrukt.

Start een nieuw document met daarin een Python programma.

Begin met de vraag naar het aantal kilometers en noem dat k.

De Python opdracht input() geeft altijd een string als uitkomst, maar we willen een getal voor k. Dat kan door het type te wijzigen naar een geheel getal met de functie int(). (We gaan er hierbij vanuit dat het aantal kilometers een geheel getal is)

De eerste twee regels van het programma kunnen er nu uitzien zoals hiernaast.

Je ziet ook aan het eind van de regel met if en die met else een dubbele punt. Dit is ook een eigenschap van Python.

Wil je daarna het programma nog een keer uitvoeren, dan kan dat vanuit de shell met opnieuw Ctrl+R. 

In les 2 van deze unit leren we hoe je opdrachten kunt herhalen.

Doelen :

• Hoe gebruik je de opdracht for .
• Wat is de syntax voor deze opdracht in Python

De letter i is de zogenaamde teller. Die start als er geen beginwaarde is opgegeven altijd bij 0.

De lus wordt 8 keer doorlopen waarbij telkens de waarde van i een groter wordt.

De laatste waarde van i zal dus 7 zijn.

De opdrachten die in het blok staan worden nu 8 keer herhaald.

We willen de kwadraten en derde machten afdrukken dus die gaan we binnen de lus berekenen.

In Python noteer je machtsverheffen met twee keertekens. Dus 2⁵ wordt in Python geschreven als: 2**5

In de for-lus moeten we telkens i**2 en i**3 berekenen en afdrukken.

We kunnen de resultaten ook opslaan in een lijst.

Begin het programma dan met een lege lijst (Een lege lijst is een lijst zonder elementen)

Elke keer als de lus wordt doorlopen voegen we een nieuwe uitkomst toe aan de lijst met .append. (In Python is dit een manier om een lijst uit te breiden.)

Pas het programma aan zodat de lijst met kwadraten wordt gemaakt en druk deze uiteindelijk af. 

In de wiskunde is 5! (5 faculteit) de uitkomst van 5*4*3*2*1 = 120.

Maak een programma waarin de faculteit-functie wordt gedefinieerd.

Aanwijzing:

Start met het getal 1 en maak een for-lus waarbij elke keer de nieuwe uitkomst wordt vermenigvuldigd met de lus-variabele (i).

Ga na dat je hiermee de faculteit van grote getallen kunt berekenen.

(Als je het programma uitvoert kom je in de shell waar dan de functie is gedefinieerd. Met de var toets of met Ctrl+L kun je hem oproepen)

In les 3 van deze unit leren we hoe je opdrachten kunt herhalen

Doelen :

• Hoe gebruik je de opdracht while ... .
• Wat is de syntax voor while opdracht in Python

Als je een serie opdrachten een aantal keren wilt herhalen, maar je weet van tevoren niet hoe vaak, dan kun je de while... lus gebruiken.

Dit kun je lezen als:

Zolang een bepaalde voorwaarde geldt blijf dan herhalen.

We maken een programma dat het volgende probleem simuleert:

Werp met een dobbelsteen en herhaal dit net zolang totdat je 6 gooit en tel het aantal keren dat je hiervoor nodig hebt.

Open een nieuw Python programma en geef het een naam.

Omdat we randomgetallen gaan gebruiken hebben we de random module nodig.

Deze module is een soort bibliotheek met functies voor randomgetallen.

In Python is het gebruikelijk om dit aan het begin van het programma te doen.

Je kunt deze module vinden in het menu bij Random en dan keuze 1 om alle functies te importeren.

In Python noteer je dat als: uitkomst != 6. (dit kun je intypen, maar je kunt ook in het menu kijken bij Built-ins en dan Ops)

We gaan het programma wijzigen zodat we het experiment niet één keer maar honderd keer uitvoeren en dan het gemiddeld aantal worpen berekenen.

Verander eerst het vorige programma zo dat het werpen met de dobbelsteen totdat zes is gegooid in een functie wordt gezet (noem die functie bijvoorbeeld dobbelen()).

Let op het gebruik van de spaties.

Je kunt het hele functieblok in een keer ‘opschuiven’ door het met de shift toets en de pijltoetsen te selecteren en dan de tab toets in te drukken.

Als je deze functie 100 keer uitvoert, de aantallen optelt en het totaal deelt door 100 krijg je het gemiddeld aantal worpen. 

Begin met een variabele som en zet deze op nul.

Maak nu een for-lus waarin de dobbel-functie 100 keer wordt uitgevoerd en tel telkens het aantal worpen op bij de som.

Als laatste komt de opdracht om som/100 af te drukken.

Om het gemiddelde nauwkeuriger te bepalen kun je bijvoorbeeld het getal 100

in het programma wijzigen in 1000 (op twee plekken).

In deze toepassing gaan we een programma schrijven dat de oplossing(en) van een tweedegraads vergelijking berekent (als die er zijn).

Doelen :

• Het gebruik van de opdracht if ... else ... .
• Een functie definiëren

De vergelijking ax² + bx + c = 0 heeft 2, 1 of 0 oplossingen.

We gaan een functie schrijven met als argumenten de getallen a, b en c.

De uitkomst zijn de oplossingen of de mededeling dat er geen oplossing is.

Begin met het sjabloon van een functie en noem deze functie los_op(a,b,c).

In de naam van een variabel (of functie) kun je een onderstrepingsteken gebruiken voor de leesbaarheid.

De functie heeft drie argumenten (a, b en c). Dit zijn de waarden van a, b en c uit de vergelijking.

Bereken eerst de discriminant D

Er zijn nu drie mogelijkheden:

D<0 (geen oplossingen), D=0 (één oplossing) of D>0 (twee oplossingen).

Gebruik det if ... elif ... else ... structuur om de drie mogelijkheden te onderscheiden.

Er zijn verschillende manieren om de functie te gebruiken.

Je kunt het programma uitvoeren met Run (Ctrl+R) en dan in de shell met de var toets de functie opvragen en de juiste argumenten invullen

Je kunt ook het programma uitbreiden en de functie daarin gebruiken.

Dat is hiernaast gedaan.

De regel a=float(input(“a: “)) doet het volgende:

De tekst “a: “ wordt afgedrukt op het scherm, het ingetypte getal is van het type string en dat wordt met de functie float() omgezet naar een komma getal.

Dit kan natuurlijk ook in meerdere regels.

In deze Unit gaan we wat dieper in op programmeren in Python.

Doelen :

• Meer over voorwaardelijke opdrachten
• True en False.
• Deelbaarheid.

Een positief geheel getal heet priemgetal als het slechts twee delers heeft (1 en zichzelf).

Zo is 7 een priemgetal want er zijn maar twee delers (1 en 7), maar 10 is geen priemgetal omdat 10 deelbaar is door 1, 2, 5 en 10.

Het kleinste priemgetal is 2.

We gaan een functie maken waarmee je kunt bepalen of een getal een priemgetal is.

De uitkomst van deze functie is True (waar) als het getal een priemgetal is en False (onwaar) als het getal geen priemgetal is.

We maken gebruik van een speciale deling: %

In Python geeft dit de rest bij een deling.

Zo is bijvoorbeeld 20%3 gelijk aan 2 want 20/3=6 met een rest van 2.

(3 past 6 keer in 20 en je houdt 2 over)

Begin met de definitie van de functie is_priem(n).

Als n<2 kan het geen priem zijn. Dan is de uitkomst dus False.

Als n>=2 dan controleren we of er een deler is.

Zo ja dan is de uitkomst False, anders is de uitkomst True.

(Je kunt True en False vinden in het menu bij Built-ins en dan bij 3:Ops)

In deze Unit gaan we wat dieper in op programmeren in Python.

Doelen :

• Een recursieve functie definiëren.
• Recursief versus rechtstreeks.

Een recursieve functie is een functie die zichzelf aanroept.

Een mooi voorbeeld hiervan is de faculteit functie.

Onder 5! (spreek uit 5 faculteit) verstaan we: 5 ∙ 4 ∙ 3 ∙ 2 ∙ 1=24.

Algemeen: n!=n∙(n-1)∙(n-2)∙⋯∙1

Dit kun je ook schrijven als: n!=n∙(n-1)!

Dus als je de functie fac(n) maakt voor n!, dan geldt: fac(n)=n*fac(n-1).

Een andere benadering is een functie die gebruik maakt van een for-lus:

Start met het getal 1 en maak een for-lus waarbij elke keer de nieuwe uitkomst wordt vermenigvuldigd met de lus-variabele (i in dit geval).

Als je wilt weten uit hoeveel cijfers het getal 500! bestaat kan dat in Python door eerst het getal naar een string om te zetten met str() en daarna de lengte van die string te berekenen (met len()).

Ga na dat 500! bestaat uit 1135 cijfers.

In deze Unit gaan we wat dieper in op programmeren in Python. Lijsten in Python

Doelen :

• Lijsten maken
• Verschillende lijst-opdrachten gebruiken.

Een lijst wordt in Python genoteerd als een opsomming van elementen tussen rechte haken waarbij de elementen door een komma gescheiden worden.

Zo is bijvoorbeeld [7,3,5] een lijst met 3 elementen (in dit geval getallen).

Open een nieuw Python programma en maak een lijst a met de getallen 1 t/m 10.

Elk element in de lijst heeft een rangnummer waarbij het eerste element nummer 0 heeft. Met a[3] krijg je het element met rangnummer 3.

Je kunt elementen toevoegen aan een rij met lijst.append().

Dit kun je vinden in Menu --> Built-ins --> Lists.

Als bijvoorbeeld a = [1,2,3], dan is a.append(5) de lijst a = [1,2,3,5]

We gaan dit gebruiken om een lijst van Fibonaccigetallen te maken.

Op deze manier kun je makkelijk een lijst van 100 Fibonaccigetallen maken.

Ga na dat het programma hiernaast het 100-ste Fibonaccigetal afdrukt.

Een lijst kan ook bestaan uit elementen die zelf een lijst zijn.

Dit is een tweedimensionale lijst of matrix.

We maken nu zo’n lijst waarbij elk element een lijst met Fibonaccigetallen is te beginnen met [1,1].

Verander het vorige programma eerst zo dat de functie f(a) een lijst geeft met Fibonaccigetallen.

Definieer nu een lege lijst. (bijvoorbeeld L = [ ])

Maak dan een for-loop waarbij steeds de lijst f(i) wordt toegevoegd aan L.

Zie hiernaast.

L bestaat uit vier lijsten met Fibonaccigetallen.

De lijst L uit dit programma bestaat uit lijsten.

Als we die lijsten onder elkaar willen afdrukken dan kan dat met een for-lus.

We gebruiken hiervoor de optie for i in L. (dit kun je vinden in Menu --> Built-ins --> Control.

In deze lus doorloopt i alle elementen van de lijst L. (Dus i is steeds zelf een lijst)

In deze unit maken we kennis met de ti_draw module waarmee je grafische figuren kunt tekenen

Doelen :

• De ti_draw module verkennen.
• Het scherm configureren en vormen tekenen.

Voor het tekenen van grafische vormen in Python kun je de ti_draw module gebruiken.

In deze module vind je opdrachten voor het tekenen van punten, lijnen, cirkels, rechthoeken, enzovoorts.

Start een nieuw Python programma en kies voor het type: Geometry Graphics.

(Je kunt ook achteraf deze module nog laden met Menu > More Modules > TI Draw)

Als je het programma begint met het importeren van deze module heb je toegang tot alle functies die in het draw-menu te vinden zijn.

Telkens als je zo’n functie wilt gebruiken kun je met Menu > More Modules > TI Draw die functie vinden.

Standaard zijn de afmetingen van het tekenscherm 318 bij 212 pixels waarbij de coördinaten van de linkerbovenhoek (0,0) zijn.

Maak een programma dat een cirkel tekent met het middelpunt in het centrum van het scherm en waarvan de straal 100 is.

Hiernaast zie je hoe je de opdracht voor het tekenen van een cirkel kunt vinden in het menu.

Verander het programma zo dat er 10 cirkels getekend worden met hetzelfde middelpunt, maar waarvan de straal varieert van 10 tot 100.

In het voorbeeld hiernaast is er nog een extra opdracht toegevoegd. Deze opdracht stelt de tekenkleur in en je kunt hem vinden in het TI Draw menu bij Control.

Een van de opdrachten in het control-menu in de ti-draw module is: set_window().

Hiermee kun je de afmetingen en de oorsprong opnieuw instellen.

Hiernaast is een window gekozen zodat de oorsprong in het centrum van het scherm ligt. Belangrijk is wel dat de breedte anderhalf keer zo groot is als de hoogte om de verhoudingen te behouden.

Teken nu 20 cirkels met het middelpunt in het midden van het scherm en waarvan de straal varieert van 0 tot 20.

Als je dit programma uitvoert kost het tekenen enige tijd.

Dat komt omdat telkens weer de tekenmodule moet worden aangeroepen.

Er zit ook een opdracht bij waarmee we dit kunnen versnellen.

In het control-menu zit de opdracht use_buffer(). Deze opdracht zorgt ervoor dat de tekenopdrachten niet direct worden afgedrukt maar worden “gebufferd”.

Pas aan het einde van het programma, of wanneer je de opdracht paint_buffer() gebruikt, wordt de buffer in een keer getekend.

Hiernaast zijn deze opdrachten toegevoegd.

Een mogelijk programma staat hiernaast.

In deze unit maken we kennis met de ti_plotlib module waarmee je grafische voorstellingen kan maken

Doelen :

• De ti_plotlib module gebruiken.
• De grafiek van een functie tekenen.

Met de module ti_plotlib kun je met Python grafieken tekenen.

Start een nieuw Python programma. Kies nu bij New voor het type Plotting (x,y) & Text.

Je ziet dan dat de module ti_plotlib is ingevoegd, maar op een iets andere manier dan andere modules.

Import ti_plotlib as plt betekent dat je in het programma elke opdracht of functie uit deze module moet beginnen met plt.

We beginnen met een rooster en een assenstelsel.

In het TI_PlotLib menu vind je onder setup de opdrachten plt.grid() en plt.axes().

Deze kun je gebruiken voor het tekenen van een rooster en een assenstelsel.

Zie hiernaast.

Verder is er in het voorbeeld ook nog een punt getekend. Je kunt de verschillende tekenopdrachten vinden in het TI_PlotLib menu onder Draw.

In deze les tekenen we een puntenwolk waarna we met lineaire regressie de best passende lijn erbij zoeken.

Doelen :

• Het tekenen van een puntenwolk.
• Lineaire regressie uitvoeren.

We bekijken het volgende probleem.

Na een overstroming in een gebied wordt elk uur de waterhoogte gemeten.

De resultaten staan in de volgende tabel:

We maken een programma dat een grafiek tekent van deze metingen en onderzoeken het verband tussen t en H.

Open een nieuw Python programma en voeg ti_plotlib module in.

Voor de grafiek hebben we een geschikt assenstelsel nodig.

Met de opdracht plt.window() kun je de vensterinstellingen aanpassen.

De functie plt.scatter (t,H,”x”) tekent de puntenwolk.

Hierbij is t de lijst met de horizontale gegevens, H de lijst met de verticale en “x” het symbool voor de punten.

(De functie scatter() is te vinden in het ti_plotlib menu onder tabblad Draw).

In deze les maken we kennis met de ti_system module waarmee data uitgewisseld kunnen worden tussen Python andere TI-Nspire toepassingen

Doelen :

• Variabelen van Python naar Nspire exporteren.
• Functiewaarden van Nspire naar Python importeren.

De ti_system module maakt het mogelijk gegevens uit te wisselen tussen Python en de andere toepassingen.

Je kunt variabelen, lijsten en functiewaarden uitwisselen.

Open een nieuw document en kies daarin voor een Calculator pagina (keuze 1).

Definieer een functie, bijvoorbeeld f(x) := x².

(Let erop dat je bij de definitie van een functie in TI-Nspire het := teken moet gebruiken.)

Voeg een nieuwe pagina toe aan het document en kies nu voor een Python pagina van het type Data Sharing.

In deze Python editor moet de ti_system module geïmporteerd worden.

(Deze module staat ook in het menu bij Menu --> More Modules --> TI System en dan keuze 1.)

In het ti_system menu (bij More Modules) staat o.a. de functie eval_function().

Bij deze functie moet je twee waarden invullen. De eerste is de naam van de functie die je in de calculator pagina gekozen hebt (in ons geval “f”) en de tweede is de waarde die je wilt invullen in de functie.

Ga na dat het programma de uitkomst 25 geeft.

Dit kunnen we ook gebruiken voor functies die Python niet kent, maar TI-Nspire wel.

We bekijken twee van dergelijke functies.

De eerste is de ggd van twee getallen berekenen. (ggd is grootste gemene deler)

De tweede is de controle of een getal een priemgetal is.

In deze les gaan we verder met de ti_system module. We kijken naar het gebruik van het toetsenbord.

Doelen :

• Detecteren welke toets is ingedrukt.

We starten met een rode stip in het midden van het scherm.

Het scherm is 318 pixels breed en 212 pixels hoog met de oorsprong in de linkerbovenhoek.

De functie get_key() uit het ti_system menu gaat na of er een toets is in gedrukt en zo ja dan is de uitkomst de naam van de toets die is ingedrukt (dus een string).

We starten met een lege string toets = ””.

Vervolgens maken we een while-lus die elke keer nagaat of er een toets is ingedrukt.

In de lus controleren we elke keer of één van de pijl-toetsen is ingedrukt.

In deze les maken we kennis met de ti_image module waarmee afbeeldingen kunnen worden bewerkt.

Doelen :

• Importeren van afbeeldingen.
• Bewerken van afbeeldingen.

De ti_image  module maakt het mogelijk afbeeldingen te bewerken.

(Je hebt de software nodig om een afbeelding in je document te importeren)

Hiernaast staat een afbeelding van Mickey Mouse.

Open een nieuw Python programma en importeer de ti_image module.

Om in Python een afbeelding te bewerken moet deze afbeelding in een Notes- pagina staan.

Als de afbeelding in de Notes pagina staat, moet je deze een naam geven.

Ga terug naar de Python pagina om het programma te schrijven.

Hiernaast zie hoe je de afbeelding in Python kunt krijgen.

(De opdracht load_image() kun je vinden in  Menu --> More Modules --> TI Image --> load_image()).

In deze les gebruiken we de TI-Innovator Hub in een Python programma.

Doelen :

• Het verkennen van de ti_hub module.
• Het toepassen van enkele basisvaardigheden.

In de ti_hub module vind je de opdrachten om vanuit Python met de TI-Innovator Hub te communiceren.

We gaan een programma maken dat de gekleurde led in de hub laat branden en dat de ingebouwde luidspreker gebruikt.

Sluit de hub aan op de rekenmachine of op de computer.

Open een nieuw Python programma en kies voor “Blank Program”.

Om de Innovator Hub te kunnen gebruiken heb je de Hub module nodig.

Kies uit het menu TI Hub en dan optie 1: from ti_hub import *.

In het TI Hub menu staat bij Hub Built-in Devices de Color Output.

In deze les lezen we een externe sensor af met de TI-Innovator Hub in een Python programma.

Doelen :

• Het aansluiten van een externe sensor.
• Het gebruik van de Ranger.

Naast de ingebouwde apparaten kun je ook externe input- en output apparaten aansluiten aan de hub.

We gaan een programma maken dat m.b.v. een afstandssensor (Ranger) de afstand tot een voorwerp meet.

Ook moet het programma een geluid geven waarvan de toonhoogte afhangt van de gemeten afstand.

Sluit de Ranger aan in poort IN1. (deze poort zit aan een van de zijkanten van de hub) en sluit de hub aan op de rekenmachine of de computer.

Open een nieuw Python programma en importeer de Hub-module.

Om de Ranger te kunnen gebruiken moeten we aangeven in welke poort hij zit aangesloten en we moeten hem nog een naam geven.

Kies uit het TI Hub-menu: Add Input Device, en kies dan voor Ranger.

Op het scherm verschijnt var=ranger(“port”).

De cursor staat nu op de plek waar je de naam kan intypen.

Typ een naam in (bijvoorbeeld rg) en geef aan in welke poort de Ranger is aangesloten (IN1 in dit geval).

Het aflezen van de Ranger gaat met de opdracht rg.measurement().

Je kunt dit makkelijk invoeren door de variabele-naam (rg) in te typen direct gevolgd door een punt.

Als je de gemeten waarde wilt gebruiken dan kun je die opslaan in een variabele (bijvoorbeeld a).

Als je het programma van hiernaast uitvoert dan wordt de gemeten afstand afgedrukt.

In deze les maken we een programma waarbij we de Rover laten rijden

Doelen :

• De Rover programmeren.
• De afstandssensor van de Rover gebruiken.

Om de Rover te kunnen programmeren heb je de ti_rover module nodig.

Hierin staan alle opdrachten die betrekking hebben op de Rover.

Open een nieuw Python programma en importeer de module ti_rover.

In de afbeelding hiernaast zie je staan: import ti_rover as rv.

Dit betekent dat elke Rover-opdracht moet beginnen met rv.

Eerst maken we een programma dat de Rover een vierkant laat tekenen met een zijde van 50 cm.

We gaan nu een programma maken dat de Rover laat rijden totdat de afstand tot een object (bijvoorbeeld een muur) kleiner is dan 10 centimeter.

Tijdens het rijden moet het lampje op de Rover groen branden.

Importeer de time-module.

De time-module vind je in het menu bij More Modules.

Begin met het aanzetten van het lampje.

De opdracht rv.color_rgb() kun je vinden in het TI Rover menu bij outputs.

Geef dan de opdracht om de afstand aan de voorkant van de Rover te meten en sla de waarde op in variabele a.

Nu moet de Rover gaan rijden totdat de afstand tot een voorwerp minder dan 10 cm is.

Een manier om dit te doen is als volgt:

Geef de Rover de opdracht om een grote afstand te gaan rijden (bijvoorbeeld 10 meter).

Meet, terwijl de Rover rijdt, telkens de afstand.

Op het moment dat deze afstand kleiner is dan 0.1 meter geef je de opdracht om te stoppen.

Dit kan met een while lus: zolang de afstand groter is dan 0.1, meet dan opnieuw.

Om ook nog het lampje twee seconden rood te laten branden moeten er nog drie regels toegevoegd worden.

Eerst krijgt het lampje de juiste kleur.

Dan moet er twee seconden gewacht worden.

In deze les maak je je eerste Python-programma’s voor het op verschillende manieren aansturen van het ‘micro:bit’-display.

• Deel 1: alien encounter
• Deel 2: plaatjes weergeven

Doelen:

• Het display van de micro:bit gebruiken met de opdrachten .show(), .scroll() en .show(image);
• De display snelheid instellen met sleep(ms).

Controleer voordat je begint het volgende:

• De TI-Nspire CX II heeft OS 5.3 of hoger.
• Je beheerst de beginselen van het programmeren in Python.
• De micro:bit is verbonden met de TI-Nspire CX II.
• Je hebt de instructies gevolgd voor het instellen van de micro:bit, zie: https://education.ti.com/en/teachers/microbit

Deze procedure hoeft maar één keer gevolgd te worden, maar zorg dat je op de hoogte blijft van eventuele updates.

Als alles goed is gegaan ziet je micro:bit er zo uit, nadat je hem hebt aangesloten op je TI-Nspire:

Op het display van de micro:bit zie je het TI-logo: de staat Texas met een heldere stip op de plek van Dallas.

Tot slot:

De micro:bit staat in de Python-bibliotheek en kun je als volgt vinden:

Druk in de Python-editor op [menu] >More Modules. Je ziet dat de ‘BBC Micro:bit’-module hieraan is toegevoegd.

Merk op dat in OS 5.3 en hoger Python-modules die in de Pylib- map zijn opgeslagen, in het menu worden toegevoegd aan de TI-modules.

Deel 1: Alien encounter

Zoals gebruikelijk bij een eerste programma begin je met een bericht op het ‘micro:bit’-display.

Begin met een nieuw ‘TI-Nspire’-document en kies voor Add Python>New om een nieuw programma te starten en noem het bijvoorbeeld: ‘greetings’.

Typ nu in de Python-editor [menu]>More Modules>BBC Micro:bit om de module te importeren:

from microbit import *

Tip: Als de mededeling ‘micro:bit not connected’ verschijnt, koppel dan de micro:bit los en sluit hem opnieuw aan.

Om een tekst op het display van de micro:bit te tonen, gebruik je de opdracht

                        display.show(image or text)

Je kunt deze opdracht vinden met:

    [menu] > More Modules > BBC micro:bit > Display > Methods

De opdracht wordt ingevoegd als display.show(Value) waarbij ‘value’ vervangen kan worden door bijvoorbeeld tekst. Typ hier tussen aanhalingstekens: “greetings, earthlings”

Als je dit programma uitvoert (bijvoorbeeld met [ctrl] [R] zie je de letters één voor één verschijnen op het display.

Een betere manier om tekst weer te geven is:

                     display.scroll(“greetings, earthlings”)

Ook deze opdracht kun je vinden bij:

    [menu] > More Modules > BBC micro:bit > Display > Methods

Voorzie de eerste opdracht van een commentaarsymbool om deze te negeren.

Je kunt natuurlijk ook gewoon ‘show’ vervangen door ‘scroll’ met het toetsenbord.

De .scroll() -methode laat de tekst scrollen (bewegen) van rechts naar links, zodat het makkelijker wordt om deze te lezen. Je kunt de snelheid aanpassen met behulp van een extra parameter delay:

       Display.scroll(“greetings, earthlings”, delay = 200)

Deze opdracht vertraagt het scrollen met 200 milliseconden (ofwel 0.2 seconden). Probeer ook andere waarden.

Deel 2: Hartslag

Open een nieuw document en kies Add Python>New om een nieuw programma te starten. Noem het bijvoorbeeld ‘hartslag’. Begin weer met het importeren van de ‘micro:bit’-module:

from microbit import *

Om een hartsymbool op het ‘micro:bit’-display weer te geven gebruik je de opdracht display.show()

Je kunt deze vinden bij:

[menu]>More Modules>BBC Micro:bit>Display>Methods

Tussen de haakjes vul je dan in Image.HEART.

Je kunt dit intypen, maar je kunt het ook in het menu vinden:

[menu]>More Modules>BBC Micro:bit>Display>Images>Set 1>HEART

Voer het programma uit ([ctrl] [R]), dan zie je een hartvorm op het ‘micro:bit’-display verschijnen. Het hartsymbool blijft op het display staan, totdat er weer een andere opdracht gegeven wordt. Ook als het programma gestopt is.

Ga terug naar de Python-editor en voeg de opdracht toe om het kleine hartsymbool weer te geven:

display.show(Image.HEART_SMALL)

Je kunt dit symbool vinden bij:

menu]>More Modules>BBC Micro:bit>Display>Images>Set 1

Maar je kunt ook de vorige regel kopiëren en plakken en dan _SMALL toevoegen (let er dan wel op dat je hoofdletters gebruikt).

Voer het programma uit. Dan zie je eerst het grote hart en dan direct daarna het kleine. .

We maken nu een lus (loop) om het hart te laten “kloppen”.

Voeg vóór de twee opdrachten de volgende opdracht toe:

while get_key() != “esc”:

deze kun je vinden met:

[menu]>More Modules>BBC micro:bit>Commands

Zorg ervoor dat de twee display-opdrachten beide inspringen (dit betekent dat beide opdrachten in een lus worden uitgevoerd).

Voer het programma weer uit, het hart klopt nu.
Je kunt het programma onderbreken met de escape-toets.

Tip: Mocht het zo zijn dat je programma in een oneindige lus zit dan kun je met de [home/on] -toets het programma toch stoppen.

In het ‘micro:bit’- Commands -menu kun je enkele nuttige Python- opdrachten vinden.
Enkele van deze opdrachten staan ook in de menu’s van andere modules.

Om de snelheid van de hartslag te veranderen kun je twee keer de opdracht sleep() toevoegen. Achter elke display-opdracht één sleep(1000) betekent een wachttijd van 1000 milliseconden ofwel 1 seconde.

De opdracht kun je vinden in:

[menu]>More Modules>BBC micro:bit>Commands

Tip: Let ook hier weer op het inspringen.

Extra: Probeer ook eens verschillende gezichten uit. Gebruik dezelfde structuur als het hartslagprogramma maar gebruik nu verschillende gezichtsuitdrukkingen uit Set 1.

In deze les leer je de knoppen en de bewegingsmogelijkheden van de micro:bit te gebruiken. Je maakt een programma dat het werpen met een dobbelsteen simuleert en de uitkomsten in een lijst opslaat die je naar dataplot van TI-Nspire exporteert.

Deze les bestaat uit twee delen:

• Deel 1: De werking van de knoppen en het effect van bewegen onderzoeken;
• Deel 2: Beweging en knoppen gebruiken voor het genereren van data.

Doelen :

• Bepalen of knop A of B is ingedrukt;
• Het verschil tussen .was en .is;
• Data uitwisselen tussen Python en TI-Nspire;
• Data vanuit de micro:bit beheren;
• Bewegingen van de micro:bit gebruiken.

De micro:bit beschikt over twee knoppen, gelabeld A en B, aan weerszijden van het display. De Python-‘micro:bit’-module kent twee gelijksoortige methodes om de knoppen af te lezen en om daarna taken uit te voeren, afhankelijk van de uitkomst. Eerst test je deze methodes en dan schrijf je een Python-programma waarmee je data verzamelt en analyseert met de TI-Nspire.

Er zit ook een accelerometer/compas-chip op de achterkant van de micro:bit en er zijn methodes (opdrachten) waarmee beweging en oriëntatie van de micro:bit kan worden gemeten.

Deel 1: Knoppen en bewegingen onderzoeken

Begin een nieuw Python-programma in een nieuw document. (Druk op de [Home] toets, kies New en dan Add Python>New). Geef het een naam bijvoorbeeld “knoppen”. Start weer met from microbit import *, deze kun je vinden in [menu]>More Modules>BBC micro:bit.

Voeg de while-lus (loop) toe

      ([menu] > More Modules > BBC micro:bit > Commands).

Vrijwel alle voorbeelden met de micro:bit hebben deze structuur.

Om knop A te testen gebruiken we de if-structuur:

             ◆◆if button_a.was_pressed():

         ◆◆◆◆print("Button A")

De if-opdracht is onderdeel van de while-opdracht en moet dus inspringen. De print opdracht springt extra in, omdat deze bij de if-opdracht hoort.

If kun je vinden bij [menu]>Built-ins>Control.

button_a_was_pressed() vind je bij:

[menu]>More Modules>BBC micro:bit>Buttons and Logo Touch.

Je kunt nu het programma testen.

Druk op [ctrl] [R] om het programma uit te voeren.
Het lijkt alsof er niets gebeurt. Maar elke keer als je knop A indrukt verschijnt “Knop A” op het scherm.

Druk op [esc] om het programma te stoppen.

Voeg nu een tweede if-opdracht toe voor knop B, maar gebruik nu de opdracht: if button_b.is_pressed()
Merk op dat er nu “.IS” staat in plaats van “.WAS”.
Let ook nu weer op de juiste inspringingen.

Voer het programma weer uit en druk op de verschillende knoppen A en B.

Het verschil is dat “Knop A” pas wordt getoond als de knop weer wordt losgelaten, terwijl “Knop B” steeds opnieuw wordt getoond, zolang deze ingedrukt blijft.

Merk op dat als je knop B indrukt en snel weer loslaat het mogelijk is dat er geen actie volgt, omdat op het moment dat de if-opdracht wordt uitgevoerd de knop niet is ingedrukt.

Bewegingsdetectie (gestures)
De micro:bit heeft een ingebouwde accelerometer (versnellingssensor) die in drie verschillende richtingen versnellingen kan meten (3D-accelerometer). Naast numerieke waarden voor de versnelling in elke richting (zie afbeelding hiernaast) kent de micro:bit ook duidelijke ‘gestures’ zoals “face up” en “face down” gebaseerd op deze numerieke waarden.

We gaan dit onderzoeken met ons programma.

De opdracht g = accelerometer.current_gesture() slaat de ‘waarde’ op in de variabele g.
(Je kunt deze opdracht vinden met:

[menu]>More Modules>BBC micro:bit>Sensors>Gestures)

Print(g) toont deze op het scherm.

Let op dat je het juiste aantal spaties gebruikt. De laatste twee regels horen bij de while-opdracht en niet bij de if-opdracht.

Voer het programma uit en kijk naar de verschillende meldingen op het rekenmachinescherm als je de micro:bit schudt, omdraait, rechtop zet, enz.

Sommige beschikbare ‘gestures’ zijn: face up, face down, up, down, left, right, shake.

Voorzie de laatste twee regels in je programma van het commentaarsymbool (#) (dit wil zeggen dat het programma deze regels tijdens het uitvoeren negeert) en voeg de volgende twee regels toe:

if accelerometer.was_gesture(“face down”):

◆◆print(“face down”)

Je vindt alle ‘gesture’-opties en functies in:

menu]>More Modules>BBC micro:bit>Sensors>Gestures.

Tip: Om een programmaregel als commentaarregel te markeren kun je [ctrl] [T] gebruiken.

Als je dit laatste programma uitvoert merk je een verschil met de vorige versie;

.current_gesture() toont continu de melding.

.was_gesture() toont deze alleen als er iets wijzigt.

Knoppen en ‘gestures’ bieden beide de mogelijkheid om input van de micro:bit te krijgen.
In het volgende deel verzamelen we data met behulp van de micro:bit en verwerken we deze met de TI-Nspire.

Deel 2: Werpen met een dobbelsteen
Als knop A is ingedrukt geef dan een variabele, een willekeurig heel getal van 1 t/m 6. Dit simuleert de dobbelsteen (in plaats van knop A kun je ook knop B gebruiken of één van de ‘gestures’).
Laat het getal op het display van de micro:bit zien.
Voordat je verdergaat, kun je eerst zelf proberen om het programma te schrijven.

Begin me een nieuw Python-programma en voeg weer de ‘micro:bit’-module toe.
Om een willekeurig (random) getal te kunnen kiezen hebben we een functie nodig uit de random-module. Deze voegen we ook toe (zie de tweede regel in het programma). Het programma lijkt op het vorige met ook weer de while-structuur.
De regel uitkomst = randint(1,6) geeft elke keer als knop A is ingedrukt de variabele ‘uitkomst’ een willekeurige waarde (1 tot 6).

Voeg nu ook de opdracht toe om deze waarde op het display van de micro:bit weer te geven.
Dat kan met display.show(uitkomst)

Voer het programma uit en elke keer als je knop A indrukt zie je de gekozen waarde op het display van de micro:bit verschijnen.

Data verzamelen
Het werpen met een dobbelsteen door op een knop te drukken is leuk, maar we willen de uitkomsten opslaan om er conclusies uit te kunnen trekken.

Begin met een lege lijst waarin de uitkomsten worden opgeslagen, in dit programma heet die lijst: uitkomsten.
Elke keer als knop A wordt ingedrukt moet de uitslag worden toegevoegd aan de lijst. Dat kan met uitkomsten.append().
Dit kun je vinden met: [menu]>Built-ins>List.
Aan het eind van het programma worden de elementen van de lijst opgeslagen in een ‘TI-Nspire’-lijst met de opdracht:
store_list(“ogen”,uitkomsten)
Deze functie kun je vinden met:
[menu]>BBC micro:bit>Commands.

In deze les meet je de lichtsterkte met de lichtsensor en sla je de data op in een ‘TI-Nspire’-lijst voor verdere analyse.

Doelen :

• De lichtsensor aflezen;
• De lichtsterkte op het display weergeven;
• De data uitwisselen tussen Python en TI-Nspire;
• De data analyseren.

De micro:bit kan de intensiteit van het omgevingslicht meten met behulp van de display-LEDs.
Deze LEDs kunnen dus ook als input-device gebruikt worden

Begin een nieuw Python-programma in een nieuw document.

(Druk op de [Home] toets, kies New en dan Add Python>New).

Geef het een naam bijvoorbeeld “lichtsterkte”.

from microbit import *

while get_key() != "esc":

    licht = display.read_light_level()

    print("Lichtsterkte =",licht)

De opdracht display.read_light_level() kun je vinden met:

[menu]>More Modules>BBC micro:bit>Sensors

Voer het programma uit en richt het ‘micro:bit’-display naar een lichtbron. Je ziet dan de lichtsterkte op je rekenmachinescherm.
Als je bijvoorbeeld je hand op het display legt, zie de waarde afnemen. Druk op [esc] om het programma te stoppen.

Maak twee lege lijsten vóór de while-opdracht:

tijd = [ ]

helderheid = [ ]

en neem t als variabele voor de tijd:

t = 0

In de eerste lijst toon je de tijden waarop gemeten is.

In de tweede lijst toon je de gemeten waarden.

Voeg in de while-lus (loop) een opdracht die t met 1 verhoogt.
Voeg ook twee opdrachten toe om de waarden van t en van de lichtsterkte in de lijsten te stoppen:

t = t+1

tijd.append(t)

helderheid.append(licht)

.append kun je vinden bij [menu]>Built-ins>Lists.

We gaan elke seconde een meting uitvoeren. Dat kan door een wachtopdracht toe te voegen aan het eind van de while-lus:

sleep(1000)

voor een wachttijd van 1000 milliseconden.

Je kunt deze opdracht vinden met:

 [menu]>BBC micro:bit>Commands.

Als we de metingen stoppen slaan we de Python-lijsten op in twee ‘TI-Nspire’-lijsten met dezelfde naam.

Je kunt hiervoor de opdracht store_list() gebruiken.

Let er wel op dat deze twee opdrachten niet inspringen want ze hoeven niet elke keer te worden uitgevoerd. Pas als de while-lus verlaten wordt moeten de lijsten worden opgeslagen.

store_list() kun je vinden met:

[menu]>BBC micro:bit>Commands.

Voer het programma uit en begin met de micro:bit dichtbij een lichtbron. Beweeg dan de micro:bit langzaam steeds verder weg van de lichtbron.

Tip: De lamp van een smartphone werkt prima als lichtbron.

Als je genoeg metingen hebt, druk je op [esc] om het programma te stoppen.

Voeg dan een extra pagina toe aan je document met [ctrl]-[doc] en kies voor Data & Statistics.

Je ziet dan een scherm dat lijkt op dat van hiernaast.

Klik onderaan het scherm om een variabele te kiezen en selecteer “tijd” als onafhankelijke variabele.
Klik ook aan de linkerkant van het scherm en kies hier voor “helderheid” als afhankelijke variabele.
De punten vormen dan een grafiek die lijkt op die van hiernaast.

Tip: Als je het experiment nog een keer uitvoert, kun je in het ‘Data & Statistics’-scherm met [menu]>Window/Zoom>Zoom Data de grafiek weer passend in beeld krijgen.

In deze toepassing schrijf je een programma waarmee je data verzamelt met behulp van de micro:bit. Daarna voer je het programma uit in een gedeeld scherm, zodat je de grafiek ziet “groeien” tijdens het verzamelen van de data.

Doelen :

• Het schrijven van een programma;
• Het maken van een dynamische grafiek met de ‘Data & Statistics’-pagina.

In deze toepassing gebruik je de technieken uit de drie lessen van deze unit:

Data verzamelen met de micro:bit waarbij je ‘gestures’ of knoppen gebruikt, en het gebruik van lijsten om de data op te slaan en uit te wisselen met TI-Nspire.

Daarna maak je een ‘TI-Nspire’-pagina waarin:

• aan de ene kant het Python-programma word uitgevoerd;
• aan de andere kant de grafiek (puntenplot of histogram) wordt getoond terwijl het programma loopt.

Begin je programma met het importeren van de ‘micro:bit’-module en ook de random-module.
Definieer daarna een lege lijst (“ogen”) en sla deze direct op als ‘TI-Nspire’-lijst zodat ook deze lijst leeg is als het programma wordt gestart.
Laat het programma dan de instructie voor de gebruiker tonen. In dit geval gebruiken we de optie om de micro:bit te schudden voor het werpen met de dobbelstenen.

Het programma moet elke keer als er “geworpen” wordt het volgende doen:

• Kies twee willekeurige getallen (van 1 tot 6).
• Tel deze op.
• Voeg de uitkomst toe aan de lijst “ogen”.
• Toon het aantal worpen, de twee getallen en hun som op het scherm.
• Laat de twee getallen ook op het display zien.
• Pas de ‘TI-Nspire‘-lijst aan.

Tip: Het aantal worpen is gelijk aan de lengte van de lijst “ogen”: len(ogen)

Begin met het werpen van de dobbelsteen.

Tel de uitkomsten op en voeg deze som toe aan de lijst “ogen”.

Laat de twee uitkomsten zien op het ‘micro:bit’-display.

display.clear() wordt gebruikt om de vorige uitkomst van het display te wissen, zodat het duidelijk is dat er weer een nieuwe waarde wordt getoond.

Voeg regels toe om de informatie op het ‘TI-Nspire’-scherm te tonen en om de ‘TI-Nspire’-lijst te updaten.

Als het Python-programma goed werkt, ga je verder met de link naar de ‘TI-Nspire’-plotmogelijkheden. Voer eerst het programma uit en werp ongeveer 50 keer met de dobbelstenen. Druk op [esc] om het programma te stoppen.

Zorg dat je in de Python-shell zit (de pagina met de >>> - cursor) en druk dan op [ctrl]-[doc] of [ctrl]-[i] om een pagina toe te voegen en kies voor Data & Statistics. Dan zie je een scherm zoals hiernaast.

Klik op “Click to add variable” onderin het scherm en selecteer “ogen”. Je ziet dan een puntenplot van de data verschijnen.

Ga een pagina terug naar de Python-shell met [ctrl]-[pijl naar links] en druk op [ctrl]-[4] om de twee pagina’s samen te voegen tot één gedeelde pagina. Links de Python-shell en rechts de ‘Data & Statistics’- toepassing.

De Shell is ‘re-initialized’. Dit betekent dat de data zijn gewist.

Ga weer naar de Python-editor en start het programma met [ctrl]-[R].

Je komt dan terug in het gedeelde scherm en als je de micro:bit heen en weer schudt dan zie je de grafiek ontstaan.

Je kunt ook het programma starten vanuit de Python-shell (het linkerdeel van het scherm) om opnieuw te starten.